designix 0.5.26 → 0.5.27

package/dist/index.js

@@ -1427,55 +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,
-  pSectionSeparator as pSectionSeparator6,
-  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/vaxis_holder.ts
+import {
+  point as point4,
+  contour as contour5,
+  contourCircle as contourCircle3,
+  figure as figure3,
+  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
-import {
-  contour as contour4,
-  contourCircle as contourCircle3,
-  figure as figure3,
-  radToDeg as radToDeg2,
-  ffix as ffix4,
-  pNumber as pNumber3,
-  pSectionSeparator as pSectionSeparator2,
-  initGeom as initGeom3,
-  EExtrude as EExtrude2,
-  EBVolume as EBVolume3
-} from "geometrix";
-var pDef3 = {
+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),
-    pSectionSeparator2("thickness"),
-    pNumber3("E1", "mm", 30, 1, 80, 1),
-    pNumber3("E2", "mm", 5, 1, 80, 1),
-    pSectionSeparator2("base holes"),
-    pNumber3("N1", "", 32, 3, 100, 1),
-    pNumber3("D5", "mm", 40, 1, 100, 1),
-    pNumber3("L1", "mm", 45, 1, 300, 1),
-    pSectionSeparator2("door"),
-    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",
@@ -1492,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,
@@ -1501,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 {
@@ -1554,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]
@@ -1608,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]
@@ -1616,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]
@@ -1624,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]
@@ -1634,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
           ]
         }
       ]
@@ -1665,59 +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,
-  pSectionSeparator as pSectionSeparator3,
-  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),
-    pSectionSeparator3("transversal"),
-    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("D8", "mm", 400, 1, 1e3, 10),
-    pSectionSeparator3("diagonal"),
-    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),
-    pSectionSeparator3("base"),
-    pNumber4("N1", "", 24, 3, 100, 1),
-    pNumber4("D7", "mm", 40, 1, 100, 1),
-    pNumber4("L1", "mm", 30, 1, 300, 1),
-    pSectionSeparator3("door"),
-    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",
@@ -1756,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 {
@@ -1782,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}`;
@@ -1818,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;
@@ -1847,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) {
@@ -1859,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));
@@ -1880,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) {
@@ -1922,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));
@@ -1960,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]
@@ -1972,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]
@@ -1987,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]
@@ -1995,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]
@@ -2003,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]
@@ -2011,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]
@@ -2019,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]
@@ -2027,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]
@@ -2035,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]
@@ -2045,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`,
@@ -2060,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`,
@@ -2070,7 +2673,7 @@ function pGeom4(t, param, suffix = "") {
         },
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume4.eSubstraction,
+          boolMethod: EBVolume5.eSubstraction,
           inList: [`ipax_${designName}_plus`, `ipax_${designName}_hollow`]
         }
       ]
@@ -2087,41 +2690,41 @@ function pGeom4(t, param, suffix = "") {
 var rakeDef = {
   pTitle: "Heliostat rake",
   pDescription: "The rake on top of the V-Axis of the heliostat",
-  pDef: pDef4,
-  pGeom: pGeom4
+  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,
-  pSectionSeparator as pSectionSeparator4,
-  initGeom as initGeom5,
-  EExtrude as EExtrude4,
-  EBVolume as EBVolume5
+  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 pDef5 = {
+var pDef6 = {
   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),
-    pSectionSeparator4("longitude"),
-    pNumber5("L5", "mm", 2e3, 1, 8e3, 1),
-    pNumber5("N1", "", 6, 1, 20, 1),
-    pNumber5("L6", "mm", 30, 1, 100, 1),
-    pSectionSeparator4("thickness"),
-    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)
+    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",
@@ -2144,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 {
@@ -2193,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));
@@ -2234,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]
@@ -2250,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]
@@ -2260,7 +2863,7 @@ function pGeom5(t, param, suffix = "") {
       volumes: [
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume5.eUnion,
+          boolMethod: EBVolume6.eUnion,
           inList: [`subpax_${designName}_tube`, ...legList]
         }
       ]
@@ -2277,47 +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,
-  pSectionSeparator as pSectionSeparator5,
-  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),
-    pSectionSeparator5("radial"),
-    pNumber6("D1", "mm", 400, 1, 1e3, 1),
-    pNumber6("E1", "mm", 5, 1, 80, 1),
-    pNumber6("H2", "mm", 100, 1, 400, 1),
-    pNumber6("H4", "mm", 100, 1, 400, 1),
-    pNumber6("E2", "mm", 3, 1, 80, 1),
-    pNumber6("L3", "mm", 500, 1, 4e3, 1),
-    pSectionSeparator5("radial"),
-    pNumber6("L4", "mm", 600, 1, 4e3, 1),
-    pNumber6("L5", "mm", 2e3, 1, 1e4, 1),
-    pNumber6("L6", "mm", 2e3, 1, 1e4, 1),
-    pNumber6("H1", "mm", 100, 1, 400, 1),
-    pNumber6("H3", "mm", 100, 1, 400, 1),
-    pNumber6("E3", "mm", 3, 1, 80, 1),
-    pSectionSeparator5("rod overlay"),
-    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",
@@ -2334,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",
@@ -2346,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));
@@ -2416,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));
     }
@@ -2434,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)
         );
       }
     }
@@ -2442,6 +3051,7 @@ function pGeom6(t, param, suffix = "") {
       faceSide: figSide,
       faceFace: figFace,
       faceTop: figTop,
+      faceButtress: figButtress,
       faceTopWithRods: figTopWithRod
     };
     const designName = rGeome.partName;
@@ -2450,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]
@@ -2458,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]
@@ -2467,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`]
         }
       ]
@@ -2484,52 +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("D1", "mm", 1e3, 20, 4e3, 10),
-    pNumber7("D2", "mm", 700, 20, 4e3, 10),
-    pNumber7("E1", "mm", 30, 1, 80, 1),
-    pSectionSeparator6("rake"),
-    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("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),
-    pSectionSeparator6("rake diagonal"),
-    pNumber7("D9", "mm", 100, 1, 1e3, 1),
-    pNumber7("L7", "mm", 100, 1, 1e3, 1),
-    pNumber7("L8", "mm", 200, 1, 1e3, 1),
-    pSectionSeparator6("spider"),
-    pNumber7("D8", "mm", 100, 1, 1e3, 1),
-    pNumber7("S1", "mm", 250, 1, 800, 1),
-    pNumber7("S2", "mm", 200, 1, 800, 1),
-    pNumber7("E2", "mm", 50, 1, 80, 1),
-    pSectionSeparator6("swing"),
-    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("H9", "mm", 100, 1, 400, 1),
-    pSectionSeparator6("motion amplitude"),
-    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",
@@ -2572,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);
@@ -2613,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);
@@ -2686,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(
@@ -2749,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`,
@@ -2800,81 +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,
-  pSectionSeparator as pSectionSeparator7,
-  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),
-    pSectionSeparator7("transversal"),
-    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("D8", "mm", 400, 1, 1e3, 1),
-    pSectionSeparator7("diagonal"),
-    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),
-    pSectionSeparator7("base"),
-    pNumber8("N1", "", 24, 3, 100, 1),
-    pNumber8("D7", "mm", 40, 1, 100, 1),
-    pNumber8("L1", "mm", 30, 1, 300, 1),
-    pSectionSeparator7("door"),
-    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),
-    pSectionSeparator7("stopper"),
-    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",
@@ -2916,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}`;
@@ -2952,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;
@@ -2961,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);
@@ -2994,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);
@@ -3023,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);
@@ -3045,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,
@@ -3101,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]
@@ -3109,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]
@@ -3117,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]
@@ -3125,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]
@@ -3133,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]
@@ -3141,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]
@@ -3150,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`,
@@ -3159,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`,
@@ -3168,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`]
         }
       ]
@@ -3190,47 +3801,47 @@ function pGeom8(t, param, suffix = "") {
 var rakeStopperDef = {
   pTitle: "Heliostat rake with stopper",
   pDescription: "The rake-stopper on top of the V-Axis of the heliostat",
-  pDef: pDef8,
-  pGeom: pGeom8
+  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("D1", "mm", 1e3, 20, 4e3, 10),
-    pNumber9("D2", "mm", 700, 20, 4e3, 10),
-    pNumber9("E1", "mm", 30, 1, 80, 1),
-    pSectionSeparator8("rake"),
-    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("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),
-    pSectionSeparator8("rake diagonal"),
-    pNumber9("D9", "mm", 100, 1, 1e3, 1),
-    pNumber9("L7", "mm", 100, 1, 1e3, 1),
-    pNumber9("L8", "mm", 200, 1, 1e3, 1),
-    pSectionSeparator8("rake stopper"),
-    pNumber9("S1", "mm", 100, 1, 800, 1),
-    pSectionSeparator8("swing"),
-    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("H9", "mm", 100, 1, 400, 1),
-    pSectionSeparator8("motion amplitude"),
-    pNumber9("al", "degree", 80, 0, 95, 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",
@@ -3268,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);
@@ -3307,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);
@@ -3370,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(
@@ -3423,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`,
@@ -3467,43 +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,
-  pSectionSeparator as pSectionSeparator9,
-  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),
-    pSectionSeparator9("side holes"),
-    pNumber10("H3", "mm", 400, 10, 4e3, 10),
-    pNumber10("N2", "", 12, 1, 100, 1),
-    pNumber10("L2", "mm", 100, 1, 400, 1),
-    pSectionSeparator9("base holes"),
-    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",
@@ -3529,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 {
@@ -3552,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) {
@@ -3579,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));
@@ -3596,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));
@@ -3623,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]
@@ -3636,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]
@@ -3653,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`]
         }
       ]
@@ -3680,149 +4292,16 @@ function pGeom10(t, param, suffix = "") {
 var baseDef = {
   pTitle: "Heliostat base",
   pDescription: "The base for the static-pole of the heliostat",
-  pDef: pDef10,
-  pGeom: pGeom10
-};
-
-// src/heliostat/vaxis.ts
-import {
-  contour as contour10,
-  contourCircle as contourCircle9,
-  figure as figure11,
-  ffix as ffix12,
-  pNumber as pNumber11,
-  pSectionSeparator as pSectionSeparator10,
-  initGeom as initGeom11,
-  EExtrude as EExtrude8,
-  EBVolume as EBVolume11
-} from "geometrix";
-var pDef11 = {
-  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),
-    pSectionSeparator10("base holes"),
-    pNumber11("N1", "", 24, 3, 100, 1),
-    pNumber11("D3", "mm", 40, 1, 100, 1),
-    pNumber11("L1", "mm", 45, 1, 300, 1)
-  ],
-  paramSvg: {
-    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,
-    tStep: 0.5,
-    tUpdate: 500
-    // every 0.5 second
-  }
-};
-function pGeom11(t, param, suffix = "") {
-  const rGeome = initGeom11(pDef11.partName + suffix);
-  let ctrPoleProfile;
-  const figCut = figure11();
-  const figBottom = figure11();
-  rGeome.logstr += `${rGeome.partName} simTime: ${t}
-`;
-  try {
-    const R1 = param.D1 / 2;
-    const R2 = param.D2 / 2;
-    const R3 = param.D3 / 2;
-    rGeome.logstr += `vaxis-height: ${ffix12(param.H1)} mm
-`;
-    const ctrCylinder = contour10(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();
-      return rPoleProfile;
-    };
-    figCut.addSecond(ctrPoleProfile(1));
-    figCut.addSecond(ctrPoleProfile(-1));
-    figBottom.addMain(contourCircle9(0, 0, R1));
-    figBottom.addMain(contourCircle9(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.addSecond(contourCircle9(0, 0, R1 - param.E1));
-    rGeome.fig = {
-      faceCut: figCut,
-      faceBottom: figBottom
-    };
-    const designName = rGeome.partName;
-    rGeome.vol = {
-      extrudes: [
-        {
-          outName: `subpax_${designName}_pole`,
-          face: `${designName}_faceCut`,
-          extrudeMethod: EExtrude8.eRotate,
-          rotate: [0, 0, 0],
-          translate: [0, 0, 0]
-        },
-        {
-          outName: `subpax_${designName}_bottom`,
-          face: `${designName}_faceBottom`,
-          extrudeMethod: EExtrude8.eLinearOrtho,
-          length: param.E2,
-          rotate: [0, 0, 0],
-          translate: [0, 0, 0]
-        },
-        {
-          outName: `subpax_${designName}_top`,
-          face: `${designName}_faceBottom`,
-          extrudeMethod: EExtrude8.eLinearOrtho,
-          length: param.E2,
-          rotate: [0, 0, 0],
-          translate: [0, 0, param.H1 - param.E2]
-        }
-      ],
-      volumes: [
-        {
-          outName: `pax_${designName}`,
-          boolMethod: EBVolume11.eUnion,
-          inList: [
-            `subpax_${designName}_pole`,
-            `subpax_${designName}_bottom`,
-            `subpax_${designName}_top`
-          ]
-        }
-      ]
-    };
-    rGeome.sub = {};
-    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: pDef11,
   pGeom: pGeom11
 };
 
-// src/heliostat/ring.ts
+// src/heliostat/vaxis.ts
 import {
-  contour as contour11,
+  contour as contour12,
   contourCircle as contourCircle10,
   figure as figure12,
-  ffix as ffix13,
+  ffix as ffix14,
   pNumber as pNumber12,
   pSectionSeparator as pSectionSeparator11,
   initGeom as initGeom12,
@@ -3830,33 +4309,28 @@ import {
   EBVolume as EBVolume12
 } from "geometrix";
 var pDef12 = {
-  partName: "ring",
+  partName: "vaxis",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber12("D1", "mm", 400, 1, 2e3, 1),
-    pNumber12("D3", "mm", 800, 1, 4e3, 1),
-    pNumber12("H1", "mm", 20, 1, 100, 1),
-    pNumber12("H2", "mm", 100, 1, 600, 1),
-    pSectionSeparator11("ring holes"),
-    pNumber12("N2", "", 24, 3, 100, 1),
-    pNumber12("D2", "mm", 40, 1, 100, 1),
-    pNumber12("L1", "mm", 45, 1, 300, 1),
-    pSectionSeparator11("ring fake teeth"),
-    pNumber12("N1", "", 100, 3, 1e4, 1),
-    pNumber12("L2", "mm", 30, 1, 200, 1),
-    pNumber12("L3", "mm", 30, 1, 200, 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: "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"
+    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,
@@ -3867,328 +4341,134 @@ var pDef12 = {
 };
 function pGeom12(t, param, suffix = "") {
   const rGeome = initGeom12(pDef12.partName + suffix);
-  const figRingBase = figure12();
-  const figRingTeeth = figure12();
-  const figSection = figure12();
+  let ctrPoleProfile;
+  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;
-    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: ${ffix13(ringHeight)} mm
+    rGeome.logstr += `vaxis-height: ${ffix14(param.H1)} mm
 `;
-    const tR1 = R3 - param.L2;
-    const tR2 = tR1 - param.L3;
-    const tA = 2 * Math.PI / (2 * param.N1);
-    const ctrTeeth = contour11(tR1, 0);
+    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 = 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(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 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(contourCircle10(0, 0, R3));
-    figRingBase.addMain(contourCircle10(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(contourCircle10(posX, posY, R2));
-      figRingTeeth.addSecond(contourCircle10(posX, posY, R2));
+      figBottom.addMain(contourCircle10(posX, posY, R3));
     }
-    figRingBase.addSecond(ctrTeeth);
-    figRingTeeth.addMain(contourCircle10(0, 0, R3));
-    figRingTeeth.addMain(ctrTeeth);
-    figRingTeeth.addSecond(contourCircle10(0, 0, R1));
-    const ctrInner = contour11(R1, 0).addSegStrokeA(-R1, 0).addSegStrokeA(-R1, -param.H1).addSegStrokeA(R1, -param.H1).closeSegStroke();
-    const ctrScrewHole = function(rnl) {
-      const rCtr = contour11(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 = contour11(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 = contour11(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));
+    figBottom.addSecond(contourCircle10(0, 0, R1 - param.E1));
     rGeome.fig = {
-      faceRingBase: figRingBase,
-      faceRingTeeth: figRingTeeth,
-      faceSection: figSection
+      faceCut: figCut,
+      faceBottom: figBottom
     };
     const designName = rGeome.partName;
     rGeome.vol = {
       extrudes: [
         {
-          outName: `subpax_${designName}_base`,
-          face: `${designName}_faceRingBase`,
-          extrudeMethod: EExtrude9.eLinearOrtho,
-          length: param.H1,
+          outName: `subpax_${designName}_pole`,
+          face: `${designName}_faceCut`,
+          extrudeMethod: EExtrude9.eRotate,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
         },
         {
-          outName: `subpax_${designName}_teeth`,
-          face: `${designName}_faceRingTeeth`,
+          outName: `subpax_${designName}_bottom`,
+          face: `${designName}_faceBottom`,
           extrudeMethod: EExtrude9.eLinearOrtho,
-          length: ringHeight,
+          length: param.E2,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
+        },
+        {
+          outName: `subpax_${designName}_top`,
+          face: `${designName}_faceBottom`,
+          extrudeMethod: EExtrude9.eLinearOrtho,
+          length: param.E2,
+          rotate: [0, 0, 0],
+          translate: [0, 0, param.H1 - param.E2]
         }
       ],
       volumes: [
         {
           outName: `pax_${designName}`,
           boolMethod: EBVolume12.eUnion,
-          inList: [`subpax_${designName}_base`, `subpax_${designName}_teeth`]
+          inList: [
+            `subpax_${designName}_pole`,
+            `subpax_${designName}_bottom`,
+            `subpax_${designName}_top`
+          ]
         }
       ]
     };
     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: pDef12,
-  pGeom: pGeom12
-};
-
-// src/heliostat/vaxis_holder.ts
-import {
-  point as point4,
-  contour as contour13,
-  contourCircle as contourCircle11,
-  figure as figure13,
-  degToRad as degToRad5,
-  ffix as ffix15,
-  pNumber as pNumber13,
-  pSectionSeparator as pSectionSeparator12,
-  initGeom as initGeom13,
-  transform3d,
-  EExtrude as EExtrude10,
-  EBVolume as EBVolume13
-} from "geometrix";
-
-// src/heliostat/common_spring_and_petal.ts
-import { point as point3, contour as contour12, degToRad as degToRad4, radToDeg as radToDeg8, ffix as ffix14 } 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 ${ffix14(param.PHL2)} mm
-`;
-  }
-  rLog += `petal angle: ${ffix14(radToDeg8(petalA2))} degree
-`;
-  rLog += `hollow angle: ${ffix14(radToDeg8(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 = contour12(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 = contour12(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 = contour12(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 = contour12(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 + degToRad4(param.a1);
-  if (iarcA2 < 0) {
-    throw `err564: N2 ${param.N2} is too large compare to D6 ${param.D6}, E2 ${param.E2}`;
-  }
-  const rCtr = contour12(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 = contour12(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);
+    rGeome.logstr += "V-Axis drawn successfully!\n";
+    rGeome.calcErr = false;
+  } catch (emsg) {
+    rGeome.logstr += emsg;
+    console.log(emsg);
   }
-  return [rLog, rCtr];
+  return rGeome;
 }
+var vaxisDef = {
+  pTitle: "Heliostat V-Axis",
+  pDescription: "The vertical axis inside the pole of an heliostat",
+  pDef: pDef12,
+  pGeom: pGeom12
+};
 
-// src/heliostat/vaxis_holder.ts
+// 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: "vaxis_holder",
+  partName: "ring",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber13("PHD1", "mm", 700, 1, 2e3, 1),
-    pNumber13("PHD2", "mm", 900, 1, 4e3, 1),
-    pNumber13("PHD5", "mm", 800, 1, 4e3, 1),
-    pNumber13("PHN1", "holes", 6, 1, 24, 1),
-    pSectionSeparator12("screw holes"),
-    pNumber13("PHD3", "mm", 40, 2, 100, 1),
-    pNumber13("PHR4", "mm", 40, 2, 100, 1),
-    pNumber13("PHL2", "mm", 120, 5, 400, 1),
-    pNumber13("PHR6", "mm", 20, 0, 400, 1),
-    pSectionSeparator12("section"),
-    pNumber13("PHE1", "mm", 10, 1, 80, 1),
-    pNumber13("PHH1", "mm", 50, 1, 200, 1),
-    pNumber13("PHA", "degree", 5, -45, 45, 0.1),
-    pNumber13("PHL1", "mm", 300, 1, 500, 1),
-    pNumber13("PHE2", "mm", 10, 1, 80, 1),
-    pNumber13("PHE3", "mm", 10, 1, 80, 1)
+    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: {
-    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"
+    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,
@@ -4199,168 +4479,109 @@ var pDef13 = {
 };
 function pGeom13(t, param, suffix = "") {
   const rGeome = initGeom13(pDef13.partName + suffix);
-  const figOuter = figure13();
-  const figPetal = figure13();
-  const figButtress1 = figure13();
-  const figButtress2 = figure13();
+  const figRingBase = figure13();
+  const figRingTeeth = figure13();
+  const figSection = figure13();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const outerA = degToRad5(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}`;
+    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}`;
     }
-    rGeome.logstr += `vaxis_holder's height: ${ffix15(vaxisHolderHeight)} mm
-`;
-    rGeome.logstr += `vaxis_holder outerD1: ${ffix15(2 * outerR1)} mm
-`;
-    rGeome.logstr += `vaxis_holder outerD2: ${ffix15(2 * outerR2)} mm
-`;
-    rGeome.logstr += `vaxis_holder innerD: ${ffix15(param.PHD1 - 2 * param.PHR4)} mm
-`;
-    rGeome.logstr += `vaxis_holder D2-next: ${ffix15(2 * R2next)} mm
+    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 ctrOuter = function(rnl) {
-      const rCtr = contour13(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 = contour13(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 = contour13(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();
+    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;
     };
-    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 = contour13(rnl * (R1 + param.PHR4), -param.PHE1 / 2).addSegStrokeA(rnl * innerR1, -param.PHE1 / 2).addSegStrokeRP(-Math.PI / 2 + rnl * outerA, innerL2).closeSegStroke();
+    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 ctrButtress2 = function(rnl) {
-      const rCtr = contour13(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();
+    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;
     };
-    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(contourCircle11(0, 0, innerR));
-    figPetal.addSecond(contourCircle11(0, 0, R2));
-    figPetal.addSecond(contourCircle11(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(contourCircle11(p4.cx, p4.cy, param.PHD3 / 2));
-    }
-    const ctrButtress = contour13(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));
-    }
+    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 = {
-      facePetal: figPetal,
-      faceOuter: figOuter,
-      faceButtress1: figButtress1,
-      faceButtress2: figButtress2
+      faceRingBase: figRingBase,
+      faceRingTeeth: figRingTeeth,
+      faceSection: figSection
     };
     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: EExtrude10.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: EExtrude10.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: EExtrude10.eRotate,
+          outName: `subpax_${designName}_base`,
+          face: `${designName}_faceRingBase`,
+          extrudeMethod: EExtrude10.eLinearOrtho,
+          length: param.H1,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
         },
         {
-          outName: `subpax_${designName}_petal`,
-          face: `${designName}_facePetal`,
+          outName: `subpax_${designName}_teeth`,
+          face: `${designName}_faceRingTeeth`,
           extrudeMethod: EExtrude10.eLinearOrtho,
-          length: param.PHE1,
+          length: ringHeight,
           rotate: [0, 0, 0],
-          translate: [0, 0, -param.PHE1 / 2]
-        },
-        ...preExtrude1,
-        ...preExtrude2
+          translate: [0, 0, 0]
+        }
       ],
       volumes: [
         {
           outName: `pax_${designName}`,
           boolMethod: EBVolume13.eUnion,
-          inList: [
-            `subpax_${designName}_petal`,
-            `subpax_${designName}_outer`,
-            ...b1List,
-            ...b2List
-          ]
+          inList: [`subpax_${designName}_base`, `subpax_${designName}_teeth`]
         }
       ]
     };
     rGeome.sub = {};
-    rGeome.logstr += "vaxis_holder drawn successfully!\n";
+    rGeome.logstr += "ring drawn successfully!\n";
     rGeome.calcErr = false;
   } catch (emsg) {
     rGeome.logstr += emsg;
@@ -4368,9 +4589,9 @@ function pGeom13(t, param, suffix = "") {
   }
   return rGeome;
 }
-var vaxisHolderDef = {
-  pTitle: "Heliostat vaxis_holder",
-  pDescription: "The holders of the guidance mechanism for azimuth motion",
+var ringDef = {
+  pTitle: "Heliostat ring",
+  pDescription: "The gear ring for adjusting the azimuth of the heliostat",
   pDef: pDef13,
   pGeom: pGeom13
 };
@@ -4516,8 +4737,8 @@ var ringGuidanceDef = {
 
 // src/heliostat/vaxis_guidance.ts
 import {
-  contour as contour15,
   contourCircle as contourCircle13,
+  ctrRectangle as ctrRectangle2,
   figure as figure15,
   ffix as ffix17,
   pNumber as pNumber15,
@@ -4610,15 +4831,11 @@ function pGeom15(t, param, suffix = "") {
     rGeome.logstr += innerLog;
     figTop.addMain(innerCtr);
     figTop.addSecond(contourCircle13(0, 0, param.Dvaxis / 2));
-    const rect = function(xbl, ybl, width, height) {
-      const rCtr = contour15(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));
+    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
@@ -4661,7 +4878,7 @@ var vaxisGuidanceDef = {
 
 // src/heliostat/rod.ts
 import {
-  contour as contour16,
+  contour as contour15,
   contourCircle as contourCircle14,
   figure as figure16,
   ffix as ffix18,
@@ -4733,7 +4950,7 @@ function pGeom16(t, param, suffix = "") {
 `;
     ctrPlate = function(py) {
       const rPlate = [];
-      const plateExt = contour16(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(contourCircle14(param.L4 / 2 - param.L7, py + i * n3step, R2));
@@ -4748,16 +4965,16 @@ function pGeom16(t, param, suffix = "") {
       return rPlate;
     };
     ctrRod = function(py, ly) {
-      const rRod = contour16(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 = contour16(L2h, 0).addSegStrokeA(L2h, param.H1).addSegStrokeA(-L2h, param.H1).addSegStrokeA(-L2h, 0).closeSegStroke();
-    const ctrRodInt = contour16(L2hi, param.E1).addSegStrokeA(L2hi, H1i).addSegStrokeA(-L2hi, H1i).addSegStrokeA(-L2hi, param.E1).closeSegStroke();
-    const ctrPlateSide = contour16(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);
@@ -4819,7 +5036,7 @@ var rodDef = {
 
 // src/heliostat/trapeze.ts
 import {
-  contour as contour17,
+  contour as contour16,
   contourCircle as contourCircle15,
   figure as figure17,
   radToDeg as radToDeg9,
@@ -4931,27 +5148,27 @@ function pGeom17(t, param, suffix = "") {
     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 = contour17(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 = contour17(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 = contour17(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 = contour17(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 = contour17(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);
@@ -5064,7 +5281,7 @@ function pGeom17(t, param, suffix = "") {
     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 = contour17(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,
@@ -5270,11 +5487,11 @@ var trapezeDef = {
 
 // src/heliostat/surface.ts
 import {
-  contour as contour18,
+  contour as contour17,
   figure as figure18,
   ffix as ffix20,
   pNumber as pNumber18,
-  pCheckbox as pCheckbox3,
+  pCheckbox as pCheckbox4,
   pDropdown as pDropdown2,
   pSectionSeparator as pSectionSeparator17,
   initGeom as initGeom18,
@@ -5292,19 +5509,19 @@ var pDef18 = {
     pNumber18("ny", "", 9, 1, 40, 1),
     pSectionSeparator17("main fantasia"),
     pDropdown2("main_direction", ["horizontal", "vertical"]),
-    pCheckbox3("crenel", false),
+    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),
-    pCheckbox3("EH_gradient", false),
+    pCheckbox4("EH_gradient", false),
     pNumber18("EH_sup", "mm", 500, 0, 1e3, 1),
     pNumber18("EH_cycle", "", 1, 0, 3, 0.05),
     pNumber18("EH_start", "", 0, 0, 1, 0.05),
     pDropdown2("EH_shape", ["sinusoid", "triangle", "sawUp", "sawDown"]),
     pSectionSeparator17("vertical spacing"),
     pNumber18("EV", "mm", 10, 0, 1e3, 1),
-    pCheckbox3("EV_gradient", false),
+    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),
@@ -5491,7 +5708,7 @@ function pGeom18(t, param, suffix = "") {
     const ox = -gLenHorizontal / 2;
     const oy = -gLenVertical / 2;
     ctrPanelProfile = function(px, py) {
-      const rPanelProfile = contour18(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 = [];
@@ -5567,7 +5784,7 @@ var surfaceDef = {
 };
 
 // src/dummy/circles.ts
-import { degToRad as degToRad6, point as point5, figure as figure19, pNumber as pNumber19, initGeom as initGeom19 } from "geometrix";
+import { degToRad as degToRad6, point as point6, figure as figure19, pNumber as pNumber19, initGeom as initGeom19 } from "geometrix";
 var pDef19 = {
   partName: "circles",
   params: [
@@ -5593,8 +5810,8 @@ function pGeom19(t, param, suffix = "") {
 `;
   try {
     const figOne = figure19();
-    const p1 = point5(10, 10);
-    const p2 = point5(10, 30);
+    const p1 = point6(10, 10);
+    const p2 = point6(10, 30);
     figOne.addPoint(p2);
     for (let i = 0; i < 20; i++) {
       figOne.addPoint(
@@ -5618,7 +5835,7 @@ var circlesDef = {
 };
 
 // src/dummy/rectangle.ts
-import { point as point6, figure as figure20, pNumber as pNumber20, initGeom as initGeom20 } from "geometrix";
+import { point as point7, figure as figure20, pNumber as pNumber20, initGeom as initGeom20 } from "geometrix";
 var pDef20 = {
   partName: "rectangle",
   params: [
@@ -5642,10 +5859,10 @@ function pGeom20(t, param, suffix = "") {
 `;
   try {
     const figOne = figure20();
-    const p1 = point6(10, 10);
-    const p2 = point6(10 + param.width, 10);
-    const p3 = point6(10 + param.width, 10 + param.height);
-    const p4 = point6(10, 10 + param.height);
+    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));
@@ -5669,7 +5886,7 @@ var rectangleDef = {
 
 // src/dummy/pole_static.ts
 import {
-  contour as contour19,
+  contour as contour18,
   contourCircle as contourCircle16,
   figure as figure21,
   pNumber as pNumber21,
@@ -5701,7 +5918,7 @@ function pGeom21(t, param, suffix = "") {
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const ctrPoleFace = contour19(-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(contourCircle16(0, 0, param.radius));
     rGeome.fig = {
@@ -5724,7 +5941,7 @@ var dummyPoleStaticDef = {
 };
 
 // src/geometrix_verification/verify_point.ts
-import { degToRad as degToRad7, point as point7, figure as figure22, pNumber as pNumber22, initGeom as initGeom22 } from "geometrix";
+import { degToRad as degToRad7, point as point8, figure as figure22, pNumber as pNumber22, initGeom as initGeom22 } from "geometrix";
 var pDef22 = {
   partName: "verify_point",
   params: [
@@ -5757,8 +5974,8 @@ function pGeom22(t, param, suffix = "") {
 `;
   try {
     const figOne = figure22();
-    const p1 = point7(param.p1x, param.p1y + t);
-    const p2 = point7(0, 0).setPolar(degToRad7(param.p2a), param.p2l);
+    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);
@@ -5782,7 +5999,7 @@ var verifyPoint1Def = {
 };
 
 // src/geometrix_verification/verify_point_2.ts
-import { point as point8, figure as figure23, pNumber as pNumber23, initGeom as initGeom23 } from "geometrix";
+import { point as point9, figure as figure23, pNumber as pNumber23, initGeom as initGeom23 } from "geometrix";
 var pDef23 = {
   partName: "verify_point_2",
   params: [
@@ -5817,9 +6034,9 @@ function pGeom23(t, param, suffix = "") {
 `;
   try {
     const figOne = figure23();
-    const p1 = point8(param.p1x, param.p1y + t);
-    const p2 = point8(param.p2x, param.p2y);
-    const p3 = point8(param.p3x, param.p3y);
+    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);
@@ -5844,7 +6061,7 @@ var verifyPoint2Def = {
 };
 
 // src/geometrix_verification/verify_line.ts
-import { point as point9, line, linePP, figure as figure24, pNumber as pNumber24, initGeom as initGeom24 } from "geometrix";
+import { point as point10, line, linePP, figure as figure24, pNumber as pNumber24, initGeom as initGeom24 } from "geometrix";
 var pDef24 = {
   partName: "verify_line",
   params: [
@@ -5877,19 +6094,19 @@ function pGeom24(t, param, suffix = "") {
 `;
   try {
     const figOne = figure24();
-    const p1 = point9(param.p1x, param.p1y + t);
-    const p2 = point9(param.p2x, param.p2y);
-    const p3 = point9(param.p3x, param.p3y);
+    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(point9(l1.getAxisXIntersection(), 0));
-    figOne.addPoint(point9(0, l1.getAxisYIntersection()));
+    figOne.addPoint(point10(l1.getAxisXIntersection(), 0));
+    figOne.addPoint(point10(0, l1.getAxisYIntersection()));
     const p4 = l1.projectOrig();
     figOne.addPoint(p4);
-    const p0 = point9(0, 0);
+    const p0 = point10(0, 0);
     if (!p0.isEqual(p4)) {
       const l2 = linePP(p0, p4);
       figOne.addLine(l2);
@@ -5916,7 +6133,7 @@ var verifyLine1Def = {
 };
 
 // src/geometrix_verification/verify_line_2.ts
-import { degToRad as degToRad8, point as point10, line as line2, figure as figure25, pNumber as pNumber25, initGeom as initGeom25 } from "geometrix";
+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: [
@@ -5953,9 +6170,9 @@ function pGeom25(t, param, suffix = "") {
 `;
   try {
     const figOne = figure25();
-    const p1 = point10(param.l1cx, param.l1cy);
-    const p2 = point10(param.l2cx, param.l2cy);
-    const p3 = point10(param.p3x, param.p3y);
+    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);
@@ -5971,7 +6188,7 @@ function pGeom25(t, param, suffix = "") {
     rGeome.logstr += `dist(l2, p3) = ${l2.distanceToPoint(p3)}
 `;
     const bisector2 = l1.bisector(l2, p3);
-    const pBisec = point10(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";
@@ -5990,7 +6207,7 @@ var verifyLine2Def = {
 };
 
 // src/geometrix_verification/verify_line_3.ts
-import { point as point11, bisector, circleCenter, figure as figure26, pNumber as pNumber26, initGeom as initGeom26 } from "geometrix";
+import { point as point12, bisector, circleCenter, figure as figure26, pNumber as pNumber26, initGeom as initGeom26 } from "geometrix";
 var pDef26 = {
   partName: "verify_line_3",
   params: [
@@ -6023,9 +6240,9 @@ function pGeom26(t, param, suffix = "") {
 `;
   try {
     const figOne = figure26();
-    const p1 = point11(param.p1x, param.p1y + t);
-    const p2 = point11(param.p2x, param.p2y);
-    const p3 = point11(param.p3x, param.p3y);
+    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);
@@ -6050,7 +6267,7 @@ var verifyLine3Def = {
 };
 
 // src/geometrix_verification/verify_vector.ts
-import { degToRad as degToRad9, point as point12, vector, figure as figure27, pNumber as pNumber27, initGeom as initGeom27 } from "geometrix";
+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: [
@@ -6087,8 +6304,8 @@ function pGeom27(t, param, suffix = "") {
 `;
   try {
     const figOne = figure27();
-    const p1 = point12(param.p1x, param.p1y + t);
-    const p2 = point12(param.p2x, param.p2y);
+    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);
@@ -6116,7 +6333,7 @@ var verifyVector1Def = {
 };
 
 // src/geometrix_verification/verify_contour_1.ts
-import { contour as contour20, contourCircle as contourCircle17, figure as figure28, pNumber as pNumber28, initGeom as initGeom28 } from "geometrix";
+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: [
@@ -6161,7 +6378,7 @@ function pGeom28(t, param, suffix = "") {
     const c12 = 2 * r1 + d1;
     const c2 = c1 + c12;
     const c3 = c1 + 2 * c12;
-    const ctr1 = contour20(0, 0);
+    const ctr1 = contour19(0, 0);
     ctr1.addSegStrokeA(w1, 0);
     ctr1.addSegStrokeA(w1, h1);
     ctr1.addSegStrokeA(0, h1);
@@ -6174,7 +6391,7 @@ function pGeom28(t, param, suffix = "") {
     const ctr2 = contourCircle17(w1 + r2, 3 * c1, r2);
     ctr2.check();
     figOne.addSecond(ctr2);
-    const ctr3 = contour20(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 };
@@ -6194,7 +6411,7 @@ var verifyContour1Def = {
 };
 
 // src/geometrix_verification/verify_contour_2.ts
-import { degToRad as degToRad10, contour as contour21, figure as figure29, pNumber as pNumber29, initGeom as initGeom29 } from "geometrix";
+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: [
@@ -6227,7 +6444,7 @@ function pGeom29(t, param, suffix = "") {
     const ata = param.a1 + t;
     const at1 = param.at1 + t;
     const at2 = param.at2 + t;
-    const ctr1 = contour21(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);
@@ -6254,7 +6471,7 @@ function pGeom29(t, param, suffix = "") {
     ctr1.closeSegStroke();
     ctr1.check();
     figOne.addMain(ctr1);
-    const ctr2 = contour21(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);
@@ -6264,13 +6481,13 @@ function pGeom29(t, param, suffix = "") {
     ctr2.addSegStrokeR(20, 20).addPointR(20, 20).addSegArc(r1, false, false).addPointRP(Math.PI / 4, 28).addSegArc(r1, false, true).addPointRP(Math.PI / 4, 28).addSegArc(r1, true, true).addPointRP(Math.PI / 4, 28).addSegArc(r1, true, false).addSegStrokeRP(Math.PI / 4, 20).addSegStrokeRP(-Math.PI / 4, 20).addPointR(10, -9).addPointR(20, -20).addSegArc2().addPointR(20, -9).addPointR(20, -20).addSegArc2().addPointR(9, -6).addPointR(20, -20).addSegArc2().addPointR(9, -14).addPointR(20, -20).addSegArc2().addPointR(9, 0).addPointR(20, -20).addSegArc2().addSegStrokeR(20, -20).addSegStrokeR(20, 20).addPointR(9, 20).addPointR(20, 20).addSegArc2().addPointR(20, 10).addPointR(20, 20).addSegArc2().addPointR(9, 6).addPointR(20, 20).addSegArc2().addPointR(9, 14).addPointR(20, 20).addSegArc2().addPointR(9, 0).addPointR(20, 20).addSegArc2().addSegStrokeR(20, 20).addSegStrokeR(0, 20).addPointR(15, 8).addPointR(0, 20).addSegArc2().addPointR(-15, 8).addPointR(0, 20).addSegArc2().addPointR(5, 8).addPointR(0, 20).addSegArc2().addPointR(-5, 8).addPointR(0, 20).addSegArc2().addSegStrokeR(0, 20).addSegStrokeR(20, 0).addPointR(8, 15).addPointR(20, 0).addSegArc2().addPointR(8, -15).addPointR(20, 0).addSegArc2().addPointR(8, 5).addPointR(20, 0).addSegArc2().addPointR(8, -5).addPointR(20, 0).addSegArc2().addSegStrokeR(20, 0).addSegStrokeR(0, -20).addPointR(15, -8).addPointR(0, -20).addSegArc2().addPointR(-15, -8).addPointR(0, -20).addSegArc2().addPointR(5, -8).addPointR(0, -20).addSegArc2().addPointR(-5, -8).addPointR(0, -20).addSegArc2().addSegStrokeR(0, -20).addSegStrokeR(-20, 0).addPointR(-8, 15).addPointR(-20, 0).addSegArc2().addPointR(-8, -15).addPointR(-20, 0).addSegArc2().addPointR(-8, 5).addPointR(-20, 0).addSegArc2().addPointR(-8, -5).addPointR(-20, 0).addSegArc2().addSegStrokeR(-20, 0).closeSegStroke();
     ctr2.check();
     figOne.addMain(ctr2);
-    const ctr3 = contour21(200, 200).addSegStrokeR(20, 0).addPointR(20, 0).addSegArc3(degToRad10(ata), true).addSegStrokeR(20, 0).addPointR(20, 0).addSegArc3(degToRad10(ata), false).addSegStrokeR(20, 0).addSegStrokeR(0, 20).addPointR(0, 20).addSegArc3(degToRad10(ata), true).addSegStrokeR(0, 20).addPointR(0, 20).addSegArc3(degToRad10(ata), false).addSegStrokeR(0, 20).addSegStrokeR(-20, 0).addPointR(-20, 0).addSegArc3(degToRad10(ata), true).addSegStrokeR(-20, 0).addPointR(-20, 0).addSegArc3(degToRad10(ata), false).addSegStrokeR(-20, 0).addSegStrokeR(0, -20).addPointR(0, -20).addSegArc3(degToRad10(ata), true).addSegStrokeR(0, -20).addPointR(0, -20).addSegArc3(degToRad10(ata), false).addSegStrokeR(0, -20);
+    const ctr3 = contour20(200, 200).addSegStrokeR(20, 0).addPointR(20, 0).addSegArc3(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 = contour21(600, 200).addSegStrokeR(20, 20).addPointR(20, 20).addSegArc3(degToRad10(ata), true).addSegStrokeR(20, 20).addPointR(20, 20).addSegArc3(degToRad10(ata), false).addSegStrokeR(20, 20).addSegStrokeR(-20, 20).addPointR(-20, 20).addSegArc3(degToRad10(ata), true).addSegStrokeR(-20, 20).addPointR(-20, 20).addSegArc3(degToRad10(ata), false).addSegStrokeR(-20, 20).addSegStrokeR(-20, -20).addPointR(-20, -20).addSegArc3(degToRad10(ata), true).addSegStrokeR(-20, -20).addPointR(-20, -20).addSegArc3(degToRad10(ata), false).addSegStrokeR(-20, -20).addSegStrokeR(20, -20).addPointR(20, -20).addSegArc3(degToRad10(ata), true).addSegStrokeR(20, -20).addPointR(20, -20).addSegArc3(degToRad10(ata), false).addSegStrokeR(20, -20);
+    const ctr4 = contour20(600, 200).addSegStrokeR(20, 20).addPointR(20, 20).addSegArc3(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 = contour21(100, 500);
+    const ctr5 = contour20(100, 500);
     for (let i = 0; i < 8; i++) {
       const adir = i * 45;
       const adirRad = degToRad10(adir);
@@ -6295,7 +6512,7 @@ var verifyContour2Def = {
 };
 
 // src/geometrix_verification/verify_contour_3.ts
-import { degToRad as degToRad11, contour as contour22, figure as figure30, pNumber as pNumber30, initGeom as initGeom30 } from "geometrix";
+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: [
@@ -6334,11 +6551,11 @@ function pGeom30(t, param, suffix = "") {
     const r4 = param.r4 + t;
     const r5 = param.r5 + t;
     const r6 = param.r6 + t;
-    const ctr1 = contour22(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 = contour22(300, 0);
+    const ctr2 = contour21(300, 0);
     for (let i = 0; i < 4; i++) {
       const angle = 90 * (1 - i);
       ctr2.addSegStrokeRP(degToRad11(angle), l2).addCornerRounded(r2).addSegStrokeRP(degToRad11(angle - 45), l2).addCornerRounded(r2).addSegStrokeRP(degToRad11(angle + 45), l2).addCornerRounded(r2).addSegStrokeRP(degToRad11(angle), l2).addCornerRounded(r2);
@@ -6347,7 +6564,7 @@ function pGeom30(t, param, suffix = "") {
     figOne.addMain(ctr2);
     const l3 = 100;
     const ra3 = 70;
-    const ctr3 = contour22(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;
@@ -6363,70 +6580,70 @@ function pGeom30(t, param, suffix = "") {
     ctr3.addSegStrokeR(l3, 0).addSegStrokeR(l3, -l3).closeSegStroke();
     rGeome.logstr += ctr3.check();
     figOne.addMain(ctr3);
-    const ctr3b = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 = contour22(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 };
@@ -6446,7 +6663,7 @@ var verifyContour3Def = {
 };
 
 // src/geometrix_verification/verify_contour_4.ts
-import { contour as contour23, figure as figure31, pNumber as pNumber31, initGeom as initGeom31 } from "geometrix";
+import { contour as contour22, figure as figure31, pNumber as pNumber31, initGeom as initGeom31 } from "geometrix";
 var pDef31 = {
   partName: "verify_contour_4",
   params: [
@@ -6478,8 +6695,8 @@ function pGeom31(t, param, suffix = "") {
     const r1 = param.r1;
     const l1 = 50 + t;
     const as = 2 * Math.PI / (n2 * 3);
-    const ctr2b = contour23(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 = contour23(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);
@@ -6488,7 +6705,7 @@ function pGeom31(t, param, suffix = "") {
     ctr1.closeSegStroke();
     rGeome.logstr += ctr1.check();
     figOne.addMain(ctr1);
-    const ctr5 = contour23(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));
     }
@@ -6525,11 +6742,11 @@ var verifyContour4Def = {
 
 // src/geometrix_verification/verify_exports_1.ts
 import {
-  contour as contour24,
+  contour as contour23,
   contourCircle as contourCircle18,
   figure as figure32,
   pNumber as pNumber32,
-  pCheckbox as pCheckbox4,
+  pCheckbox as pCheckbox5,
   initGeom as initGeom32,
   EExtrude as EExtrude16,
   EBVolume as EBVolume19
@@ -6538,11 +6755,11 @@ var pDef32 = {
   partName: "verify_exports_1",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pCheckbox4("circle", true),
+    pCheckbox5("circle", true),
     pNumber32("circle-size", "mm", 100, 1, 1e3, 1),
-    pCheckbox4("contour", true),
+    pCheckbox5("contour", true),
     pNumber32("contour-size", "mm", 30, 1, 1e3, 1),
-    pCheckbox4("contour-arc-large", false)
+    pCheckbox5("contour-arc-large", false)
   ],
   paramSvg: {
     circle: "default_param_blank.svg",
@@ -6570,7 +6787,7 @@ function pGeom32(t, param, suffix = "") {
     if (param.contour === 1) {
       const csize = param["contour-size"];
       const carcl = param["contour-arc-large"] === 1 ? true : false;
-      const ctr1 = contour24(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 };