designix 0.5.25 → 0.5.27

package/dist/index.js

@@ -1427,50 +1427,478 @@ var simplifiedGearWheelDef = {
 };
 
 // src/heliostat/heliostat.ts
+import {
+  designParam as designParam3,
+  checkGeom as checkGeom3,
+  prefixLog as prefixLog3,
+  figure as figure8,
+  degToRad as degToRad4,
+  radToDeg as radToDeg6,
+  ffix as ffix10,
+  pNumber as pNumber8,
+  pSectionSeparator as pSectionSeparator7,
+  initGeom as initGeom8,
+  EBVolume as EBVolume8
+} from "geometrix";
+
+// src/heliostat/pole_static.ts
 import {
   designParam as designParam2,
   checkGeom as checkGeom2,
   prefixLog as prefixLog2,
-  figure as figure7,
-  degToRad as degToRad2,
-  radToDeg as radToDeg5,
-  ffix as ffix8,
-  pNumber as pNumber7,
-  initGeom as initGeom7,
-  EBVolume as EBVolume7
+  contour as contour6,
+  contourCircle as contourCircle4,
+  figure as figure4,
+  radToDeg as radToDeg3,
+  ffix as ffix6,
+  pNumber as pNumber4,
+  pCheckbox as pCheckbox3,
+  pSectionSeparator as pSectionSeparator3,
+  initGeom as initGeom4,
+  EExtrude as EExtrude3,
+  EBVolume as EBVolume4
 } from "geometrix";
 
-// src/heliostat/pole_static.ts
+// src/heliostat/vaxis_holder.ts
 import {
-  contour as contour4,
+  point as point4,
+  contour as contour5,
   contourCircle as contourCircle3,
   figure as figure3,
-  radToDeg as radToDeg2,
-  ffix as ffix4,
+  degToRad as degToRad3,
+  ffix as ffix5,
   pNumber as pNumber3,
+  pSectionSeparator as pSectionSeparator2,
   initGeom as initGeom3,
+  transform3d,
   EExtrude as EExtrude2,
   EBVolume as EBVolume3
 } from "geometrix";
+
+// src/heliostat/common_spring_and_petal.ts
+import { point as point3, contour as contour4, degToRad as degToRad2, radToDeg as radToDeg2, ffix as ffix4 } from "geometrix";
+function ctrHolderPetal(param) {
+  let rLog = "";
+  const R1 = param.PHD1 / 2;
+  const R5 = param.PHD5 / 2;
+  const petalA1 = 2 * Math.asin(param.PHR4 / R1);
+  const petalA2 = 2 * Math.asin(param.PHL2 / (2 * R5));
+  const hollowA = 2 * Math.PI / param.PHN1 - petalA2;
+  const lCD = param.PHL2 / 2;
+  const lAD = Math.sqrt(R5 ** 2 - lCD ** 2) - R1;
+  const lAC = Math.sqrt(lCD ** 2 + lAD ** 2);
+  const aDAC = Math.acos(lAD / lAC);
+  const aCAB = Math.acos(param.PHR4 / lAC);
+  const aTan = Math.PI - aDAC - aCAB;
+  if (R5 < R1 + param.PHR4) {
+    throw `err211: PHD5 ${param.PHD5} too small compare to PHD1 ${param.PHD1} or PHR4 ${param.PHR4}`;
+  }
+  if (hollowA < petalA2) {
+    throw `err212: PHL2 ${param.PHL2} too large compare to PHN1 ${param.PHN1}`;
+  }
+  if (param.PHD3 > 2 * param.PHR4) {
+    throw `err213: PHD3 ${param.PHD3} too large compare to PHR4 ${param.PHR4}`;
+  }
+  if (aTan > Math.PI / 2 - petalA1) {
+    rLog += `warn345: PHL2 is quiet small ${ffix4(param.PHL2)} mm
+`;
+  }
+  rLog += `petal angle: ${ffix4(radToDeg2(petalA2))} degree
+`;
+  rLog += `hollow angle: ${ffix4(radToDeg2(hollowA))} degree
+`;
+  const p0 = point3(0, 0);
+  const p1 = point3(R5, 0);
+  const p2 = p1.rotate(p0, -petalA2 / 2);
+  const p10 = point3(R1, 0);
+  const p11 = point3(R1 - param.PHR4, 0);
+  const p12 = p11.rotate(p10, aTan);
+  const p13 = p11.rotate(p10, -aTan);
+  const ctrPetalPartial = contour4(p2.cx, p2.cy).addCornerRounded(param.PHR6).addSegStrokeA(p12.cx, p12.cy).addPointA(R1 - param.PHR4, 0).addPointA(p13.cx, p13.cy).addSegArc2().addSegStrokeAP(petalA2 / 2, R5).addCornerRounded(param.PHR6).addPointAP(petalA2 / 2 + hollowA / 2, R5).addPointAP(petalA2 / 2 + hollowA, R5).addSegArc2();
+  const rCtr = contour4(p2.cx, p2.cy);
+  const petalAngles = [...Array(param.PHN1).keys()].map((i) => i * (petalA2 + hollowA));
+  for (const rota of petalAngles) {
+    rCtr.addPartial(ctrPetalPartial.rotate(0, 0, rota));
+  }
+  return [rLog, rCtr, petalAngles];
+}
+function ctrGuidanceOuter(param) {
+  const rLog = "";
+  const R1 = param.D1 / 2;
+  const R2 = param.D2 / 2;
+  const R4 = param.D4 / 2;
+  const stepA1 = 2 * Math.PI / param.N1;
+  const L12 = param.L1 / 2;
+  const L3b = Math.sqrt(R2 ** 2 - L12 ** 2);
+  const aAOD = Math.asin(L12 / R2);
+  const L3 = R1 - L3b;
+  const aABD = Math.atan2(L12, L3);
+  const lBD = Math.sqrt(L12 ** 2 + L3 ** 2);
+  const aDBC = Math.acos(R4 / lBD);
+  const aABC = aABD + aDBC;
+  const larcA2 = (stepA1 - 2 * aAOD) / 2;
+  if (larcA2 < 0) {
+    throw `err464: N1 ${param.N1} is too large compare to D2 ${param.D2}, L1 ${param.L1}`;
+  }
+  if (R1 < R2) {
+    throw `err465: D2 ${param.D2} is too large compare to D1 ${param.D1}`;
+  }
+  const rCtr = contour4(L3b, -L12);
+  const pO = point3(0, 0);
+  const pA = point3(R2, 0);
+  const pB = point3(R1, 0);
+  const pE = point3(R1 - R4, 0);
+  const pC = pE.rotate(pB, aABC);
+  const pA2 = pA.rotate(pO, aAOD + larcA2);
+  const pA3 = pA.rotate(pO, stepA1 - aAOD);
+  const ctrOuterPartial = contour4(L3b, -L12).addCornerRounded(param.R5).addSegStrokeA(pC.cx, pC.cy).addPointA(R1 + R4, 0).addPointA(pC.cx, -pC.cy).addSegArc2().addSegStrokeA(L3b, L12).addCornerRounded(param.R5).addPointA(pA2.cx, pA2.cy).addPointA(pA3.cx, pA3.cy).addSegArc2();
+  for (let i = 0; i < param.N1; i++) {
+    rCtr.addPartial(ctrOuterPartial.rotate(0, 0, i * stepA1));
+  }
+  return [rLog, rCtr, stepA1];
+}
+function ctrGuidanceInner(param) {
+  const 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);
+  if (iarcA2 < 0) {
+    throw `err564: N2 ${param.N2} is too large compare to D6 ${param.D6}, E2 ${param.E2}`;
+  }
+  const rCtr = contour4(R6, 0);
+  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;
+    }
+  } 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);
+  }
+  return [rLog, rCtr];
+}
+
+// src/heliostat/vaxis_holder.ts
 var pDef3 = {
+  partName: "vaxis_holder",
+  params: [
+    //pNumber(name, unit, init, min, max, step)
+    pNumber3("PHD1", "mm", 700, 1, 2e3, 1),
+    pNumber3("PHD2", "mm", 900, 1, 4e3, 1),
+    pNumber3("PHD5", "mm", 800, 1, 4e3, 1),
+    pNumber3("PHN1", "holes", 6, 1, 24, 1),
+    pSectionSeparator2("screw holes"),
+    pNumber3("PHD3", "mm", 40, 2, 100, 1),
+    pNumber3("PHR4", "mm", 40, 2, 100, 1),
+    pNumber3("PHL2", "mm", 120, 5, 400, 1),
+    pNumber3("PHR6", "mm", 20, 0, 400, 1),
+    pSectionSeparator2("section"),
+    pNumber3("PHE1", "mm", 10, 1, 80, 1),
+    pNumber3("PHH1", "mm", 50, 1, 200, 1),
+    pNumber3("PHA", "degree", 5, -45, 45, 0.1),
+    pNumber3("PHL1", "mm", 300, 1, 500, 1),
+    pNumber3("PHE2", "mm", 10, 1, 80, 1),
+    pNumber3("PHE3", "mm", 10, 1, 80, 1)
+  ],
+  paramSvg: {
+    PHD1: "vaxis_holder_top.svg",
+    PHD2: "vaxis_holder_top.svg",
+    PHD5: "vaxis_holder_top.svg",
+    PHD3: "vaxis_holder_top.svg",
+    PHR4: "vaxis_holder_top.svg",
+    PHN1: "vaxis_holder_top.svg",
+    PHL2: "vaxis_holder_top.svg",
+    PHR6: "vaxis_holder_top.svg",
+    PHE1: "vaxis_holder_section.svg",
+    PHH1: "vaxis_holder_section.svg",
+    PHA: "vaxis_holder_section.svg",
+    PHL1: "vaxis_holder_section.svg",
+    PHE2: "vaxis_holder_section.svg",
+    PHE3: "vaxis_holder_top.svg"
+  },
+  sim: {
+    tMax: 180,
+    tStep: 0.5,
+    tUpdate: 500
+    // every 0.5 second
+  }
+};
+function pGeom3(t, param, suffix = "") {
+  const rGeome = initGeom3(pDef3.partName + suffix);
+  const figOuter = figure3();
+  const figPetal = figure3();
+  const figButtress1 = figure3();
+  const figButtress2 = figure3();
+  rGeome.logstr += `${rGeome.partName} simTime: ${t}
+`;
+  try {
+    const outerA = degToRad3(param.PHA);
+    const R1 = param.PHD1 / 2;
+    const R2 = param.PHD2 / 2;
+    const R3 = param.PHD3 / 2;
+    const R5 = param.PHD5 / 2;
+    const outerR1 = R2 + param.PHL1 / 2 * Math.sin(outerA);
+    const outerR2 = R2 - param.PHL1 / 2 * Math.sin(outerA);
+    const vaxisHolderHeight = param.PHL1 * Math.cos(outerA);
+    const innerR1 = R2 - param.PHE2 / Math.cos(outerA) + param.PHE1 / 2 * Math.tan(outerA);
+    const innerR2 = R2 - param.PHE2 / Math.cos(outerA) - param.PHE1 / 2 * Math.tan(outerA);
+    const innerR = Math.min(innerR1, innerR2);
+    const innerL2 = (param.PHL1 - param.PHE1 / Math.cos(outerA)) / 2;
+    const R2next = R2 - param.PHE2 / Math.cos(outerA);
+    if (innerR < R5) {
+      throw `err210: PHD5 ${param.PHD5} too large compare to PHE2 ${param.PHE2} or PHA ${param.PHA}`;
+    }
+    rGeome.logstr += `vaxis_holder's height: ${ffix5(vaxisHolderHeight)} mm
+`;
+    rGeome.logstr += `vaxis_holder outerD1: ${ffix5(2 * outerR1)} mm
+`;
+    rGeome.logstr += `vaxis_holder outerD2: ${ffix5(2 * outerR2)} mm
+`;
+    rGeome.logstr += `vaxis_holder innerD: ${ffix5(param.PHD1 - 2 * param.PHR4)} mm
+`;
+    rGeome.logstr += `vaxis_holder D2-next: ${ffix5(2 * R2next)} mm
+`;
+    const ctrOuter = function(rnl) {
+      const rCtr = contour5(rnl * R5, -param.PHE1 / 2).addSegStrokeR(rnl * (innerR1 - R5), 0).addSegStrokeRP(-Math.PI / 2 + rnl * outerA, innerL2).addSegStrokeRP(-Math.PI / 2 + rnl * (Math.PI / 2 + outerA), param.PHE2).addSegStrokeRP(Math.PI / 2 + rnl * outerA, param.PHL1).addSegStrokeRP(Math.PI / 2 + rnl * (Math.PI / 2 + outerA), param.PHE2).addSegStrokeRP(-Math.PI / 2 + rnl * outerA, innerL2).addSegStrokeA(rnl * R5, param.PHE1 / 2).closeSegStroke();
+      return rCtr;
+    };
+    const ctrLeg = function(rnl) {
+      const rCtr = contour5(rnl * innerR, -param.PHE1 / 2).addSegStrokeA(rnl * innerR, param.PHE1 / 2).addSegStrokeA(rnl * (R1 - param.PHR4), param.PHE1 / 2).addSegStrokeA(rnl * (R1 - param.PHR4), -param.PHE1 / 2).closeSegStroke();
+      return rCtr;
+    };
+    const ctrLegHole = function(rnl) {
+      const rCtr = contour5(rnl * (R1 + R3), -param.PHE1 / 2).addSegStrokeA(rnl * (R1 + R3), param.PHE1 / 2).addSegStrokeA(rnl * (R1 - R3), param.PHE1 / 2).addSegStrokeA(rnl * (R1 - R3), -param.PHE1 / 2).closeSegStroke();
+      return rCtr;
+    };
+    figOuter.addMain(ctrOuter(1));
+    figOuter.addSecond(ctrOuter(-1));
+    figOuter.addSecond(ctrLeg(1));
+    figOuter.addSecond(ctrLegHole(1));
+    figOuter.addSecond(ctrLeg(-1));
+    figOuter.addSecond(ctrLegHole(-1));
+    const ctrButtress1 = function(rnl) {
+      const rCtr = contour5(rnl * (R1 + param.PHR4), -param.PHE1 / 2).addSegStrokeA(rnl * innerR1, -param.PHE1 / 2).addSegStrokeRP(-Math.PI / 2 + rnl * outerA, innerL2).closeSegStroke();
+      return rCtr;
+    };
+    const ctrButtress2 = function(rnl) {
+      const rCtr = contour5(rnl * (R1 + param.PHR4), param.PHE1 / 2).addSegStrokeA(rnl * innerR2, param.PHE1 / 2).addSegStrokeRP(Math.PI / 2 + rnl * outerA, innerL2).addSegStrokeA(rnl * (R1 + param.PHR4), param.PHE1 + param.PHH1).closeSegStroke();
+      return rCtr;
+    };
+    figOuter.addSecond(ctrButtress1(-1));
+    figOuter.addSecond(ctrButtress2(-1));
+    figButtress1.mergeFigure(figOuter, true);
+    figButtress2.mergeFigure(figOuter, true);
+    figOuter.addSecond(ctrButtress1(1));
+    figOuter.addSecond(ctrButtress2(1));
+    figButtress1.addMain(ctrButtress1(1));
+    figButtress1.addSecond(ctrButtress2(1));
+    figButtress2.addSecond(ctrButtress1(1));
+    figButtress2.addMain(ctrButtress2(1));
+    figPetal.addMain(contourCircle3(0, 0, innerR));
+    figPetal.addSecond(contourCircle3(0, 0, R2));
+    figPetal.addSecond(contourCircle3(0, 0, Math.max(outerR1, outerR2)));
+    const [petalLog, petalCtr, petalAngles] = ctrHolderPetal(param);
+    rGeome.logstr += petalLog;
+    figPetal.addMain(petalCtr);
+    for (const rota of petalAngles) {
+      const p4 = point4(0, 0).translatePolar(rota, R1);
+      figPetal.addMain(contourCircle3(p4.cx, p4.cy, param.PHD3 / 2));
+    }
+    const ctrButtress = contour5(R1 + param.PHR4, -param.PHE3).addSegStrokeA(innerR, -param.PHE3).addSegStrokeA(innerR, param.PHE3).addSegStrokeA(R1 + param.PHR4, param.PHE3).closeSegStroke();
+    for (const rota of petalAngles) {
+      figPetal.addSecond(ctrButtress.rotate(0, 0, rota));
+    }
+    rGeome.fig = {
+      facePetal: figPetal,
+      faceOuter: figOuter,
+      faceButtress1: figButtress1,
+      faceButtress2: figButtress2
+    };
+    const designName = rGeome.partName;
+    const tm = transform3d();
+    tm.addRotation(Math.PI / 2, 0, 0);
+    tm.addTranslation(0, param.PHE3 / 2, 0);
+    const preExtrude1 = petalAngles.map((rota, idx) => {
+      const tm1 = transform3d(tm.getMatrix());
+      tm1.addRotation(0, 0, rota);
+      const rElem = {
+        outName: `subpax_${designName}_b1_${idx}`,
+        face: `${designName}_faceButtress1`,
+        extrudeMethod: EExtrude2.eLinearOrtho,
+        length: param.PHE3,
+        rotate: tm1.getRotation(),
+        translate: tm1.getTranslation()
+      };
+      return rElem;
+    });
+    const preExtrude2 = petalAngles.map((rota, idx) => {
+      const tm2 = transform3d(tm.getMatrix());
+      tm2.addRotation(0, 0, rota);
+      const rElem = {
+        outName: `subpax_${designName}_b2_${idx}`,
+        face: `${designName}_faceButtress2`,
+        extrudeMethod: EExtrude2.eLinearOrtho,
+        length: param.PHE3,
+        rotate: tm2.getRotation(),
+        translate: tm2.getTranslation()
+      };
+      return rElem;
+    });
+    const b1List = petalAngles.map((elem, idx) => {
+      const subElem = `subpax_${designName}_b1_${idx}`;
+      return subElem;
+    });
+    const b2List = petalAngles.map((elem, idx) => {
+      const subElem = `subpax_${designName}_b2_${idx}`;
+      return subElem;
+    });
+    rGeome.vol = {
+      extrudes: [
+        {
+          outName: `subpax_${designName}_outer`,
+          face: `${designName}_faceOuter`,
+          extrudeMethod: EExtrude2.eRotate,
+          rotate: [0, 0, 0],
+          translate: [0, 0, 0]
+        },
+        {
+          outName: `subpax_${designName}_petal`,
+          face: `${designName}_facePetal`,
+          extrudeMethod: EExtrude2.eLinearOrtho,
+          length: param.PHE1,
+          rotate: [0, 0, 0],
+          translate: [0, 0, -param.PHE1 / 2]
+        },
+        ...preExtrude1,
+        ...preExtrude2
+      ],
+      volumes: [
+        {
+          outName: `pax_${designName}`,
+          boolMethod: EBVolume3.eUnion,
+          inList: [
+            `subpax_${designName}_petal`,
+            `subpax_${designName}_outer`,
+            ...b1List,
+            ...b2List
+          ]
+        }
+      ]
+    };
+    rGeome.sub = {};
+    rGeome.logstr += "vaxis_holder drawn successfully!\n";
+    rGeome.calcErr = false;
+  } catch (emsg) {
+    rGeome.logstr += emsg;
+    console.log(emsg);
+  }
+  return rGeome;
+}
+var vaxisHolderDef = {
+  pTitle: "Heliostat vaxis_holder",
+  pDescription: "The holders of the guidance mechanism for azimuth motion",
+  pDef: pDef3,
+  pGeom: pGeom3
+};
+
+// src/heliostat/pole_static.ts
+var pDef4 = {
   partName: "pole_static",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber3("D1", "mm", 1e3, 20, 4e3, 1),
-    pNumber3("D2", "mm", 700, 10, 4e3, 1),
-    pNumber3("D3", "mm", 800, 10, 4e3, 1),
-    pNumber3("H1", "mm", 3e3, 10, 4e4, 10),
-    pNumber3("H2", "mm", 7e3, 50, 4e4, 10),
-    pNumber3("E1", "mm", 30, 1, 80, 1),
-    pNumber3("E2", "mm", 5, 1, 80, 1),
-    pNumber3("N1", "", 32, 3, 100, 1),
-    pNumber3("D5", "mm", 40, 1, 100, 1),
-    pNumber3("L1", "mm", 45, 1, 300, 1),
-    pNumber3("D4", "mm", 600, 1, 1200, 1),
-    pNumber3("H3", "mm", 300, 5, 1200, 1),
-    pNumber3("H4", "mm", 1800, 10, 2500, 1),
-    pNumber3("L2", "mm", 30, 1, 100, 1),
-    pNumber3("E3", "mm", 40, 1, 100, 1)
+    pNumber4("D1", "mm", 1e3, 20, 4e3, 1),
+    pNumber4("D2", "mm", 700, 10, 4e3, 1),
+    pNumber4("D3", "mm", 800, 10, 4e3, 1),
+    pNumber4("H1", "mm", 3e3, 10, 4e4, 10),
+    pNumber4("H2", "mm", 7e3, 50, 4e4, 10),
+    pSectionSeparator3("thickness"),
+    pNumber4("E1", "mm", 30, 1, 80, 1),
+    pNumber4("E2", "mm", 5, 1, 80, 1),
+    pSectionSeparator3("base holes"),
+    pNumber4("N1", "", 32, 3, 100, 1),
+    pNumber4("D5", "mm", 40, 1, 100, 1),
+    pNumber4("L1", "mm", 45, 1, 300, 1),
+    pSectionSeparator3("door"),
+    pNumber4("D4", "mm", 600, 1, 1200, 1),
+    pNumber4("H3", "mm", 300, 5, 1200, 1),
+    pNumber4("H4", "mm", 1800, 10, 2500, 1),
+    pNumber4("L2", "mm", 30, 1, 100, 1),
+    pNumber4("E3", "mm", 40, 1, 100, 1),
+    pSectionSeparator3("holders"),
+    pCheckbox3("holders", true),
+    pNumber4("PHL1A", "mm", 400, 10, 1e3, 1),
+    pNumber4("PHL1B", "mm", 400, 10, 1e3, 1),
+    pNumber4("PHB", "mm", 5e3, 10, 2e4, 1),
+    pNumber4("PHD1A", "mm", 600, 10, 4e3, 1),
+    pNumber4("PHD1B", "mm", 380, 10, 4e3, 1),
+    pNumber4("PHN1AB", "petal", 6, 1, 24, 1),
+    pSectionSeparator3("holder-B"),
+    pNumber4("PHD5B", "mm", 600, 10, 4e3, 1),
+    pNumber4("PHR4B", "mm", 30, 3, 400, 1),
+    pNumber4("PHD3B", "mm", 40, 3, 400, 1),
+    pNumber4("PHL2B", "mm", 140, 3, 400, 1),
+    pNumber4("PHE3B", "mm", 10, 1, 50, 1),
+    pNumber4("PHR6B", "mm", 20, 0, 400, 1),
+    pNumber4("PHE1B", "mm", 10, 1, 50, 1),
+    pNumber4("PHH1B", "mm", 10, 1, 50, 1),
+    pSectionSeparator3("holder-A"),
+    pNumber4("PHD5A", "mm", 900, 10, 4e3, 1),
+    pNumber4("PHR4A", "mm", 30, 3, 400, 1),
+    pNumber4("PHD3A", "mm", 40, 3, 400, 1),
+    pNumber4("PHL2A", "mm", 200, 3, 400, 1),
+    pNumber4("PHE3A", "mm", 10, 1, 50, 1),
+    pNumber4("PHR6A", "mm", 20, 0, 400, 1),
+    pNumber4("PHE1A", "mm", 10, 1, 50, 1),
+    pNumber4("PHH1A", "mm", 10, 1, 50, 1)
   ],
   paramSvg: {
     D1: "pole_stator_cut.svg",
@@ -1487,7 +1915,30 @@ var pDef3 = {
     H3: "pole_stator_face.svg",
     H4: "pole_stator_face.svg",
     L2: "pole_stator_face.svg",
-    E3: "pole_stator_right.svg"
+    E3: "pole_stator_right.svg",
+    holders: "pole_stator_holders.svg",
+    PHL1A: "pole_stator_holders.svg",
+    PHL1B: "pole_stator_holders.svg",
+    PHB: "pole_stator_holders.svg",
+    PHD1A: "pole_stator_holders.svg",
+    PHD1B: "pole_stator_holders.svg",
+    PHN1AB: "pole_stator_holders.svg",
+    PHD5A: "pole_stator_holderB_top.svg",
+    PHR4A: "pole_stator_holderB_top.svg",
+    PHD3A: "pole_stator_holderB_top.svg",
+    PHL2A: "pole_stator_holderB_top.svg",
+    PHE3A: "pole_stator_holderB_top.svg",
+    PHR6A: "pole_stator_holderB_top.svg",
+    PHE1A: "pole_stator_holderB_section.svg",
+    PHH1A: "pole_stator_holderB_section.svg",
+    PHD5B: "pole_stator_holderB_top.svg",
+    PHR4B: "pole_stator_holderB_top.svg",
+    PHD3B: "pole_stator_holderB_top.svg",
+    PHL2B: "pole_stator_holderB_top.svg",
+    PHE3B: "pole_stator_holderB_top.svg",
+    PHR6B: "pole_stator_holderB_top.svg",
+    PHE1B: "pole_stator_holderB_section.svg",
+    PHH1B: "pole_stator_holderB_section.svg"
   },
   sim: {
     tMax: 180,
@@ -1496,40 +1947,77 @@ var pDef3 = {
     // every 0.5 second
   }
 };
-function pGeom3(t, param, suffix = "") {
-  const rGeome = initGeom3(pDef3.partName + suffix);
-  let ctrPoleProfile;
-  let ctrDoorFace;
-  const figCut = figure3();
-  const figFace = figure3();
-  const figBottom = figure3();
-  const figEmptyPole = figure3();
-  const figEmptyDoor = figure3();
+function pGeom4(t, param, suffix = "") {
+  const rGeome = initGeom4(pDef4.partName + suffix);
+  const figCut = figure4();
+  const figFace = figure4();
+  const figBottom = figure4();
+  const figEmptyPole = figure4();
+  const figEmptyDoor = figure4();
+  const figHolderB2Section = figure4();
+  const figHolderB2Top = figure4();
+  const figHolderB1Section = figure4();
+  const figHolderB1Top = figure4();
+  const figHolderASection = figure4();
+  const figHolderATop = figure4();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
     const R1 = param.D1 / 2;
     const R2 = param.D2 / 2;
     const R3 = param.D3 / 2;
+    const poleHeight = param.H1 + param.H2;
+    const coneAngle = Math.atan2(R1 - R2, param.H2);
+    const H1bminus = param.E2 * Math.tan(coneAngle / 2);
+    const H1b = param.H1 - H1bminus;
+    const phl1b = param.PHL1B / Math.cos(coneAngle);
+    const hb2R2 = R2 + param.PHL1B / 2 * Math.tan(coneAngle);
+    const hb2PosH = param.H1 + param.H2 - param.PHL1B / 2;
+    const hb1R2 = R2 + (param.PHL1B / 2 + param.PHB) * Math.tan(coneAngle);
+    const hb1PosH = param.H1 + param.H2 - param.PHL1B / 2 - param.PHB;
+    const phl1a = param.PHL1A / Math.cos(coneAngle);
+    const haR2 = R1 - param.PHL1A / 2 * Math.tan(coneAngle);
+    const haPosH = param.H1 + param.PHL1A / 2;
     if (R2 > R1) {
       throw `err091: D2 ${param.D2} is larger than D1 ${param.D1}`;
     }
     if (R3 + param.E2 > R1) {
       throw `err095: D3 ${param.D3} and E2 ${param.E2} are too large compare to D1 ${param.D1}`;
     }
-    const poleHeight = param.H1 + param.H2;
-    rGeome.logstr += `pole-height: ${ffix4(poleHeight)} mm
+    if (param.holders) {
+      if (param.PHB < param.PHL1B) {
+        throw `err131: PHB ${param.PHB} is too small compare to PHL1B ${param.PHL1B}`;
+      }
+      if (param.PHB > param.H2 - param.PHL1B - param.PHL1A) {
+        throw `err132: PHB ${param.PHB} is too large compare to H2 ${param.H2}, PHL1B ${param.PHL1B} and PHL1A ${param.PHL1A}`;
+      }
+    }
+    rGeome.logstr += `pole-height: ${ffix6(poleHeight)} mm
 `;
-    const coneAngle = Math.atan2(R1 - R2, param.H2);
-    rGeome.logstr += `cone-half-angle: ${ffix4(radToDeg2(coneAngle))} degree
+    rGeome.logstr += `cone-half-angle: ${ffix6(radToDeg3(coneAngle))} degree
 `;
-    const H1bminus = param.E2 * Math.tan(coneAngle / 2);
-    const H1b = param.H1 - H1bminus;
-    ctrPoleProfile = function(orient, withR3) {
-      const rPoleProfile = contour4(orient * R1, 0).addSegStrokeA(orient * R1, param.H1).addSegStrokeA(orient * R2, poleHeight).addSegStrokeR(
+    rGeome.logstr += `holder position: A: ${ffix6(haPosH)}  B1: ${ffix6(hb1PosH)}  B2: ${ffix6(hb2PosH)} mm
+`;
+    const innerX = function(posY) {
+      let rPosX = R2 - param.E2 * Math.cos(coneAngle);
+      rPosX += (poleHeight - param.E2 * Math.sin(coneAngle) - posY) * Math.tan(coneAngle);
+      return rPosX;
+    };
+    const ctrPoleProfile = function(orient, withR3) {
+      const rPoleProfile = contour6(orient * R1, 0).addSegStrokeA(orient * R1, param.H1).addSegStrokeA(orient * R2, poleHeight).addSegStrokeR(
         -orient * param.E2 * Math.cos(coneAngle),
         -param.E2 * Math.sin(coneAngle)
-      ).addSegStrokeA(orient * (R1 - param.E2), H1b);
+      );
+      if (withR3 && param.holders) {
+        const py1 = param.H1 + param.PHL1A / 2 - param.PHE1A / 2;
+        const py2 = py1 + param.PHE1A;
+        const py6 = poleHeight - param.PHL1B / 2 + param.PHE1B / 2;
+        const py5 = py6 - param.PHE1B;
+        const py4 = py6 - param.PHB;
+        const py3 = py4 - param.PHE1B;
+        rPoleProfile.addSegStrokeA(orient * innerX(py6), py6).addSegStrokeA(orient * (param.PHD1B / 2 - param.PHR4B), py6).addSegStrokeA(orient * (param.PHD1B / 2 - param.PHR4B), py5).addSegStrokeA(orient * innerX(py5), py5).addSegStrokeA(orient * innerX(py4), py4).addSegStrokeA(orient * (param.PHD1B / 2 - param.PHR4B), py4).addSegStrokeA(orient * (param.PHD1B / 2 - param.PHR4B), py3).addSegStrokeA(orient * innerX(py3), py3).addSegStrokeA(orient * innerX(py2), py2).addSegStrokeA(orient * (param.PHD1A / 2 - param.PHR4A), py2).addSegStrokeA(orient * (param.PHD1A / 2 - param.PHR4A), py1).addSegStrokeA(orient * innerX(py1), py1);
+      }
+      rPoleProfile.addSegStrokeA(orient * (R1 - param.E2), H1b);
       if (withR3) {
         rPoleProfile.addSegStrokeA(orient * (R1 - param.E2), param.E1).addSegStrokeA(orient * R3, param.E1).addSegStrokeA(orient * R3, 0);
       } else {
@@ -1549,53 +2037,172 @@ function pGeom3(t, param, suffix = "") {
     if (R4 - param.L2 < 0) {
       throw `err121: D4 ${param.D4} is too small compare to L2 ${param.L2}`;
     }
-    ctrDoorFace = function(pL2) {
+    const ctrDoorFace = function(pL2) {
       const R4b = R4 - pL2;
       const H3b = param.H3 + R4;
-      const rCtrDoorFace = contour4(R4b, H3b + doorStraightLenght).addPointR(-R4b, R4b).addSegArc(R4b, false, true).addPointR(-R4b, -R4b).addSegArc(R4b, false, true).addSegStrokeR(0, -doorStraightLenght).addPointR(R4b, -R4b).addSegArc(R4b, false, true).addPointR(R4b, R4b).addSegArc(R4b, false, true).closeSegStroke();
+      const rCtrDoorFace = contour6(R4b, H3b + doorStraightLenght).addPointR(-R4b, R4b).addSegArc(R4b, false, true).addPointR(-R4b, -R4b).addSegArc(R4b, false, true).addSegStrokeR(0, -doorStraightLenght).addPointR(R4b, -R4b).addSegArc(R4b, false, true).addPointR(R4b, R4b).addSegArc(R4b, false, true).closeSegStroke();
       return rCtrDoorFace;
     };
     figFace.addMain(ctrDoorFace(0));
     figFace.addMain(ctrDoorFace(param.L2));
-    const ctrPoleFace = contour4(R1, 0).addSegStrokeA(R1, param.H1).addSegStrokeA(R2, poleHeight).addSegStrokeA(-R2, poleHeight).addSegStrokeA(-R1, param.H1).addSegStrokeA(-R1, 0).closeSegStroke();
+    const ctrPoleFace = contour6(R1, 0).addSegStrokeA(R1, param.H1).addSegStrokeA(R2, poleHeight).addSegStrokeA(-R2, poleHeight).addSegStrokeA(-R1, param.H1).addSegStrokeA(-R1, 0).closeSegStroke();
     figFace.addSecond(ctrPoleFace);
-    const ctrDoorSide = contour4(-R1, param.H3).addSegStrokeR(0, param.H4).addSegStrokeR(-param.E3, 0).addSegStrokeR(0, -param.H4).closeSegStroke();
+    const ctrDoorSide = contour6(-R1, param.H3).addSegStrokeR(0, param.H4).addSegStrokeR(-param.E3, 0).addSegStrokeR(0, -param.H4).closeSegStroke();
     figFace.addSecond(ctrDoorSide);
-    figBottom.addMain(contourCircle3(0, 0, R1));
-    figBottom.addMain(contourCircle3(0, 0, R3));
+    figBottom.addMain(contourCircle4(0, 0, R1));
+    figBottom.addMain(contourCircle4(0, 0, R3));
     const posR = R3 + param.L1;
     const posA = 2 * Math.PI / param.N1;
     for (let i = 0; i < param.N1; i++) {
       const posX = posR * Math.cos(i * posA);
       const posY = posR * Math.sin(i * posA);
-      figBottom.addMain(contourCircle3(posX, posY, param.D5 / 2));
+      figBottom.addMain(contourCircle4(posX, posY, param.D5 / 2));
     }
-    figBottom.addSecond(contourCircle3(0, 0, R2));
-    figBottom.addSecond(contourCircle3(0, 0, R1 - param.E2));
-    figEmptyPole.addMain(contourCircle3(0, 0, R1 + param.E3));
-    figEmptyPole.addMain(contourCircle3(0, 0, R1 - param.E2));
+    figBottom.addSecond(contourCircle4(0, 0, R2));
+    figBottom.addSecond(contourCircle4(0, 0, R1 - param.E2));
+    figEmptyPole.addMain(contourCircle4(0, 0, R1 + param.E3));
+    figEmptyPole.addMain(contourCircle4(0, 0, R1 - param.E2));
     figEmptyDoor.addMain(ctrDoorFace(param.L2));
+    const designName = rGeome.partName;
+    const inheritList = [];
+    const inheritNames = [];
+    if (param.holders) {
+      const vaxisHolderB2Param = designParam2(vaxisHolderDef.pDef, "B2");
+      vaxisHolderB2Param.setVal("PHD1", param.PHD1B);
+      vaxisHolderB2Param.setVal("PHD2", 2 * hb2R2);
+      vaxisHolderB2Param.setVal("PHD5", param.PHD5B);
+      vaxisHolderB2Param.setVal("PHN1", param.PHN1AB);
+      vaxisHolderB2Param.setVal("PHD3", param.PHD3B);
+      vaxisHolderB2Param.setVal("PHR4", param.PHR4B);
+      vaxisHolderB2Param.setVal("PHL2", param.PHL2B);
+      vaxisHolderB2Param.setVal("PHR6", param.PHR6B);
+      vaxisHolderB2Param.setVal("PHE1", param.PHE1B);
+      vaxisHolderB2Param.setVal("PHH1", param.PHH1B);
+      vaxisHolderB2Param.setVal("PHA", radToDeg3(coneAngle));
+      vaxisHolderB2Param.setVal("PHL1", phl1b);
+      vaxisHolderB2Param.setVal("PHE2", param.E2);
+      vaxisHolderB2Param.setVal("PHE3", param.PHE3B);
+      const vaxisHolderB2Geom = vaxisHolderDef.pGeom(
+        0,
+        vaxisHolderB2Param.getParamVal(),
+        vaxisHolderB2Param.getSuffix()
+      );
+      checkGeom2(vaxisHolderB2Geom);
+      rGeome.logstr += prefixLog2(
+        vaxisHolderB2Geom.logstr,
+        vaxisHolderB2Param.getPartNameSuffix()
+      );
+      figHolderB2Section.mergeFigure(vaxisHolderB2Geom.fig.faceOuter);
+      figHolderB2Top.mergeFigure(vaxisHolderB2Geom.fig.facePetal);
+      const inheritHb2 = {
+        outName: `inpax_${designName}_hB2`,
+        subdesign: "pax_vaxis_holderB2",
+        subgeom: vaxisHolderB2Geom,
+        rotate: [0, 0, 0],
+        translate: [0, 0, hb2PosH]
+      };
+      inheritList.push(inheritHb2);
+      inheritNames.push(`inpax_${designName}_hB2`);
+      const vaxisHolderB1Param = designParam2(vaxisHolderDef.pDef, "B1");
+      vaxisHolderB1Param.setVal("PHD1", param.PHD1B);
+      vaxisHolderB1Param.setVal("PHD2", 2 * hb1R2);
+      vaxisHolderB1Param.setVal("PHD5", param.PHD5B);
+      vaxisHolderB1Param.setVal("PHN1", param.PHN1AB);
+      vaxisHolderB1Param.setVal("PHD3", param.PHD3B);
+      vaxisHolderB1Param.setVal("PHR4", param.PHR4B);
+      vaxisHolderB1Param.setVal("PHL2", param.PHL2B);
+      vaxisHolderB1Param.setVal("PHR6", param.PHR6B);
+      vaxisHolderB1Param.setVal("PHE1", param.PHE1B);
+      vaxisHolderB1Param.setVal("PHH1", param.PHH1B);
+      vaxisHolderB1Param.setVal("PHA", radToDeg3(coneAngle));
+      vaxisHolderB1Param.setVal("PHL1", phl1b);
+      vaxisHolderB1Param.setVal("PHE2", param.E2);
+      vaxisHolderB1Param.setVal("PHE3", param.PHE3B);
+      const vaxisHolderB1Geom = vaxisHolderDef.pGeom(
+        0,
+        vaxisHolderB1Param.getParamVal(),
+        vaxisHolderB1Param.getSuffix()
+      );
+      checkGeom2(vaxisHolderB1Geom);
+      rGeome.logstr += prefixLog2(
+        vaxisHolderB1Geom.logstr,
+        vaxisHolderB1Param.getPartNameSuffix()
+      );
+      figHolderB1Section.mergeFigure(vaxisHolderB1Geom.fig.faceOuter);
+      figHolderB1Top.mergeFigure(vaxisHolderB1Geom.fig.facePetal);
+      const inheritHb1 = {
+        outName: `inpax_${designName}_hB1`,
+        subdesign: "pax_vaxis_holderB1",
+        subgeom: vaxisHolderB1Geom,
+        rotate: [0, 0, 0],
+        translate: [0, 0, hb1PosH]
+      };
+      inheritList.push(inheritHb1);
+      inheritNames.push(`inpax_${designName}_hB1`);
+      const vaxisHolderAParam = designParam2(vaxisHolderDef.pDef, "A");
+      vaxisHolderAParam.setVal("PHD1", param.PHD1A);
+      vaxisHolderAParam.setVal("PHD2", 2 * haR2);
+      vaxisHolderAParam.setVal("PHD5", param.PHD5A);
+      vaxisHolderAParam.setVal("PHN1", param.PHN1AB);
+      vaxisHolderAParam.setVal("PHD3", param.PHD3A);
+      vaxisHolderAParam.setVal("PHR4", param.PHR4A);
+      vaxisHolderAParam.setVal("PHL2", param.PHL2A);
+      vaxisHolderAParam.setVal("PHR6", param.PHR6A);
+      vaxisHolderAParam.setVal("PHE1", param.PHE1A);
+      vaxisHolderAParam.setVal("PHH1", param.PHH1A);
+      vaxisHolderAParam.setVal("PHA", radToDeg3(coneAngle));
+      vaxisHolderAParam.setVal("PHL1", phl1a);
+      vaxisHolderAParam.setVal("PHE2", param.E2);
+      vaxisHolderAParam.setVal("PHE3", param.PHE3A);
+      const vaxisHolderAGeom = vaxisHolderDef.pGeom(
+        0,
+        vaxisHolderAParam.getParamVal(),
+        vaxisHolderAParam.getSuffix()
+      );
+      checkGeom2(vaxisHolderAGeom);
+      rGeome.logstr += prefixLog2(
+        vaxisHolderAGeom.logstr,
+        vaxisHolderAParam.getPartNameSuffix()
+      );
+      figHolderASection.mergeFigure(vaxisHolderAGeom.fig.faceOuter);
+      figHolderATop.mergeFigure(vaxisHolderAGeom.fig.facePetal);
+      const inheritHa = {
+        outName: `inpax_${designName}_hA`,
+        subdesign: "pax_vaxis_holderA",
+        subgeom: vaxisHolderAGeom,
+        rotate: [0, 0, 0],
+        translate: [0, 0, haPosH]
+      };
+      inheritList.push(inheritHa);
+      inheritNames.push(`inpax_${designName}_hA`);
+    }
     rGeome.fig = {
       poleCut: figCut,
       poleFace: figFace,
       poleBottom: figBottom,
       emptyPole: figEmptyPole,
-      emptyDoor: figEmptyDoor
+      emptyDoor: figEmptyDoor,
+      holderB2Section: figHolderB2Section,
+      holderB2Top: figHolderB2Top,
+      holderB1Section: figHolderB1Section,
+      holderB1Top: figHolderB1Top,
+      holderASection: figHolderASection,
+      holderATop: figHolderATop
     };
-    const designName = rGeome.partName;
     rGeome.vol = {
+      inherits: inheritList,
       extrudes: [
         {
           outName: `subpax_${designName}_pole`,
           face: `${designName}_poleCut`,
-          extrudeMethod: EExtrude2.eRotate,
+          extrudeMethod: EExtrude3.eRotate,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
         },
         {
           outName: `subpax_${designName}_bottom`,
           face: `${designName}_poleBottom`,
-          extrudeMethod: EExtrude2.eLinearOrtho,
+          extrudeMethod: EExtrude3.eLinearOrtho,
           length: param.E1,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
@@ -1603,7 +2210,7 @@ function pGeom3(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_door`,
           face: `${designName}_poleFace`,
-          extrudeMethod: EExtrude2.eLinearOrtho,
+          extrudeMethod: EExtrude3.eLinearOrtho,
           length: R1 + param.E3,
           rotate: [Math.PI / 2, 0, 0],
           translate: [0, 0, 0]
@@ -1611,7 +2218,7 @@ function pGeom3(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_emptyPole`,
           face: `${designName}_emptyPole`,
-          extrudeMethod: EExtrude2.eLinearOrtho,
+          extrudeMethod: EExtrude3.eLinearOrtho,
           length: param.H1,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
@@ -1619,7 +2226,7 @@ function pGeom3(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_emptyDoor`,
           face: `${designName}_emptyDoor`,
-          extrudeMethod: EExtrude2.eLinearOrtho,
+          extrudeMethod: EExtrude3.eLinearOrtho,
           length: R1 + param.E3 + 10,
           rotate: [Math.PI / 2, 0, 0],
           translate: [0, 0, 0]
@@ -1629,21 +2236,22 @@ function pGeom3(t, param, suffix = "") {
         {
           outName: `ipax_${designName}_door`,
           //boolMethod: EBVolume.eSubstraction,
-          boolMethod: EBVolume3.eIntersection,
+          boolMethod: EBVolume4.eIntersection,
           inList: [`subpax_${designName}_door`, `subpax_${designName}_emptyPole`]
         },
         {
           outName: `ipax_${designName}_pole`,
-          boolMethod: EBVolume3.eSubstraction,
+          boolMethod: EBVolume4.eSubstraction,
           inList: [`subpax_${designName}_pole`, `subpax_${designName}_emptyDoor`]
         },
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume3.eUnion,
+          boolMethod: EBVolume4.eUnion,
           inList: [
             `ipax_${designName}_pole`,
             `subpax_${designName}_bottom`,
-            `ipax_${designName}_door`
+            `ipax_${designName}_door`,
+            ...inheritNames
           ]
         }
       ]
@@ -1660,54 +2268,59 @@ function pGeom3(t, param, suffix = "") {
 var poleStaticDef = {
   pTitle: "Heliostat pole static",
   pDescription: "The vertical pole of an heliostat",
-  pDef: pDef3,
-  pGeom: pGeom3
+  pDef: pDef4,
+  pGeom: pGeom4
 };
 
 // src/heliostat/rake.ts
 import {
-  contour as contour5,
-  contourCircle as contourCircle4,
-  figure as figure4,
-  radToDeg as radToDeg3,
-  ffix as ffix5,
-  pNumber as pNumber4,
-  initGeom as initGeom4,
-  EExtrude as EExtrude3,
-  EBVolume as EBVolume4
+  contour as contour7,
+  contourCircle as contourCircle5,
+  figure as figure5,
+  radToDeg as radToDeg4,
+  ffix as ffix7,
+  pNumber as pNumber5,
+  pSectionSeparator as pSectionSeparator4,
+  initGeom as initGeom5,
+  EExtrude as EExtrude4,
+  EBVolume as EBVolume5
 } from "geometrix";
-var pDef4 = {
+var pDef5 = {
   partName: "rake",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber4("D1", "mm", 600, 10, 4e3, 10),
-    pNumber4("D2", "mm", 400, 10, 4e3, 10),
-    pNumber4("D3", "mm", 400, 10, 4e3, 10),
-    pNumber4("H1", "mm", 800, 1, 4e3, 10),
-    pNumber4("H2", "mm", 3e3, 20, 6e3, 10),
-    pNumber4("H3", "mm", 400, 0, 4e3, 10),
-    pNumber4("E1", "mm", 20, 1, 80, 1),
-    pNumber4("E3", "mm", 30, 1, 80, 1),
-    pNumber4("H4", "mm", 400, 10, 1e3, 10),
-    pNumber4("D4", "mm", 300, 10, 1e3, 10),
-    pNumber4("E4", "mm", 20, 1, 80, 1),
-    pNumber4("H5", "mm", 1e3, 10, 2e3, 10),
-    pNumber4("D5", "mm", 200, 1, 1e3, 10),
-    pNumber4("L4", "mm", 300, 1, 1e3, 10),
-    pNumber4("L5", "mm", 2e3, 10, 4e3, 10),
-    pNumber4("L6", "mm", 2e3, 1, 4e3, 10),
-    pNumber4("D6", "mm", 100, 1, 600, 10),
-    pNumber4("E6", "mm", 10, 1, 80, 1),
-    pNumber4("L7", "mm", 100, 1, 1e3, 1),
-    pNumber4("L8", "mm", 200, 1, 1e3, 1),
-    pNumber4("N1", "", 24, 3, 100, 1),
-    pNumber4("D7", "mm", 40, 1, 100, 1),
-    pNumber4("L1", "mm", 30, 1, 300, 1),
-    pNumber4("D8", "mm", 400, 1, 1e3, 10),
-    pNumber4("H6", "mm", 100, 1, 1e3, 10),
-    pNumber4("H7", "mm", 600, 10, 2e3, 10),
-    pNumber4("L9", "mm", 300, 1, 1e3, 10),
-    pNumber4("R9", "mm", 50, 0, 300, 1)
+    pNumber5("D1", "mm", 600, 10, 4e3, 10),
+    pNumber5("D2", "mm", 400, 10, 4e3, 10),
+    pNumber5("D3", "mm", 400, 10, 4e3, 10),
+    pNumber5("H1", "mm", 800, 1, 4e3, 10),
+    pNumber5("H2", "mm", 3e3, 20, 6e3, 10),
+    pNumber5("H3", "mm", 400, 0, 4e3, 10),
+    pNumber5("E1", "mm", 20, 1, 80, 1),
+    pNumber5("E3", "mm", 30, 1, 80, 1),
+    pSectionSeparator4("transversal"),
+    pNumber5("H4", "mm", 400, 10, 1e3, 10),
+    pNumber5("D4", "mm", 300, 10, 1e3, 10),
+    pNumber5("E4", "mm", 20, 1, 80, 1),
+    pNumber5("H5", "mm", 1e3, 10, 2e3, 10),
+    pNumber5("D5", "mm", 200, 1, 1e3, 10),
+    pNumber5("L4", "mm", 300, 1, 1e3, 10),
+    pNumber5("L5", "mm", 2e3, 10, 4e3, 10),
+    pNumber5("L6", "mm", 2e3, 1, 4e3, 10),
+    pNumber5("D8", "mm", 400, 1, 1e3, 10),
+    pSectionSeparator4("diagonal"),
+    pNumber5("D6", "mm", 100, 1, 600, 10),
+    pNumber5("E6", "mm", 10, 1, 80, 1),
+    pNumber5("L7", "mm", 100, 1, 1e3, 1),
+    pNumber5("L8", "mm", 200, 1, 1e3, 1),
+    pSectionSeparator4("base"),
+    pNumber5("N1", "", 24, 3, 100, 1),
+    pNumber5("D7", "mm", 40, 1, 100, 1),
+    pNumber5("L1", "mm", 30, 1, 300, 1),
+    pSectionSeparator4("door"),
+    pNumber5("H6", "mm", 100, 1, 1e3, 10),
+    pNumber5("H7", "mm", 600, 10, 2e3, 10),
+    pNumber5("L9", "mm", 300, 1, 1e3, 10),
+    pNumber5("R9", "mm", 50, 0, 300, 1)
   ],
   paramSvg: {
     D1: "rake_face.svg",
@@ -1746,19 +2359,19 @@ var pDef4 = {
     // every 0.5 second
   }
 };
-function pGeom4(t, param, suffix = "") {
-  const rGeome = initGeom4(pDef4.partName + suffix);
+function pGeom5(t, param, suffix = "") {
+  const rGeome = initGeom5(pDef5.partName + suffix);
   let ctrCone;
   let ctrConePlus;
   let ctrRect;
-  const figCone = figure4();
-  const figBeam = figure4();
-  const figBeamHollow = figure4();
-  const figDisc = figure4();
-  const figHand = figure4();
-  const figWing = figure4();
-  const figWingHollow = figure4();
-  const figDoor = figure4();
+  const figCone = figure5();
+  const figBeam = figure5();
+  const figBeamHollow = figure5();
+  const figDisc = figure5();
+  const figHand = figure5();
+  const figWing = figure5();
+  const figWingHollow = figure5();
+  const figDoor = figure5();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
@@ -1772,9 +2385,9 @@ function pGeom4(t, param, suffix = "") {
     const R8 = param.D8 / 2;
     const H1H2 = param.H1 + param.H2;
     const H1H5 = H1H2 - param.H4 + param.H5;
-    rGeome.logstr += `cone-height: ${ffix5(H1H2)} mm
+    rGeome.logstr += `cone-height: ${ffix7(H1H2)} mm
 `;
-    rGeome.logstr += `cone-height total: ${ffix5(H1H5)} mm
+    rGeome.logstr += `cone-height total: ${ffix7(H1H5)} mm
 `;
     if (param.D2 > param.D1) {
       throw `err110: D2 ${param.D2} is larger than D1 ${param.D1}`;
@@ -1808,12 +2421,12 @@ function pGeom4(t, param, suffix = "") {
       throw `err140: H2 ${param.H2} too small compare to L8 ${param.L8}, H4 ${param.H4} and D4 ${param.D4}`;
     }
     const coneAngle = Math.atan2(R1 - R2, param.H2);
-    rGeome.logstr += `cone-angle: ${ffix5(radToDeg3(coneAngle))} degree
+    rGeome.logstr += `cone-angle: ${ffix7(radToDeg4(coneAngle))} degree
 `;
     const wingLx = beamL / 2 - param.L7 - R1 + param.L8 * Math.tan(coneAngle);
     const wingL = Math.sqrt(wingLx ** 2 + wingLy ** 2);
     const wingAngle = Math.atan2(wingLx, wingLy);
-    rGeome.logstr += `wing-angle: ${ffix5(radToDeg3(wingAngle))} degree
+    rGeome.logstr += `wing-angle: ${ffix7(radToDeg4(wingAngle))} degree
 `;
     const wingLPre = param.E1 / Math.sin(wingAngle + coneAngle);
     const wingL2 = wingL + param.E4 / Math.cos(wingAngle) + wingLPre;
@@ -1837,11 +2450,11 @@ function pGeom4(t, param, suffix = "") {
     const coneSlopeY = param.E1 * Math.sin(coneAngle);
     const coneFC = param.E1 * Math.tan(coneAngle / 2);
     ctrCone = function(orient) {
-      const rCtr = contour5(orient * R1, 0).addSegStrokeA(orient * R1, param.H1).addSegStrokeA(orient * R2, H1H2).addSegStrokeA(orient * (R2 - coneSlopeX), H1H2 - coneSlopeY).addSegStrokeA(orient * (R1 - param.E1), param.H1 - coneFC).addSegStrokeA(orient * (R1 - param.E1), 0).closeSegStroke();
+      const rCtr = contour7(orient * R1, 0).addSegStrokeA(orient * R1, param.H1).addSegStrokeA(orient * R2, H1H2).addSegStrokeA(orient * (R2 - coneSlopeX), H1H2 - coneSlopeY).addSegStrokeA(orient * (R1 - param.E1), param.H1 - coneFC).addSegStrokeA(orient * (R1 - param.E1), 0).closeSegStroke();
       return rCtr;
     };
     ctrConePlus = function(orient) {
-      const rCtr = contour5(orient * R1, 0).addSegStrokeA(orient * R1, param.H1).addSegStrokeA(orient * R2, H1H2).addSegStrokeA(orient * (R2 - coneSlopeX), H1H2 - coneSlopeY).addSegStrokeA(orient * (R1 - param.E1), param.H1 - coneFC).addSegStrokeA(orient * (R1 - param.E1), param.H1 - param.H3).addSegStrokeA(orient * R3, param.H1 - param.H3).addSegStrokeA(orient * R3, param.H1 - param.H3 - param.E3).addSegStrokeA(orient * (R1 - param.E1), param.H1 - param.H3 - param.E3).addSegStrokeA(orient * (R1 - param.E1), 0).closeSegStroke();
+      const rCtr = contour7(orient * R1, 0).addSegStrokeA(orient * R1, param.H1).addSegStrokeA(orient * R2, H1H2).addSegStrokeA(orient * (R2 - coneSlopeX), H1H2 - coneSlopeY).addSegStrokeA(orient * (R1 - param.E1), param.H1 - coneFC).addSegStrokeA(orient * (R1 - param.E1), param.H1 - param.H3).addSegStrokeA(orient * R3, param.H1 - param.H3).addSegStrokeA(orient * R3, param.H1 - param.H3 - param.E3).addSegStrokeA(orient * (R1 - param.E1), param.H1 - param.H3 - param.E3).addSegStrokeA(orient * (R1 - param.E1), 0).closeSegStroke();
       return rCtr;
     };
     ctrRect = function(width, height, xpos, ypos, angle) {
@@ -1849,10 +2462,10 @@ function pGeom4(t, param, suffix = "") {
       const yWidth = width * Math.sin(angle);
       const xHeight = -height * Math.sin(angle);
       const yHeight = height * Math.cos(angle);
-      const rCtr = contour5(xpos, ypos).addSegStrokeA(xpos + xWidth, ypos + yWidth).addSegStrokeA(xpos + xWidth + xHeight, ypos + yWidth + yHeight).addSegStrokeA(xpos + xHeight, ypos + yHeight).closeSegStroke();
+      const rCtr = contour7(xpos, ypos).addSegStrokeA(xpos + xWidth, ypos + yWidth).addSegStrokeA(xpos + xWidth + xHeight, ypos + yWidth + yHeight).addSegStrokeA(xpos + xHeight, ypos + yHeight).closeSegStroke();
       return rCtr;
     };
-    const ctrDoor = contour5(doorLowX, param.H1 + param.H6).addCornerRounded(param.R9).addSegStrokeA(doorHighX, param.H1 + param.H6 + param.H7).addCornerRounded(param.R9).addSegStrokeA(-doorHighX, param.H1 + param.H6 + param.H7).addCornerRounded(param.R9).addSegStrokeA(-doorLowX, param.H1 + param.H6).addCornerRounded(param.R9).closeSegStroke();
+    const ctrDoor = contour7(doorLowX, param.H1 + param.H6).addCornerRounded(param.R9).addSegStrokeA(doorHighX, param.H1 + param.H6 + param.H7).addCornerRounded(param.R9).addSegStrokeA(-doorHighX, param.H1 + param.H6 + param.H7).addCornerRounded(param.R9).addSegStrokeA(-doorLowX, param.H1 + param.H6).addCornerRounded(param.R9).closeSegStroke();
     figCone.addMain(ctrCone(1));
     figCone.addSecond(ctrConePlus(1));
     figCone.addSecond(ctrConePlus(-1));
@@ -1870,30 +2483,30 @@ function pGeom4(t, param, suffix = "") {
     figCone.addSecond(ctrRect(2 * R6, wingL2, -wingPosX, wingPosY, wingAngle));
     figCone.addSecond(ctrRect(2 * wingHR, wingL2, -wingHPosX, wingHPosY, wingAngle));
     figCone.addSecond(ctrDoor);
-    const ctrHand = contour5(handLowX, beamH + handLowY).addSegStrokeA(handHighXext, beamH + param.H5 - handHighYext).addSegStrokeA(handHighXint, beamH + param.H5 - handHighYint).addPointA(-handHighXint, beamH + param.H5 - handHighYint).addSegArc(R5, false, false).addSegStrokeA(-handHighXext, beamH + param.H5 - handHighYext).addSegStrokeA(-handLowX, beamH + handLowY).closeSegArc(R4, false, false);
-    figBeam.addMain(contourCircle4(0, beamH, R4));
-    figBeam.addMain(contourCircle4(0, beamH, R4 - param.E4));
+    const ctrHand = contour7(handLowX, beamH + handLowY).addSegStrokeA(handHighXext, beamH + param.H5 - handHighYext).addSegStrokeA(handHighXint, beamH + param.H5 - handHighYint).addPointA(-handHighXint, beamH + param.H5 - handHighYint).addSegArc(R5, false, false).addSegStrokeA(-handHighXext, beamH + param.H5 - handHighYext).addSegStrokeA(-handLowX, beamH + handLowY).closeSegArc(R4, false, false);
+    figBeam.addMain(contourCircle5(0, beamH, R4));
+    figBeam.addMain(contourCircle5(0, beamH, R4 - param.E4));
     figBeam.addSecond(ctrConePlus(1));
     figBeam.addSecond(ctrConePlus(-1));
     figBeam.addSecond(ctrHand);
-    figBeam.addSecond(contourCircle4(0, beamH + param.H5, R5));
+    figBeam.addSecond(contourCircle5(0, beamH + param.H5, R5));
     figBeam.addSecond(ctrRect(2 * R6, wingLy, -R6, param.H1 + param.L8, 0));
     figBeam.addSecond(ctrRect(2 * wingHR, wingLy, -wingHR, param.H1 + param.L8, 0));
     figBeam.addSecond(ctrDoor);
-    figBeamHollow.addMain(contourCircle4(0, beamH, R4 - param.E4));
-    figBeamHollow.addSecond(contourCircle4(0, beamH, R4));
+    figBeamHollow.addMain(contourCircle5(0, beamH, R4 - param.E4));
+    figBeamHollow.addSecond(contourCircle5(0, beamH, R4));
     figBeamHollow.addSecond(ctrHand);
-    figDisc.addMain(contourCircle4(0, 0, R1));
-    figDisc.addMain(contourCircle4(0, 0, R3));
+    figDisc.addMain(contourCircle5(0, 0, R1));
+    figDisc.addMain(contourCircle5(0, 0, R3));
     const posR = R3 + param.L1;
     const posA = 2 * Math.PI / param.N1;
     for (let i = 0; i < param.N1; i++) {
       const posX = posR * Math.cos(i * posA);
       const posY = posR * Math.sin(i * posA);
-      figDisc.addMain(contourCircle4(posX, posY, R7));
+      figDisc.addMain(contourCircle5(posX, posY, R7));
     }
-    figDisc.addSecond(contourCircle4(0, 0, R1 - param.E1));
-    figDisc.addSecond(contourCircle4(0, 0, R2));
+    figDisc.addSecond(contourCircle5(0, 0, R1 - param.E1));
+    figDisc.addSecond(contourCircle5(0, 0, R2));
     figDisc.addSecond(ctrRect(param.D4, beamL, -R4, -beamL / 2, 0));
     figDisc.addSecond(ctrRect(param.D4 - 2 * param.E4, beamL, -R4 + param.E4, -beamL / 2, 0));
     for (const posX of handPos) {
@@ -1912,13 +2525,13 @@ function pGeom4(t, param, suffix = "") {
       ctrRect(2 * wingHR, wingLx, -wingHR, -R1 + param.L8 * Math.tan(coneAngle) - wingLx, 0)
     );
     figHand.addMain(ctrHand);
-    figHand.addSecond(contourCircle4(0, beamH, R4));
-    figHand.addSecond(contourCircle4(0, beamH, R4 - param.E4));
-    figHand.addSecond(contourCircle4(0, beamH + param.H5, R5));
-    figWing.addMain(contourCircle4(0, 0, R6));
-    figWing.addMain(contourCircle4(0, 0, wingHR));
-    figWingHollow.addSecond(contourCircle4(0, 0, R6));
-    figWingHollow.addMain(contourCircle4(0, 0, wingHR));
+    figHand.addSecond(contourCircle5(0, beamH, R4));
+    figHand.addSecond(contourCircle5(0, beamH, R4 - param.E4));
+    figHand.addSecond(contourCircle5(0, beamH + param.H5, R5));
+    figWing.addMain(contourCircle5(0, 0, R6));
+    figWing.addMain(contourCircle5(0, 0, wingHR));
+    figWingHollow.addSecond(contourCircle5(0, 0, R6));
+    figWingHollow.addMain(contourCircle5(0, 0, wingHR));
     figDoor.addMain(ctrDoor);
     figDoor.addSecond(ctrConePlus(1));
     figDoor.addSecond(ctrConePlus(-1));
@@ -1950,7 +2563,7 @@ function pGeom4(t, param, suffix = "") {
       const rHand = {
         outName: `subpax_${designName}_hand_${idx}`,
         face: `${designName}_faceHand`,
-        extrudeMethod: EExtrude3.eLinearOrtho,
+        extrudeMethod: EExtrude4.eLinearOrtho,
         length: param.L4,
         rotate: [Math.PI / 2, 0, 0],
         translate: [0, -posX, 0]
@@ -1962,14 +2575,14 @@ function pGeom4(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_cone`,
           face: `${designName}_faceCone`,
-          extrudeMethod: EExtrude3.eRotate,
+          extrudeMethod: EExtrude4.eRotate,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
         },
         {
           outName: `subpax_${designName}_beam`,
           face: `${designName}_faceBeam`,
-          extrudeMethod: EExtrude3.eLinearOrtho,
+          extrudeMethod: EExtrude4.eLinearOrtho,
           length: beamL,
           rotate: [Math.PI / 2, 0, 0],
           translate: [0, beamL / 2, 0]
@@ -1977,7 +2590,7 @@ function pGeom4(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_beamHollow`,
           face: `${designName}_faceBeamHollow`,
-          extrudeMethod: EExtrude3.eLinearOrtho,
+          extrudeMethod: EExtrude4.eLinearOrtho,
           length: beamL,
           rotate: [Math.PI / 2, 0, 0],
           translate: [0, beamL / 2, 0]
@@ -1985,7 +2598,7 @@ function pGeom4(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_disc`,
           face: `${designName}_faceDisc`,
-          extrudeMethod: EExtrude3.eLinearOrtho,
+          extrudeMethod: EExtrude4.eLinearOrtho,
           length: param.E3,
           rotate: [0, 0, 0],
           translate: [0, 0, param.H1 - param.H3 - param.E3]
@@ -1993,7 +2606,7 @@ function pGeom4(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_wing_right`,
           face: `${designName}_faceWing`,
-          extrudeMethod: EExtrude3.eLinearOrtho,
+          extrudeMethod: EExtrude4.eLinearOrtho,
           length: wingL2,
           rotate: [-wingAngle, 0, 0],
           translate: [0, wingCPosX, wingCPosY]
@@ -2001,7 +2614,7 @@ function pGeom4(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_wing_left`,
           face: `${designName}_faceWing`,
-          extrudeMethod: EExtrude3.eLinearOrtho,
+          extrudeMethod: EExtrude4.eLinearOrtho,
           length: wingL2,
           rotate: [wingAngle, 0, 0],
           translate: [0, -wingCPosX, wingCPosY]
@@ -2009,7 +2622,7 @@ function pGeom4(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_wing_hollow_right`,
           face: `${designName}_faceWingHollow`,
-          extrudeMethod: EExtrude3.eLinearOrtho,
+          extrudeMethod: EExtrude4.eLinearOrtho,
           length: wingL2,
           rotate: [-wingAngle, 0, 0],
           translate: [0, wingCPosX, wingCPosY]
@@ -2017,7 +2630,7 @@ function pGeom4(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_wing_hollow_left`,
           face: `${designName}_faceWingHollow`,
-          extrudeMethod: EExtrude3.eLinearOrtho,
+          extrudeMethod: EExtrude4.eLinearOrtho,
           length: wingL2,
           rotate: [wingAngle, 0, 0],
           translate: [0, -wingCPosX, wingCPosY]
@@ -2025,7 +2638,7 @@ function pGeom4(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_door`,
           face: `${designName}_faceDoor`,
-          extrudeMethod: EExtrude3.eLinearOrtho,
+          extrudeMethod: EExtrude4.eLinearOrtho,
           length: param.D1,
           rotate: [Math.PI / 2, 0, Math.PI / 2],
           translate: [0, 0, 0]
@@ -2035,7 +2648,7 @@ function pGeom4(t, param, suffix = "") {
       volumes: [
         {
           outName: `ipax_${designName}_plus`,
-          boolMethod: EBVolume4.eUnion,
+          boolMethod: EBVolume5.eUnion,
           inList: [
             `subpax_${designName}_cone`,
             `subpax_${designName}_beam`,
@@ -2050,7 +2663,7 @@ function pGeom4(t, param, suffix = "") {
         },
         {
           outName: `ipax_${designName}_hollow`,
-          boolMethod: EBVolume4.eUnion,
+          boolMethod: EBVolume5.eUnion,
           inList: [
             `subpax_${designName}_beamHollow`,
             `subpax_${designName}_wing_hollow_right`,
@@ -2060,7 +2673,7 @@ function pGeom4(t, param, suffix = "") {
         },
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume4.eSubstraction,
+          boolMethod: EBVolume5.eSubstraction,
           inList: [`ipax_${designName}_plus`, `ipax_${designName}_hollow`]
         }
       ]
@@ -2076,41 +2689,44 @@ function pGeom4(t, param, suffix = "") {
 }
 var rakeDef = {
   pTitle: "Heliostat rake",
-  pDescription: "The rake on top of the pole-rotor of the heliostat",
-  pDef: pDef4,
-  pGeom: pGeom4
+  pDescription: "The rake on top of the V-Axis of the heliostat",
+  pDef: pDef5,
+  pGeom: pGeom5
 };
 
 // src/heliostat/spider.ts
 import {
-  contour as contour6,
-  contourCircle as contourCircle5,
-  figure as figure5,
-  radToDeg as radToDeg4,
-  ffix as ffix6,
-  pNumber as pNumber5,
-  initGeom as initGeom5,
-  EExtrude as EExtrude4,
-  EBVolume as EBVolume5
-} from "geometrix";
-var pDef5 = {
-  partName: "spider",
-  params: [
-    //pNumber(name, unit, init, min, max, step)
-    pNumber5("D1", "mm", 100, 1, 400, 1),
-    pNumber5("L1", "mm", 400, 1, 1e3, 1),
-    pNumber5("L2", "mm", 400, 1, 1e3, 1),
-    pNumber5("L3", "mm", 100, 1, 400, 1),
-    pNumber5("L4", "mm", 3e3, 10, 8e3, 10),
-    pNumber5("L5", "mm", 2e3, 1, 8e3, 1),
-    pNumber5("L6", "mm", 30, 1, 100, 1),
-    pNumber5("E1", "mm", 3, 1, 80, 1),
-    pNumber5("E2", "mm", 50, 1, 200, 1),
-    pNumber5("E3", "mm", 3, 1, 80, 1),
-    pNumber5("R2", "mm", 100, 0, 400, 10),
-    pNumber5("N1", "", 6, 1, 20, 1)
-  ],
-  paramSvg: {
+  contour as contour8,
+  contourCircle as contourCircle6,
+  figure as figure6,
+  radToDeg as radToDeg5,
+  ffix as ffix8,
+  pNumber as pNumber6,
+  pSectionSeparator as pSectionSeparator5,
+  initGeom as initGeom6,
+  EExtrude as EExtrude5,
+  EBVolume as EBVolume6
+} from "geometrix";
+var pDef6 = {
+  partName: "spider",
+  params: [
+    //pNumber(name, unit, init, min, max, step)
+    pNumber6("D1", "mm", 100, 1, 400, 1),
+    pNumber6("L1", "mm", 400, 1, 1e3, 1),
+    pNumber6("L2", "mm", 400, 1, 1e3, 1),
+    pNumber6("L3", "mm", 100, 1, 400, 1),
+    pNumber6("L4", "mm", 3e3, 10, 8e3, 10),
+    pSectionSeparator5("longitude"),
+    pNumber6("L5", "mm", 2e3, 1, 8e3, 1),
+    pNumber6("N1", "", 6, 1, 20, 1),
+    pNumber6("L6", "mm", 30, 1, 100, 1),
+    pSectionSeparator5("thickness"),
+    pNumber6("E1", "mm", 3, 1, 80, 1),
+    pNumber6("E2", "mm", 50, 1, 200, 1),
+    pNumber6("E3", "mm", 3, 1, 80, 1),
+    pNumber6("R2", "mm", 100, 0, 400, 10)
+  ],
+  paramSvg: {
     D1: "spider_profile.svg",
     L1: "spider_profile.svg",
     L2: "spider_profile.svg",
@@ -2131,13 +2747,13 @@ var pDef5 = {
     // every 0.5 second
   }
 };
-function pGeom5(t, param, suffix = "") {
-  const rGeome = initGeom5(pDef5.partName + suffix);
+function pGeom6(t, param, suffix = "") {
+  const rGeome = initGeom6(pDef6.partName + suffix);
   let ctrSquare;
   let ctrRect;
-  const figLegs = figure5();
-  const figTube = figure5();
-  const figBody = figure5();
+  const figLegs = figure6();
+  const figTube = figure6();
+  const figBody = figure6();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
@@ -2180,27 +2796,27 @@ function pGeom5(t, param, suffix = "") {
     }
     const legPos = [...Array(param.N1).keys()].map((i) => i * legStep);
     ctrSquare = function(sx, sy, sl) {
-      const rCtr = contour6(sx, sy).addSegStrokeA(sx + sl * Math.cos(Math.PI / 4), sy - sl * Math.sin(Math.PI / 4)).addSegStrokeA(sx, sy - 2 * sl * Math.sin(Math.PI / 4)).addSegStrokeA(sx - sl * Math.cos(Math.PI / 4), sy - sl * Math.sin(Math.PI / 4)).closeSegStroke();
+      const rCtr = contour8(sx, sy).addSegStrokeA(sx + sl * Math.cos(Math.PI / 4), sy - sl * Math.sin(Math.PI / 4)).addSegStrokeA(sx, sy - 2 * sl * Math.sin(Math.PI / 4)).addSegStrokeA(sx - sl * Math.cos(Math.PI / 4), sy - sl * Math.sin(Math.PI / 4)).closeSegStroke();
       return rCtr;
     };
     ctrRect = function(width, height, xpos, ypos) {
-      const rCtr = contour6(xpos, ypos).addSegStrokeA(xpos + width, ypos).addSegStrokeA(xpos + width, ypos + height).addSegStrokeA(xpos, ypos + height).closeSegStroke();
+      const rCtr = contour8(xpos, ypos).addSegStrokeA(xpos + width, ypos).addSegStrokeA(xpos + width, ypos + height).addSegStrokeA(xpos, ypos + height).closeSegStroke();
       return rCtr;
     };
-    const posAngle = Math.sin(2 * Math.PI * t / pDef5.sim.tMax) * Math.PI / 2;
+    const posAngle = Math.sin(2 * Math.PI * t / pDef6.sim.tMax) * Math.PI / 2;
     rGeome.logstr += `spide leg number: ${param.N1}
 `;
-    rGeome.logstr += `spide position angle: ${ffix6(radToDeg4(posAngle))} degree
+    rGeome.logstr += `spide position angle: ${ffix8(radToDeg5(posAngle))} degree
 `;
-    const ctrLeg = contour6(legE2, -legStartY).addCornerRounded(param.R2).addSegStrokeA(legE2, -param.L1).addCornerRounded(param.R2).addSegStrokeA(legL2, -param.L1).addCornerRounded(param.R2 + param.E2).addSegStrokeA(legL2 + legL4x, -param.L1 - legL4y).addSegStrokeA(legL2 + legL4x - E2x, -param.L1 - legL4y - E2y).addSegStrokeA(legL2 - elbowx, -param.L1 - param.E2).addCornerRounded(param.R2).addSegStrokeA(-legL2 + elbowx, -param.L1 - param.E2).addCornerRounded(param.R2).addSegStrokeA(-legL2 - legL4x + E2x, -param.L1 - legL4y - E2y).addSegStrokeA(-legL2 - legL4x, -param.L1 - legL4y).addSegStrokeA(-legL2, -param.L1).addCornerRounded(param.R2 + param.E2).addSegStrokeA(-legE2, -param.L1).addCornerRounded(param.R2).addSegStrokeA(-legE2, -legStartY).addCornerRounded(param.R2).closeSegArc(R1, true, false);
+    const ctrLeg = contour8(legE2, -legStartY).addCornerRounded(param.R2).addSegStrokeA(legE2, -param.L1).addCornerRounded(param.R2).addSegStrokeA(legL2, -param.L1).addCornerRounded(param.R2 + param.E2).addSegStrokeA(legL2 + legL4x, -param.L1 - legL4y).addSegStrokeA(legL2 + legL4x - E2x, -param.L1 - legL4y - E2y).addSegStrokeA(legL2 - elbowx, -param.L1 - param.E2).addCornerRounded(param.R2).addSegStrokeA(-legL2 + elbowx, -param.L1 - param.E2).addCornerRounded(param.R2).addSegStrokeA(-legL2 - legL4x + E2x, -param.L1 - legL4y - E2y).addSegStrokeA(-legL2 - legL4x, -param.L1 - legL4y).addSegStrokeA(-legL2, -param.L1).addCornerRounded(param.R2 + param.E2).addSegStrokeA(-legE2, -param.L1).addCornerRounded(param.R2).addSegStrokeA(-legE2, -legStartY).addCornerRounded(param.R2).closeSegArc(R1, true, false);
     figLegs.addMain(ctrLeg);
-    figLegs.addMain(contourCircle5(0, 0, R1 - param.E1));
+    figLegs.addMain(contourCircle6(0, 0, R1 - param.E1));
     figLegs.addSecond(ctrSquare(squareX, squareY, param.L3));
     figLegs.addSecond(ctrSquare(squareX, squareY2, param.L3 - 2 * param.E3));
     figLegs.addSecond(ctrSquare(-squareX, squareY, param.L3));
     figLegs.addSecond(ctrSquare(-squareX, squareY2, param.L3 - 2 * param.E3));
-    figTube.addMain(contourCircle5(0, 0, R1));
-    figTube.addMain(contourCircle5(0, 0, R1 - param.E1));
+    figTube.addMain(contourCircle6(0, 0, R1));
+    figTube.addMain(contourCircle6(0, 0, R1 - param.E1));
     figTube.addMain(ctrSquare(squareX, squareY, param.L3));
     figTube.addMain(ctrSquare(squareX, squareY2, param.L3 - 2 * param.E3));
     figTube.addMain(ctrSquare(-squareX, squareY, param.L3));
@@ -2221,7 +2837,7 @@ function pGeom5(t, param, suffix = "") {
       const rElem = {
         outName: `subpax_${designName}_leg_${idx}`,
         face: `${designName}_faceLegs`,
-        extrudeMethod: EExtrude4.eLinearOrtho,
+        extrudeMethod: EExtrude5.eLinearOrtho,
         length: param.L6,
         rotate: [0, 0, 0],
         translate: [0, 0, posX]
@@ -2237,7 +2853,7 @@ function pGeom5(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_tube`,
           face: `${designName}_faceTube`,
-          extrudeMethod: EExtrude4.eLinearOrtho,
+          extrudeMethod: EExtrude5.eLinearOrtho,
           length: param.L5,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
@@ -2247,7 +2863,7 @@ function pGeom5(t, param, suffix = "") {
       volumes: [
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume5.eUnion,
+          boolMethod: EBVolume6.eUnion,
           inList: [`subpax_${designName}_tube`, ...legList]
         }
       ]
@@ -2264,43 +2880,52 @@ function pGeom5(t, param, suffix = "") {
 var spiderDef = {
   pTitle: "Heliostat spider",
   pDescription: "The spider part for the control of the inclination of the heliostat",
-  pDef: pDef5,
-  pGeom: pGeom5
+  pDef: pDef6,
+  pGeom: pGeom6
 };
 
 // src/heliostat/swing.ts
 import {
-  contour as contour7,
-  contourCircle as contourCircle6,
-  figure as figure6,
-  ffix as ffix7,
-  pNumber as pNumber6,
-  initGeom as initGeom6,
-  EExtrude as EExtrude5,
-  EBVolume as EBVolume6
+  point as point5,
+  contour as contour9,
+  contourCircle as contourCircle7,
+  ctrRectangle,
+  figure as figure7,
+  ffix as ffix9,
+  pNumber as pNumber7,
+  pSectionSeparator as pSectionSeparator6,
+  initGeom as initGeom7,
+  EExtrude as EExtrude6,
+  EBVolume as EBVolume7
 } from "geometrix";
-var pDef6 = {
+var pDef7 = {
   partName: "swing",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber6("L1", "mm", 12500, 100, 4e4, 10),
-    pNumber6("L2", "mm", 6e3, 100, 4e4, 10),
-    pNumber6("L3", "mm", 500, 1, 4e3, 1),
-    pNumber6("L4", "mm", 600, 1, 4e3, 1),
-    pNumber6("L5", "mm", 2e3, 1, 1e4, 1),
-    pNumber6("L6", "mm", 2e3, 1, 1e4, 1),
-    pNumber6("D1", "mm", 400, 1, 1e3, 1),
-    pNumber6("H1", "mm", 100, 1, 400, 1),
-    pNumber6("H2", "mm", 100, 1, 400, 1),
-    pNumber6("H3", "mm", 100, 1, 400, 1),
-    pNumber6("H4", "mm", 100, 1, 400, 1),
-    pNumber6("E1", "mm", 5, 1, 80, 1),
-    pNumber6("E2", "mm", 3, 1, 80, 1),
-    pNumber6("E3", "mm", 3, 1, 80, 1),
-    pNumber6("rod1", "", 10, 1, 40, 1),
-    pNumber6("rod2", "mm", 1300, 10, 4e3, 10),
-    pNumber6("rod3", "mm", 400, 10, 1e3, 10),
-    pNumber6("rod4", "mm", 100, 1, 400, 1)
+    pNumber7("L1", "mm", 12500, 100, 4e4, 10),
+    pNumber7("L2", "mm", 6e3, 100, 4e4, 10),
+    pSectionSeparator6("radial"),
+    pNumber7("D1", "mm", 400, 1, 1e3, 1),
+    pNumber7("E1", "mm", 5, 1, 80, 1),
+    pNumber7("H2", "mm", 100, 1, 400, 1),
+    pNumber7("H4", "mm", 100, 1, 400, 1),
+    pNumber7("E2", "mm", 3, 1, 80, 1),
+    pNumber7("L3", "mm", 500, 1, 4e3, 1),
+    pSectionSeparator6("radial"),
+    pNumber7("L4", "mm", 600, 1, 4e3, 1),
+    pNumber7("L5", "mm", 2e3, 1, 1e4, 1),
+    pNumber7("L6", "mm", 2e3, 1, 1e4, 1),
+    pNumber7("H1", "mm", 100, 1, 400, 1),
+    pNumber7("H3", "mm", 100, 1, 400, 1),
+    pNumber7("E3", "mm", 3, 1, 80, 1),
+    pSectionSeparator6("buttress"),
+    pNumber7("S1", "mm", 300, 0, 1e3, 1),
+    pNumber7("R2", "mm", 100, 0, 1e3, 1),
+    pSectionSeparator6("rod overlay"),
+    pNumber7("rod1", "", 10, 1, 40, 1),
+    pNumber7("rod2", "mm", 1300, 10, 4e3, 10),
+    pNumber7("rod3", "mm", 400, 10, 1e3, 10),
+    pNumber7("rod4", "mm", 100, 1, 400, 1)
   ],
   paramSvg: {
     L1: "swing_top.svg",
@@ -2317,6 +2942,8 @@ var pDef6 = {
     E1: "swing_side.svg",
     E2: "swing_side.svg",
     E3: "swing_face.svg",
+    S1: "swing_buttress.svg",
+    R2: "swing_buttress.svg",
     rod1: "swing_with_rod.svg",
     rod2: "swing_with_rod.svg",
     rod3: "swing_with_rod.svg",
@@ -2329,30 +2956,21 @@ var pDef6 = {
     // every 0.5 second
   }
 };
-function pGeom6(t, param, suffix = "") {
-  const rGeome = initGeom6(pDef6.partName + suffix);
-  let ctrRectangle;
-  let ctrRectRound;
-  const figSide = figure6();
-  const figFace = figure6();
-  const figTop = figure6();
-  const figTopWithRod = figure6();
+function pGeom7(t, param, suffix = "") {
+  const rGeome = initGeom7(pDef7.partName + suffix);
+  const figSide = figure7();
+  const figFace = figure7();
+  const figTop = figure7();
+  const figButtress = figure7();
+  const figTopWithRod = figure7();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
     const R1 = param.D1 / 2;
-    rGeome.logstr += `swing size: L1 ${ffix7(param.L1)} x L2 ${ffix7(param.L2)} mm
+    rGeome.logstr += `swing size: L1 ${ffix9(param.L1)} x L2 ${ffix9(param.L2)} mm
 `;
-    ctrRectangle = function(px, py, lx, ly) {
-      const rRect = contour7(px, py).addSegStrokeA(px + lx, py).addSegStrokeA(px + lx, py + ly).addSegStrokeA(px, py + ly).closeSegStroke();
-      return rRect;
-    };
-    ctrRectRound = function(px, py, lx, ly, round) {
-      const rRect = contour7(px, py).addCornerRounded(round).addSegStrokeA(px + lx, py).addCornerRounded(round).addSegStrokeA(px + lx, py + ly).addCornerRounded(round).addSegStrokeA(px, py + ly).addCornerRounded(round).closeSegStroke();
-      return rRect;
-    };
-    figSide.addMain(contourCircle6(0, 0, R1));
-    figSide.addMain(contourCircle6(0, 0, R1 - param.E1));
+    figSide.addMain(contourCircle7(0, 0, R1));
+    figSide.addMain(contourCircle7(0, 0, R1 - param.E1));
     const sidePx = [-param.L2 / 2, -param.L3 - param.H2, param.L3, param.L2 / 2 - param.H2];
     for (const px of sidePx) {
       figSide.addMain(ctrRectangle(px, R1 - param.H4, param.H2, param.H4));
@@ -2399,6 +3017,14 @@ function pGeom6(t, param, suffix = "") {
       figTop.addSecond(ctrRectangle(-param.L1 / 2, py, param.L1, param.H2));
     }
     figTop.addSecond(ctrRectangle(-param.L1 / 2, -R1, param.L1, param.D1));
+    const aBAC = Math.atan2(param.S1, R1);
+    const aDAB = 2 * aBAC;
+    const pA = point5(0, 0);
+    const pB = point5(0, R1);
+    const pD = pB.rotate(pA, aDAB);
+    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));
     for (const px of facePx) {
       figTopWithRod.addMain(ctrRectangle(px, -param.L2 / 2, param.H1, param.L2));
     }
@@ -2417,7 +3043,7 @@ function pGeom6(t, param, suffix = "") {
       figTopWithRod.addSecond(ctrRectangle(px + rodOffset, rodPy0, param.rod4, rodLength));
       for (let j = 0; j < 4; j++) {
         figTopWithRod.addSecond(
-          ctrRectRound(px, rodPy0 + j * rodPyStep, param.rod3, rodPlateH, rodPlateH / 4)
+          ctrRectangle(px, rodPy0 + j * rodPyStep, param.rod3, rodPlateH, rodPlateH / 4)
         );
       }
     }
@@ -2425,6 +3051,7 @@ function pGeom6(t, param, suffix = "") {
       faceSide: figSide,
       faceFace: figFace,
       faceTop: figTop,
+      faceButtress: figButtress,
       faceTopWithRods: figTopWithRod
     };
     const designName = rGeome.partName;
@@ -2433,7 +3060,7 @@ function pGeom6(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_side`,
           face: `${designName}_faceSide`,
-          extrudeMethod: EExtrude5.eLinearOrtho,
+          extrudeMethod: EExtrude6.eLinearOrtho,
           length: param.L1,
           rotate: [0, 0, 0],
           translate: [0, 0, -param.L1 / 2]
@@ -2441,7 +3068,7 @@ function pGeom6(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_face`,
           face: `${designName}_faceFace`,
-          extrudeMethod: EExtrude5.eLinearOrtho,
+          extrudeMethod: EExtrude6.eLinearOrtho,
           length: param.L2,
           rotate: [0, Math.PI / 2, 0],
           translate: [-param.L2 / 2, 0, 0]
@@ -2450,7 +3077,7 @@ function pGeom6(t, param, suffix = "") {
       volumes: [
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume6.eUnion,
+          boolMethod: EBVolume7.eUnion,
           inList: [`subpax_${designName}_side`, `subpax_${designName}_face`]
         }
       ]
@@ -2467,47 +3094,52 @@ function pGeom6(t, param, suffix = "") {
 var swingDef = {
   pTitle: "Heliostat swing",
   pDescription: "The swing for the heliostat inclination",
-  pDef: pDef6,
-  pGeom: pGeom6
+  pDef: pDef7,
+  pGeom: pGeom7
 };
 
 // src/heliostat/heliostat.ts
-var pDef7 = {
+var pDef8 = {
   partName: "heliostat",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber7("H1", "mm", 3e3, 10, 4e4, 10),
-    pNumber7("H2", "mm", 2500, 50, 4e4, 10),
-    pNumber7("H3", "mm", 200, 1, 500, 1),
-    pNumber7("H4", "mm", 800, 1, 4e3, 1),
-    pNumber7("H5", "mm", 3e3, 50, 6e3, 10),
-    pNumber7("H6", "mm", 200, 1, 4e3, 1),
-    pNumber7("H7", "mm", 800, 1, 4e3, 1),
-    pNumber7("H8", "mm", 200, 1, 4e3, 1),
-    pNumber7("H9", "mm", 100, 1, 400, 1),
-    pNumber7("D1", "mm", 1e3, 20, 4e3, 10),
-    pNumber7("D2", "mm", 700, 20, 4e3, 10),
-    pNumber7("D3", "mm", 900, 20, 4e3, 10),
-    pNumber7("D4", "mm", 400, 20, 4e3, 10),
-    pNumber7("D5", "mm", 300, 20, 1e3, 10),
-    pNumber7("D6", "mm", 200, 10, 1e3, 10),
-    pNumber7("D7", "mm", 400, 10, 1e3, 10),
-    pNumber7("D8", "mm", 100, 1, 1e3, 1),
-    pNumber7("D9", "mm", 100, 1, 1e3, 1),
-    pNumber7("S1", "mm", 250, 1, 800, 1),
-    pNumber7("S2", "mm", 200, 1, 800, 1),
-    pNumber7("E1", "mm", 30, 1, 80, 1),
-    pNumber7("E2", "mm", 50, 1, 80, 1),
-    pNumber7("L1", "mm", 12500, 100, 4e4, 10),
-    pNumber7("L2", "mm", 6e3, 100, 4e4, 10),
-    pNumber7("L3", "mm", 100, 1, 500, 1),
-    pNumber7("L4", "mm", 600, 1, 4e3, 1),
-    pNumber7("L5", "mm", 2e3, 10, 6e3, 1),
-    pNumber7("L6", "mm", 2e3, 1, 6e3, 1),
-    pNumber7("L7", "mm", 100, 1, 1e3, 1),
-    pNumber7("L8", "mm", 200, 1, 1e3, 1),
-    pNumber7("al", "degree", 80, 0, 95, 1),
-    pNumber7("ar", "degree", 80, 0, 95, 1)
+    pNumber8("H1", "mm", 3e3, 10, 4e4, 10),
+    pNumber8("H2", "mm", 2500, 50, 4e4, 10),
+    pNumber8("D1", "mm", 1e3, 20, 4e3, 10),
+    pNumber8("D2", "mm", 700, 20, 4e3, 10),
+    pNumber8("E1", "mm", 30, 1, 80, 1),
+    pSectionSeparator7("rake"),
+    pNumber8("H3", "mm", 200, 1, 500, 1),
+    pNumber8("H4", "mm", 800, 1, 4e3, 1),
+    pNumber8("H5", "mm", 3e3, 50, 6e3, 10),
+    pNumber8("H6", "mm", 200, 1, 4e3, 1),
+    pNumber8("H7", "mm", 800, 1, 4e3, 1),
+    pNumber8("H8", "mm", 200, 1, 4e3, 1),
+    pNumber8("D3", "mm", 900, 20, 4e3, 10),
+    pNumber8("D4", "mm", 400, 20, 4e3, 10),
+    pNumber8("D5", "mm", 300, 20, 1e3, 10),
+    pNumber8("D6", "mm", 200, 10, 1e3, 10),
+    pNumber8("D7", "mm", 400, 10, 1e3, 10),
+    pSectionSeparator7("rake diagonal"),
+    pNumber8("D9", "mm", 100, 1, 1e3, 1),
+    pNumber8("L7", "mm", 100, 1, 1e3, 1),
+    pNumber8("L8", "mm", 200, 1, 1e3, 1),
+    pSectionSeparator7("spider"),
+    pNumber8("D8", "mm", 100, 1, 1e3, 1),
+    pNumber8("S1", "mm", 250, 1, 800, 1),
+    pNumber8("S2", "mm", 200, 1, 800, 1),
+    pNumber8("E2", "mm", 50, 1, 80, 1),
+    pSectionSeparator7("swing"),
+    pNumber8("L1", "mm", 12500, 100, 4e4, 10),
+    pNumber8("L2", "mm", 6e3, 100, 4e4, 10),
+    pNumber8("L3", "mm", 100, 1, 500, 1),
+    pNumber8("L4", "mm", 600, 1, 4e3, 1),
+    pNumber8("L5", "mm", 2e3, 10, 6e3, 1),
+    pNumber8("L6", "mm", 2e3, 1, 6e3, 1),
+    pNumber8("H9", "mm", 100, 1, 400, 1),
+    pSectionSeparator7("motion amplitude"),
+    pNumber8("al", "degree", 80, 0, 95, 1),
+    pNumber8("ar", "degree", 80, 0, 95, 1)
   ],
   paramSvg: {
     H1: "heliostat_overview.svg",
@@ -2550,30 +3182,30 @@ var pDef7 = {
     // every 0.5 second
   }
 };
-function pGeom7(t, param, suffix = "") {
-  const rGeome = initGeom7(pDef7.partName + suffix);
-  const figSide = figure7();
-  const figFace = figure7();
+function pGeom8(t, param, suffix = "") {
+  const rGeome = initGeom8(pDef8.partName + suffix);
+  const figSide = figure8();
+  const figFace = figure8();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
     const helioHeight = param.H1 + param.H2 - param.H3 + param.H4 + param.H5 - param.H6 + param.H7;
-    rGeome.logstr += `heliostat-height: ${ffix8(helioHeight)}, diameter ${ffix8(param.D1)} m
+    rGeome.logstr += `heliostat-height: ${ffix10(helioHeight)}, diameter ${ffix10(param.D1)} m
 `;
-    rGeome.logstr += `heliostat-swing-length: ${ffix8(param.L1)}, width ${ffix8(param.L2)} m
+    rGeome.logstr += `heliostat-swing-length: ${ffix10(param.L1)}, width ${ffix10(param.L2)} m
 `;
     const posAngleMid = (param.al - param.ar) / 2;
-    const posAngleDegree = posAngleMid - Math.sin(2 * Math.PI * t / pDef7.sim.tMax) * (param.al + param.ar) / 2;
-    const posAngle = degToRad2(posAngleDegree);
-    rGeome.logstr += `swing position angle: ${ffix8(radToDeg5(posAngle))} degree
+    const posAngleDegree = posAngleMid - Math.sin(2 * Math.PI * t / pDef8.sim.tMax) * (param.al + param.ar) / 2;
+    const posAngle = degToRad4(posAngleDegree);
+    rGeome.logstr += `swing position angle: ${ffix10(radToDeg6(posAngle))} degree
 `;
     const rakePosY = param.H1 + param.H2 - param.H3;
     const spiderPosY = rakePosY + param.H4 + param.H5 - param.H6 + param.H7;
     const swingPosY = spiderPosY + param.H8;
-    const poleStaticParam = designParam2(poleStaticDef.pDef);
-    const rakeParam = designParam2(rakeDef.pDef);
-    const spiderParam = designParam2(spiderDef.pDef);
-    const swingParam = designParam2(swingDef.pDef);
+    const poleStaticParam = designParam3(poleStaticDef.pDef);
+    const rakeParam = designParam3(rakeDef.pDef);
+    const spiderParam = designParam3(spiderDef.pDef);
+    const swingParam = designParam3(swingDef.pDef);
     poleStaticParam.setVal("H1", param.H1);
     poleStaticParam.setVal("H2", param.H2);
     poleStaticParam.setVal("D1", param.D1);
@@ -2591,6 +3223,7 @@ function pGeom7(t, param, suffix = "") {
     poleStaticParam.setVal("D4", param.H1 / 4);
     poleStaticParam.setVal("L2", param.H1 / 80);
     poleStaticParam.setVal("E3", param.H1 / 80);
+    poleStaticParam.setVal("holders", 0);
     rakeParam.setVal("H1", param.H4);
     rakeParam.setVal("H2", param.H5);
     rakeParam.setVal("H3", param.H4 - 2 * param.E1);
@@ -2664,17 +3297,17 @@ function pGeom7(t, param, suffix = "") {
       poleStaticParam.getParamVal(),
       poleStaticParam.getSuffix()
     );
-    checkGeom2(poleStaticGeom);
-    rGeome.logstr += prefixLog2(poleStaticGeom.logstr, poleStaticParam.getPartNameSuffix());
+    checkGeom3(poleStaticGeom);
+    rGeome.logstr += prefixLog3(poleStaticGeom.logstr, poleStaticParam.getPartNameSuffix());
     const rakeGeom = rakeDef.pGeom(0, rakeParam.getParamVal(), rakeParam.getSuffix());
-    checkGeom2(rakeGeom);
-    rGeome.logstr += prefixLog2(rakeGeom.logstr, rakeParam.getPartNameSuffix());
+    checkGeom3(rakeGeom);
+    rGeome.logstr += prefixLog3(rakeGeom.logstr, rakeParam.getPartNameSuffix());
     const spiderGeom = spiderDef.pGeom(0, spiderParam.getParamVal(), spiderParam.getSuffix());
-    checkGeom2(spiderGeom);
-    rGeome.logstr += prefixLog2(spiderGeom.logstr, spiderParam.getPartNameSuffix());
+    checkGeom3(spiderGeom);
+    rGeome.logstr += prefixLog3(spiderGeom.logstr, spiderParam.getPartNameSuffix());
     const swingGeom = swingDef.pGeom(0, swingParam.getParamVal(), swingParam.getSuffix());
-    checkGeom2(swingGeom);
-    rGeome.logstr += prefixLog2(swingGeom.logstr, swingParam.getPartNameSuffix());
+    checkGeom3(swingGeom);
+    rGeome.logstr += prefixLog3(swingGeom.logstr, swingParam.getPartNameSuffix());
     figSide.mergeFigure(poleStaticGeom.fig.poleCut);
     figSide.mergeFigure(rakeGeom.fig.faceBeam.translate(0, rakePosY));
     figSide.mergeFigure(
@@ -2727,7 +3360,7 @@ function pGeom7(t, param, suffix = "") {
       volumes: [
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume7.eUnion,
+          boolMethod: EBVolume8.eUnion,
           inList: [
             `inpax_${designName}_poleStatic`,
             `inpax_${designName}_rake`,
@@ -2778,74 +3411,81 @@ function pGeom7(t, param, suffix = "") {
 var heliostatDef = {
   pTitle: "Heliostat overview",
   pDescription: "The heliostat inclination mechanism",
-  pDef: pDef7,
-  pGeom: pGeom7
+  pDef: pDef8,
+  pGeom: pGeom8
 };
 
 // src/heliostat/heliostat_2.ts
+import {
+  designParam as designParam5,
+  checkGeom as checkGeom5,
+  prefixLog as prefixLog5,
+  figure as figure10,
+  degToRad as degToRad5,
+  radToDeg as radToDeg8,
+  ffix as ffix12,
+  pNumber as pNumber10,
+  pSectionSeparator as pSectionSeparator9,
+  initGeom as initGeom10,
+  EBVolume as EBVolume10
+} from "geometrix";
+
+// src/heliostat/rake_stopper.ts
 import {
   designParam as designParam4,
   checkGeom as checkGeom4,
   prefixLog as prefixLog4,
+  contour as contour10,
+  contourCircle as contourCircle8,
   figure as figure9,
-  degToRad as degToRad3,
   radToDeg as radToDeg7,
-  ffix as ffix10,
+  ffix as ffix11,
   pNumber as pNumber9,
+  pSectionSeparator as pSectionSeparator8,
   initGeom as initGeom9,
+  EExtrude as EExtrude7,
   EBVolume as EBVolume9
 } from "geometrix";
-
-// src/heliostat/rake_stopper.ts
-import {
-  designParam as designParam3,
-  checkGeom as checkGeom3,
-  prefixLog as prefixLog3,
-  contour as contour8,
-  contourCircle as contourCircle7,
-  figure as figure8,
-  radToDeg as radToDeg6,
-  ffix as ffix9,
-  pNumber as pNumber8,
-  initGeom as initGeom8,
-  EExtrude as EExtrude6,
-  EBVolume as EBVolume8
-} from "geometrix";
-var pDef8 = {
+var pDef9 = {
   partName: "rake_stopper",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber8("D1", "mm", 600, 10, 4e3, 10),
-    pNumber8("D2", "mm", 400, 10, 4e3, 10),
-    pNumber8("D3", "mm", 400, 1, 4e3, 1),
-    pNumber8("H1", "mm", 800, 1, 4e3, 1),
-    pNumber8("H2", "mm", 3e3, 20, 6e3, 10),
-    pNumber8("H3", "mm", 400, 0, 4e3, 1),
-    pNumber8("E1", "mm", 20, 1, 80, 1),
-    pNumber8("E3", "mm", 30, 1, 80, 1),
-    pNumber8("H4", "mm", 200, 1, 1e3, 1),
-    pNumber8("D4", "mm", 300, 1, 1e3, 1),
-    pNumber8("E4", "mm", 20, 1, 80, 1),
-    pNumber8("H5", "mm", 400, 1, 2e3, 1),
-    pNumber8("D5", "mm", 200, 1, 1e3, 1),
-    pNumber8("L4", "mm", 300, 1, 1e3, 1),
-    pNumber8("L5", "mm", 2e3, 1, 4e3, 1),
-    pNumber8("L6", "mm", 2e3, 1, 4e3, 1),
-    pNumber8("D6", "mm", 100, 1, 600, 1),
-    pNumber8("E6", "mm", 10, 1, 80, 1),
-    pNumber8("L7", "mm", 100, 1, 1e3, 1),
-    pNumber8("L8", "mm", 200, 1, 1e3, 1),
-    pNumber8("N1", "", 24, 3, 100, 1),
-    pNumber8("D7", "mm", 40, 1, 100, 1),
-    pNumber8("L1", "mm", 30, 1, 300, 1),
-    pNumber8("D8", "mm", 400, 1, 1e3, 1),
-    pNumber8("H6", "mm", 100, 1, 1e3, 1),
-    pNumber8("H7", "mm", 600, 1, 2e3, 1),
-    pNumber8("L9", "mm", 300, 1, 1e3, 1),
-    pNumber8("R9", "mm", 50, 0, 300, 1),
-    pNumber8("S1", "mm", 100, 1, 300, 1),
-    pNumber8("S2", "mm", 2e3, 1, 8e3, 1),
-    pNumber8("E7", "mm", 5, 1, 80, 1)
+    pNumber9("D1", "mm", 600, 10, 4e3, 10),
+    pNumber9("D2", "mm", 400, 10, 4e3, 10),
+    pNumber9("D3", "mm", 400, 1, 4e3, 1),
+    pNumber9("H1", "mm", 800, 1, 4e3, 1),
+    pNumber9("H2", "mm", 3e3, 20, 6e3, 10),
+    pNumber9("H3", "mm", 400, 0, 4e3, 1),
+    pNumber9("E1", "mm", 20, 1, 80, 1),
+    pNumber9("E3", "mm", 30, 1, 80, 1),
+    pSectionSeparator8("transversal"),
+    pNumber9("H4", "mm", 200, 1, 1e3, 1),
+    pNumber9("D4", "mm", 300, 1, 1e3, 1),
+    pNumber9("E4", "mm", 20, 1, 80, 1),
+    pNumber9("H5", "mm", 400, 1, 2e3, 1),
+    pNumber9("D5", "mm", 200, 1, 1e3, 1),
+    pNumber9("L4", "mm", 300, 1, 1e3, 1),
+    pNumber9("L5", "mm", 2e3, 1, 4e3, 1),
+    pNumber9("L6", "mm", 2e3, 1, 4e3, 1),
+    pNumber9("D8", "mm", 400, 1, 1e3, 1),
+    pSectionSeparator8("diagonal"),
+    pNumber9("D6", "mm", 100, 1, 600, 1),
+    pNumber9("E6", "mm", 10, 1, 80, 1),
+    pNumber9("L7", "mm", 100, 1, 1e3, 1),
+    pNumber9("L8", "mm", 200, 1, 1e3, 1),
+    pSectionSeparator8("base"),
+    pNumber9("N1", "", 24, 3, 100, 1),
+    pNumber9("D7", "mm", 40, 1, 100, 1),
+    pNumber9("L1", "mm", 30, 1, 300, 1),
+    pSectionSeparator8("door"),
+    pNumber9("H6", "mm", 100, 1, 1e3, 1),
+    pNumber9("H7", "mm", 600, 1, 2e3, 1),
+    pNumber9("L9", "mm", 300, 1, 1e3, 1),
+    pNumber9("R9", "mm", 50, 0, 300, 1),
+    pSectionSeparator8("stopper"),
+    pNumber9("S1", "mm", 100, 1, 300, 1),
+    pNumber9("S2", "mm", 2e3, 1, 8e3, 1),
+    pNumber9("E7", "mm", 5, 1, 80, 1)
   ],
   paramSvg: {
     D1: "rake_face.svg",
@@ -2887,33 +3527,33 @@ var pDef8 = {
     // every 0.5 second
   }
 };
-function pGeom8(t, param, suffix = "") {
-  const rGeome = initGeom8(pDef8.partName + suffix);
+function pGeom9(t, param, suffix = "") {
+  const rGeome = initGeom9(pDef9.partName + suffix);
   let ctrRect;
-  const figCone = figure8();
-  const figBeam = figure8();
-  const figBeamHollow = figure8();
-  const figDisc = figure8();
-  const figHand = figure8();
-  const figWing = figure8();
-  const figWingHollow = figure8();
-  const figDoor = figure8();
-  const figStopperTop = figure8();
-  const figStopperSide = figure8();
-  const figStopperSideH = figure8();
-  const figStopperFaceT = figure8();
-  const figStopperFaceTH = figure8();
-  const figStopperFaceB = figure8();
-  const figStopperFaceBH = figure8();
+  const figCone = figure9();
+  const figBeam = figure9();
+  const figBeamHollow = figure9();
+  const figDisc = figure9();
+  const figHand = figure9();
+  const figWing = figure9();
+  const figWingHollow = figure9();
+  const figDoor = figure9();
+  const figStopperTop = figure9();
+  const figStopperSide = figure9();
+  const figStopperSideH = figure9();
+  const figStopperFaceT = figure9();
+  const figStopperFaceTH = figure9();
+  const figStopperFaceB = figure9();
+  const figStopperFaceBH = 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: ${ffix9(H1H2)} mm
+    rGeome.logstr += `cone-height: ${ffix11(H1H2)} mm
 `;
-    rGeome.logstr += `cone-height total: ${ffix9(H1H5)} mm
+    rGeome.logstr += `cone-height total: ${ffix11(H1H5)} mm
 `;
     if (2 * param.E7 >= param.S1) {
       throw `err135: E7 ${param.E7} too large compare to S1 ${param.S1}`;
@@ -2923,7 +3563,7 @@ function pGeom8(t, param, suffix = "") {
     }
     const stopper1H = H1H5 - param.S2;
     if (stopper1H < 0) {
-      throw `err143: S2 ${param.S2} too large compare to H1H5 ${ffix9(H1H5)}`;
+      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;
@@ -2932,10 +3572,10 @@ function pGeom8(t, param, suffix = "") {
       const yWidth = width * Math.sin(angle);
       const xHeight = -height * Math.sin(angle);
       const yHeight = height * Math.cos(angle);
-      const rCtr = contour8(xpos, ypos).addSegStrokeA(xpos + xWidth, ypos + yWidth).addSegStrokeA(xpos + xWidth + xHeight, ypos + yWidth + yHeight).addSegStrokeA(xpos + xHeight, ypos + yHeight).closeSegStroke();
+      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;
     };
-    const rakeParam = designParam3(rakeDef.pDef);
+    const rakeParam = designParam4(rakeDef.pDef);
     rakeParam.setVal("D1", param.D1);
     rakeParam.setVal("D2", param.D2);
     rakeParam.setVal("D3", param.D3);
@@ -2965,8 +3605,8 @@ function pGeom8(t, param, suffix = "") {
     rakeParam.setVal("L9", param.L9);
     rakeParam.setVal("R9", param.R9);
     const rakeGeom = rakeDef.pGeom(0, rakeParam.getParamVal(), rakeParam.getSuffix());
-    checkGeom3(rakeGeom);
-    rGeome.logstr += prefixLog3(rakeGeom.logstr, rakeParam.getPartNameSuffix());
+    checkGeom4(rakeGeom);
+    rGeome.logstr += prefixLog4(rakeGeom.logstr, rakeParam.getPartNameSuffix());
     figCone.mergeFigure(rakeGeom.fig.faceCone);
     figBeam.mergeFigure(rakeGeom.fig.faceBeam);
     figBeamHollow.mergeFigure(rakeGeom.fig.faceBeamHollow);
@@ -2994,17 +3634,17 @@ function pGeom8(t, param, suffix = "") {
     figStopperTop.addMain(ctrRect(S2s, param.S1, 0, R1, 0));
     figStopperTop.addMain(ctrRect(S2s, S1h, 0, R1 + param.E7, 0));
     figStopperSide.mergeFigure(rakeGeom.fig.faceBeam, true);
-    figStopperSide.addMain(contourCircle7(-R1 - S1r, stopper1H + S1r, S1r));
-    figStopperSide.addMain(contourCircle7(-R1 - S1r, stopper1H + S1r, S1hr));
-    figStopperSide.addMain(contourCircle7(param.S2 - S1r, stopper2H + S1r, S1r));
-    figStopperSide.addMain(contourCircle7(param.S2 - S1r, stopper2H + S1r, S1hr));
+    figStopperSide.addMain(contourCircle8(-R1 - S1r, stopper1H + S1r, S1r));
+    figStopperSide.addMain(contourCircle8(-R1 - S1r, stopper1H + S1r, S1hr));
+    figStopperSide.addMain(contourCircle8(param.S2 - S1r, stopper2H + S1r, S1r));
+    figStopperSide.addMain(contourCircle8(param.S2 - S1r, stopper2H + S1r, S1hr));
     figStopperSide.addSecond(ctrRect(S2s, param.S1, 0, stopper2H, 0));
     figStopperSide.addSecond(ctrRect(S2s, S1h, 0, stopper2H + param.E7, 0));
     const stopper3Ly = stopper2H + param.S1 / 2 - stopper3H;
     const stopper3L = Math.sqrt(S2s ** 2 + stopper3Ly ** 2);
     const stopper3A = Math.atan2(stopper3Ly, S2s);
-    rGeome.logstr += `stopper-rod: L ${ffix9(stopper3L)} mm, A ${ffix9(
-      radToDeg6(stopper3A)
+    rGeome.logstr += `stopper-rod: L ${ffix11(stopper3L)} mm, A ${ffix11(
+      radToDeg7(stopper3A)
     )} degree
 `;
     const stp3posdX = S1r * Math.sin(stopper3A);
@@ -3016,30 +3656,30 @@ function pGeom8(t, param, suffix = "") {
     const stp3posY2 = stopper3H - stp3posdY2;
     figStopperSide.addSecond(ctrRect(stopper3L, S1h, stp3posdX2, stp3posY2, stopper3A));
     figStopperSideH.mergeFigure(rakeGeom.fig.faceBeam, true);
-    figStopperSideH.addSecond(contourCircle7(-R1 - S1r, stopper1H + S1r, S1r));
-    figStopperSideH.addMain(contourCircle7(-R1 - S1r, stopper1H + S1r, S1hr));
-    figStopperSideH.addSecond(contourCircle7(param.S2 - S1r, stopper2H + S1r, S1r));
-    figStopperSideH.addMain(contourCircle7(param.S2 - S1r, stopper2H + S1r, S1hr));
+    figStopperSideH.addSecond(contourCircle8(-R1 - S1r, stopper1H + S1r, S1r));
+    figStopperSideH.addMain(contourCircle8(-R1 - S1r, stopper1H + S1r, S1hr));
+    figStopperSideH.addSecond(contourCircle8(param.S2 - S1r, stopper2H + S1r, S1r));
+    figStopperSideH.addMain(contourCircle8(param.S2 - S1r, stopper2H + S1r, S1hr));
     figStopperFaceT.mergeFigure(rakeGeom.fig.faceCone, true);
-    figStopperFaceT.addMain(contourCircle7(-param.L5 / 2 + S1r, stopper2H + S1r, S1r));
-    figStopperFaceT.addMain(contourCircle7(-param.L5 / 2 + S1r, stopper2H + S1r, S1hr));
-    figStopperFaceT.addMain(contourCircle7(param.L5 / 2 - S1r, stopper2H + S1r, S1r));
-    figStopperFaceT.addMain(contourCircle7(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));
+    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.addSecond(contourCircle7(-param.L5 / 2 + S1r, stopper2H + S1r, S1r));
-    figStopperFaceTH.addMain(contourCircle7(-param.L5 / 2 + S1r, stopper2H + S1r, S1hr));
-    figStopperFaceTH.addSecond(contourCircle7(param.L5 / 2 - S1r, stopper2H + S1r, S1r));
-    figStopperFaceTH.addMain(contourCircle7(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));
+    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.addMain(contourCircle7(-R1 - S1r, 0, S1r));
-    figStopperFaceB.addMain(contourCircle7(-R1 - S1r, 0, S1hr));
-    figStopperFaceB.addMain(contourCircle7(R1 + S1r, 0, S1r));
-    figStopperFaceB.addMain(contourCircle7(R1 + S1r, 0, S1hr));
+    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.addSecond(contourCircle7(-R1 - S1r, 0, S1r));
-    figStopperFaceBH.addMain(contourCircle7(-R1 - S1r, 0, S1hr));
-    figStopperFaceBH.addSecond(contourCircle7(R1 + S1r, 0, S1r));
-    figStopperFaceBH.addMain(contourCircle7(R1 + S1r, 0, S1hr));
+    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));
     rGeome.fig = {
       faceCone: figCone,
       faceBeam: figBeam,
@@ -3072,7 +3712,7 @@ function pGeom8(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_stpSide`,
           face: `${designName}_faceStopperSide`,
-          extrudeMethod: EExtrude6.eLinearOrtho,
+          extrudeMethod: EExtrude7.eLinearOrtho,
           length: param.L5,
           rotate: [Math.PI / 2, 0, 0],
           translate: [0, param.L5 / 2, 0]
@@ -3080,7 +3720,7 @@ function pGeom8(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_stpSideH`,
           face: `${designName}_faceStopperSideH`,
-          extrudeMethod: EExtrude6.eLinearOrtho,
+          extrudeMethod: EExtrude7.eLinearOrtho,
           length: param.L5,
           rotate: [Math.PI / 2, 0, 0],
           translate: [0, param.L5 / 2, 0]
@@ -3088,7 +3728,7 @@ function pGeom8(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_stpFaceT`,
           face: `${designName}_faceStopperFaceT`,
-          extrudeMethod: EExtrude6.eLinearOrtho,
+          extrudeMethod: EExtrude7.eLinearOrtho,
           length: S2s,
           rotate: [Math.PI / 2, 0, Math.PI / 2],
           translate: [0, 0, 0]
@@ -3096,7 +3736,7 @@ function pGeom8(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_stpFaceTH`,
           face: `${designName}_faceStopperFaceTH`,
-          extrudeMethod: EExtrude6.eLinearOrtho,
+          extrudeMethod: EExtrude7.eLinearOrtho,
           length: S2s,
           rotate: [Math.PI / 2, 0, Math.PI / 2],
           translate: [0, 0, 0]
@@ -3104,7 +3744,7 @@ function pGeom8(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_stpFaceB`,
           face: `${designName}_faceStopperFaceB`,
-          extrudeMethod: EExtrude6.eLinearOrtho,
+          extrudeMethod: EExtrude7.eLinearOrtho,
           length: stopper3L,
           rotate: [Math.PI / 2 - stopper3A, 0, Math.PI / 2],
           translate: [0, 0, stopper3H]
@@ -3112,7 +3752,7 @@ function pGeom8(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_stpFaceBH`,
           face: `${designName}_faceStopperFaceBH`,
-          extrudeMethod: EExtrude6.eLinearOrtho,
+          extrudeMethod: EExtrude7.eLinearOrtho,
           length: stopper3L,
           rotate: [Math.PI / 2 - stopper3A, 0, Math.PI / 2],
           translate: [0, 0, stopper3H]
@@ -3121,7 +3761,7 @@ function pGeom8(t, param, suffix = "") {
       volumes: [
         {
           outName: `ipax_${designName}_plus`,
-          boolMethod: EBVolume8.eUnion,
+          boolMethod: EBVolume9.eUnion,
           inList: [
             `subpax_${designName}_stpSide`,
             `subpax_${designName}_stpFaceT`,
@@ -3130,7 +3770,7 @@ function pGeom8(t, param, suffix = "") {
         },
         {
           outName: `ipax_${designName}_hollow`,
-          boolMethod: EBVolume8.eUnion,
+          boolMethod: EBVolume9.eUnion,
           inList: [
             `subpax_${designName}_stpSideH`,
             `subpax_${designName}_stpFaceTH`,
@@ -3139,12 +3779,12 @@ function pGeom8(t, param, suffix = "") {
         },
         {
           outName: `ipax_${designName}_stopper`,
-          boolMethod: EBVolume8.eSubstraction,
+          boolMethod: EBVolume9.eSubstraction,
           inList: [`ipax_${designName}_plus`, `ipax_${designName}_hollow`]
         },
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume8.eUnion,
+          boolMethod: EBVolume9.eUnion,
           inList: [`inpax_${designName}_rake`, `ipax_${designName}_stopper`]
         }
       ]
@@ -3160,43 +3800,48 @@ function pGeom8(t, param, suffix = "") {
 }
 var rakeStopperDef = {
   pTitle: "Heliostat rake with stopper",
-  pDescription: "The rake-stopper on top of the pole-rotor of the heliostat",
-  pDef: pDef8,
-  pGeom: pGeom8
+  pDescription: "The rake-stopper on top of the V-Axis of the heliostat",
+  pDef: pDef9,
+  pGeom: pGeom9
 };
 
 // src/heliostat/heliostat_2.ts
-var pDef9 = {
+var pDef10 = {
   partName: "heliostat_2",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber9("H1", "mm", 3e3, 10, 4e4, 10),
-    pNumber9("H2", "mm", 2500, 50, 4e4, 10),
-    pNumber9("H3", "mm", 200, 1, 500, 1),
-    pNumber9("H4", "mm", 800, 1, 4e3, 1),
-    pNumber9("H5", "mm", 3e3, 50, 6e3, 10),
-    pNumber9("H6", "mm", 200, 1, 4e3, 1),
-    pNumber9("H7", "mm", 400, 1, 4e3, 1),
-    pNumber9("H9", "mm", 100, 1, 400, 1),
-    pNumber9("D1", "mm", 1e3, 20, 4e3, 10),
-    pNumber9("D2", "mm", 700, 20, 4e3, 10),
-    pNumber9("D3", "mm", 900, 20, 4e3, 10),
-    pNumber9("D4", "mm", 400, 20, 4e3, 10),
-    pNumber9("D5", "mm", 300, 20, 1e3, 10),
-    pNumber9("D6", "mm", 200, 10, 1e3, 10),
-    pNumber9("D7", "mm", 400, 10, 1e3, 10),
-    pNumber9("D9", "mm", 100, 1, 1e3, 1),
-    pNumber9("E1", "mm", 30, 1, 80, 1),
-    pNumber9("L1", "mm", 12500, 100, 4e4, 10),
-    pNumber9("L2", "mm", 6e3, 100, 4e4, 10),
-    pNumber9("L3", "mm", 100, 1, 500, 1),
-    pNumber9("L4", "mm", 600, 1, 4e3, 1),
-    pNumber9("L5", "mm", 2e3, 10, 6e3, 10),
-    pNumber9("L6", "mm", 2e3, 1, 6e3, 1),
-    pNumber9("L7", "mm", 100, 1, 1e3, 1),
-    pNumber9("L8", "mm", 200, 1, 1e3, 1),
-    pNumber9("al", "degree", 80, 0, 95, 1),
-    pNumber9("S1", "mm", 100, 1, 800, 1)
+    pNumber10("H1", "mm", 3e3, 10, 4e4, 10),
+    pNumber10("H2", "mm", 2500, 50, 4e4, 10),
+    pNumber10("D1", "mm", 1e3, 20, 4e3, 10),
+    pNumber10("D2", "mm", 700, 20, 4e3, 10),
+    pNumber10("E1", "mm", 30, 1, 80, 1),
+    pSectionSeparator9("rake"),
+    pNumber10("H3", "mm", 200, 1, 500, 1),
+    pNumber10("H4", "mm", 800, 1, 4e3, 1),
+    pNumber10("H5", "mm", 3e3, 50, 6e3, 10),
+    pNumber10("H6", "mm", 200, 1, 4e3, 1),
+    pNumber10("H7", "mm", 400, 1, 4e3, 1),
+    pNumber10("D3", "mm", 900, 20, 4e3, 10),
+    pNumber10("D4", "mm", 400, 20, 4e3, 10),
+    pNumber10("D5", "mm", 300, 20, 1e3, 10),
+    pNumber10("D6", "mm", 200, 10, 1e3, 10),
+    pNumber10("D7", "mm", 400, 10, 1e3, 10),
+    pSectionSeparator9("rake diagonal"),
+    pNumber10("D9", "mm", 100, 1, 1e3, 1),
+    pNumber10("L7", "mm", 100, 1, 1e3, 1),
+    pNumber10("L8", "mm", 200, 1, 1e3, 1),
+    pSectionSeparator9("rake stopper"),
+    pNumber10("S1", "mm", 100, 1, 800, 1),
+    pSectionSeparator9("swing"),
+    pNumber10("L1", "mm", 12500, 100, 4e4, 10),
+    pNumber10("L2", "mm", 6e3, 100, 4e4, 10),
+    pNumber10("L3", "mm", 100, 1, 500, 1),
+    pNumber10("L4", "mm", 600, 1, 4e3, 1),
+    pNumber10("L5", "mm", 2e3, 10, 6e3, 10),
+    pNumber10("L6", "mm", 2e3, 1, 6e3, 1),
+    pNumber10("H9", "mm", 100, 1, 400, 1),
+    pSectionSeparator9("motion amplitude"),
+    pNumber10("al", "degree", 80, 0, 95, 1)
   ],
   paramSvg: {
     H1: "heliostat_overview.svg",
@@ -3234,28 +3879,28 @@ var pDef9 = {
     // every 0.5 second
   }
 };
-function pGeom9(t, param, suffix = "") {
-  const rGeome = initGeom9(pDef9.partName + suffix);
-  const figSide = figure9();
-  const figFace = figure9();
-  const figTop = figure9();
+function pGeom10(t, param, suffix = "") {
+  const rGeome = initGeom10(pDef10.partName + suffix);
+  const figSide = figure10();
+  const figFace = figure10();
+  const figTop = figure10();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
     const helioHeight = param.H1 + param.H2 - param.H3 + param.H4 + param.H5 - param.H6 + param.H7;
-    rGeome.logstr += `heliostat-height: ${ffix10(helioHeight)}, diameter ${ffix10(param.D1)} m
+    rGeome.logstr += `heliostat-height: ${ffix12(helioHeight)}, diameter ${ffix12(param.D1)} m
 `;
-    rGeome.logstr += `heliostat-swing-length: ${ffix10(param.L1)}, width ${ffix10(param.L2)} m
+    rGeome.logstr += `heliostat-swing-length: ${ffix12(param.L1)}, width ${ffix12(param.L2)} m
 `;
-    const posAngleDegree = param.al * t / pDef9.sim.tMax;
-    const posAngle = degToRad3(posAngleDegree);
-    rGeome.logstr += `swing position angle: ${ffix10(radToDeg7(posAngle))} degree
+    const posAngleDegree = param.al * t / pDef10.sim.tMax;
+    const posAngle = degToRad5(posAngleDegree);
+    rGeome.logstr += `swing position angle: ${ffix12(radToDeg8(posAngle))} degree
 `;
     const rakePosY = param.H1 + param.H2 - param.H3;
     const swingPosY = rakePosY + param.H4 + param.H5 - param.H6 + param.H7;
-    const poleStaticParam = designParam4(poleStaticDef.pDef);
-    const rakeParam = designParam4(rakeStopperDef.pDef);
-    const swingParam = designParam4(swingDef.pDef);
+    const poleStaticParam = designParam5(poleStaticDef.pDef);
+    const rakeParam = designParam5(rakeStopperDef.pDef);
+    const swingParam = designParam5(swingDef.pDef);
     poleStaticParam.setVal("H1", param.H1);
     poleStaticParam.setVal("H2", param.H2);
     poleStaticParam.setVal("D1", param.D1);
@@ -3273,6 +3918,7 @@ function pGeom9(t, param, suffix = "") {
     poleStaticParam.setVal("D4", param.H1 / 4);
     poleStaticParam.setVal("L2", param.H1 / 80);
     poleStaticParam.setVal("E3", param.H1 / 80);
+    poleStaticParam.setVal("holders", 0);
     rakeParam.setVal("H1", param.H4);
     rakeParam.setVal("H2", param.H5);
     rakeParam.setVal("H3", param.H4 - 2 * param.E1);
@@ -3336,14 +3982,14 @@ function pGeom9(t, param, suffix = "") {
       poleStaticParam.getParamVal(),
       poleStaticParam.getSuffix()
     );
-    checkGeom4(poleStaticGeom);
-    rGeome.logstr += prefixLog4(poleStaticGeom.logstr, poleStaticParam.getPartNameSuffix());
+    checkGeom5(poleStaticGeom);
+    rGeome.logstr += prefixLog5(poleStaticGeom.logstr, poleStaticParam.getPartNameSuffix());
     const rakeGeom = rakeStopperDef.pGeom(0, rakeParam.getParamVal(), rakeParam.getSuffix());
-    checkGeom4(rakeGeom);
-    rGeome.logstr += prefixLog4(rakeGeom.logstr, rakeParam.getPartNameSuffix());
+    checkGeom5(rakeGeom);
+    rGeome.logstr += prefixLog5(rakeGeom.logstr, rakeParam.getPartNameSuffix());
     const swingGeom = swingDef.pGeom(0, swingParam.getParamVal(), swingParam.getSuffix());
-    checkGeom4(swingGeom);
-    rGeome.logstr += prefixLog4(swingGeom.logstr, swingParam.getPartNameSuffix());
+    checkGeom5(swingGeom);
+    rGeome.logstr += prefixLog5(swingGeom.logstr, swingParam.getPartNameSuffix());
     figSide.mergeFigure(poleStaticGeom.fig.poleCut);
     figSide.mergeFigure(rakeGeom.fig.faceStopperSide.translate(0, rakePosY));
     figSide.mergeFigure(
@@ -3389,7 +4035,7 @@ function pGeom9(t, param, suffix = "") {
       volumes: [
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume9.eUnion,
+          boolMethod: EBVolume10.eUnion,
           inList: [
             `inpax_${designName}_poleStatic`,
             `inpax_${designName}_rake`,
@@ -3433,40 +4079,43 @@ function pGeom9(t, param, suffix = "") {
 var heliostat_2Def = {
   pTitle: "Heliostat-2 overview",
   pDescription: "The heliostat-2 inclination mechanism",
-  pDef: pDef9,
-  pGeom: pGeom9
+  pDef: pDef10,
+  pGeom: pGeom10
 };
 
 // src/heliostat/base.ts
 import {
-  contour as contour9,
-  contourCircle as contourCircle8,
-  figure as figure10,
-  ffix as ffix11,
-  pNumber as pNumber10,
-  initGeom as initGeom10,
-  EExtrude as EExtrude7,
-  EBVolume as EBVolume10
+  contour as contour11,
+  contourCircle as contourCircle9,
+  figure as figure11,
+  ffix as ffix13,
+  pNumber as pNumber11,
+  pSectionSeparator as pSectionSeparator10,
+  initGeom as initGeom11,
+  EExtrude as EExtrude8,
+  EBVolume as EBVolume11
 } from "geometrix";
-var pDef10 = {
+var pDef11 = {
   partName: "base",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber10("D1", "mm", 600, 10, 4e3, 10),
-    pNumber10("D2", "mm", 700, 10, 4e3, 10),
-    pNumber10("D3", "mm", 400, 10, 4e3, 10),
-    pNumber10("D4", "mm", 500, 10, 4e3, 10),
-    pNumber10("E1", "mm", 30, 1, 80, 1),
-    pNumber10("E2", "mm", 30, 1, 80, 1),
-    pNumber10("E3", "mm", 30, 1, 80, 1),
-    pNumber10("H1", "mm", 800, 10, 4e3, 10),
-    pNumber10("H2", "mm", 50, 1, 4e3, 1),
-    pNumber10("H3", "mm", 400, 10, 4e3, 10),
-    pNumber10("N2", "", 12, 1, 100, 1),
-    pNumber10("L2", "mm", 100, 1, 400, 1),
-    pNumber10("N1", "", 24, 3, 100, 1),
-    pNumber10("D5", "mm", 40, 1, 100, 1),
-    pNumber10("L1", "mm", 34, 1, 300, 1)
+    pNumber11("D1", "mm", 600, 10, 4e3, 10),
+    pNumber11("D2", "mm", 700, 10, 4e3, 10),
+    pNumber11("D3", "mm", 400, 10, 4e3, 10),
+    pNumber11("D4", "mm", 500, 10, 4e3, 10),
+    pNumber11("E1", "mm", 30, 1, 80, 1),
+    pNumber11("E2", "mm", 30, 1, 80, 1),
+    pNumber11("E3", "mm", 30, 1, 80, 1),
+    pNumber11("H1", "mm", 800, 10, 4e3, 10),
+    pNumber11("H2", "mm", 50, 1, 4e3, 1),
+    pSectionSeparator10("side holes"),
+    pNumber11("H3", "mm", 400, 10, 4e3, 10),
+    pNumber11("N2", "", 12, 1, 100, 1),
+    pNumber11("L2", "mm", 100, 1, 400, 1),
+    pSectionSeparator10("base holes"),
+    pNumber11("N1", "", 24, 3, 100, 1),
+    pNumber11("D5", "mm", 40, 1, 100, 1),
+    pNumber11("L1", "mm", 34, 1, 300, 1)
   ],
   paramSvg: {
     D1: "base_cut.svg",
@@ -3492,14 +4141,14 @@ var pDef10 = {
     // every 0.5 second
   }
 };
-function pGeom10(t, param, suffix = "") {
-  const rGeome = initGeom10(pDef10.partName + suffix);
+function pGeom11(t, param, suffix = "") {
+  const rGeome = initGeom11(pDef11.partName + suffix);
   let ctrBaseCut1;
   let ctrBaseCut2;
   let ctrHollow;
-  const figCut = figure10();
-  const figTop = figure10();
-  const figHollow = figure10();
+  const figCut = figure11();
+  const figTop = figure11();
+  const figHollow = figure11();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
@@ -3515,19 +4164,19 @@ function pGeom10(t, param, suffix = "") {
     if (R4 > R1 - param.E2) {
       throw `err189: D4 ${param.D4} too large compare to D1 ${param.D1} and E2 ${param.E2}`;
     }
-    rGeome.logstr += `base-height: ${ffix11(param.H1)} mm
+    rGeome.logstr += `base-height: ${ffix13(param.H1)} mm
 `;
-    rGeome.logstr += `base-external-diameter: ${ffix11(param.D2)} mm
+    rGeome.logstr += `base-external-diameter: ${ffix13(param.D2)} mm
 `;
     const interHollow = param.D1 * Math.PI / param.N2 - param.L2;
-    rGeome.logstr += `inter-hollow: ${ffix11(interHollow)} mm
+    rGeome.logstr += `inter-hollow: ${ffix13(interHollow)} mm
 `;
     ctrBaseCut1 = function(orient) {
-      const rBaseCut1 = contour9(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 = 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();
       return rBaseCut1;
     };
     ctrBaseCut2 = function(orient) {
-      const rBaseCut2 = contour9(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 = 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();
       return rBaseCut2;
     };
     if (param.H1 < param.E3 + param.H2 + param.H3 + param.E1) {
@@ -3542,7 +4191,7 @@ function pGeom10(t, param, suffix = "") {
     }
     const hollowH = param.E3 + param.H2 + RL2;
     ctrHollow = function(orient) {
-      const rHollow = contour9(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 = 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);
       return rHollow;
     };
     figCut.addMain(ctrBaseCut1(1));
@@ -3559,18 +4208,18 @@ function pGeom10(t, param, suffix = "") {
     if (param.N1 * holeAngle > 2 * Math.PI) {
       throw `err134: N1 ${param.N1} too large compare to D5 ${param.D5}, L1 ${param.L1}, D2 ${param.D2}`;
     }
-    figTop.addMain(contourCircle8(0, 0, R1));
-    figTop.addMain(contourCircle8(0, 0, R3));
+    figTop.addMain(contourCircle9(0, 0, R1));
+    figTop.addMain(contourCircle9(0, 0, R3));
     const posR = R3 + param.L1;
     const posA = 2 * Math.PI / param.N1;
     for (let i = 0; i < param.N1; i++) {
       const posX = posR * Math.cos(i * posA);
       const posY = posR * Math.sin(i * posA);
-      figTop.addMain(contourCircle8(posX, posY, R5));
+      figTop.addMain(contourCircle9(posX, posY, R5));
     }
-    figTop.addSecond(contourCircle8(0, 0, R1 - param.E1));
-    figTop.addSecond(contourCircle8(0, 0, R2));
-    figTop.addSecond(contourCircle8(0, 0, R4));
+    figTop.addSecond(contourCircle9(0, 0, R1 - param.E1));
+    figTop.addSecond(contourCircle9(0, 0, R2));
+    figTop.addSecond(contourCircle9(0, 0, R4));
     figHollow.addMain(ctrHollow(1));
     figHollow.addSecond(ctrBaseCut2(1));
     figHollow.addSecond(ctrBaseCut2(-1));
@@ -3586,7 +4235,7 @@ function pGeom10(t, param, suffix = "") {
       const rHollow = {
         outName: `subpax_${designName}_hollow_${idx}`,
         face: `${designName}_faceHollow`,
-        extrudeMethod: EExtrude7.eLinearOrtho,
+        extrudeMethod: EExtrude8.eLinearOrtho,
         length: R2 + param.E2,
         rotate: [Math.PI / 2, 0, idx * hollowStep],
         translate: [0, 0, 0]
@@ -3599,14 +4248,14 @@ function pGeom10(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_cut`,
           face: `${designName}_faceCut`,
-          extrudeMethod: EExtrude7.eRotate,
+          extrudeMethod: EExtrude8.eRotate,
           rotate: [0, 0, 0],
           translate: [Math.PI / 2, 0, 0]
         },
         {
           outName: `subpax_${designName}_top`,
           face: `${designName}_faceTop`,
-          extrudeMethod: EExtrude7.eLinearOrtho,
+          extrudeMethod: EExtrude8.eLinearOrtho,
           length: param.E1,
           rotate: [0, 0, 0],
           translate: [0, 0, param.H1 - param.E1]
@@ -3616,17 +4265,17 @@ function pGeom10(t, param, suffix = "") {
       volumes: [
         {
           outName: `ipax_${designName}_hollows`,
-          boolMethod: EBVolume10.eUnion,
+          boolMethod: EBVolume11.eUnion,
           inList: [...lVolHollow]
         },
         {
           outName: `ipax_${designName}_cylinder`,
-          boolMethod: EBVolume10.eSubstraction,
+          boolMethod: EBVolume11.eSubstraction,
           inList: [`subpax_${designName}_cut`, `ipax_${designName}_hollows`]
         },
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume10.eUnion,
+          boolMethod: EBVolume11.eUnion,
           inList: [`ipax_${designName}_cylinder`, `subpax_${designName}_top`]
         }
       ]
@@ -3643,43 +4292,45 @@ function pGeom10(t, param, suffix = "") {
 var baseDef = {
   pTitle: "Heliostat base",
   pDescription: "The base for the static-pole of the heliostat",
-  pDef: pDef10,
-  pGeom: pGeom10
+  pDef: pDef11,
+  pGeom: pGeom11
 };
 
-// src/heliostat/pole_rotor.ts
+// src/heliostat/vaxis.ts
 import {
-  contour as contour10,
-  contourCircle as contourCircle9,
-  figure as figure11,
-  ffix as ffix12,
-  pNumber as pNumber11,
-  initGeom as initGeom11,
-  EExtrude as EExtrude8,
-  EBVolume as EBVolume11
+  contour as contour12,
+  contourCircle as contourCircle10,
+  figure as figure12,
+  ffix as ffix14,
+  pNumber as pNumber12,
+  pSectionSeparator as pSectionSeparator11,
+  initGeom as initGeom12,
+  EExtrude as EExtrude9,
+  EBVolume as EBVolume12
 } from "geometrix";
-var pDef11 = {
-  partName: "pole_rotor",
+var pDef12 = {
+  partName: "vaxis",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber11("D1", "mm", 600, 1, 4e3, 1),
-    pNumber11("D2", "mm", 400, 1, 4e3, 1),
-    pNumber11("H1", "mm", 8e3, 10, 4e4, 10),
-    pNumber11("E1", "mm", 5, 1, 80, 1),
-    pNumber11("E2", "mm", 30, 1, 80, 1),
-    pNumber11("N1", "", 24, 3, 100, 1),
-    pNumber11("D3", "mm", 40, 1, 100, 1),
-    pNumber11("L1", "mm", 45, 1, 300, 1)
+    pNumber12("D1", "mm", 600, 1, 4e3, 1),
+    pNumber12("D2", "mm", 400, 1, 4e3, 1),
+    pNumber12("H1", "mm", 8e3, 10, 4e4, 10),
+    pNumber12("E1", "mm", 5, 1, 80, 1),
+    pNumber12("E2", "mm", 30, 1, 80, 1),
+    pSectionSeparator11("base holes"),
+    pNumber12("N1", "", 24, 3, 100, 1),
+    pNumber12("D3", "mm", 40, 1, 100, 1),
+    pNumber12("L1", "mm", 45, 1, 300, 1)
   ],
   paramSvg: {
-    D1: "pole_rotor_cut.svg",
-    D2: "pole_rotor_cut.svg",
-    H1: "pole_rotor_cut.svg",
-    E1: "pole_rotor_cut.svg",
-    E2: "pole_rotor_cut.svg",
-    N1: "pole_rotor_ends.svg",
-    D3: "pole_rotor_ends.svg",
-    L1: "pole_rotor_ends.svg"
+    D1: "vaxis_cut.svg",
+    D2: "vaxis_cut.svg",
+    H1: "vaxis_cut.svg",
+    E1: "vaxis_cut.svg",
+    E2: "vaxis_cut.svg",
+    N1: "vaxis_ends.svg",
+    D3: "vaxis_ends.svg",
+    L1: "vaxis_ends.svg"
   },
   sim: {
     tMax: 180,
@@ -3688,37 +4339,37 @@ var pDef11 = {
     // every 0.5 second
   }
 };
-function pGeom11(t, param, suffix = "") {
-  const rGeome = initGeom11(pDef11.partName + suffix);
+function pGeom12(t, param, suffix = "") {
+  const rGeome = initGeom12(pDef12.partName + suffix);
   let ctrPoleProfile;
-  const figCut = figure11();
-  const figBottom = figure11();
+  const figCut = figure12();
+  const figBottom = figure12();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
     const R1 = param.D1 / 2;
     const R2 = param.D2 / 2;
     const R3 = param.D3 / 2;
-    rGeome.logstr += `pole-height: ${ffix12(param.H1)} mm
+    rGeome.logstr += `vaxis-height: ${ffix14(param.H1)} mm
 `;
-    const ctrCylinder = contour10(R1, 0).addSegStrokeA(R1, param.H1).addSegStrokeA(R1 - param.E1, param.H1).addSegStrokeA(R1 - param.E1, 0).closeSegStroke();
+    const ctrCylinder = contour12(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 = contour10(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 = 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();
       return rPoleProfile;
     };
     figCut.addSecond(ctrPoleProfile(1));
     figCut.addSecond(ctrPoleProfile(-1));
-    figBottom.addMain(contourCircle9(0, 0, R1));
-    figBottom.addMain(contourCircle9(0, 0, R2));
+    figBottom.addMain(contourCircle10(0, 0, R1));
+    figBottom.addMain(contourCircle10(0, 0, R2));
     const posR = R2 + param.L1;
     const posA = 2 * Math.PI / param.N1;
     for (let i = 0; i < param.N1; i++) {
       const posX = posR * Math.cos(i * posA);
       const posY = posR * Math.sin(i * posA);
-      figBottom.addMain(contourCircle9(posX, posY, R3));
+      figBottom.addMain(contourCircle10(posX, posY, R3));
     }
-    figBottom.addSecond(contourCircle9(0, 0, R1 - param.E1));
+    figBottom.addSecond(contourCircle10(0, 0, R1 - param.E1));
     rGeome.fig = {
       faceCut: figCut,
       faceBottom: figBottom
@@ -3729,14 +4380,14 @@ function pGeom11(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_pole`,
           face: `${designName}_faceCut`,
-          extrudeMethod: EExtrude8.eRotate,
+          extrudeMethod: EExtrude9.eRotate,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
         },
         {
           outName: `subpax_${designName}_bottom`,
           face: `${designName}_faceBottom`,
-          extrudeMethod: EExtrude8.eLinearOrtho,
+          extrudeMethod: EExtrude9.eLinearOrtho,
           length: param.E2,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
@@ -3744,7 +4395,7 @@ function pGeom11(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_top`,
           face: `${designName}_faceBottom`,
-          extrudeMethod: EExtrude8.eLinearOrtho,
+          extrudeMethod: EExtrude9.eLinearOrtho,
           length: param.E2,
           rotate: [0, 0, 0],
           translate: [0, 0, param.H1 - param.E2]
@@ -3753,7 +4404,7 @@ function pGeom11(t, param, suffix = "") {
       volumes: [
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume11.eUnion,
+          boolMethod: EBVolume12.eUnion,
           inList: [
             `subpax_${designName}_pole`,
             `subpax_${designName}_bottom`,
@@ -3763,7 +4414,454 @@ function pGeom11(t, param, suffix = "") {
       ]
     };
     rGeome.sub = {};
-    rGeome.logstr += "pole_rotor drawn successfully!\n";
+    rGeome.logstr += "V-Axis drawn successfully!\n";
+    rGeome.calcErr = false;
+  } catch (emsg) {
+    rGeome.logstr += emsg;
+    console.log(emsg);
+  }
+  return rGeome;
+}
+var vaxisDef = {
+  pTitle: "Heliostat V-Axis",
+  pDescription: "The vertical axis inside the pole of an heliostat",
+  pDef: pDef12,
+  pGeom: pGeom12
+};
+
+// src/heliostat/ring.ts
+import {
+  contour as contour13,
+  contourCircle as contourCircle11,
+  figure as figure13,
+  ffix as ffix15,
+  pNumber as pNumber13,
+  pSectionSeparator as pSectionSeparator12,
+  initGeom as initGeom13,
+  EExtrude as EExtrude10,
+  EBVolume as EBVolume13
+} from "geometrix";
+var pDef13 = {
+  partName: "ring",
+  params: [
+    //pNumber(name, unit, init, min, max, step)
+    pNumber13("D1", "mm", 400, 1, 2e3, 1),
+    pNumber13("D3", "mm", 800, 1, 4e3, 1),
+    pNumber13("H1", "mm", 20, 1, 100, 1),
+    pNumber13("H2", "mm", 100, 1, 600, 1),
+    pSectionSeparator12("ring holes"),
+    pNumber13("N2", "", 24, 3, 100, 1),
+    pNumber13("D2", "mm", 40, 1, 100, 1),
+    pNumber13("L1", "mm", 45, 1, 300, 1),
+    pSectionSeparator12("ring fake teeth"),
+    pNumber13("N1", "", 100, 3, 1e4, 1),
+    pNumber13("L2", "mm", 30, 1, 200, 1),
+    pNumber13("L3", "mm", 30, 1, 200, 1)
+  ],
+  paramSvg: {
+    D1: "ring_top.svg",
+    D3: "ring_top.svg",
+    H1: "ring_section.svg",
+    H2: "ring_section.svg",
+    N2: "ring_top.svg",
+    D2: "ring_top.svg",
+    L1: "ring_top.svg",
+    N1: "ring_top.svg",
+    L2: "ring_top.svg",
+    L3: "ring_top.svg"
+  },
+  sim: {
+    tMax: 180,
+    tStep: 0.5,
+    tUpdate: 500
+    // every 0.5 second
+  }
+};
+function pGeom13(t, param, suffix = "") {
+  const rGeome = initGeom13(pDef13.partName + suffix);
+  const figRingBase = figure13();
+  const figRingTeeth = figure13();
+  const figSection = figure13();
+  rGeome.logstr += `${rGeome.partName} simTime: ${t}
+`;
+  try {
+    const R1 = param.D1 / 2;
+    const R2 = param.D2 / 2;
+    const R3 = param.D3 / 2;
+    const ringHeight = param.H1 + param.H2;
+    if (param.L1 < R2) {
+      throw `err203: L1 ${param.L1} too small compare to D2 ${param.D2}`;
+    }
+    if (R1 + param.L1 + R2 > R3 - param.L2 - param.L3) {
+      throw `err204: D3 ${param.D3} too small compare to D1 ${param.D1}, L1 ${param.L1}, L2 ${param.L2}, L3 ${param.L3}`;
+    }
+    if (2 * Math.atan2(R2, R1 + param.L1) > 2 * Math.PI / param.N2) {
+      throw `err205: D2 ${param.D2} too large compare to N2 ${param.N2}`;
+    }
+    rGeome.logstr += `ring-height: ${ffix15(ringHeight)} mm
+`;
+    const tR1 = R3 - param.L2;
+    const tR2 = tR1 - param.L3;
+    const tA = 2 * Math.PI / (2 * param.N1);
+    const ctrTeeth = contour13(tR1, 0);
+    for (let i = 0; i < param.N1; i++) {
+      const ti1 = 2 * i + 1;
+      const ti2 = 2 * i + 2;
+      const p1X = tR2 * Math.cos(ti1 * tA);
+      const p1Y = tR2 * Math.sin(ti1 * tA);
+      const p2X = tR1 * Math.cos(ti2 * tA);
+      const p2Y = tR1 * Math.sin(ti2 * tA);
+      ctrTeeth.addSegStrokeA(p1X, p1Y).addSegStrokeA(p2X, p2Y);
+    }
+    figRingBase.addMain(contourCircle11(0, 0, R3));
+    figRingBase.addMain(contourCircle11(0, 0, R1));
+    const posR = R1 + param.L1;
+    const posA = 2 * Math.PI / param.N2;
+    for (let i = 0; i < param.N2; i++) {
+      const posX = posR * Math.cos(i * posA);
+      const posY = posR * Math.sin(i * posA);
+      figRingBase.addMain(contourCircle11(posX, posY, R2));
+      figRingTeeth.addSecond(contourCircle11(posX, posY, R2));
+    }
+    figRingBase.addSecond(ctrTeeth);
+    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 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();
+      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();
+      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();
+      return rCtr;
+    };
+    figSection.addSecond(ctrInner);
+    figSection.addSecond(ctrScrewHole(1));
+    figSection.addSecond(ctrScrewHole(-1));
+    figSection.addSecond(ctrGearTeeth(1));
+    figSection.addSecond(ctrGearTeeth(-1));
+    figSection.addMain(ctrL(1));
+    figSection.addSecond(ctrL(-1));
+    rGeome.fig = {
+      faceRingBase: figRingBase,
+      faceRingTeeth: figRingTeeth,
+      faceSection: figSection
+    };
+    const designName = rGeome.partName;
+    rGeome.vol = {
+      extrudes: [
+        {
+          outName: `subpax_${designName}_base`,
+          face: `${designName}_faceRingBase`,
+          extrudeMethod: EExtrude10.eLinearOrtho,
+          length: param.H1,
+          rotate: [0, 0, 0],
+          translate: [0, 0, 0]
+        },
+        {
+          outName: `subpax_${designName}_teeth`,
+          face: `${designName}_faceRingTeeth`,
+          extrudeMethod: EExtrude10.eLinearOrtho,
+          length: ringHeight,
+          rotate: [0, 0, 0],
+          translate: [0, 0, 0]
+        }
+      ],
+      volumes: [
+        {
+          outName: `pax_${designName}`,
+          boolMethod: EBVolume13.eUnion,
+          inList: [`subpax_${designName}_base`, `subpax_${designName}_teeth`]
+        }
+      ]
+    };
+    rGeome.sub = {};
+    rGeome.logstr += "ring drawn successfully!\n";
+    rGeome.calcErr = false;
+  } catch (emsg) {
+    rGeome.logstr += emsg;
+    console.log(emsg);
+  }
+  return rGeome;
+}
+var ringDef = {
+  pTitle: "Heliostat ring",
+  pDescription: "The gear ring for adjusting the azimuth of the heliostat",
+  pDef: pDef13,
+  pGeom: pGeom13
+};
+
+// src/heliostat/ring_guidance.ts
+import {
+  contour as contour14,
+  contourCircle as contourCircle12,
+  figure as figure14,
+  ffix as ffix16,
+  pNumber as pNumber14,
+  pSectionSeparator as pSectionSeparator13,
+  initGeom as initGeom14,
+  EExtrude as EExtrude11,
+  EBVolume as EBVolume14
+} from "geometrix";
+var pDef14 = {
+  partName: "ring_guidance",
+  params: [
+    //pNumber(name, unit, init, min, max, step)
+    pNumber14("D1", "mm", 700, 100, 2500, 1),
+    pNumber14("N1", "legs", 6, 1, 24, 1),
+    pNumber14("D2", "mm", 600, 100, 2e3, 1),
+    pSectionSeparator13("leg details"),
+    pNumber14("D3", "mm", 30, 1, 200, 1),
+    pNumber14("D4", "mm", 50, 1, 200, 1),
+    pNumber14("L1", "mm", 90, 1, 900, 1),
+    pNumber14("R5", "mm", 20, 0, 500, 1),
+    pSectionSeparator13("inner"),
+    pNumber14("D6", "mm", 300, 1, 1e3, 1),
+    pNumber14("N2", "motors", 8, 1, 200, 1),
+    pNumber14("L2", "mm", 50, 1, 200, 1),
+    pNumber14("D7", "mm", 80, 1, 200, 1),
+    pSectionSeparator13("thickness"),
+    pNumber14("T1", "mm", 10, 1, 200, 1)
+  ],
+  paramSvg: {
+    D1: "ring_guidance_top.svg",
+    D2: "ring_guidance_top.svg",
+    D3: "ring_guidance_top.svg",
+    D4: "ring_guidance_top.svg",
+    R5: "ring_guidance_top.svg",
+    D6: "ring_guidance_top.svg",
+    D7: "ring_guidance_top.svg",
+    N1: "ring_guidance_top.svg",
+    N2: "ring_guidance_top.svg",
+    L1: "ring_guidance_top.svg",
+    L2: "ring_guidance_top.svg",
+    T1: "ring_guidance_top.svg"
+  },
+  sim: {
+    tMax: 100,
+    tStep: 0.5,
+    tUpdate: 500
+    // every 0.5 second
+  }
+};
+function pGeom14(t, param, suffix = "") {
+  const rGeome = initGeom14(pDef14.partName + suffix);
+  const figTop = figure14();
+  const figSection = figure14();
+  rGeome.logstr += `${rGeome.partName} simTime: ${t}
+`;
+  try {
+    const R1 = param.D1 / 2;
+    const R3 = param.D3 / 2;
+    const R4 = param.D4 / 2;
+    const R6 = param.D6 / 2;
+    const R7 = param.D7 / 2;
+    const stepA2 = 2 * Math.PI / param.N2;
+    if (R7 > param.L2) {
+      throw `err461: D7 ${param.D7} is too large compare to L2 ${param.L2}`;
+    }
+    if (param.N2 * param.D7 > (param.D6 + 2 * param.L2) * Math.PI) {
+      throw `err462: N2 ${param.N2} is too large compare to D6 ${param.D6}, D7 ${param.D7} and L2 ${param.L2}`;
+    }
+    if (param.D2 < param.D6 + 2 * param.L2 + 2 * R7) {
+      throw `err463: D2 ${param.D2} is too small compare to D6 ${param.D6}, L2 ${param.L2} and D7 ${param.D7}`;
+    }
+    rGeome.logstr += `ring_guidance: Dmax ${ffix16(param.D1 + 2 * R4)} mm
+`;
+    const [outerLog, outerCtr, stepA1] = ctrGuidanceOuter(param);
+    rGeome.logstr += outerLog;
+    figTop.addMain(outerCtr);
+    figTop.addMain(contourCircle12(0, 0, R6));
+    for (let i = 0; i < param.N2; i++) {
+      figTop.addMain(contourCircle12(R6 + param.L2, 0, R7).rotate(0, 0, i * stepA2));
+    }
+    for (let i = 0; i < param.N1; i++) {
+      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();
+      return rCtr;
+    };
+    const w1 = R1 - R6 + R4;
+    figSection.addMain(rect(R6, 0, w1, param.T1));
+    figSection.addMain(rect(-R6 - w1, 0, w1, param.T1));
+    figSection.addSecond(rect(R1 - R3, 0, 2 * R3, param.T1));
+    figSection.addSecond(rect(-R1 - R3, 0, 2 * R3, param.T1));
+    const px2 = R6 + param.L2;
+    figSection.addSecond(rect(px2 - R7, 0, 2 * R7, param.T1));
+    figSection.addSecond(rect(-px2 - R7, 0, 2 * R7, param.T1));
+    rGeome.fig = {
+      faceTop: figTop,
+      faceSection: figSection
+    };
+    const designName = rGeome.partName;
+    rGeome.vol = {
+      extrudes: [
+        {
+          outName: `subpax_${designName}_top`,
+          face: `${designName}_faceTop`,
+          extrudeMethod: EExtrude11.eLinearOrtho,
+          length: param.T1,
+          rotate: [0, 0, 0],
+          translate: [0, 0, 0]
+        }
+      ],
+      volumes: [
+        {
+          outName: `pax_${designName}`,
+          boolMethod: EBVolume14.eIdentity,
+          inList: [`subpax_${designName}_top`]
+        }
+      ]
+    };
+    rGeome.sub = {};
+    rGeome.logstr += "ring_guidance drawn successfully!\n";
+    rGeome.calcErr = false;
+  } catch (emsg) {
+    rGeome.logstr += emsg;
+    console.log(emsg);
+  }
+  return rGeome;
+}
+var ringGuidanceDef = {
+  pTitle: "Ring-guidance",
+  pDescription: "The guidance of the gear-ring for the heliostat azimuth",
+  pDef: pDef14,
+  pGeom: pGeom14
+};
+
+// src/heliostat/vaxis_guidance.ts
+import {
+  contourCircle as contourCircle13,
+  ctrRectangle as ctrRectangle2,
+  figure as figure15,
+  ffix as ffix17,
+  pNumber as pNumber15,
+  pSectionSeparator as pSectionSeparator14,
+  initGeom as initGeom15,
+  EExtrude as EExtrude12,
+  EBVolume as EBVolume15
+} from "geometrix";
+var pDef15 = {
+  partName: "vaxis_guidance",
+  params: [
+    //pNumber(name, unit, init, min, max, step)
+    pNumber15("D1", "mm", 700, 100, 2500, 1),
+    pNumber15("N1", "legs", 6, 1, 24, 1),
+    pNumber15("D2", "mm", 600, 100, 2e3, 1),
+    pSectionSeparator14("leg details"),
+    pNumber15("D3", "mm", 30, 1, 200, 1),
+    pNumber15("D4", "mm", 50, 1, 200, 1),
+    pNumber15("L1", "mm", 90, 1, 900, 1),
+    pNumber15("R5", "mm", 20, 0, 500, 1),
+    pSectionSeparator14("inner spring"),
+    pNumber15("D6", "mm", 540, 1, 1e3, 1),
+    pNumber15("N2", "springs", 6, 1, 24, 1),
+    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),
+    pSectionSeparator14("thickness"),
+    pNumber15("T1", "mm", 10, 1, 200, 1),
+    pNumber15("Dvaxis", "mm", 260, 5, 1e3, 1)
+  ],
+  paramSvg: {
+    D1: "vaxis_guidance_top.svg",
+    N1: "vaxis_guidance_top.svg",
+    D2: "vaxis_guidance_top.svg",
+    D3: "vaxis_guidance_top.svg",
+    D4: "vaxis_guidance_top.svg",
+    L1: "vaxis_guidance_top.svg",
+    R5: "vaxis_guidance_top.svg",
+    D6: "vaxis_guidance_top.svg",
+    N2: "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",
+    T1: "vaxis_guidance_top.svg",
+    Dvaxis: "vaxis_guidance_top.svg"
+  },
+  sim: {
+    tMax: 100,
+    tStep: 0.5,
+    tUpdate: 500
+    // every 0.5 second
+  }
+};
+function pGeom15(t, param, suffix = "") {
+  const rGeome = initGeom15(pDef15.partName + suffix);
+  const figTop = figure15();
+  const figSection = figure15();
+  rGeome.logstr += `${rGeome.partName} simTime: ${t}
+`;
+  try {
+    const R1 = param.D1 / 2;
+    const R2 = param.D2 / 2;
+    const R3 = param.D3 / 2;
+    const R4 = param.D4 / 2;
+    const R6 = param.D6 / 2;
+    if (R2 < R6) {
+      throw `err466: D6 ${param.D6} is too large compare to D2 ${param.D2}`;
+    }
+    rGeome.logstr += `vaxis_guidance: Dmax ${ffix17(param.D1 + 2 * R4)} mm
+`;
+    const [outerLog, outerCtr, stepA1] = ctrGuidanceOuter(param);
+    rGeome.logstr += outerLog;
+    figTop.addMain(outerCtr);
+    for (let i = 0; i < param.N1; i++) {
+      figTop.addMain(contourCircle13(R1, 0, R3).rotate(0, 0, i * stepA1));
+    }
+    const [innerLog, innerCtr] = ctrGuidanceInner(param);
+    rGeome.logstr += innerLog;
+    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));
+    rGeome.fig = {
+      faceTop: figTop,
+      faceSection: figSection
+    };
+    const designName = rGeome.partName;
+    rGeome.vol = {
+      extrudes: [
+        {
+          outName: `subpax_${designName}_top`,
+          face: `${designName}_faceTop`,
+          extrudeMethod: EExtrude12.eLinearOrtho,
+          length: param.T1,
+          rotate: [0, 0, 0],
+          translate: [0, 0, 0]
+        }
+      ],
+      volumes: [
+        {
+          outName: `pax_${designName}`,
+          boolMethod: EBVolume15.eIdentity,
+          inList: [`subpax_${designName}_top`]
+        }
+      ]
+    };
+    rGeome.sub = {};
+    rGeome.logstr += "vaxis_guidance drawn successfully!\n";
     rGeome.calcErr = false;
   } catch (emsg) {
     rGeome.logstr += emsg;
@@ -3771,41 +4869,44 @@ function pGeom11(t, param, suffix = "") {
   }
   return rGeome;
 }
-var poleRotorDef = {
-  pTitle: "Heliostat pole rotor",
-  pDescription: "The vertical axis inside the pole of an heliostat",
-  pDef: pDef11,
-  pGeom: pGeom11
+var vaxisGuidanceDef = {
+  pTitle: "Vaxis-guidance",
+  pDescription: "The guidance of the V-Axis for the heliostat azimuth",
+  pDef: pDef15,
+  pGeom: pGeom15
 };
 
 // src/heliostat/rod.ts
 import {
-  contour as contour11,
-  contourCircle as contourCircle10,
-  figure as figure12,
-  ffix as ffix13,
-  pNumber as pNumber12,
-  initGeom as initGeom12,
-  EExtrude as EExtrude9,
-  EBVolume as EBVolume12
+  contour as contour15,
+  contourCircle as contourCircle14,
+  figure as figure16,
+  ffix as ffix18,
+  pNumber as pNumber16,
+  pSectionSeparator as pSectionSeparator15,
+  initGeom as initGeom16,
+  EExtrude as EExtrude13,
+  EBVolume as EBVolume16
 } from "geometrix";
-var pDef12 = {
+var pDef16 = {
   partName: "rod",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber12("L1", "mm", 1e4, 100, 4e4, 10),
-    pNumber12("L2", "mm", 100, 2, 400, 1),
-    pNumber12("L3", "mm", 400, 10, 1e3, 1),
-    pNumber12("L4", "mm", 600, 10, 1e3, 1),
-    pNumber12("H1", "mm", 200, 5, 4e3, 1),
-    pNumber12("E1", "mm", 2, 1, 80, 1),
-    pNumber12("E2", "mm", 10, 1, 80, 1),
-    pNumber12("N1", "", 10, 2, 50, 1),
-    pNumber12("N3", "", 2, 1, 20, 1),
-    pNumber12("N4", "", 4, 1, 20, 1),
-    pNumber12("R3", "mm", 100, 1, 500, 1),
-    pNumber12("D2", "mm", 10, 1, 100, 1),
-    pNumber12("L7", "mm", 10, 1, 300, 1)
+    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)
   ],
   paramSvg: {
     L1: "rod_top.svg",
@@ -3829,51 +4930,51 @@ var pDef12 = {
     // every 0.5 second
   }
 };
-function pGeom12(t, param, suffix = "") {
-  const rGeome = initGeom12(pDef12.partName + suffix);
+function pGeom16(t, param, suffix = "") {
+  const rGeome = initGeom16(pDef16.partName + suffix);
   let ctrPlate;
   let ctrRod;
-  const figCut = figure12();
-  const figPlate = figure12();
-  const figTop = figure12();
+  const figCut = figure16();
+  const figPlate = figure16();
+  const figTop = figure16();
   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: ${ffix13(param.L1)} mm
+    rGeome.logstr += `rod-length: ${ffix18(param.L1)} mm
 `;
     const space_length = (param.L1 - param.L3) / (param.N1 - 1);
-    rGeome.logstr += `space-length: ${ffix13(space_length)} mm
+    rGeome.logstr += `space-length: ${ffix18(space_length)} mm
 `;
     ctrPlate = function(py) {
       const rPlate = [];
-      const plateExt = contour11(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();
+      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(contourCircle10(param.L4 / 2 - param.L7, py + i * n3step, R2));
-        rPlate.push(contourCircle10(-param.L4 / 2 + param.L7, py + i * n3step, R2));
+        rPlate.push(contourCircle14(param.L4 / 2 - param.L7, py + i * n3step, R2));
+        rPlate.push(contourCircle14(-param.L4 / 2 + param.L7, py + i * n3step, R2));
       }
       for (let i = 1; i < param.N4 + 1; i++) {
-        rPlate.push(contourCircle10(-param.L4 / 2 + i * n4step, py + param.L7, R2));
+        rPlate.push(contourCircle14(-param.L4 / 2 + i * n4step, py + param.L7, R2));
         rPlate.push(
-          contourCircle10(-param.L4 / 2 + i * n4step, py + param.L3 - param.L7, R2)
+          contourCircle14(-param.L4 / 2 + i * n4step, py + param.L3 - param.L7, R2)
         );
       }
       return rPlate;
     };
     ctrRod = function(py, ly) {
-      const rRod = contour11(param.L2 / 2, py).addSegStrokeA(param.L2 / 2, py + ly).addSegStrokeA(-param.L2 / 2, py + ly).addSegStrokeA(-param.L2 / 2, py).closeSegStroke();
+      const rRod = contour15(param.L2 / 2, py).addSegStrokeA(param.L2 / 2, py + ly).addSegStrokeA(-param.L2 / 2, py + ly).addSegStrokeA(-param.L2 / 2, py).closeSegStroke();
       return rRod;
     };
     const L2h = param.L2 / 2;
     const L4h = param.L4 / 2;
     const L2hi = (param.L2 - 2 * param.E1) / 2;
     const H1i = param.H1 - param.E1;
-    const ctrRodExt = contour11(L2h, 0).addSegStrokeA(L2h, param.H1).addSegStrokeA(-L2h, param.H1).addSegStrokeA(-L2h, 0).closeSegStroke();
-    const ctrRodInt = contour11(L2hi, param.E1).addSegStrokeA(L2hi, H1i).addSegStrokeA(-L2hi, H1i).addSegStrokeA(-L2hi, param.E1).closeSegStroke();
-    const ctrPlateSide = contour11(L4h, param.H1).addSegStrokeA(L4h, param.H1 + param.E2).addSegStrokeA(-L4h, param.H1 + param.E2).addSegStrokeA(-L4h, param.H1).closeSegStroke();
+    const ctrRodExt = contour15(L2h, 0).addSegStrokeA(L2h, param.H1).addSegStrokeA(-L2h, param.H1).addSegStrokeA(-L2h, 0).closeSegStroke();
+    const ctrRodInt = contour15(L2hi, param.E1).addSegStrokeA(L2hi, H1i).addSegStrokeA(-L2hi, H1i).addSegStrokeA(-L2hi, param.E1).closeSegStroke();
+    const ctrPlateSide = contour15(L4h, param.H1).addSegStrokeA(L4h, param.H1 + param.E2).addSegStrokeA(-L4h, param.H1 + param.E2).addSegStrokeA(-L4h, param.H1).closeSegStroke();
     figCut.addMain(ctrRodExt);
     figCut.addMain(ctrRodInt);
     figCut.addSecond(ctrPlateSide);
@@ -3895,7 +4996,7 @@ function pGeom12(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rod`,
           face: `${designName}_faceCut`,
-          extrudeMethod: EExtrude9.eLinearOrtho,
+          extrudeMethod: EExtrude13.eLinearOrtho,
           length: param.L1,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
@@ -3903,7 +5004,7 @@ function pGeom12(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_plates`,
           face: `${designName}_faceTop`,
-          extrudeMethod: EExtrude9.eLinearOrtho,
+          extrudeMethod: EExtrude13.eLinearOrtho,
           length: param.E2,
           rotate: [Math.PI / 2, 0, 0],
           translate: [0, param.E2 + param.H1, 0]
@@ -3912,7 +5013,7 @@ function pGeom12(t, param, suffix = "") {
       volumes: [
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume12.eUnion,
+          boolMethod: EBVolume16.eUnion,
           inList: [`subpax_${designName}_rod`, `subpax_${designName}_plates`]
         }
       ]
@@ -3929,47 +5030,51 @@ function pGeom12(t, param, suffix = "") {
 var rodDef = {
   pTitle: "Heliostat rod",
   pDescription: "The rod of an heliostat-surface",
-  pDef: pDef12,
-  pGeom: pGeom12
+  pDef: pDef16,
+  pGeom: pGeom16
 };
 
 // src/heliostat/trapeze.ts
 import {
-  contour as contour12,
-  contourCircle as contourCircle11,
-  figure as figure13,
-  radToDeg as radToDeg8,
-  ffix as ffix14,
-  pNumber as pNumber13,
-  initGeom as initGeom13,
-  EExtrude as EExtrude10,
-  EBVolume as EBVolume13
+  contour as contour16,
+  contourCircle as contourCircle15,
+  figure as figure17,
+  radToDeg as radToDeg9,
+  ffix as ffix19,
+  pNumber as pNumber17,
+  pSectionSeparator as pSectionSeparator16,
+  initGeom as initGeom17,
+  EExtrude as EExtrude14,
+  EBVolume as EBVolume17
 } from "geometrix";
-var pDef13 = {
+var pDef17 = {
   partName: "trapeze",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber13("L1", "mm", 1600, 10, 4e3, 1),
-    pNumber13("L2", "mm", 1e3, 10, 4e3, 1),
-    pNumber13("L3", "mm", 400, 5, 800, 1),
-    pNumber13("L4", "mm", 300, 5, 800, 1),
-    pNumber13("N1", "", 7, 1, 20, 1),
-    pNumber13("N2", "", 4, 1, 20, 1),
-    pNumber13("N3", "", 2, 1, 20, 1),
-    pNumber13("N4", "", 2, 1, 20, 1),
-    pNumber13("L5", "mm", 100, 1, 400, 1),
-    pNumber13("L6", "mm", 20, 1, 400, 1),
-    pNumber13("L7", "mm", 20, 1, 400, 1),
-    pNumber13("D1", "mm", 10, 1, 40, 1),
-    pNumber13("D2", "mm", 10, 1, 40, 1),
-    pNumber13("D3", "mm", 30, 1, 100, 1),
-    pNumber13("D4", "mm", 26, 1, 100, 1),
-    pNumber13("R1", "mm", 60, 1, 400, 1),
-    pNumber13("R2", "mm", 20, 1, 400, 1),
-    pNumber13("R3", "mm", 20, 1, 400, 1),
-    pNumber13("H1", "mm", 300, 0.5, 800, 0.5),
-    pNumber13("H2", "mm", 2, 0.5, 800, 0.5),
-    pNumber13("H3", "mm", 5, 0.5, 800, 0.5)
+    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)
   ],
   paramSvg: {
     L1: "trapeze_top.svg",
@@ -4001,15 +5106,15 @@ var pDef13 = {
     // every 0.5 second
   }
 };
-function pGeom13(t, param, suffix = "") {
-  const rGeome = initGeom13(pDef13.partName + suffix);
+function pGeom17(t, param, suffix = "") {
+  const rGeome = initGeom17(pDef17.partName + suffix);
   let ctrRodFootprint;
   let ctrRod;
-  const figFrame = figure13();
-  const figPlate = figure13();
-  const figRod = figure13();
-  const figRodHollow = figure13();
-  const figCutRod = figure13();
+  const figFrame = figure17();
+  const figPlate = figure17();
+  const figRod = figure17();
+  const figRodHollow = figure17();
+  const figCutRod = figure17();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
@@ -4031,39 +5136,39 @@ function pGeom13(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: ${ffix14(rod_slope_length)} mm,  angle: ${ffix14(
-      radToDeg8(rod_slope_angle)
+    rGeome.logstr += `rod-slope:  length: ${ffix19(rod_slope_length)} mm,  angle: ${ffix19(
+      radToDeg9(rod_slope_angle)
     )} degree
 `;
-    rGeome.logstr += `rod-xy-angle: ${ffix14(radToDeg8(rod_xy_angle))} degree
+    rGeome.logstr += `rod-xy-angle: ${ffix19(radToDeg9(rod_xy_angle))} degree
 `;
     const rodFootprintLength = param.D3 / Math.cos(Math.PI / 2 - rod_slope_angle);
-    rGeome.logstr += `rod-footprint-length: ${ffix14(rodFootprintLength)} mm
+    rGeome.logstr += `rod-footprint-length: ${ffix19(rodFootprintLength)} mm
 `;
     const rodFPl = Math.sqrt((rodFootprintLength / 2) ** 2 + (param.D3 / 2) ** 2);
     const rodFPa = Math.atan2(param.D3, rodFootprintLength);
     ctrRodFootprint = function(px, py, angle) {
-      const rCtr = contour12(px, py).addPointRP(angle + Math.PI - rodFPa, rodFPl).addSeg2Arcs(angle + Math.PI / 2, angle).addPointRP(angle + Math.PI + rodFPa, rodFPl).addSeg2Arcs(angle + Math.PI, angle + Math.PI / 2).addPointRP(angle - rodFPa, rodFPl).addSeg2Arcs(angle + 3 * Math.PI / 2, angle + Math.PI).addPointRP(angle + rodFPa, rodFPl).addSeg2Arcs(angle, angle - Math.PI / 2);
+      const rCtr = contour16(px, py).addPointRP(angle + Math.PI - rodFPa, rodFPl).addSeg2Arcs(angle + Math.PI / 2, angle).addPointRP(angle + Math.PI + rodFPa, rodFPl).addSeg2Arcs(angle + Math.PI, angle + Math.PI / 2).addPointRP(angle - rodFPa, rodFPl).addSeg2Arcs(angle + 3 * Math.PI / 2, angle + Math.PI).addPointRP(angle + rodFPa, rodFPl).addSeg2Arcs(angle, angle - Math.PI / 2);
       return rCtr;
     };
     ctrRod = function(px, py, angle) {
       const px0 = px + rodFPl * Math.cos(angle + Math.PI - rodFPa);
       const py0 = py + rodFPl * Math.sin(angle + Math.PI - rodFPa);
-      const rCtr = contour12(px0, py0).addSegStrokeRP(angle + Math.PI, rod_xy).addSegStrokeRP(angle - Math.PI / 2, param.D3).addSegStrokeRP(angle, rod_xy).closeSegStroke();
+      const rCtr = contour16(px0, py0).addSegStrokeRP(angle + Math.PI, rod_xy).addSegStrokeRP(angle - Math.PI / 2, param.D3).addSegStrokeRP(angle, rod_xy).closeSegStroke();
       return rCtr;
     };
     if (param.R1 > param.L1 / 4 || param.R1 > param.L2 / 4) {
       throw `err614: R1 ${param.R1} too large compare to L1 ${param.L1} or L2 ${param.L2}`;
     }
-    const ctrFrameExt = contour12(param.L2 / 2, param.L1 / 2).addSegStrokeA(-param.L2 / 2, param.L1 / 2).addCornerRounded(param.R1).addSegStrokeA(-param.L2 / 2, -param.L1 / 2).addCornerRounded(param.R1).addSegStrokeA(param.L2 / 2, -param.L1 / 2).addCornerRounded(param.R1).closeSegStroke().addCornerRounded(param.R1);
+    const ctrFrameExt = contour16(param.L2 / 2, param.L1 / 2).addSegStrokeA(-param.L2 / 2, param.L1 / 2).addCornerRounded(param.R1).addSegStrokeA(-param.L2 / 2, -param.L1 / 2).addCornerRounded(param.R1).addSegStrokeA(param.L2 / 2, -param.L1 / 2).addCornerRounded(param.R1).closeSegStroke().addCornerRounded(param.R1);
     if (param.R2 > (param.L1 - 2 * param.L5) / 4 || param.R2 > (param.L2 - 2 * param.L5) / 4) {
       throw `err627: R2 ${param.R2} too large compare to L1 ${param.L1}, L2 ${param.L2} and L5 ${param.L5}`;
     }
-    const ctrFrameInt = contour12(param.L2 / 2 - param.L5, param.L1 / 2 - param.L5).addSegStrokeA(-param.L2 / 2 + param.L5, param.L1 / 2 - param.L5).addCornerRounded(param.R2).addSegStrokeA(-param.L2 / 2 + param.L5, -param.L1 / 2 + param.L5).addCornerRounded(param.R2).addSegStrokeA(param.L2 / 2 - param.L5, -param.L1 / 2 + param.L5).addCornerRounded(param.R2).closeSegStroke().addCornerRounded(param.R2);
+    const ctrFrameInt = contour16(param.L2 / 2 - param.L5, param.L1 / 2 - param.L5).addSegStrokeA(-param.L2 / 2 + param.L5, param.L1 / 2 - param.L5).addCornerRounded(param.R2).addSegStrokeA(-param.L2 / 2 + param.L5, -param.L1 / 2 + param.L5).addCornerRounded(param.R2).addSegStrokeA(param.L2 / 2 - param.L5, -param.L1 / 2 + param.L5).addCornerRounded(param.R2).closeSegStroke().addCornerRounded(param.R2);
     if (param.R3 > param.L3 / 4 || param.R3 > param.L4 / 4) {
       throw `err639: R3 ${param.R3} too large compare to L3 ${param.L3} or L4 ${param.L4}`;
     }
-    const ctrPlate = contour12(param.L4 / 2, param.L3 / 2).addSegStrokeA(-param.L4 / 2, param.L3 / 2).addCornerRounded(param.R3).addSegStrokeA(-param.L4 / 2, -param.L3 / 2).addCornerRounded(param.R3).addSegStrokeA(param.L4 / 2, -param.L3 / 2).addCornerRounded(param.R3).closeSegStroke().addCornerRounded(param.R3);
+    const ctrPlate = contour16(param.L4 / 2, param.L3 / 2).addSegStrokeA(-param.L4 / 2, param.L3 / 2).addCornerRounded(param.R3).addSegStrokeA(-param.L4 / 2, -param.L3 / 2).addCornerRounded(param.R3).addSegStrokeA(param.L4 / 2, -param.L3 / 2).addCornerRounded(param.R3).closeSegStroke().addCornerRounded(param.R3);
     figFrame.addMain(ctrFrameExt);
     figFrame.addMain(ctrFrameInt);
     figFrame.addSecond(ctrPlate);
@@ -4083,35 +5188,35 @@ function pGeom13(t, param, suffix = "") {
     const lFrameHole = [];
     for (let i = 1; i < param.N1 + 1; i++) {
       lFrameHole.push(
-        contourCircle11(param.L2 / 2 - param.L6, -param.L1 / 2 + i * step1, param.D1 / 2)
+        contourCircle15(param.L2 / 2 - param.L6, -param.L1 / 2 + i * step1, param.D1 / 2)
       );
       lFrameHole.push(
-        contourCircle11(-param.L2 / 2 + param.L6, -param.L1 / 2 + i * step1, param.D1 / 2)
+        contourCircle15(-param.L2 / 2 + param.L6, -param.L1 / 2 + i * step1, param.D1 / 2)
       );
     }
     for (let i = 1; i < param.N2 + 1; i++) {
       lFrameHole.push(
-        contourCircle11(-param.L2 / 2 + i * step2, param.L1 / 2 - param.L6, param.D1 / 2)
+        contourCircle15(-param.L2 / 2 + i * step2, param.L1 / 2 - param.L6, param.D1 / 2)
       );
       lFrameHole.push(
-        contourCircle11(-param.L2 / 2 + i * step2, -param.L1 / 2 + param.L6, param.D1 / 2)
+        contourCircle15(-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(
-        contourCircle11(param.L4 / 2 - param.L7, -param.L3 / 2 + i * step3, param.D2 / 2)
+        contourCircle15(param.L4 / 2 - param.L7, -param.L3 / 2 + i * step3, param.D2 / 2)
       );
       lPlateHole.push(
-        contourCircle11(-param.L4 / 2 + param.L7, -param.L3 / 2 + i * step3, param.D2 / 2)
+        contourCircle15(-param.L4 / 2 + param.L7, -param.L3 / 2 + i * step3, param.D2 / 2)
       );
     }
     for (let i = 1; i < param.N4 + 1; i++) {
       lPlateHole.push(
-        contourCircle11(-param.L4 / 2 + i * step4, param.L3 / 2 - param.L7, param.D2 / 2)
+        contourCircle15(-param.L4 / 2 + i * step4, param.L3 / 2 - param.L7, param.D2 / 2)
       );
       lPlateHole.push(
-        contourCircle11(-param.L4 / 2 + i * step4, -param.L3 / 2 + param.L7, param.D2 / 2)
+        contourCircle15(-param.L4 / 2 + i * step4, -param.L3 / 2 + param.L7, param.D2 / 2)
       );
     }
     lFrameHole.forEach((ctr) => {
@@ -4166,17 +5271,17 @@ function pGeom13(t, param, suffix = "") {
     if (param.D4 >= param.D3) {
       throw `err218: D4 ${param.D4} larger than D3 ${param.D3}`;
     }
-    figRod.addMain(contourCircle11(0, 0, param.D3 / 2));
-    figRod.addSecond(contourCircle11(0, 0, param.D4 / 2));
-    figRodHollow.addMain(contourCircle11(0, 0, param.D4 / 2));
-    figRodHollow.addSecond(contourCircle11(0, 0, param.D3 / 2));
+    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));
     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);
     const pad3y = pad3 + (rodFootprintLength / 2 + rodFootprintBack) * Math.sin(rod_xy_angle);
     const rodExtrudeLength = rod_slope_length + 2 * (rodFootprintLength + rodFootprintBack + rodFootprintHeight);
     const cutL = rodExtrudeLength + param.L3 + param.L4 + rodFootprintHeight;
-    const ctrCutRod = contour12(cutL, cutL).addSegStrokeA(-cutL, cutL).addSegStrokeA(-cutL, -cutL).addSegStrokeA(cutL, -cutL).closeSegStroke();
+    const ctrCutRod = contour16(cutL, cutL).addSegStrokeA(-cutL, cutL).addSegStrokeA(-cutL, -cutL).addSegStrokeA(cutL, -cutL).closeSegStroke();
     figCutRod.addMain(ctrCutRod);
     rGeome.fig = {
       faceFrame: figFrame,
@@ -4191,7 +5296,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_frame`,
           face: `${designName}_faceFrame`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: param.H2,
           rotate: [0, 0, 0],
           translate: [0, 0, param.H1 - param.H2]
@@ -4199,7 +5304,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_plate`,
           face: `${designName}_facePlate`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: param.H3,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
@@ -4207,7 +5312,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rod1`,
           face: `${designName}_faceRod`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, rod_xy_angle],
           translate: [
@@ -4219,7 +5324,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rod2`,
           face: `${designName}_faceRod`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, Math.PI - rod_xy_angle],
           translate: [
@@ -4231,7 +5336,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rod3`,
           face: `${designName}_faceRod`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, Math.PI + rod_xy_angle],
           translate: [
@@ -4243,7 +5348,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rod4`,
           face: `${designName}_faceRod`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, -rod_xy_angle],
           translate: [
@@ -4255,7 +5360,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rodH1`,
           face: `${designName}_faceRodHollow`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, rod_xy_angle],
           translate: [
@@ -4267,7 +5372,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rodH2`,
           face: `${designName}_faceRodHollow`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, Math.PI - rod_xy_angle],
           translate: [
@@ -4279,7 +5384,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rodH3`,
           face: `${designName}_faceRodHollow`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, Math.PI + rod_xy_angle],
           translate: [
@@ -4291,7 +5396,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rodH4`,
           face: `${designName}_faceRodHollow`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, -rod_xy_angle],
           translate: [
@@ -4303,7 +5408,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_cut1`,
           face: `${designName}_faceCutRod`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: cutL,
           rotate: [0, 0, 0],
           translate: [0, 0, -cutL]
@@ -4311,7 +5416,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_cut2`,
           face: `${designName}_faceCutRod`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: cutL,
           rotate: [0, 0, 0],
           translate: [0, 0, param.H1]
@@ -4320,7 +5425,7 @@ function pGeom13(t, param, suffix = "") {
       volumes: [
         {
           outName: `ipax_${designName}_rawRod`,
-          boolMethod: EBVolume13.eUnion,
+          boolMethod: EBVolume17.eUnion,
           inList: [
             `subpax_${designName}_rod1`,
             `subpax_${designName}_rod2`,
@@ -4330,7 +5435,7 @@ function pGeom13(t, param, suffix = "") {
         },
         {
           outName: `ipax_${designName}_rodHollow`,
-          boolMethod: EBVolume13.eUnion,
+          boolMethod: EBVolume17.eUnion,
           inList: [
             `subpax_${designName}_rodH1`,
             `subpax_${designName}_rodH2`,
@@ -4340,17 +5445,17 @@ function pGeom13(t, param, suffix = "") {
         },
         {
           outName: `ipax_${designName}_halfRods`,
-          boolMethod: EBVolume13.eSubstraction,
+          boolMethod: EBVolume17.eSubstraction,
           inList: [`ipax_${designName}_rawRod`, `subpax_${designName}_cut1`]
         },
         {
           outName: `ipax_${designName}_rods`,
-          boolMethod: EBVolume13.eSubstraction,
+          boolMethod: EBVolume17.eSubstraction,
           inList: [`ipax_${designName}_halfRods`, `subpax_${designName}_cut2`]
         },
         {
           outName: `ipax_${designName}_plus`,
-          boolMethod: EBVolume13.eUnion,
+          boolMethod: EBVolume17.eUnion,
           inList: [
             `subpax_${designName}_frame`,
             `subpax_${designName}_plate`,
@@ -4359,7 +5464,7 @@ function pGeom13(t, param, suffix = "") {
         },
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume13.eSubstraction,
+          boolMethod: EBVolume17.eSubstraction,
           inList: [`ipax_${designName}_plus`, `ipax_${designName}_rodHollow`]
         }
       ]
@@ -4376,49 +5481,54 @@ function pGeom13(t, param, suffix = "") {
 var trapezeDef = {
   pTitle: "Heliostat trapeze",
   pDescription: "The support of one solar panel. Made out of aluminium for lightness and cooling",
-  pDef: pDef13,
-  pGeom: pGeom13
+  pDef: pDef17,
+  pGeom: pGeom17
 };
 
 // src/heliostat/surface.ts
 import {
-  contour as contour13,
-  figure as figure14,
-  ffix as ffix15,
-  pNumber as pNumber14,
-  pCheckbox as pCheckbox3,
+  contour as contour17,
+  figure as figure18,
+  ffix as ffix20,
+  pNumber as pNumber18,
+  pCheckbox as pCheckbox4,
   pDropdown as pDropdown2,
-  initGeom as initGeom14,
-  EExtrude as EExtrude11,
-  EBVolume as EBVolume14
+  pSectionSeparator as pSectionSeparator17,
+  initGeom as initGeom18,
+  EExtrude as EExtrude15,
+  EBVolume as EBVolume18
 } from "geometrix";
-var pDef14 = {
+var pDef18 = {
   partName: "surface",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber14("LH", "mm", 1600, 10, 4e3, 1),
-    pNumber14("LV", "mm", 1e3, 10, 4e3, 1),
-    pNumber14("LZ", "mm", 40, 0, 100, 1),
-    pNumber14("nx", "", 9, 1, 40, 1),
-    pNumber14("ny", "", 9, 1, 40, 1),
+    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"]),
-    pCheckbox3("crenel", false),
-    pNumber14("first_row", "", 9, 1, 40, 1),
-    pNumber14("second_row", "", 9, 1, 40, 1),
-    pNumber14("EH", "mm", 10, 0, 1e3, 1),
-    pCheckbox3("EH_gradient", false),
-    pNumber14("EH_sup", "mm", 500, 0, 1e3, 1),
-    pNumber14("EH_cycle", "", 1, 0, 3, 0.05),
-    pNumber14("EH_start", "", 0, 0, 1, 0.05),
+    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),
+    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"]),
-    pNumber14("EV", "mm", 10, 0, 1e3, 1),
-    pCheckbox3("EV_gradient", false),
-    pNumber14("EV_sup", "mm", 500, 0, 1e3, 1),
-    pNumber14("EV_cycle", "", 1, 0, 3, 0.05),
-    pNumber14("EV_start", "", 0, 0, 1, 0.05),
+    pSectionSeparator17("vertical spacing"),
+    pNumber18("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"]),
-    pNumber14("power_efficiency", "%", 16, 0, 100, 0.1),
-    pNumber14("solar_power", "W/m2", 816, 100, 2e3, 1)
+    pSectionSeparator17("solar power"),
+    pNumber18("power_efficiency", "%", 16, 0, 100, 0.1),
+    pNumber18("solar_power", "W/m2", 816, 100, 2e3, 1)
     // 1361*0.6=816 W/m2
   ],
   paramSvg: {
@@ -4453,26 +5563,26 @@ var pDef14 = {
     // every 0.5 second
   }
 };
-function pGeom14(t, param, suffix = "") {
-  const rGeome = initGeom14(pDef14.partName + suffix);
+function pGeom18(t, param, suffix = "") {
+  const rGeome = initGeom18(pDef18.partName + suffix);
   let ctrPanelProfile;
-  const figSurface = figure14();
-  const figOnePanel = figure14();
+  const figSurface = figure18();
+  const figOnePanel = figure18();
   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: ${ffix15(panel_surface)} m2
+    rGeome.logstr += `panel surface: ${ffix20(panel_surface)} m2
 `;
-    rGeome.logstr += `panel power: ${ffix15(panel_power)} W
+    rGeome.logstr += `panel power: ${ffix20(panel_power)} W
 `;
     const max_panel_nb = param.nx * param.ny;
     rGeome.logstr += `max panel number: ${max_panel_nb}
 `;
-    rGeome.logstr += `max panel surface: ${ffix15(max_panel_nb * panel_surface)} m2
+    rGeome.logstr += `max panel surface: ${ffix20(max_panel_nb * panel_surface)} m2
 `;
-    rGeome.logstr += `max panel power: ${ffix15(max_panel_nb * panel_power)} W
+    rGeome.logstr += `max panel power: ${ffix20(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;
@@ -4505,13 +5615,13 @@ function pGeom14(t, param, suffix = "") {
     lenRow.forEach((oneRow) => {
       panelNb += oneRow;
     });
-    rGeome.logstr += `actual panel number: ${panelNb} (${ffix15(
+    rGeome.logstr += `actual panel number: ${panelNb} (${ffix20(
       100 * panelNb / max_panel_nb
     )} %)
 `;
-    rGeome.logstr += `actual panel surface: ${ffix15(panelNb * panel_surface)} m2
+    rGeome.logstr += `actual panel surface: ${ffix20(panelNb * panel_surface)} m2
 `;
-    rGeome.logstr += `actual panel power: ${ffix15(panelNb * panel_power)} W
+    rGeome.logstr += `actual panel power: ${ffix20(panelNb * panel_power)} W
 `;
     const eMain = [];
     for (let i = 0; i < lenMain - 1; i++) {
@@ -4587,18 +5697,18 @@ function pGeom14(t, param, suffix = "") {
       gLenVertical = lenMain * param.LV + eMainTotal;
     }
     const gArea = gLenHorizontal * gLenVertical / 10 ** 6;
-    rGeome.logstr += `global horizontal width: ${ffix15(gLenHorizontal / 1e3)} m
+    rGeome.logstr += `global horizontal width: ${ffix20(gLenHorizontal / 1e3)} m
 `;
-    rGeome.logstr += `global vertical height: ${ffix15(gLenVertical / 1e3)} m
+    rGeome.logstr += `global vertical height: ${ffix20(gLenVertical / 1e3)} m
 `;
-    rGeome.logstr += `global area: ${ffix15(gArea)} m2
+    rGeome.logstr += `global area: ${ffix20(gArea)} m2
 `;
-    rGeome.logstr += `area efficiency: ${ffix15(100 * panelNb * panel_surface / gArea)} %
+    rGeome.logstr += `area efficiency: ${ffix20(100 * panelNb * panel_surface / gArea)} %
 `;
     const ox = -gLenHorizontal / 2;
     const oy = -gLenVertical / 2;
     ctrPanelProfile = function(px, py) {
-      const rPanelProfile = contour13(px, py).addSegStrokeA(px + param.LH, py).addSegStrokeA(px + param.LH, py + param.LV).addSegStrokeA(px, py + param.LV).closeSegStroke();
+      const rPanelProfile = contour17(px, py).addSegStrokeA(px + param.LH, py).addSegStrokeA(px + param.LH, py + param.LV).addSegStrokeA(px, py + param.LV).closeSegStroke();
       return rPanelProfile;
     };
     const panelPositions = [];
@@ -4638,7 +5748,7 @@ function pGeom14(t, param, suffix = "") {
         const rElem = {
           outName: `subpax_${designName}_panel_${idx}`,
           face: `${designName}_faceOnePanel`,
-          extrudeMethod: EExtrude11.eLinearOrtho,
+          extrudeMethod: EExtrude15.eLinearOrtho,
           length: param.LZ,
           rotate: [0, 0, 0],
           translate: [elem[0], elem[1], 0]
@@ -4649,7 +5759,7 @@ function pGeom14(t, param, suffix = "") {
         {
           outName: `pax_${designName}`,
           //boolMethod: EBVolume.eIdentity,
-          boolMethod: EBVolume14.eUnion,
+          boolMethod: EBVolume18.eUnion,
           inList: panelPositions.map((elem, idx) => {
             const subElem = `subpax_${designName}_panel_${idx}`;
             return subElem;
@@ -4669,19 +5779,19 @@ function pGeom14(t, param, suffix = "") {
 var surfaceDef = {
   pTitle: "Heliostat panel-surface",
   pDescription: "The surface collecting the solar power",
-  pDef: pDef14,
-  pGeom: pGeom14
+  pDef: pDef18,
+  pGeom: pGeom18
 };
 
 // src/dummy/circles.ts
-import { degToRad as degToRad4, point as point3, figure as figure15, pNumber as pNumber15, initGeom as initGeom15 } from "geometrix";
-var pDef15 = {
+import { degToRad as degToRad6, point as point6, figure as figure19, pNumber as pNumber19, initGeom as initGeom19 } from "geometrix";
+var pDef19 = {
   partName: "circles",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber15("angle", "degree", 15, 5, 45, 1),
-    pNumber15("amplitude-offset", "mm", 1, 0.5, 4, 0.1),
-    pNumber15("amplitude-scale", "scalar", 0.2, 0.1, 0.5, 0.01)
+    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)
   ],
   paramSvg: {
     angle: "circles_angle.svg",
@@ -4694,18 +5804,18 @@ var pDef15 = {
     tUpdate: 500
   }
 };
-function pGeom15(t, param, suffix = "") {
-  const rGeome = initGeom15(pDef15.partName + suffix);
+function pGeom19(t, param, suffix = "") {
+  const rGeome = initGeom19(pDef19.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure15();
-    const p1 = point3(10, 10);
-    const p2 = point3(10, 30);
+    const figOne = figure19();
+    const p1 = point6(10, 10);
+    const p2 = point6(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 * degToRad4(param.angle) + t * Math.PI / 2 / pDef15.sim.tMax)
+        p1.scale(p2, param["amplitude-offset"] + param["amplitude-scale"] * i).rotate(p2, i * degToRad6(param.angle) + t * Math.PI / 2 / pDef19.sim.tMax)
       );
     }
     rGeome.fig = { one: figOne };
@@ -4720,18 +5830,18 @@ function pGeom15(t, param, suffix = "") {
 var circlesDef = {
   pTitle: "Circles",
   pDescription: "A spiral made by points.",
-  pDef: pDef15,
-  pGeom: pGeom15
+  pDef: pDef19,
+  pGeom: pGeom19
 };
 
 // src/dummy/rectangle.ts
-import { point as point4, figure as figure16, pNumber as pNumber16, initGeom as initGeom16 } from "geometrix";
-var pDef16 = {
+import { point as point7, figure as figure20, pNumber as pNumber20, initGeom as initGeom20 } from "geometrix";
+var pDef20 = {
   partName: "rectangle",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber16("width", "mm", 15, 3, 40, 0.5),
-    pNumber16("height", "mm", 10, 3, 40, 0.5)
+    pNumber20("width", "mm", 15, 3, 40, 0.5),
+    pNumber20("height", "mm", 10, 3, 40, 0.5)
   ],
   paramSvg: {
     width: "rectangle_width.svg",
@@ -4743,16 +5853,16 @@ var pDef16 = {
     tUpdate: 500
   }
 };
-function pGeom16(t, param, suffix = "") {
-  const rGeome = initGeom16(pDef16.partName + suffix);
+function pGeom20(t, param, suffix = "") {
+  const rGeome = initGeom20(pDef20.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure16();
-    const p1 = point4(10, 10);
-    const p2 = point4(10 + param.width, 10);
-    const p3 = point4(10 + param.width, 10 + param.height);
-    const p4 = point4(10, 10 + param.height);
+    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 angle = t * Math.PI / 180;
     figOne.addPoint(p1);
     figOne.addPoint(p2.rotate(p1, angle));
@@ -4770,25 +5880,25 @@ function pGeom16(t, param, suffix = "") {
 var rectangleDef = {
   pTitle: "Rectangle",
   pDescription: "Just a rectangle.",
-  pDef: pDef16,
-  pGeom: pGeom16
+  pDef: pDef20,
+  pGeom: pGeom20
 };
 
 // src/dummy/pole_static.ts
 import {
-  contour as contour14,
-  contourCircle as contourCircle12,
-  figure as figure17,
-  pNumber as pNumber17,
-  initGeom as initGeom17
+  contour as contour18,
+  contourCircle as contourCircle16,
+  figure as figure21,
+  pNumber as pNumber21,
+  initGeom as initGeom21
 } from "geometrix";
-var pDef17 = {
+var pDef21 = {
   partName: "pole_static",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber17("H1", "mm", 4e3, 100, 4e4, 10),
-    pNumber17("H2", "mm", 5e3, 100, 4e4, 10),
-    pNumber17("radius", "mm", 1e3, 100, 4e4, 10)
+    pNumber21("H1", "mm", 4e3, 100, 4e4, 10),
+    pNumber21("H2", "mm", 5e3, 100, 4e4, 10),
+    pNumber21("radius", "mm", 1e3, 100, 4e4, 10)
   ],
   paramSvg: {
     H1: "dummy_pole_static_face.svg",
@@ -4802,15 +5912,15 @@ var pDef17 = {
     // every 0.5 second
   }
 };
-function pGeom17(t, param, suffix = "") {
-  const rGeome = initGeom17(pDef17.partName + suffix);
-  const figFace = figure17();
+function pGeom21(t, param, suffix = "") {
+  const rGeome = initGeom21(pDef21.partName + suffix);
+  const figFace = figure21();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const ctrPoleFace = contour14(-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();
+    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(contourCircle12(0, 0, param.radius));
+    figFace.addMain(contourCircle16(0, 0, param.radius));
     rGeome.fig = {
       poleFace: figFace
     };
@@ -4826,22 +5936,22 @@ function pGeom17(t, param, suffix = "") {
 var dummyPoleStaticDef = {
   pTitle: "Dummy pole static",
   pDescription: "Testing two design with identical name",
-  pDef: pDef17,
-  pGeom: pGeom17
+  pDef: pDef21,
+  pGeom: pGeom21
 };
 
 // src/geometrix_verification/verify_point.ts
-import { degToRad as degToRad5, point as point5, figure as figure18, pNumber as pNumber18, initGeom as initGeom18 } from "geometrix";
-var pDef18 = {
+import { degToRad as degToRad7, point as point8, figure as figure22, pNumber as pNumber22, initGeom as initGeom22 } from "geometrix";
+var pDef22 = {
   partName: "verify_point",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber18("p1x", "mm", 30, -200, 200, 1),
-    pNumber18("p1y", "mm", 50, -200, 200, 1),
-    pNumber18("p2a", "degree", 30, -200, 200, 1),
-    pNumber18("p2l", "mm", 60, 0, 200, 1),
-    pNumber18("rotateOrig", "degree", 45, -200, 200, 1),
-    pNumber18("scaleOrig", "scalar", 1.5, 0.1, 2, 0.1)
+    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)
   ],
   paramSvg: {
     p1x: "verify_point_p1x.svg",
@@ -4858,15 +5968,15 @@ var pDef18 = {
     // every 0.5 second
   }
 };
-function pGeom18(t, param, suffix = "") {
-  const rGeome = initGeom18(pDef18.partName + suffix);
+function pGeom22(t, param, suffix = "") {
+  const rGeome = initGeom22(pDef22.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure18();
-    const p1 = point5(param.p1x, param.p1y + t);
-    const p2 = point5(0, 0).setPolar(degToRad5(param.p2a), param.p2l);
-    const p3 = p1.rotateOrig(degToRad5(param.rotateOrig));
+    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 p4 = p1.scaleOrig(param.scaleOrig);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
@@ -4884,23 +5994,23 @@ function pGeom18(t, param, suffix = "") {
 var verifyPoint1Def = {
   pTitle: "Verify point",
   pDescription: "Debugging point.ts",
-  pDef: pDef18,
-  pGeom: pGeom18
+  pDef: pDef22,
+  pGeom: pGeom22
 };
 
 // src/geometrix_verification/verify_point_2.ts
-import { point as point6, figure as figure19, pNumber as pNumber19, initGeom as initGeom19 } from "geometrix";
-var pDef19 = {
+import { point as point9, figure as figure23, pNumber as pNumber23, initGeom as initGeom23 } from "geometrix";
+var pDef23 = {
   partName: "verify_point_2",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber19("p1x", "mm", 30, -200, 200, 1),
-    pNumber19("p1y", "mm", 50, -200, 200, 1),
-    pNumber19("p2x", "mm", -10, -200, 200, 1),
-    pNumber19("p2y", "mm", 60, -200, 200, 1),
-    pNumber19("p3x", "mm", 70, -200, 200, 1),
-    pNumber19("p3y", "mm", -20, -200, 200, 1),
-    pNumber19("dist", "mm", 50, 0, 200, 1)
+    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)
   ],
   paramSvg: {
     p1x: "verify_line_p1x.svg",
@@ -4918,15 +6028,15 @@ var pDef19 = {
     // every 0.5 second
   }
 };
-function pGeom19(t, param, suffix = "") {
-  const rGeome = initGeom19(pDef19.partName + suffix);
+function pGeom23(t, param, suffix = "") {
+  const rGeome = initGeom23(pDef23.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure19();
-    const p1 = point6(param.p1x, param.p1y + t);
-    const p2 = point6(param.p2x, param.p2y);
-    const p3 = point6(param.p3x, param.p3y);
+    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 mp1p2 = p1.middlePoint(p2);
     const ep1p2 = p1.equidistantPoint(p2, param.dist, p3);
     figOne.addPoint(p1);
@@ -4946,22 +6056,22 @@ function pGeom19(t, param, suffix = "") {
 var verifyPoint2Def = {
   pTitle: "Verify point 2",
   pDescription: "Debugging more point.ts",
-  pDef: pDef19,
-  pGeom: pGeom19
+  pDef: pDef23,
+  pGeom: pGeom23
 };
 
 // src/geometrix_verification/verify_line.ts
-import { point as point7, line, linePP, figure as figure20, pNumber as pNumber20, initGeom as initGeom20 } from "geometrix";
-var pDef20 = {
+import { point as point10, line, linePP, figure as figure24, pNumber as pNumber24, initGeom as initGeom24 } from "geometrix";
+var pDef24 = {
   partName: "verify_line",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber20("p1x", "mm", 30, -200, 200, 1),
-    pNumber20("p1y", "mm", 50, -200, 200, 1),
-    pNumber20("p2x", "mm", 40, -200, 200, 1),
-    pNumber20("p2y", "mm", -20, -200, 200, 1),
-    pNumber20("p3x", "mm", -30, -200, 200, 1),
-    pNumber20("p3y", "mm", 30, -200, 200, 1)
+    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)
   ],
   paramSvg: {
     p1x: "verify_line_p1x.svg",
@@ -4978,25 +6088,25 @@ var pDef20 = {
     // every 0.5 second
   }
 };
-function pGeom20(t, param, suffix = "") {
-  const rGeome = initGeom20(pDef20.partName + suffix);
+function pGeom24(t, param, suffix = "") {
+  const rGeome = initGeom24(pDef24.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure20();
-    const p1 = point7(param.p1x, param.p1y + t);
-    const p2 = point7(param.p2x, param.p2y);
-    const p3 = point7(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);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
     figOne.addPoint(p3);
     const l1 = line(0, 0, 0).setFromPoints(p1, p2);
     figOne.addLine(l1);
-    figOne.addPoint(point7(l1.getAxisXIntersection(), 0));
-    figOne.addPoint(point7(0, l1.getAxisYIntersection()));
+    figOne.addPoint(point10(l1.getAxisXIntersection(), 0));
+    figOne.addPoint(point10(0, l1.getAxisYIntersection()));
     const p4 = l1.projectOrig();
     figOne.addPoint(p4);
-    const p0 = point7(0, 0);
+    const p0 = point10(0, 0);
     if (!p0.isEqual(p4)) {
       const l2 = linePP(p0, p4);
       figOne.addLine(l2);
@@ -5018,24 +6128,24 @@ function pGeom20(t, param, suffix = "") {
 var verifyLine1Def = {
   pTitle: "Verify line",
   pDescription: "Debugging line.ts",
-  pDef: pDef20,
-  pGeom: pGeom20
+  pDef: pDef24,
+  pGeom: pGeom24
 };
 
 // src/geometrix_verification/verify_line_2.ts
-import { degToRad as degToRad6, point as point8, line as line2, figure as figure21, pNumber as pNumber21, initGeom as initGeom21 } from "geometrix";
-var pDef21 = {
+import { degToRad as degToRad8, point as point11, line as line2, figure as figure25, pNumber as pNumber25, initGeom as initGeom25 } from "geometrix";
+var pDef25 = {
   partName: "verify_line_2",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber21("l1cx", "mm", 10, -200, 200, 1),
-    pNumber21("l1cy", "mm", 20, -200, 200, 1),
-    pNumber21("l1ca", "degree", 15, -200, 200, 1),
-    pNumber21("l2cx", "mm", 30, -200, 200, 1),
-    pNumber21("l2cy", "mm", 50, -200, 200, 1),
-    pNumber21("l2ca", "degree", 35, -200, 200, 1),
-    pNumber21("p3x", "mm", -30, -200, 200, 1),
-    pNumber21("p3y", "mm", 30, -200, 200, 1)
+    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)
   ],
   paramSvg: {
     l1cx: "verify_line_2_l1cx.svg",
@@ -5054,20 +6164,20 @@ var pDef21 = {
     // every 0.5 second
   }
 };
-function pGeom21(t, param, suffix = "") {
-  const rGeome = initGeom21(pDef21.partName + suffix);
+function pGeom25(t, param, suffix = "") {
+  const rGeome = initGeom25(pDef25.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure21();
-    const p1 = point8(param.l1cx, param.l1cy);
-    const p2 = point8(param.l2cx, param.l2cy);
-    const p3 = point8(param.p3x, param.p3y);
+    const figOne = figure25();
+    const p1 = point11(param.l1cx, param.l1cy);
+    const p2 = point11(param.l2cx, param.l2cy);
+    const p3 = point11(param.p3x, param.p3y);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
     figOne.addPoint(p3);
-    const l1 = line2(param.l1cx, param.l1cy, degToRad6(param.l1ca + t));
-    const l2 = line2(param.l2cx, param.l2cy, degToRad6(param.l2ca));
+    const l1 = line2(param.l1cx, param.l1cy, degToRad8(param.l1ca + t));
+    const l2 = line2(param.l2cx, param.l2cy, degToRad8(param.l2ca));
     figOne.addLine(l1);
     figOne.addLine(l2);
     figOne.addPoint(l1.intersection(l2));
@@ -5078,7 +6188,7 @@ function pGeom21(t, param, suffix = "") {
     rGeome.logstr += `dist(l2, p3) = ${l2.distanceToPoint(p3)}
 `;
     const bisector2 = l1.bisector(l2, p3);
-    const pBisec = point8(bisector2.cx, bisector2.cy).translatePolar(bisector2.ca, 30);
+    const pBisec = point11(bisector2.cx, bisector2.cy).translatePolar(bisector2.ca, 30);
     figOne.addPoint(pBisec);
     rGeome.fig = { one: figOne };
     rGeome.logstr += "verify_line_2 drawn successfully!\n";
@@ -5092,22 +6202,22 @@ function pGeom21(t, param, suffix = "") {
 var verifyLine2Def = {
   pTitle: "Verify line 2",
   pDescription: "Debugging more line.ts",
-  pDef: pDef21,
-  pGeom: pGeom21
+  pDef: pDef25,
+  pGeom: pGeom25
 };
 
 // src/geometrix_verification/verify_line_3.ts
-import { point as point9, bisector, circleCenter, figure as figure22, pNumber as pNumber22, initGeom as initGeom22 } from "geometrix";
-var pDef22 = {
+import { point as point12, bisector, circleCenter, figure as figure26, pNumber as pNumber26, initGeom as initGeom26 } from "geometrix";
+var pDef26 = {
   partName: "verify_line_3",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber22("p1x", "mm", 30, -200, 200, 1),
-    pNumber22("p1y", "mm", 50, -200, 200, 1),
-    pNumber22("p2x", "mm", 40, -200, 200, 1),
-    pNumber22("p2y", "mm", -20, -200, 200, 1),
-    pNumber22("p3x", "mm", -30, -200, 200, 1),
-    pNumber22("p3y", "mm", 30, -200, 200, 1)
+    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)
   ],
   paramSvg: {
     p1x: "verify_line_p1x.svg",
@@ -5124,15 +6234,15 @@ var pDef22 = {
     // every 0.5 second
   }
 };
-function pGeom22(t, param, suffix = "") {
-  const rGeome = initGeom22(pDef22.partName + suffix);
+function pGeom26(t, param, suffix = "") {
+  const rGeome = initGeom26(pDef26.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure22();
-    const p1 = point9(param.p1x, param.p1y + t);
-    const p2 = point9(param.p2x, param.p2y);
-    const p3 = point9(param.p3x, param.p3y);
+    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);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
     figOne.addPoint(p3);
@@ -5152,24 +6262,24 @@ function pGeom22(t, param, suffix = "") {
 var verifyLine3Def = {
   pTitle: "Verify line 3",
   pDescription: "Debugging more more line.ts",
-  pDef: pDef22,
-  pGeom: pGeom22
+  pDef: pDef26,
+  pGeom: pGeom26
 };
 
 // src/geometrix_verification/verify_vector.ts
-import { degToRad as degToRad7, point as point10, vector, figure as figure23, pNumber as pNumber23, initGeom as initGeom23 } from "geometrix";
-var pDef23 = {
+import { degToRad as degToRad9, point as point13, vector, figure as figure27, pNumber as pNumber27, initGeom as initGeom27 } from "geometrix";
+var pDef27 = {
   partName: "verify_vector",
   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", 80, -200, 200, 1),
-    pNumber23("p2y", "mm", -30, -200, 200, 1),
-    pNumber23("v1a", "degree", 30, -200, 200, 1),
-    pNumber23("v1l", "mm", 60, 0, 200, 1),
-    pNumber23("v2a", "degree", 30, -200, 200, 1),
-    pNumber23("v2l", "mm", 60, 0, 200, 1)
+    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)
   ],
   paramSvg: {
     p1x: "verify_vector_p1x.svg",
@@ -5188,16 +6298,16 @@ var pDef23 = {
     // every 0.5 second
   }
 };
-function pGeom23(t, param, suffix = "") {
-  const rGeome = initGeom23(pDef23.partName + suffix);
+function pGeom27(t, param, suffix = "") {
+  const rGeome = initGeom27(pDef27.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure23();
-    const p1 = point10(param.p1x, param.p1y + t);
-    const p2 = point10(param.p2x, param.p2y);
-    const v1 = vector(degToRad7(param.v1a), param.v1l, p1);
-    const v2 = vector(degToRad7(param.v2a), param.v2l, p1);
+    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);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
     figOne.addVector(v1);
@@ -5218,22 +6328,22 @@ function pGeom23(t, param, suffix = "") {
 var verifyVector1Def = {
   pTitle: "Verify vector",
   pDescription: "Debugging vector.ts",
-  pDef: pDef23,
-  pGeom: pGeom23
+  pDef: pDef27,
+  pGeom: pGeom27
 };
 
 // src/geometrix_verification/verify_contour_1.ts
-import { contour as contour15, contourCircle as contourCircle13, figure as figure24, pNumber as pNumber24, initGeom as initGeom24 } from "geometrix";
-var pDef24 = {
+import { contour as contour19, contourCircle as contourCircle17, figure as figure28, pNumber as pNumber28, initGeom as initGeom28 } from "geometrix";
+var pDef28 = {
   partName: "verify_contour_1",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber24("r1", "mm", 30, 10, 200, 1),
-    pNumber24("d1", "mm", 20, 10, 200, 1),
-    pNumber24("w1", "mm", 100, 10, 200, 1),
-    pNumber24("r2", "mm", 60, 10, 200, 1),
-    pNumber24("l1", "mm", 10, 5, 200, 1),
-    pNumber24("l2", "mm", 30, 5, 200, 1)
+    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)
   ],
   paramSvg: {
     r1: "verify_contour_1_r1.svg",
@@ -5250,12 +6360,12 @@ var pDef24 = {
     // every 0.5 second
   }
 };
-function pGeom24(t, param, suffix = "") {
-  const rGeome = initGeom24(pDef24.partName + suffix);
+function pGeom28(t, param, suffix = "") {
+  const rGeome = initGeom28(pDef28.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure24();
+    const figOne = figure28();
     const r1 = param.r1;
     const d1 = param.d1;
     const w1 = param.w1;
@@ -5268,20 +6378,20 @@ function pGeom24(t, param, suffix = "") {
     const c12 = 2 * r1 + d1;
     const c2 = c1 + c12;
     const c3 = c1 + 2 * c12;
-    const ctr1 = contour15(0, 0);
+    const ctr1 = contour19(0, 0);
     ctr1.addSegStrokeA(w1, 0);
     ctr1.addSegStrokeA(w1, h1);
     ctr1.addSegStrokeA(0, h1);
     ctr1.closeSegStroke();
     ctr1.check();
     figOne.addMain(ctr1);
-    figOne.addMain(contourCircle13(w12, c1, r1));
-    figOne.addMain(contourCircle13(w12, c2, r1 + t));
-    figOne.addMain(contourCircle13(w12, c3, r1));
-    const ctr2 = contourCircle13(w1 + r2, 3 * c1, r2);
+    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);
     ctr2.check();
     figOne.addSecond(ctr2);
-    const ctr3 = contour15(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();
+    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();
     ctr3.check();
     figOne.addSecond(ctr3);
     rGeome.fig = { one: figOne };
@@ -5296,20 +6406,20 @@ function pGeom24(t, param, suffix = "") {
 var verifyContour1Def = {
   pTitle: "Verify contour 1",
   pDescription: "Debugging contour.ts",
-  pDef: pDef24,
-  pGeom: pGeom24
+  pDef: pDef28,
+  pGeom: pGeom28
 };
 
 // src/geometrix_verification/verify_contour_2.ts
-import { degToRad as degToRad8, contour as contour16, figure as figure25, pNumber as pNumber25, initGeom as initGeom25 } from "geometrix";
-var pDef25 = {
+import { degToRad as degToRad10, contour as contour20, figure as figure29, pNumber as pNumber29, initGeom as initGeom29 } from "geometrix";
+var pDef29 = {
   partName: "verify_contour_2",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber25("r1", "mm", 20, 5, 200, 1),
-    pNumber25("a1", "deg", 30, -200, 200, 1),
-    pNumber25("at1", "deg", 30, -200, 200, 1),
-    pNumber25("at2", "deg", 50, -200, 200, 1)
+    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)
   ],
   paramSvg: {
     r1: "verify_contour_1_r1.svg",
@@ -5324,17 +6434,17 @@ var pDef25 = {
     // every 0.5 second
   }
 };
-function pGeom25(t, param, suffix = "") {
-  const rGeome = initGeom25(pDef25.partName + suffix);
+function pGeom29(t, param, suffix = "") {
+  const rGeome = initGeom29(pDef29.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure25();
+    const figOne = figure29();
     const r1 = param.r1 + t;
     const ata = param.a1 + t;
     const at1 = param.at1 + t;
     const at2 = param.at2 + t;
-    const ctr1 = contour16(20, 20);
+    const ctr1 = contour20(20, 20);
     ctr1.addSegStrokeA(40, 20);
     ctr1.addPointA(60, 20).addSegArc(r1, true, true);
     ctr1.addPointA(80, 20).addSegArc(r1, true, false);
@@ -5361,7 +6471,7 @@ function pGeom25(t, param, suffix = "") {
     ctr1.closeSegStroke();
     ctr1.check();
     figOne.addMain(ctr1);
-    const ctr2 = contour16(20, -20);
+    const ctr2 = contour20(20, -20);
     ctr2.addSegStrokeA(40, -40);
     ctr2.addPointA(60, -60).addSegArc(r1, true, true);
     ctr2.addPointA(80, -80).addSegArc(r1, true, false);
@@ -5371,17 +6481,17 @@ function pGeom25(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 = contour16(200, 200).addSegStrokeR(20, 0).addPointR(20, 0).addSegArc3(degToRad8(ata), true).addSegStrokeR(20, 0).addPointR(20, 0).addSegArc3(degToRad8(ata), false).addSegStrokeR(20, 0).addSegStrokeR(0, 20).addPointR(0, 20).addSegArc3(degToRad8(ata), true).addSegStrokeR(0, 20).addPointR(0, 20).addSegArc3(degToRad8(ata), false).addSegStrokeR(0, 20).addSegStrokeR(-20, 0).addPointR(-20, 0).addSegArc3(degToRad8(ata), true).addSegStrokeR(-20, 0).addPointR(-20, 0).addSegArc3(degToRad8(ata), false).addSegStrokeR(-20, 0).addSegStrokeR(0, -20).addPointR(0, -20).addSegArc3(degToRad8(ata), true).addSegStrokeR(0, -20).addPointR(0, -20).addSegArc3(degToRad8(ata), false).addSegStrokeR(0, -20);
+    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);
     ctr3.check();
     figOne.addMain(ctr3);
-    const ctr4 = contour16(600, 200).addSegStrokeR(20, 20).addPointR(20, 20).addSegArc3(degToRad8(ata), true).addSegStrokeR(20, 20).addPointR(20, 20).addSegArc3(degToRad8(ata), false).addSegStrokeR(20, 20).addSegStrokeR(-20, 20).addPointR(-20, 20).addSegArc3(degToRad8(ata), true).addSegStrokeR(-20, 20).addPointR(-20, 20).addSegArc3(degToRad8(ata), false).addSegStrokeR(-20, 20).addSegStrokeR(-20, -20).addPointR(-20, -20).addSegArc3(degToRad8(ata), true).addSegStrokeR(-20, -20).addPointR(-20, -20).addSegArc3(degToRad8(ata), false).addSegStrokeR(-20, -20).addSegStrokeR(20, -20).addPointR(20, -20).addSegArc3(degToRad8(ata), true).addSegStrokeR(20, -20).addPointR(20, -20).addSegArc3(degToRad8(ata), false).addSegStrokeR(20, -20);
+    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);
     ctr4.check();
     figOne.addMain(ctr4);
-    const ctr5 = contour16(100, 500);
+    const ctr5 = contour20(100, 500);
     for (let i = 0; i < 8; i++) {
       const adir = i * 45;
-      const adirRad = degToRad8(adir);
-      ctr5.addSegStrokeRP(adirRad, 20).addPointRP(adirRad, 20).addSeg2Arcs(degToRad8(adir + at1), degToRad8(180 + adir - at2)).addSegStrokeRP(adirRad, 20).addPointRP(adirRad, 20).addSeg2Arcs(degToRad8(adir - at1), degToRad8(180 + adir + at2)).addSegStrokeRP(adirRad, 20);
+      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);
     }
     ctr5.check();
     figOne.addMain(ctr5);
@@ -5397,22 +6507,22 @@ function pGeom25(t, param, suffix = "") {
 var verifyContour2Def = {
   pTitle: "Verify contour 2",
   pDescription: "Debugging more contour.ts",
-  pDef: pDef25,
-  pGeom: pGeom25
+  pDef: pDef29,
+  pGeom: pGeom29
 };
 
 // src/geometrix_verification/verify_contour_3.ts
-import { degToRad as degToRad9, contour as contour17, figure as figure26, pNumber as pNumber26, initGeom as initGeom26 } from "geometrix";
-var pDef26 = {
+import { degToRad as degToRad11, contour as contour21, figure as figure30, pNumber as pNumber30, initGeom as initGeom30 } from "geometrix";
+var pDef30 = {
   partName: "verify_contour_3",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber26("r1", "mm", 10, 0, 200, 1),
-    pNumber26("r2", "mm", 10, 0, 200, 1),
-    pNumber26("r3", "mm", 10, 0, 200, 1),
-    pNumber26("r4", "mm", 10, 0, 200, 1),
-    pNumber26("r5", "mm", 10, 0, 200, 1),
-    pNumber26("r6", "mm", 5, 0, 200, 1)
+    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)
   ],
   paramSvg: {
     r1: "verify_contour_1_r1.svg",
@@ -5429,32 +6539,32 @@ var pDef26 = {
     // every 0.5 second
   }
 };
-function pGeom26(t, param, suffix = "") {
-  const rGeome = initGeom26(pDef26.partName + suffix);
+function pGeom30(t, param, suffix = "") {
+  const rGeome = initGeom30(pDef30.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure26();
+    const figOne = figure30();
     const r1 = param.r1 + t;
     const r2 = param.r2 + t;
     const r3 = param.r3 + t;
     const r4 = param.r4 + t;
     const r5 = param.r5 + t;
     const r6 = param.r6 + t;
-    const ctr1 = contour17(100, 0).addSegStrokeR(30, 200).addCornerRounded(r1).addSegStrokeR(200, 30).addCornerRounded(r1).addSegStrokeR(-200, 30).addCornerRounded(r1).addSegStrokeR(-30, 200).addCornerRounded(r1).addSegStrokeR(-30, -200).addCornerRounded(r1).addSegStrokeR(-200, -30).addCornerRounded(r1).addSegStrokeR(200, -30).addCornerRounded(r1).closeSegStroke().addCornerRounded(r1);
+    const ctr1 = contour21(100, 0).addSegStrokeR(30, 200).addCornerRounded(r1).addSegStrokeR(200, 30).addCornerRounded(r1).addSegStrokeR(-200, 30).addCornerRounded(r1).addSegStrokeR(-30, 200).addCornerRounded(r1).addSegStrokeR(-30, -200).addCornerRounded(r1).addSegStrokeR(-200, -30).addCornerRounded(r1).addSegStrokeR(200, -30).addCornerRounded(r1).closeSegStroke().addCornerRounded(r1);
     rGeome.logstr += ctr1.check();
     figOne.addMain(ctr1);
     const l2 = 100;
-    const ctr2 = contour17(300, 0);
+    const ctr2 = contour21(300, 0);
     for (let i = 0; i < 4; i++) {
       const angle = 90 * (1 - i);
-      ctr2.addSegStrokeRP(degToRad9(angle), l2).addCornerRounded(r2).addSegStrokeRP(degToRad9(angle - 45), l2).addCornerRounded(r2).addSegStrokeRP(degToRad9(angle + 45), l2).addCornerRounded(r2).addSegStrokeRP(degToRad9(angle), l2).addCornerRounded(r2);
+      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);
     }
     rGeome.logstr += ctr2.check();
     figOne.addMain(ctr2);
     const l3 = 100;
     const ra3 = 70;
-    const ctr3 = contour17(0, 600).addSegStrokeR(l3, l3);
+    const ctr3 = contour21(0, 600).addSegStrokeR(l3, l3);
     for (let i = 0; i < 3; i++) {
       const large = (i & 1) === 0 ? false : true;
       const ccw = (i & 2) === 0 ? false : true;
@@ -5470,70 +6580,70 @@ function pGeom26(t, param, suffix = "") {
     ctr3.addSegStrokeR(l3, 0).addSegStrokeR(l3, -l3).closeSegStroke();
     rGeome.logstr += ctr3.check();
     figOne.addMain(ctr3);
-    const ctr3b = contour17(0, 900).addCornerRounded(r3).addPointR(l3, l3).addSegArc(l3, false, true).addSegStrokeR(0, 2 * l3).addCornerRounded(r3).addPointR(l3, -l3).addSegArc(l3, false, true).addSegStrokeR(l3, 0).addCornerRounded(r3).addPointR(l3, l3).addSegArc(l3, false, false).addCornerRounded(r3).addSegStrokeR(0, 2 * l3).addCornerRounded(r3).addPointR(-l3, l3).addSegArc(l3, false, false).addPointR(l3, l3).addSegArc(l3, false, false).addCornerRounded(r3).addSegStrokeR(0, 3 * l3).addCornerRounded(r3).addPointR(-l3, -l3).addSegArc(l3, false, false).addPointR(-l3, l3).addSegArc(l3, false, false).addCornerRounded(r3).addSegStrokeR(0, -3 * l3).addCornerRounded(r3).addPointR(-l3, l3).addSegArc(l3, false, true).addSegStrokeR(-l3, 0).closeSegStroke();
+    const ctr3b = contour21(0, 900).addCornerRounded(r3).addPointR(l3, l3).addSegArc(l3, false, true).addSegStrokeR(0, 2 * l3).addCornerRounded(r3).addPointR(l3, -l3).addSegArc(l3, false, true).addSegStrokeR(l3, 0).addCornerRounded(r3).addPointR(l3, l3).addSegArc(l3, false, false).addCornerRounded(r3).addSegStrokeR(0, 2 * l3).addCornerRounded(r3).addPointR(-l3, l3).addSegArc(l3, false, false).addPointR(l3, l3).addSegArc(l3, false, false).addCornerRounded(r3).addSegStrokeR(0, 3 * l3).addCornerRounded(r3).addPointR(-l3, -l3).addSegArc(l3, false, false).addPointR(-l3, l3).addSegArc(l3, false, false).addCornerRounded(r3).addSegStrokeR(0, -3 * l3).addCornerRounded(r3).addPointR(-l3, l3).addSegArc(l3, false, true).addSegStrokeR(-l3, 0).closeSegStroke();
     rGeome.logstr += ctr3b.check();
     figOne.addMain(ctr3b);
     const l4 = 200;
     const ra4 = 180;
-    const ctr4 = contour17(0, 2e3).addPointR(l4, 0).addSegArc(ra4, false, true).addCornerRounded(r4).addPointR(0, l4).addSegArc(ra4, false, true).addCornerRounded(r4).addPointR(-l4, -l4).addSegArc(1.4 * ra4, false, true).addCornerRounded(r4);
+    const ctr4 = contour21(0, 2e3).addPointR(l4, 0).addSegArc(ra4, false, true).addCornerRounded(r4).addPointR(0, l4).addSegArc(ra4, false, true).addCornerRounded(r4).addPointR(-l4, -l4).addSegArc(1.4 * ra4, false, true).addCornerRounded(r4);
     rGeome.logstr += ctr4.check();
     figOne.addMain(ctr4);
-    const ctr4b = contour17(400, 2e3).addPointR(0, 1.7 * l4).addSegArc(2.3 * ra4, false, false).addCornerRounded(r4).addPointR(l4, -0.7 * l4).addSegArc(ra4, false, false).addCornerRounded(r4).addPointR(-l4, -l4).addSegArc(1.4 * ra4, false, false).addCornerRounded(r4);
+    const ctr4b = contour21(400, 2e3).addPointR(0, 1.7 * l4).addSegArc(2.3 * ra4, false, false).addCornerRounded(r4).addPointR(l4, -0.7 * l4).addSegArc(ra4, false, false).addCornerRounded(r4).addPointR(-l4, -l4).addSegArc(1.4 * ra4, false, false).addCornerRounded(r4);
     rGeome.logstr += ctr4b.check();
     figOne.addMain(ctr4b);
-    const ctr4c = contour17(1e3, 2e3).addPointR(l4, 0).addSegArc(0.6 * ra4, true, true).addCornerRounded(r4).addPointR(0, l4).addSegArc(ra4, true, true).addCornerRounded(r4).addPointR(-l4, -l4).addSegArc(1.4 * ra4, true, true).addCornerRounded(r4);
+    const ctr4c = contour21(1e3, 2e3).addPointR(l4, 0).addSegArc(0.6 * ra4, true, true).addCornerRounded(r4).addPointR(0, l4).addSegArc(ra4, true, true).addCornerRounded(r4).addPointR(-l4, -l4).addSegArc(1.4 * ra4, true, true).addCornerRounded(r4);
     rGeome.logstr += ctr4c.check();
     figOne.addMain(ctr4c);
-    const ctr4d = contour17(3e3, 2e3).addPointR(0, 1.7 * l4).addSegArc(2.3 * ra4, true, false).addCornerRounded(r4).addPointR(l4, -0.7 * l4).addSegArc(ra4, true, false).addCornerRounded(r4).addPointR(-l4, -l4).addSegArc(1.1 * ra4, true, false).addCornerRounded(r4);
+    const ctr4d = contour21(3e3, 2e3).addPointR(0, 1.7 * l4).addSegArc(2.3 * ra4, true, false).addCornerRounded(r4).addPointR(l4, -0.7 * l4).addSegArc(ra4, true, false).addCornerRounded(r4).addPointR(-l4, -l4).addSegArc(1.1 * ra4, true, false).addCornerRounded(r4);
     rGeome.logstr += ctr4d.check();
     figOne.addMain(ctr4d);
     const l4b = 3 * l4;
     const ra4b = 3 * ra4;
-    const ctr4e = contour17(3800, 2e3).addPointR(l4b, 0).addSegArc(ra4b, false, false).addCornerRounded(r4).addPointR(0, l4b).addSegArc(ra4b, false, false).addCornerRounded(r4).addPointR(-l4b, 0).addSegArc(ra4b, false, false).addCornerRounded(r4).addPointR(0, -l4b).addSegArc(ra4b, false, false).addCornerRounded(r4);
+    const ctr4e = contour21(3800, 2e3).addPointR(l4b, 0).addSegArc(ra4b, false, false).addCornerRounded(r4).addPointR(0, l4b).addSegArc(ra4b, false, false).addCornerRounded(r4).addPointR(-l4b, 0).addSegArc(ra4b, false, false).addCornerRounded(r4).addPointR(0, -l4b).addSegArc(ra4b, false, false).addCornerRounded(r4);
     rGeome.logstr += ctr4e.check();
     figOne.addMain(ctr4e);
-    const ctr4f = contour17(4500, 2e3).addPointR(l4, l4).addSegArc(l4, false, false).addPointR(l4, -l4).addSegArc(l4, false, false).addCornerRounded(r4).addPointR(-l4, 1.6 * l4).addSegArc(1.1 * ra4, false, true).addCornerRounded(r4).addPointR(-l4, -1.6 * l4).addSegArc(1.2 * ra4, false, true).addCornerRounded(r4);
+    const ctr4f = contour21(4500, 2e3).addPointR(l4, l4).addSegArc(l4, false, false).addPointR(l4, -l4).addSegArc(l4, false, false).addCornerRounded(r4).addPointR(-l4, 1.6 * l4).addSegArc(1.1 * ra4, false, true).addCornerRounded(r4).addPointR(-l4, -1.6 * l4).addSegArc(1.2 * ra4, false, true).addCornerRounded(r4);
     rGeome.logstr += ctr4f.check();
     figOne.addMain(ctr4f);
-    const ctr4g = contour17(5200, 2e3).addPointR(l4, 0).addSegArc(0.9 * l4, false, false).addCornerRounded(r4).addPointR(l4, 0).addSegArc(0.9 * l4, false, false).addCornerRounded(r4).addPointR(-2 * l4, 0).addSegArc(1.3 * l4, true, true).addCornerRounded(r4);
+    const ctr4g = contour21(5200, 2e3).addPointR(l4, 0).addSegArc(0.9 * l4, false, false).addCornerRounded(r4).addPointR(l4, 0).addSegArc(0.9 * l4, false, false).addCornerRounded(r4).addPointR(-2 * l4, 0).addSegArc(1.3 * l4, true, true).addCornerRounded(r4);
     rGeome.logstr += ctr4g.check();
     figOne.addMain(ctr4g);
     const c099 = 0.999;
-    const ctr4h = contour17(6e3, 2e3).addPointR(2 * l4, 2 * l4).addSegArc(1.5 * l4, false, false).addCornerRounded(r4).addPointR(2 * l4, -2 * l4).addSegArc(1.5 * l4, false, false).addCornerRounded(r4).addPointR(-l4, l4).addSegArc(l4, false, true).addPointR(-l4, -c099 * l4).addSegArc(l4, false, true).addCornerRounded(r4).addPointR(-l4, c099 * l4).addSegArc(l4, false, true).addPointR(-l4, -l4).addSegArc(l4, false, true).addCornerRounded(r4);
+    const ctr4h = contour21(6e3, 2e3).addPointR(2 * l4, 2 * l4).addSegArc(1.5 * l4, false, false).addCornerRounded(r4).addPointR(2 * l4, -2 * l4).addSegArc(1.5 * l4, false, false).addCornerRounded(r4).addPointR(-l4, l4).addSegArc(l4, false, true).addPointR(-l4, -c099 * l4).addSegArc(l4, false, true).addCornerRounded(r4).addPointR(-l4, c099 * l4).addSegArc(l4, false, true).addPointR(-l4, -l4).addSegArc(l4, false, true).addCornerRounded(r4);
     rGeome.logstr += ctr4h.check();
     figOne.addMain(ctr4h);
     const l5 = 200;
     const ra5 = 180;
-    const ctr5 = contour17(0, 3e3).addSegStrokeR(l5, 0).addCornerWidened(r5).addSegStrokeR(0, l5).addCornerWidened(r5).closeSegStroke().addCornerWidened(r5);
+    const ctr5 = contour21(0, 3e3).addSegStrokeR(l5, 0).addCornerWidened(r5).addSegStrokeR(0, l5).addCornerWidened(r5).closeSegStroke().addCornerWidened(r5);
     rGeome.logstr += ctr5.check();
     figOne.addMain(ctr5);
-    const ctr5b = contour17(400, 3e3).addSegStrokeR(l5, 0).addCornerWidened(r5).addPointR(0, l5).addSegArc(ra5, false, true).addCornerWidened(r5).addPointR(-l5, 0).addSegArc(ra5, false, false).addCornerWidened(r5).closeSegStroke().addCornerWidened(r5);
+    const ctr5b = contour21(400, 3e3).addSegStrokeR(l5, 0).addCornerWidened(r5).addPointR(0, l5).addSegArc(ra5, false, true).addCornerWidened(r5).addPointR(-l5, 0).addSegArc(ra5, false, false).addCornerWidened(r5).closeSegStroke().addCornerWidened(r5);
     rGeome.logstr += ctr5b.check();
     figOne.addMain(ctr5b);
-    const ctr5d = contour17(3e3, 3e3).addPointR(0, 1.7 * l5).addSegArc(2.3 * ra5, true, false).addCornerWidened(r5).addPointR(l5, -0.7 * l5).addSegArc(ra5, true, false).addCornerWidened(r5).addPointR(-l5, -l5).addSegArc(1.1 * ra5, true, false).addCornerWidened(r5);
+    const ctr5d = contour21(3e3, 3e3).addPointR(0, 1.7 * l5).addSegArc(2.3 * ra5, true, false).addCornerWidened(r5).addPointR(l5, -0.7 * l5).addSegArc(ra5, true, false).addCornerWidened(r5).addPointR(-l5, -l5).addSegArc(1.1 * ra5, true, false).addCornerWidened(r5);
     rGeome.logstr += ctr5d.check();
     figOne.addMain(ctr5d);
-    const ctr5e = contour17(3800, 3e3).addPointR(l5, 0).addSegArc(ra5, false, false).addCornerWidened(r5).addPointR(0, l5).addSegArc(ra5, false, false).addCornerWidened(r5).addPointR(-l5, 0).addSegArc(ra5, false, false).addCornerWidened(r5).addPointR(0, -l5).addSegArc(ra5, false, false).addCornerWidened(r5);
+    const ctr5e = contour21(3800, 3e3).addPointR(l5, 0).addSegArc(ra5, false, false).addCornerWidened(r5).addPointR(0, l5).addSegArc(ra5, false, false).addCornerWidened(r5).addPointR(-l5, 0).addSegArc(ra5, false, false).addCornerWidened(r5).addPointR(0, -l5).addSegArc(ra5, false, false).addCornerWidened(r5);
     rGeome.logstr += ctr5e.check();
     figOne.addMain(ctr5e);
-    const ctr5f = contour17(4500, 3e3).addPointR(l5, l5).addSegArc(l5, false, false).addPointR(l5, -l5).addSegArc(l5, false, false).addCornerWidened(r5).addPointR(-l5, 1.6 * l5).addSegArc(1.1 * ra5, false, true).addCornerWidened(r5).addPointR(-l5, -1.6 * l5).addSegArc(1.2 * ra5, false, true).addCornerWidened(r5);
+    const ctr5f = contour21(4500, 3e3).addPointR(l5, l5).addSegArc(l5, false, false).addPointR(l5, -l5).addSegArc(l5, false, false).addCornerWidened(r5).addPointR(-l5, 1.6 * l5).addSegArc(1.1 * ra5, false, true).addCornerWidened(r5).addPointR(-l5, -1.6 * l5).addSegArc(1.2 * ra5, false, true).addCornerWidened(r5);
     rGeome.logstr += ctr5f.check();
     figOne.addMain(ctr5f);
     const l6 = 200;
     const ra6 = 180;
-    const ctr6 = contour17(0, 4e3).addSegStrokeR(l6, 0).addCornerWideAcc(r6).addSegStrokeR(0, l6).addCornerWideAcc(r6).closeSegStroke().addCornerWideAcc(r6);
+    const ctr6 = contour21(0, 4e3).addSegStrokeR(l6, 0).addCornerWideAcc(r6).addSegStrokeR(0, l6).addCornerWideAcc(r6).closeSegStroke().addCornerWideAcc(r6);
     rGeome.logstr += ctr6.check();
     figOne.addMain(ctr6);
-    const ctr6b = contour17(400, 4e3).addSegStrokeR(l6, 0).addCornerWideAcc(r6).addPointR(0, l6).addSegArc(ra6, false, true).addCornerWideAcc(r6).addPointR(-l6, 0).addSegArc(ra6, false, false).addCornerWideAcc(r6).closeSegStroke().addCornerWideAcc(r6);
+    const ctr6b = contour21(400, 4e3).addSegStrokeR(l6, 0).addCornerWideAcc(r6).addPointR(0, l6).addSegArc(ra6, false, true).addCornerWideAcc(r6).addPointR(-l6, 0).addSegArc(ra6, false, false).addCornerWideAcc(r6).closeSegStroke().addCornerWideAcc(r6);
     rGeome.logstr += ctr6b.check();
     figOne.addMain(ctr6b);
-    const ctr6d = contour17(3e3, 4e3).addPointR(0, 1.7 * l6).addSegArc(2.3 * ra6, true, false).addCornerWideAcc(r6).addPointR(l6, -0.7 * l6).addSegArc(ra6, true, false).addCornerWideAcc(r6).addPointR(-l6, -l6).addSegArc(1.1 * ra6, true, false).addCornerWideAcc(r6);
+    const ctr6d = contour21(3e3, 4e3).addPointR(0, 1.7 * l6).addSegArc(2.3 * ra6, true, false).addCornerWideAcc(r6).addPointR(l6, -0.7 * l6).addSegArc(ra6, true, false).addCornerWideAcc(r6).addPointR(-l6, -l6).addSegArc(1.1 * ra6, true, false).addCornerWideAcc(r6);
     rGeome.logstr += ctr6d.check();
     figOne.addMain(ctr6d);
-    const ctr6e = contour17(3800, 4e3).addPointR(l6, 0).addSegArc(ra6, false, false).addCornerWideAcc(r6).addPointR(0, l6).addSegArc(ra6, false, false).addCornerWideAcc(r6).addPointR(-l6, 0).addSegArc(ra6, false, false).addCornerWideAcc(r6).addPointR(0, -l6).addSegArc(ra6, false, false).addCornerWideAcc(r6);
+    const ctr6e = contour21(3800, 4e3).addPointR(l6, 0).addSegArc(ra6, false, false).addCornerWideAcc(r6).addPointR(0, l6).addSegArc(ra6, false, false).addCornerWideAcc(r6).addPointR(-l6, 0).addSegArc(ra6, false, false).addCornerWideAcc(r6).addPointR(0, -l6).addSegArc(ra6, false, false).addCornerWideAcc(r6);
     rGeome.logstr += ctr6e.check();
     figOne.addMain(ctr6e);
-    const ctr6f = contour17(4500, 4e3).addPointR(l6, l6).addSegArc(l6, false, false).addPointR(l6, -l6).addSegArc(l6, false, false).addCornerWideAcc(r6).addPointR(-l6, 1.6 * l6).addSegArc(1.1 * ra6, false, true).addCornerWideAcc(r6).addPointR(-l6, -1.6 * l6).addSegArc(1.2 * ra6, false, true).addCornerWideAcc(r6);
+    const ctr6f = contour21(4500, 4e3).addPointR(l6, l6).addSegArc(l6, false, false).addPointR(l6, -l6).addSegArc(l6, false, false).addCornerWideAcc(r6).addPointR(-l6, 1.6 * l6).addSegArc(1.1 * ra6, false, true).addCornerWideAcc(r6).addPointR(-l6, -1.6 * l6).addSegArc(1.2 * ra6, false, true).addCornerWideAcc(r6);
     rGeome.logstr += ctr6f.check();
     figOne.addMain(ctr6f);
     rGeome.fig = { one: figOne };
@@ -5548,19 +6658,19 @@ function pGeom26(t, param, suffix = "") {
 var verifyContour3Def = {
   pTitle: "Verify contour 3",
   pDescription: "Debugging contour.ts for rounded corners and widened corners",
-  pDef: pDef26,
-  pGeom: pGeom26
+  pDef: pDef30,
+  pGeom: pGeom30
 };
 
 // src/geometrix_verification/verify_contour_4.ts
-import { contour as contour18, figure as figure27, pNumber as pNumber27, initGeom as initGeom27 } from "geometrix";
-var pDef27 = {
+import { contour as contour22, figure as figure31, pNumber as pNumber31, initGeom as initGeom31 } from "geometrix";
+var pDef31 = {
   partName: "verify_contour_4",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber27("n1", "scalar", 16, 1, 50, 1),
-    pNumber27("n2", "scalar", 6, 3, 50, 1),
-    pNumber27("r1", "mm", 5, 0, 20, 1)
+    pNumber31("n1", "scalar", 16, 1, 50, 1),
+    pNumber31("n2", "scalar", 6, 3, 50, 1),
+    pNumber31("r1", "mm", 5, 0, 20, 1)
   ],
   paramSvg: {
     n1: "verify_contour_1_r1.svg",
@@ -5574,19 +6684,19 @@ var pDef27 = {
     // every 0.5 second
   }
 };
-function pGeom27(t, param, suffix = "") {
-  const rGeome = initGeom27(pDef27.partName + suffix);
+function pGeom31(t, param, suffix = "") {
+  const rGeome = initGeom31(pDef31.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure27();
+    const figOne = figure31();
     const n1 = param.n1;
     const n2 = param.n2;
     const r1 = param.r1;
     const l1 = 50 + t;
     const as = 2 * Math.PI / (n2 * 3);
-    const ctr2b = contour18(l1, 0).addSegStrokeAP(as, 1.5 * l1).addCornerRounded(r1).addPointAP(2 * as, l1).addSegArc(0.45 * l1, false, true).addCornerWidened(r1).addSegStrokeAP(3 * as, 1.2 * l1);
-    const ctr1 = contour18(l1, 0);
+    const ctr2b = contour22(l1, 0).addSegStrokeAP(as, 1.5 * l1).addCornerRounded(r1).addPointAP(2 * as, l1).addSegArc(0.45 * l1, false, true).addCornerWidened(r1).addSegStrokeAP(3 * as, 1.2 * l1);
+    const ctr1 = contour22(l1, 0);
     const ctr1b = ctr2b.clone().addCornerRounded(r1);
     for (let i = 0; i < n1; i++) {
       const ctr1c = ctr1b.rotate(0, 0, i * 3 * as).scale(0, 0, 1 + i * 0.2, true);
@@ -5595,7 +6705,7 @@ function pGeom27(t, param, suffix = "") {
     ctr1.closeSegStroke();
     rGeome.logstr += ctr1.check();
     figOne.addMain(ctr1);
-    const ctr5 = contour18(l1, 0);
+    const ctr5 = contour22(l1, 0);
     for (let i = 0; i < n1; i++) {
       ctr5.addPartial(ctr1b.rotate(0, 0, i * 3 * as).scale(0, 0, 1 + i * 0.2, false));
     }
@@ -5626,30 +6736,30 @@ function pGeom27(t, param, suffix = "") {
 var verifyContour4Def = {
   pTitle: "Verify contour 4",
   pDescription: "Debugging contour.ts for addPartial",
-  pDef: pDef27,
-  pGeom: pGeom27
+  pDef: pDef31,
+  pGeom: pGeom31
 };
 
 // src/geometrix_verification/verify_exports_1.ts
 import {
-  contour as contour19,
-  contourCircle as contourCircle14,
-  figure as figure28,
-  pNumber as pNumber28,
-  pCheckbox as pCheckbox4,
-  initGeom as initGeom28,
-  EExtrude as EExtrude12,
-  EBVolume as EBVolume15
+  contour as contour23,
+  contourCircle as contourCircle18,
+  figure as figure32,
+  pNumber as pNumber32,
+  pCheckbox as pCheckbox5,
+  initGeom as initGeom32,
+  EExtrude as EExtrude16,
+  EBVolume as EBVolume19
 } from "geometrix";
-var pDef28 = {
+var pDef32 = {
   partName: "verify_exports_1",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pCheckbox4("circle", true),
-    pNumber28("circle-size", "mm", 100, 1, 1e3, 1),
-    pCheckbox4("contour", true),
-    pNumber28("contour-size", "mm", 30, 1, 1e3, 1),
-    pCheckbox4("contour-arc-large", false)
+    pCheckbox5("circle", true),
+    pNumber32("circle-size", "mm", 100, 1, 1e3, 1),
+    pCheckbox5("contour", true),
+    pNumber32("contour-size", "mm", 30, 1, 1e3, 1),
+    pCheckbox5("contour-arc-large", false)
   ],
   paramSvg: {
     circle: "default_param_blank.svg",
@@ -5664,20 +6774,20 @@ var pDef28 = {
     tUpdate: 500
   }
 };
-function pGeom28(t, param, suffix = "") {
-  const rGeome = initGeom28(pDef28.partName + suffix);
+function pGeom32(t, param, suffix = "") {
+  const rGeome = initGeom32(pDef32.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure28();
+    const figOne = figure32();
     if (param.circle === 1) {
-      const theCircle = contourCircle14(0, 0, param["circle-size"]);
+      const theCircle = contourCircle18(0, 0, param["circle-size"]);
       figOne.addMain(theCircle);
     }
     if (param.contour === 1) {
       const csize = param["contour-size"];
       const carcl = param["contour-arc-large"] === 1 ? true : false;
-      const ctr1 = contour19(0, 0).addSegStrokeA(csize, 0).addPointA(csize, csize).addSegArc(csize * 0.8, carcl, true).closeSegStroke();
+      const ctr1 = contour23(0, 0).addSegStrokeA(csize, 0).addPointA(csize, csize).addSegArc(csize * 0.8, carcl, true).closeSegStroke();
       figOne.addMain(ctr1);
     }
     rGeome.fig = { one: figOne };
@@ -5687,7 +6797,7 @@ function pGeom28(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_one`,
           face: `${designName}_one`,
-          extrudeMethod: EExtrude12.eLinearOrtho,
+          extrudeMethod: EExtrude16.eLinearOrtho,
           length: 10,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
@@ -5696,7 +6806,7 @@ function pGeom28(t, param, suffix = "") {
       volumes: [
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume15.eIdentity,
+          boolMethod: EBVolume19.eIdentity,
           inList: [`subpax_${designName}_one`]
         }
       ]
@@ -5712,8 +6822,8 @@ function pGeom28(t, param, suffix = "") {
 var verifyExports1Def = {
   pTitle: "Verify exports 1",
   pDescription: "For dev & debug of Openscad export",
-  pDef: pDef28,
-  pGeom: pGeom28
+  pDef: pDef32,
+  pGeom: pGeom32
 };
 export {
   baseDef,
@@ -5722,17 +6832,21 @@ export {
   gearWheelWheelDef,
   heliostatDef,
   heliostat_2Def,
-  poleRotorDef,
   poleStaticDef,
   rakeDef,
   rakeStopperDef,
   rectangleDef,
+  ringDef,
+  ringGuidanceDef,
   rodDef,
   simplifiedGearWheelDef,
   spiderDef,
   surfaceDef,
   swingDef,
   trapezeDef,
+  vaxisDef,
+  vaxisGuidanceDef,
+  vaxisHolderDef,
   verifyContour1Def,
   verifyContour2Def,
   verifyContour3Def,