designix 0.5.25 → 0.5.26

package/dist/index.js

@@ -1436,6 +1436,7 @@ import {
   radToDeg as radToDeg5,
   ffix as ffix8,
   pNumber as pNumber7,
+  pSectionSeparator as pSectionSeparator6,
   initGeom as initGeom7,
   EBVolume as EBVolume7
 } from "geometrix";
@@ -1448,6 +1449,7 @@ import {
   radToDeg as radToDeg2,
   ffix as ffix4,
   pNumber as pNumber3,
+  pSectionSeparator as pSectionSeparator2,
   initGeom as initGeom3,
   EExtrude as EExtrude2,
   EBVolume as EBVolume3
@@ -1461,11 +1463,14 @@ var pDef3 = {
     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),
@@ -1672,6 +1677,7 @@ import {
   radToDeg as radToDeg3,
   ffix as ffix5,
   pNumber as pNumber4,
+  pSectionSeparator as pSectionSeparator3,
   initGeom as initGeom4,
   EExtrude as EExtrude3,
   EBVolume as EBVolume4
@@ -1688,6 +1694,7 @@ var pDef4 = {
     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),
@@ -1696,14 +1703,17 @@ var pDef4 = {
     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),
-    pNumber4("D8", "mm", 400, 1, 1e3, 10),
+    pSectionSeparator3("door"),
     pNumber4("H6", "mm", 100, 1, 1e3, 10),
     pNumber4("H7", "mm", 600, 10, 2e3, 10),
     pNumber4("L9", "mm", 300, 1, 1e3, 10),
@@ -2076,7 +2086,7 @@ function pGeom4(t, param, suffix = "") {
 }
 var rakeDef = {
   pTitle: "Heliostat rake",
-  pDescription: "The rake on top of the pole-rotor of the heliostat",
+  pDescription: "The rake on top of the V-Axis of the heliostat",
   pDef: pDef4,
   pGeom: pGeom4
 };
@@ -2089,6 +2099,7 @@ import {
   radToDeg as radToDeg4,
   ffix as ffix6,
   pNumber as pNumber5,
+  pSectionSeparator as pSectionSeparator4,
   initGeom as initGeom5,
   EExtrude as EExtrude4,
   EBVolume as EBVolume5
@@ -2102,13 +2113,15 @@ var pDef5 = {
     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),
-    pNumber5("N1", "", 6, 1, 20, 1)
+    pNumber5("R2", "mm", 100, 0, 400, 10)
   ],
   paramSvg: {
     D1: "spider_profile.svg",
@@ -2275,6 +2288,7 @@ import {
   figure as figure6,
   ffix as ffix7,
   pNumber as pNumber6,
+  pSectionSeparator as pSectionSeparator5,
   initGeom as initGeom6,
   EExtrude as EExtrude5,
   EBVolume as EBVolume6
@@ -2285,18 +2299,21 @@ var pDef6 = {
     //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("D1", "mm", 400, 1, 1e3, 1),
     pNumber6("H1", "mm", 100, 1, 400, 1),
-    pNumber6("H2", "mm", 100, 1, 400, 1),
     pNumber6("H3", "mm", 100, 1, 400, 1),
-    pNumber6("H4", "mm", 100, 1, 400, 1),
-    pNumber6("E1", "mm", 5, 1, 80, 1),
-    pNumber6("E2", "mm", 3, 1, 80, 1),
     pNumber6("E3", "mm", 3, 1, 80, 1),
+    pSectionSeparator5("rod overlay"),
     pNumber6("rod1", "", 10, 1, 40, 1),
     pNumber6("rod2", "mm", 1300, 10, 4e3, 10),
     pNumber6("rod3", "mm", 400, 10, 1e3, 10),
@@ -2478,34 +2495,39 @@ var pDef7 = {
     //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("H9", "mm", 100, 1, 400, 1),
-    pNumber7("D1", "mm", 1e3, 20, 4e3, 10),
-    pNumber7("D2", "mm", 700, 20, 4e3, 10),
     pNumber7("D3", "mm", 900, 20, 4e3, 10),
     pNumber7("D4", "mm", 400, 20, 4e3, 10),
     pNumber7("D5", "mm", 300, 20, 1e3, 10),
     pNumber7("D6", "mm", 200, 10, 1e3, 10),
     pNumber7("D7", "mm", 400, 10, 1e3, 10),
-    pNumber7("D8", "mm", 100, 1, 1e3, 1),
+    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("E1", "mm", 30, 1, 80, 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("L7", "mm", 100, 1, 1e3, 1),
-    pNumber7("L8", "mm", 200, 1, 1e3, 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)
   ],
@@ -2792,6 +2814,7 @@ import {
   radToDeg as radToDeg7,
   ffix as ffix10,
   pNumber as pNumber9,
+  pSectionSeparator as pSectionSeparator8,
   initGeom as initGeom9,
   EBVolume as EBVolume9
 } from "geometrix";
@@ -2807,6 +2830,7 @@ import {
   radToDeg as radToDeg6,
   ffix as ffix9,
   pNumber as pNumber8,
+  pSectionSeparator as pSectionSeparator7,
   initGeom as initGeom8,
   EExtrude as EExtrude6,
   EBVolume as EBVolume8
@@ -2823,6 +2847,7 @@ var pDef8 = {
     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),
@@ -2831,18 +2856,22 @@ var pDef8 = {
     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),
-    pNumber8("D8", "mm", 400, 1, 1e3, 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)
@@ -3160,7 +3189,7 @@ function pGeom8(t, param, suffix = "") {
 }
 var rakeStopperDef = {
   pTitle: "Heliostat rake with stopper",
-  pDescription: "The rake-stopper on top of the pole-rotor of the heliostat",
+  pDescription: "The rake-stopper on top of the V-Axis of the heliostat",
   pDef: pDef8,
   pGeom: pGeom8
 };
@@ -3172,31 +3201,36 @@ var pDef9 = {
     //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("H9", "mm", 100, 1, 400, 1),
-    pNumber9("D1", "mm", 1e3, 20, 4e3, 10),
-    pNumber9("D2", "mm", 700, 20, 4e3, 10),
     pNumber9("D3", "mm", 900, 20, 4e3, 10),
     pNumber9("D4", "mm", 400, 20, 4e3, 10),
     pNumber9("D5", "mm", 300, 20, 1e3, 10),
     pNumber9("D6", "mm", 200, 10, 1e3, 10),
     pNumber9("D7", "mm", 400, 10, 1e3, 10),
+    pSectionSeparator8("rake diagonal"),
     pNumber9("D9", "mm", 100, 1, 1e3, 1),
-    pNumber9("E1", "mm", 30, 1, 80, 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("L7", "mm", 100, 1, 1e3, 1),
-    pNumber9("L8", "mm", 200, 1, 1e3, 1),
-    pNumber9("al", "degree", 80, 0, 95, 1),
-    pNumber9("S1", "mm", 100, 1, 800, 1)
+    pNumber9("H9", "mm", 100, 1, 400, 1),
+    pSectionSeparator8("motion amplitude"),
+    pNumber9("al", "degree", 80, 0, 95, 1)
   ],
   paramSvg: {
     H1: "heliostat_overview.svg",
@@ -3444,6 +3478,7 @@ import {
   figure as figure10,
   ffix as ffix11,
   pNumber as pNumber10,
+  pSectionSeparator as pSectionSeparator9,
   initGeom as initGeom10,
   EExtrude as EExtrude7,
   EBVolume as EBVolume10
@@ -3461,9 +3496,11 @@ var pDef10 = {
     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)
@@ -3647,19 +3684,20 @@ var baseDef = {
   pGeom: pGeom10
 };
 
-// src/heliostat/pole_rotor.ts
+// src/heliostat/vaxis.ts
 import {
   contour as contour10,
   contourCircle as contourCircle9,
   figure as figure11,
   ffix as ffix12,
   pNumber as pNumber11,
+  pSectionSeparator as pSectionSeparator10,
   initGeom as initGeom11,
   EExtrude as EExtrude8,
   EBVolume as EBVolume11
 } from "geometrix";
 var pDef11 = {
-  partName: "pole_rotor",
+  partName: "vaxis",
   params: [
     //pNumber(name, unit, init, min, max, step)
     pNumber11("D1", "mm", 600, 1, 4e3, 1),
@@ -3667,19 +3705,20 @@ var pDef11 = {
     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: "pole_rotor_cut.svg",
-    D2: "pole_rotor_cut.svg",
-    H1: "pole_rotor_cut.svg",
-    E1: "pole_rotor_cut.svg",
-    E2: "pole_rotor_cut.svg",
-    N1: "pole_rotor_ends.svg",
-    D3: "pole_rotor_ends.svg",
-    L1: "pole_rotor_ends.svg"
+    D1: "vaxis_cut.svg",
+    D2: "vaxis_cut.svg",
+    H1: "vaxis_cut.svg",
+    E1: "vaxis_cut.svg",
+    E2: "vaxis_cut.svg",
+    N1: "vaxis_ends.svg",
+    D3: "vaxis_ends.svg",
+    L1: "vaxis_ends.svg"
   },
   sim: {
     tMax: 180,
@@ -3699,7 +3738,7 @@ function pGeom11(t, param, suffix = "") {
     const R1 = param.D1 / 2;
     const R2 = param.D2 / 2;
     const R3 = param.D3 / 2;
-    rGeome.logstr += `pole-height: ${ffix12(param.H1)} mm
+    rGeome.logstr += `vaxis-height: ${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);
@@ -3763,7 +3802,7 @@ function pGeom11(t, param, suffix = "") {
       ]
     };
     rGeome.sub = {};
-    rGeome.logstr += "pole_rotor drawn successfully!\n";
+    rGeome.logstr += "V-Axis drawn successfully!\n";
     rGeome.calcErr = false;
   } catch (emsg) {
     rGeome.logstr += emsg;
@@ -3771,56 +3810,53 @@ function pGeom11(t, param, suffix = "") {
   }
   return rGeome;
 }
-var poleRotorDef = {
-  pTitle: "Heliostat pole rotor",
+var vaxisDef = {
+  pTitle: "Heliostat V-Axis",
   pDescription: "The vertical axis inside the pole of an heliostat",
   pDef: pDef11,
   pGeom: pGeom11
 };
 
-// src/heliostat/rod.ts
+// src/heliostat/ring.ts
 import {
   contour as contour11,
   contourCircle as contourCircle10,
   figure as figure12,
   ffix as ffix13,
   pNumber as pNumber12,
+  pSectionSeparator as pSectionSeparator11,
   initGeom as initGeom12,
   EExtrude as EExtrude9,
   EBVolume as EBVolume12
 } from "geometrix";
 var pDef12 = {
-  partName: "rod",
+  partName: "ring",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber12("L1", "mm", 1e4, 100, 4e4, 10),
-    pNumber12("L2", "mm", 100, 2, 400, 1),
-    pNumber12("L3", "mm", 400, 10, 1e3, 1),
-    pNumber12("L4", "mm", 600, 10, 1e3, 1),
-    pNumber12("H1", "mm", 200, 5, 4e3, 1),
-    pNumber12("E1", "mm", 2, 1, 80, 1),
-    pNumber12("E2", "mm", 10, 1, 80, 1),
-    pNumber12("N1", "", 10, 2, 50, 1),
-    pNumber12("N3", "", 2, 1, 20, 1),
-    pNumber12("N4", "", 4, 1, 20, 1),
-    pNumber12("R3", "mm", 100, 1, 500, 1),
-    pNumber12("D2", "mm", 10, 1, 100, 1),
-    pNumber12("L7", "mm", 10, 1, 300, 1)
+    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)
   ],
   paramSvg: {
-    L1: "rod_top.svg",
-    L2: "rod_top.svg",
-    L3: "rod_top.svg",
-    L4: "rod_top.svg",
-    H1: "rod_cut.svg",
-    E1: "rod_cut.svg",
-    E2: "rod_cut.svg",
-    N1: "rod_top.svg",
-    N3: "rod_top.svg",
-    N4: "rod_top.svg",
-    R3: "rod_top.svg",
-    D2: "rod_plate.svg",
-    L7: "rod_plate.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,
@@ -3831,94 +3867,109 @@ var pDef12 = {
 };
 function pGeom12(t, param, suffix = "") {
   const rGeome = initGeom12(pDef12.partName + suffix);
-  let ctrPlate;
-  let ctrRod;
-  const figCut = figure12();
-  const figPlate = figure12();
-  const figTop = figure12();
+  const figRingBase = figure12();
+  const figRingTeeth = figure12();
+  const figSection = figure12();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
+    const R1 = param.D1 / 2;
     const R2 = param.D2 / 2;
-    const n3step = param.L3 / (param.N3 + 1);
-    const n4step = param.L4 / (param.N4 + 1);
-    rGeome.logstr += `rod-length: ${ffix13(param.L1)} mm
-`;
-    const space_length = (param.L1 - param.L3) / (param.N1 - 1);
-    rGeome.logstr += `space-length: ${ffix13(space_length)} mm
+    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
 `;
-    ctrPlate = function(py) {
-      const rPlate = [];
-      const plateExt = contour11(param.L4 / 2, py).addCornerRounded(param.R3).addSegStrokeA(param.L4 / 2, py + param.L3).addCornerRounded(param.R3).addSegStrokeA(-param.L4 / 2, py + param.L3).addCornerRounded(param.R3).addSegStrokeA(-param.L4 / 2, py).addCornerRounded(param.R3).closeSegStroke();
-      rPlate.push(plateExt);
-      for (let i = 1; i < param.N3 + 1; i++) {
-        rPlate.push(contourCircle10(param.L4 / 2 - param.L7, py + i * n3step, R2));
-        rPlate.push(contourCircle10(-param.L4 / 2 + param.L7, py + i * n3step, R2));
-      }
-      for (let i = 1; i < param.N4 + 1; i++) {
-        rPlate.push(contourCircle10(-param.L4 / 2 + i * n4step, py + param.L7, R2));
-        rPlate.push(
-          contourCircle10(-param.L4 / 2 + i * n4step, py + param.L3 - param.L7, R2)
-        );
-      }
-      return rPlate;
+    const tR1 = R3 - param.L2;
+    const tR2 = tR1 - param.L3;
+    const tA = 2 * Math.PI / (2 * param.N1);
+    const ctrTeeth = contour11(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(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));
+    }
+    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;
     };
-    ctrRod = function(py, ly) {
-      const rRod = contour11(param.L2 / 2, py).addSegStrokeA(param.L2 / 2, py + ly).addSegStrokeA(-param.L2 / 2, py + ly).addSegStrokeA(-param.L2 / 2, py).closeSegStroke();
-      return rRod;
+    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 L2h = param.L2 / 2;
-    const L4h = param.L4 / 2;
-    const L2hi = (param.L2 - 2 * param.E1) / 2;
-    const H1i = param.H1 - param.E1;
-    const ctrRodExt = contour11(L2h, 0).addSegStrokeA(L2h, param.H1).addSegStrokeA(-L2h, param.H1).addSegStrokeA(-L2h, 0).closeSegStroke();
-    const ctrRodInt = contour11(L2hi, param.E1).addSegStrokeA(L2hi, H1i).addSegStrokeA(-L2hi, H1i).addSegStrokeA(-L2hi, param.E1).closeSegStroke();
-    const ctrPlateSide = contour11(L4h, param.H1).addSegStrokeA(L4h, param.H1 + param.E2).addSegStrokeA(-L4h, param.H1 + param.E2).addSegStrokeA(-L4h, param.H1).closeSegStroke();
-    figCut.addMain(ctrRodExt);
-    figCut.addMain(ctrRodInt);
-    figCut.addSecond(ctrPlateSide);
-    ctrPlate(0).forEach((ctr) => figPlate.addMain(ctr));
-    figPlate.addSecond(ctrRod(-param.L3 / 2, 2 * param.L3));
-    const plateStep = (param.L1 - param.L3) / (param.N1 - 1);
-    for (let i = 0; i < param.N1; i++) {
-      ctrPlate(i * plateStep).forEach((ctr) => figTop.addMain(ctr));
-    }
-    figTop.addSecond(ctrRod(0, param.L1));
+    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));
     rGeome.fig = {
-      faceCut: figCut,
-      facePlate: figPlate,
-      faceTop: figTop
+      faceRingBase: figRingBase,
+      faceRingTeeth: figRingTeeth,
+      faceSection: figSection
     };
     const designName = rGeome.partName;
     rGeome.vol = {
       extrudes: [
         {
-          outName: `subpax_${designName}_rod`,
-          face: `${designName}_faceCut`,
+          outName: `subpax_${designName}_base`,
+          face: `${designName}_faceRingBase`,
           extrudeMethod: EExtrude9.eLinearOrtho,
-          length: param.L1,
+          length: param.H1,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
         },
         {
-          outName: `subpax_${designName}_plates`,
-          face: `${designName}_faceTop`,
+          outName: `subpax_${designName}_teeth`,
+          face: `${designName}_faceRingTeeth`,
           extrudeMethod: EExtrude9.eLinearOrtho,
-          length: param.E2,
-          rotate: [Math.PI / 2, 0, 0],
-          translate: [0, param.E2 + param.H1, 0]
+          length: ringHeight,
+          rotate: [0, 0, 0],
+          translate: [0, 0, 0]
         }
       ],
       volumes: [
         {
           outName: `pax_${designName}`,
           boolMethod: EBVolume12.eUnion,
-          inList: [`subpax_${designName}_rod`, `subpax_${designName}_plates`]
+          inList: [`subpax_${designName}_base`, `subpax_${designName}_teeth`]
         }
       ]
     };
     rGeome.sub = {};
-    rGeome.logstr += "heliostat-rod drawn successfully!\n";
+    rGeome.logstr += "ring drawn successfully!\n";
     rGeome.calcErr = false;
   } catch (emsg) {
     rGeome.logstr += emsg;
@@ -3926,73 +3977,218 @@ function pGeom12(t, param, suffix = "") {
   }
   return rGeome;
 }
-var rodDef = {
-  pTitle: "Heliostat rod",
-  pDescription: "The rod of an heliostat-surface",
+var ringDef = {
+  pTitle: "Heliostat ring",
+  pDescription: "The gear ring for adjusting the azimuth of the heliostat",
   pDef: pDef12,
   pGeom: pGeom12
 };
 
-// src/heliostat/trapeze.ts
+// src/heliostat/vaxis_holder.ts
 import {
-  contour as contour12,
+  point as point4,
+  contour as contour13,
   contourCircle as contourCircle11,
   figure as figure13,
-  radToDeg as radToDeg8,
-  ffix as ffix14,
+  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);
+  }
+  return [rLog, rCtr];
+}
+
+// src/heliostat/vaxis_holder.ts
 var pDef13 = {
-  partName: "trapeze",
+  partName: "vaxis_holder",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber13("L1", "mm", 1600, 10, 4e3, 1),
-    pNumber13("L2", "mm", 1e3, 10, 4e3, 1),
-    pNumber13("L3", "mm", 400, 5, 800, 1),
-    pNumber13("L4", "mm", 300, 5, 800, 1),
-    pNumber13("N1", "", 7, 1, 20, 1),
-    pNumber13("N2", "", 4, 1, 20, 1),
-    pNumber13("N3", "", 2, 1, 20, 1),
-    pNumber13("N4", "", 2, 1, 20, 1),
-    pNumber13("L5", "mm", 100, 1, 400, 1),
-    pNumber13("L6", "mm", 20, 1, 400, 1),
-    pNumber13("L7", "mm", 20, 1, 400, 1),
-    pNumber13("D1", "mm", 10, 1, 40, 1),
-    pNumber13("D2", "mm", 10, 1, 40, 1),
-    pNumber13("D3", "mm", 30, 1, 100, 1),
-    pNumber13("D4", "mm", 26, 1, 100, 1),
-    pNumber13("R1", "mm", 60, 1, 400, 1),
-    pNumber13("R2", "mm", 20, 1, 400, 1),
-    pNumber13("R3", "mm", 20, 1, 400, 1),
-    pNumber13("H1", "mm", 300, 0.5, 800, 0.5),
-    pNumber13("H2", "mm", 2, 0.5, 800, 0.5),
-    pNumber13("H3", "mm", 5, 0.5, 800, 0.5)
+    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)
   ],
   paramSvg: {
-    L1: "trapeze_top.svg",
-    L2: "trapeze_top.svg",
-    L3: "trapeze_top.svg",
-    L4: "trapeze_top.svg",
-    N1: "trapeze_top.svg",
-    N2: "trapeze_top.svg",
-    N3: "trapeze_top.svg",
-    N4: "trapeze_top.svg",
-    L5: "trapeze_top.svg",
-    L6: "trapeze_top.svg",
-    L7: "trapeze_top.svg",
-    D1: "trapeze_top.svg",
-    D2: "trapeze_top.svg",
-    D3: "trapeze_rod.svg",
-    D4: "trapeze_rod.svg",
-    R1: "trapeze_top.svg",
-    R2: "trapeze_top.svg",
-    R3: "trapeze_top.svg",
-    H1: "trapeze_side.svg",
-    H2: "trapeze_side.svg",
-    H3: "trapeze_side.svg"
+    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,
@@ -4003,123 +4199,815 @@ var pDef13 = {
 };
 function pGeom13(t, param, suffix = "") {
   const rGeome = initGeom13(pDef13.partName + suffix);
-  let ctrRodFootprint;
-  let ctrRod;
-  const figFrame = figure13();
-  const figPlate = figure13();
-  const figRod = figure13();
-  const figRodHollow = figure13();
-  const figCutRod = figure13();
+  const figOuter = figure13();
+  const figPetal = figure13();
+  const figButtress1 = figure13();
+  const figButtress2 = figure13();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    if (param.L3 > param.L1 - param.L5) {
-      throw `err595: L3 ${param.L3} too large compare to L1 ${param.L1} and L5 ${param.L5}`;
-    }
-    if (param.L4 > param.L2 - param.L5) {
-      throw `err596: L4 ${param.L4} too large compare to L2 ${param.L2} and L5 ${param.L5}`;
-    }
-    if (param.H1 - param.H2 - param.H3 < 4 * param.D3) {
-      throw `err597: H1 ${param.H1} too small compare to H2 ${param.H2}, H3 ${param.H3} and D3 ${param.D3}`;
-    }
-    const pad1 = param.R1 * (1 - 1 / Math.sqrt(2));
-    const pad3 = param.R3 * (1 - 1 / Math.sqrt(2));
-    const rod_x = param.L2 / 2 - pad1 - (param.L4 / 2 - pad3);
-    const rod_y = param.L1 / 2 - pad1 - (param.L3 / 2 - pad3);
-    const rod_xy = Math.sqrt(rod_x ** 2 + rod_y ** 2);
-    const rod_z = param.H1 - param.H2 - param.H3;
-    const rod_slope_length = Math.sqrt(rod_xy ** 2 + rod_z ** 2);
-    const rod_slope_angle = Math.atan2(rod_z, rod_xy);
-    const rod_xy_angle = Math.atan2(rod_y, rod_x);
-    rGeome.logstr += `rod-slope:  length: ${ffix14(rod_slope_length)} mm,  angle: ${ffix14(
-      radToDeg8(rod_slope_angle)
-    )} degree
+    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}`;
+    }
+    rGeome.logstr += `vaxis_holder's height: ${ffix15(vaxisHolderHeight)} mm
 `;
-    rGeome.logstr += `rod-xy-angle: ${ffix14(radToDeg8(rod_xy_angle))} degree
+    rGeome.logstr += `vaxis_holder outerD1: ${ffix15(2 * outerR1)} mm
 `;
-    const rodFootprintLength = param.D3 / Math.cos(Math.PI / 2 - rod_slope_angle);
-    rGeome.logstr += `rod-footprint-length: ${ffix14(rodFootprintLength)} mm
+    rGeome.logstr += `vaxis_holder outerD2: ${ffix15(2 * outerR2)} mm
 `;
-    const rodFPl = Math.sqrt((rodFootprintLength / 2) ** 2 + (param.D3 / 2) ** 2);
-    const rodFPa = Math.atan2(param.D3, rodFootprintLength);
-    ctrRodFootprint = function(px, py, angle) {
-      const rCtr = contour12(px, py).addPointRP(angle + Math.PI - rodFPa, rodFPl).addSeg2Arcs(angle + Math.PI / 2, angle).addPointRP(angle + Math.PI + rodFPa, rodFPl).addSeg2Arcs(angle + Math.PI, angle + Math.PI / 2).addPointRP(angle - rodFPa, rodFPl).addSeg2Arcs(angle + 3 * Math.PI / 2, angle + Math.PI).addPointRP(angle + rodFPa, rodFPl).addSeg2Arcs(angle, angle - Math.PI / 2);
+    rGeome.logstr += `vaxis_holder innerD: ${ffix15(param.PHD1 - 2 * param.PHR4)} mm
+`;
+    rGeome.logstr += `vaxis_holder D2-next: ${ffix15(2 * R2next)} 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;
     };
-    ctrRod = function(px, py, angle) {
-      const px0 = px + rodFPl * Math.cos(angle + Math.PI - rodFPa);
-      const py0 = py + rodFPl * Math.sin(angle + Math.PI - rodFPa);
-      const rCtr = contour12(px0, py0).addSegStrokeRP(angle + Math.PI, rod_xy).addSegStrokeRP(angle - Math.PI / 2, param.D3).addSegStrokeRP(angle, rod_xy).closeSegStroke();
+    const 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;
     };
-    if (param.R1 > param.L1 / 4 || param.R1 > param.L2 / 4) {
-      throw `err614: R1 ${param.R1} too large compare to L1 ${param.L1} or L2 ${param.L2}`;
-    }
-    const ctrFrameExt = contour12(param.L2 / 2, param.L1 / 2).addSegStrokeA(-param.L2 / 2, param.L1 / 2).addCornerRounded(param.R1).addSegStrokeA(-param.L2 / 2, -param.L1 / 2).addCornerRounded(param.R1).addSegStrokeA(param.L2 / 2, -param.L1 / 2).addCornerRounded(param.R1).closeSegStroke().addCornerRounded(param.R1);
-    if (param.R2 > (param.L1 - 2 * param.L5) / 4 || param.R2 > (param.L2 - 2 * param.L5) / 4) {
-      throw `err627: R2 ${param.R2} too large compare to L1 ${param.L1}, L2 ${param.L2} and L5 ${param.L5}`;
-    }
-    const ctrFrameInt = contour12(param.L2 / 2 - param.L5, param.L1 / 2 - param.L5).addSegStrokeA(-param.L2 / 2 + param.L5, param.L1 / 2 - param.L5).addCornerRounded(param.R2).addSegStrokeA(-param.L2 / 2 + param.L5, -param.L1 / 2 + param.L5).addCornerRounded(param.R2).addSegStrokeA(param.L2 / 2 - param.L5, -param.L1 / 2 + param.L5).addCornerRounded(param.R2).closeSegStroke().addCornerRounded(param.R2);
-    if (param.R3 > param.L3 / 4 || param.R3 > param.L4 / 4) {
-      throw `err639: R3 ${param.R3} too large compare to L3 ${param.L3} or L4 ${param.L4}`;
-    }
-    const ctrPlate = contour12(param.L4 / 2, param.L3 / 2).addSegStrokeA(-param.L4 / 2, param.L3 / 2).addCornerRounded(param.R3).addSegStrokeA(-param.L4 / 2, -param.L3 / 2).addCornerRounded(param.R3).addSegStrokeA(param.L4 / 2, -param.L3 / 2).addCornerRounded(param.R3).closeSegStroke().addCornerRounded(param.R3);
-    figFrame.addMain(ctrFrameExt);
-    figFrame.addMain(ctrFrameInt);
-    figFrame.addSecond(ctrPlate);
-    const step1 = param.L1 / (param.N1 + 1);
-    const step2 = param.L2 / (param.N2 + 1);
-    const step3 = param.L3 / (param.N3 + 1);
-    const step4 = param.L4 / (param.N4 + 1);
-    if (param.L5 < param.D1 / 2 + param.L6) {
-      throw `err658: L5 ${param.L5} too small compare to D1 ${param.D1} or L6 ${param.L6}`;
-    }
-    if (step3 < param.D2 / 2 + param.L7) {
-      throw `err661: D2 ${param.D2} or L7 ${param.L7} too large compare to L3 ${param.l3}`;
-    }
-    if (step4 < param.D2 / 2 + param.L7) {
-      throw `err664: D2 ${param.D2} or L7 ${param.L7} too large compare to L4 ${param.l4}`;
-    }
-    const lFrameHole = [];
-    for (let i = 1; i < param.N1 + 1; i++) {
-      lFrameHole.push(
-        contourCircle11(param.L2 / 2 - param.L6, -param.L1 / 2 + i * step1, param.D1 / 2)
-      );
-      lFrameHole.push(
-        contourCircle11(-param.L2 / 2 + param.L6, -param.L1 / 2 + i * step1, param.D1 / 2)
-      );
-    }
-    for (let i = 1; i < param.N2 + 1; i++) {
-      lFrameHole.push(
-        contourCircle11(-param.L2 / 2 + i * step2, param.L1 / 2 - param.L6, param.D1 / 2)
-      );
-      lFrameHole.push(
-        contourCircle11(-param.L2 / 2 + i * step2, -param.L1 / 2 + param.L6, param.D1 / 2)
-      );
-    }
-    const lPlateHole = [];
-    for (let i = 1; i < param.N3 + 1; i++) {
-      lPlateHole.push(
-        contourCircle11(param.L4 / 2 - param.L7, -param.L3 / 2 + i * step3, param.D2 / 2)
-      );
-      lPlateHole.push(
-        contourCircle11(-param.L4 / 2 + param.L7, -param.L3 / 2 + i * step3, param.D2 / 2)
-      );
-    }
-    for (let i = 1; i < param.N4 + 1; i++) {
-      lPlateHole.push(
-        contourCircle11(-param.L4 / 2 + i * step4, param.L3 / 2 - param.L7, param.D2 / 2)
-      );
-      lPlateHole.push(
-        contourCircle11(-param.L4 / 2 + i * step4, -param.L3 / 2 + param.L7, param.D2 / 2)
-      );
+    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();
+      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();
+      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();
+      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));
     }
-    lFrameHole.forEach((ctr) => {
-      figFrame.addMain(ctr);
-    });
-    lPlateHole.forEach((ctr) => {
-      figFrame.addSecond(ctr);
-    });
+    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: 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,
+          rotate: [0, 0, 0],
+          translate: [0, 0, 0]
+        },
+        {
+          outName: `subpax_${designName}_petal`,
+          face: `${designName}_facePetal`,
+          extrudeMethod: EExtrude10.eLinearOrtho,
+          length: param.PHE1,
+          rotate: [0, 0, 0],
+          translate: [0, 0, -param.PHE1 / 2]
+        },
+        ...preExtrude1,
+        ...preExtrude2
+      ],
+      volumes: [
+        {
+          outName: `pax_${designName}`,
+          boolMethod: EBVolume13.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: pDef13,
+  pGeom: pGeom13
+};
+
+// src/heliostat/ring_guidance.ts
+import {
+  contour as contour14,
+  contourCircle as contourCircle12,
+  figure as figure14,
+  ffix as ffix16,
+  pNumber as pNumber14,
+  pSectionSeparator as pSectionSeparator13,
+  initGeom as initGeom14,
+  EExtrude as EExtrude11,
+  EBVolume as EBVolume14
+} from "geometrix";
+var pDef14 = {
+  partName: "ring_guidance",
+  params: [
+    //pNumber(name, unit, init, min, max, step)
+    pNumber14("D1", "mm", 700, 100, 2500, 1),
+    pNumber14("N1", "legs", 6, 1, 24, 1),
+    pNumber14("D2", "mm", 600, 100, 2e3, 1),
+    pSectionSeparator13("leg details"),
+    pNumber14("D3", "mm", 30, 1, 200, 1),
+    pNumber14("D4", "mm", 50, 1, 200, 1),
+    pNumber14("L1", "mm", 90, 1, 900, 1),
+    pNumber14("R5", "mm", 20, 0, 500, 1),
+    pSectionSeparator13("inner"),
+    pNumber14("D6", "mm", 300, 1, 1e3, 1),
+    pNumber14("N2", "motors", 8, 1, 200, 1),
+    pNumber14("L2", "mm", 50, 1, 200, 1),
+    pNumber14("D7", "mm", 80, 1, 200, 1),
+    pSectionSeparator13("thickness"),
+    pNumber14("T1", "mm", 10, 1, 200, 1)
+  ],
+  paramSvg: {
+    D1: "ring_guidance_top.svg",
+    D2: "ring_guidance_top.svg",
+    D3: "ring_guidance_top.svg",
+    D4: "ring_guidance_top.svg",
+    R5: "ring_guidance_top.svg",
+    D6: "ring_guidance_top.svg",
+    D7: "ring_guidance_top.svg",
+    N1: "ring_guidance_top.svg",
+    N2: "ring_guidance_top.svg",
+    L1: "ring_guidance_top.svg",
+    L2: "ring_guidance_top.svg",
+    T1: "ring_guidance_top.svg"
+  },
+  sim: {
+    tMax: 100,
+    tStep: 0.5,
+    tUpdate: 500
+    // every 0.5 second
+  }
+};
+function pGeom14(t, param, suffix = "") {
+  const rGeome = initGeom14(pDef14.partName + suffix);
+  const figTop = figure14();
+  const figSection = figure14();
+  rGeome.logstr += `${rGeome.partName} simTime: ${t}
+`;
+  try {
+    const R1 = param.D1 / 2;
+    const R3 = param.D3 / 2;
+    const R4 = param.D4 / 2;
+    const R6 = param.D6 / 2;
+    const R7 = param.D7 / 2;
+    const stepA2 = 2 * Math.PI / param.N2;
+    if (R7 > param.L2) {
+      throw `err461: D7 ${param.D7} is too large compare to L2 ${param.L2}`;
+    }
+    if (param.N2 * param.D7 > (param.D6 + 2 * param.L2) * Math.PI) {
+      throw `err462: N2 ${param.N2} is too large compare to D6 ${param.D6}, D7 ${param.D7} and L2 ${param.L2}`;
+    }
+    if (param.D2 < param.D6 + 2 * param.L2 + 2 * R7) {
+      throw `err463: D2 ${param.D2} is too small compare to D6 ${param.D6}, L2 ${param.L2} and D7 ${param.D7}`;
+    }
+    rGeome.logstr += `ring_guidance: Dmax ${ffix16(param.D1 + 2 * R4)} mm
+`;
+    const [outerLog, outerCtr, stepA1] = ctrGuidanceOuter(param);
+    rGeome.logstr += outerLog;
+    figTop.addMain(outerCtr);
+    figTop.addMain(contourCircle12(0, 0, R6));
+    for (let i = 0; i < param.N2; i++) {
+      figTop.addMain(contourCircle12(R6 + param.L2, 0, R7).rotate(0, 0, i * stepA2));
+    }
+    for (let i = 0; i < param.N1; i++) {
+      figTop.addMain(contourCircle12(R1, 0, R3).rotate(0, 0, i * stepA1));
+    }
+    const rect = function(xbl, ybl, width, height) {
+      const rCtr = contour14(xbl, ybl).addSegStrokeR(width, 0).addSegStrokeR(0, height).addSegStrokeR(-width, 0).closeSegStroke();
+      return rCtr;
+    };
+    const w1 = R1 - R6 + R4;
+    figSection.addMain(rect(R6, 0, w1, param.T1));
+    figSection.addMain(rect(-R6 - w1, 0, w1, param.T1));
+    figSection.addSecond(rect(R1 - R3, 0, 2 * R3, param.T1));
+    figSection.addSecond(rect(-R1 - R3, 0, 2 * R3, param.T1));
+    const px2 = R6 + param.L2;
+    figSection.addSecond(rect(px2 - R7, 0, 2 * R7, param.T1));
+    figSection.addSecond(rect(-px2 - R7, 0, 2 * R7, param.T1));
+    rGeome.fig = {
+      faceTop: figTop,
+      faceSection: figSection
+    };
+    const designName = rGeome.partName;
+    rGeome.vol = {
+      extrudes: [
+        {
+          outName: `subpax_${designName}_top`,
+          face: `${designName}_faceTop`,
+          extrudeMethod: EExtrude11.eLinearOrtho,
+          length: param.T1,
+          rotate: [0, 0, 0],
+          translate: [0, 0, 0]
+        }
+      ],
+      volumes: [
+        {
+          outName: `pax_${designName}`,
+          boolMethod: EBVolume14.eIdentity,
+          inList: [`subpax_${designName}_top`]
+        }
+      ]
+    };
+    rGeome.sub = {};
+    rGeome.logstr += "ring_guidance drawn successfully!\n";
+    rGeome.calcErr = false;
+  } catch (emsg) {
+    rGeome.logstr += emsg;
+    console.log(emsg);
+  }
+  return rGeome;
+}
+var ringGuidanceDef = {
+  pTitle: "Ring-guidance",
+  pDescription: "The guidance of the gear-ring for the heliostat azimuth",
+  pDef: pDef14,
+  pGeom: pGeom14
+};
+
+// src/heliostat/vaxis_guidance.ts
+import {
+  contour as contour15,
+  contourCircle as contourCircle13,
+  figure as figure15,
+  ffix as ffix17,
+  pNumber as pNumber15,
+  pSectionSeparator as pSectionSeparator14,
+  initGeom as initGeom15,
+  EExtrude as EExtrude12,
+  EBVolume as EBVolume15
+} from "geometrix";
+var pDef15 = {
+  partName: "vaxis_guidance",
+  params: [
+    //pNumber(name, unit, init, min, max, step)
+    pNumber15("D1", "mm", 700, 100, 2500, 1),
+    pNumber15("N1", "legs", 6, 1, 24, 1),
+    pNumber15("D2", "mm", 600, 100, 2e3, 1),
+    pSectionSeparator14("leg details"),
+    pNumber15("D3", "mm", 30, 1, 200, 1),
+    pNumber15("D4", "mm", 50, 1, 200, 1),
+    pNumber15("L1", "mm", 90, 1, 900, 1),
+    pNumber15("R5", "mm", 20, 0, 500, 1),
+    pSectionSeparator14("inner spring"),
+    pNumber15("D6", "mm", 540, 1, 1e3, 1),
+    pNumber15("N2", "springs", 6, 1, 24, 1),
+    pNumber15("R7", "mm", 10, 0, 100, 1),
+    pNumber15("a1", "degree", 0, -45, 45, 1),
+    pNumber15("E2", "mm", 50, 1, 200, 1),
+    pNumber15("E1", "mm", 10, 1, 200, 1),
+    pNumber15("W1", "mm", 20, 1, 200, 1),
+    pNumber15("L2", "mm", 100, 1, 900, 1),
+    pNumber15("L3", "mm", 40, 1, 900, 1),
+    pNumber15("N3", "loops", 2, 0, 8, 1),
+    pNumber15("L4", "mm", 40, 0, 900, 1),
+    pSectionSeparator14("thickness"),
+    pNumber15("T1", "mm", 10, 1, 200, 1),
+    pNumber15("Dvaxis", "mm", 260, 5, 1e3, 1)
+  ],
+  paramSvg: {
+    D1: "vaxis_guidance_top.svg",
+    N1: "vaxis_guidance_top.svg",
+    D2: "vaxis_guidance_top.svg",
+    D3: "vaxis_guidance_top.svg",
+    D4: "vaxis_guidance_top.svg",
+    L1: "vaxis_guidance_top.svg",
+    R5: "vaxis_guidance_top.svg",
+    D6: "vaxis_guidance_top.svg",
+    N2: "vaxis_guidance_top.svg",
+    R7: "vaxis_guidance_top.svg",
+    a1: "vaxis_guidance_spring.svg",
+    E2: "vaxis_guidance_top.svg",
+    E1: "vaxis_guidance_spring.svg",
+    W1: "vaxis_guidance_spring.svg",
+    L2: "vaxis_guidance_spring.svg",
+    L3: "vaxis_guidance_spring.svg",
+    N3: "vaxis_guidance_spring.svg",
+    L4: "vaxis_guidance_spring.svg",
+    T1: "vaxis_guidance_top.svg",
+    Dvaxis: "vaxis_guidance_top.svg"
+  },
+  sim: {
+    tMax: 100,
+    tStep: 0.5,
+    tUpdate: 500
+    // every 0.5 second
+  }
+};
+function pGeom15(t, param, suffix = "") {
+  const rGeome = initGeom15(pDef15.partName + suffix);
+  const figTop = figure15();
+  const figSection = figure15();
+  rGeome.logstr += `${rGeome.partName} simTime: ${t}
+`;
+  try {
+    const R1 = param.D1 / 2;
+    const R2 = param.D2 / 2;
+    const R3 = param.D3 / 2;
+    const R4 = param.D4 / 2;
+    const R6 = param.D6 / 2;
+    if (R2 < R6) {
+      throw `err466: D6 ${param.D6} is too large compare to D2 ${param.D2}`;
+    }
+    rGeome.logstr += `vaxis_guidance: Dmax ${ffix17(param.D1 + 2 * R4)} mm
+`;
+    const [outerLog, outerCtr, stepA1] = ctrGuidanceOuter(param);
+    rGeome.logstr += outerLog;
+    figTop.addMain(outerCtr);
+    for (let i = 0; i < param.N1; i++) {
+      figTop.addMain(contourCircle13(R1, 0, R3).rotate(0, 0, i * stepA1));
+    }
+    const [innerLog, innerCtr] = ctrGuidanceInner(param);
+    rGeome.logstr += innerLog;
+    figTop.addMain(innerCtr);
+    figTop.addSecond(contourCircle13(0, 0, param.Dvaxis / 2));
+    const 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));
+    rGeome.fig = {
+      faceTop: figTop,
+      faceSection: figSection
+    };
+    const designName = rGeome.partName;
+    rGeome.vol = {
+      extrudes: [
+        {
+          outName: `subpax_${designName}_top`,
+          face: `${designName}_faceTop`,
+          extrudeMethod: EExtrude12.eLinearOrtho,
+          length: param.T1,
+          rotate: [0, 0, 0],
+          translate: [0, 0, 0]
+        }
+      ],
+      volumes: [
+        {
+          outName: `pax_${designName}`,
+          boolMethod: EBVolume15.eIdentity,
+          inList: [`subpax_${designName}_top`]
+        }
+      ]
+    };
+    rGeome.sub = {};
+    rGeome.logstr += "vaxis_guidance drawn successfully!\n";
+    rGeome.calcErr = false;
+  } catch (emsg) {
+    rGeome.logstr += emsg;
+    console.log(emsg);
+  }
+  return rGeome;
+}
+var vaxisGuidanceDef = {
+  pTitle: "Vaxis-guidance",
+  pDescription: "The guidance of the V-Axis for the heliostat azimuth",
+  pDef: pDef15,
+  pGeom: pGeom15
+};
+
+// src/heliostat/rod.ts
+import {
+  contour as contour16,
+  contourCircle as contourCircle14,
+  figure as figure16,
+  ffix as ffix18,
+  pNumber as pNumber16,
+  pSectionSeparator as pSectionSeparator15,
+  initGeom as initGeom16,
+  EExtrude as EExtrude13,
+  EBVolume as EBVolume16
+} from "geometrix";
+var pDef16 = {
+  partName: "rod",
+  params: [
+    //pNumber(name, unit, init, min, max, step)
+    pNumber16("L1", "mm", 1e4, 100, 4e4, 10),
+    pNumber16("L2", "mm", 100, 2, 400, 1),
+    pNumber16("L3", "mm", 400, 10, 1e3, 1),
+    pNumber16("L4", "mm", 600, 10, 1e3, 1),
+    pNumber16("N1", "", 10, 2, 50, 1),
+    pSectionSeparator15("section"),
+    pNumber16("H1", "mm", 200, 5, 4e3, 1),
+    pNumber16("E1", "mm", 2, 1, 80, 1),
+    pNumber16("E2", "mm", 10, 1, 80, 1),
+    pSectionSeparator15("pad"),
+    pNumber16("N3", "", 2, 1, 20, 1),
+    pNumber16("N4", "", 4, 1, 20, 1),
+    pNumber16("R3", "mm", 100, 1, 500, 1),
+    pNumber16("D2", "mm", 10, 1, 100, 1),
+    pNumber16("L7", "mm", 10, 1, 300, 1)
+  ],
+  paramSvg: {
+    L1: "rod_top.svg",
+    L2: "rod_top.svg",
+    L3: "rod_top.svg",
+    L4: "rod_top.svg",
+    H1: "rod_cut.svg",
+    E1: "rod_cut.svg",
+    E2: "rod_cut.svg",
+    N1: "rod_top.svg",
+    N3: "rod_top.svg",
+    N4: "rod_top.svg",
+    R3: "rod_top.svg",
+    D2: "rod_plate.svg",
+    L7: "rod_plate.svg"
+  },
+  sim: {
+    tMax: 180,
+    tStep: 0.5,
+    tUpdate: 500
+    // every 0.5 second
+  }
+};
+function pGeom16(t, param, suffix = "") {
+  const rGeome = initGeom16(pDef16.partName + suffix);
+  let ctrPlate;
+  let ctrRod;
+  const figCut = figure16();
+  const figPlate = figure16();
+  const figTop = figure16();
+  rGeome.logstr += `${rGeome.partName} simTime: ${t}
+`;
+  try {
+    const R2 = param.D2 / 2;
+    const n3step = param.L3 / (param.N3 + 1);
+    const n4step = param.L4 / (param.N4 + 1);
+    rGeome.logstr += `rod-length: ${ffix18(param.L1)} mm
+`;
+    const space_length = (param.L1 - param.L3) / (param.N1 - 1);
+    rGeome.logstr += `space-length: ${ffix18(space_length)} mm
+`;
+    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();
+      rPlate.push(plateExt);
+      for (let i = 1; i < param.N3 + 1; i++) {
+        rPlate.push(contourCircle14(param.L4 / 2 - param.L7, py + i * n3step, R2));
+        rPlate.push(contourCircle14(-param.L4 / 2 + param.L7, py + i * n3step, R2));
+      }
+      for (let i = 1; i < param.N4 + 1; i++) {
+        rPlate.push(contourCircle14(-param.L4 / 2 + i * n4step, py + param.L7, R2));
+        rPlate.push(
+          contourCircle14(-param.L4 / 2 + i * n4step, py + param.L3 - param.L7, R2)
+        );
+      }
+      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();
+      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();
+    figCut.addMain(ctrRodExt);
+    figCut.addMain(ctrRodInt);
+    figCut.addSecond(ctrPlateSide);
+    ctrPlate(0).forEach((ctr) => figPlate.addMain(ctr));
+    figPlate.addSecond(ctrRod(-param.L3 / 2, 2 * param.L3));
+    const plateStep = (param.L1 - param.L3) / (param.N1 - 1);
+    for (let i = 0; i < param.N1; i++) {
+      ctrPlate(i * plateStep).forEach((ctr) => figTop.addMain(ctr));
+    }
+    figTop.addSecond(ctrRod(0, param.L1));
+    rGeome.fig = {
+      faceCut: figCut,
+      facePlate: figPlate,
+      faceTop: figTop
+    };
+    const designName = rGeome.partName;
+    rGeome.vol = {
+      extrudes: [
+        {
+          outName: `subpax_${designName}_rod`,
+          face: `${designName}_faceCut`,
+          extrudeMethod: EExtrude13.eLinearOrtho,
+          length: param.L1,
+          rotate: [0, 0, 0],
+          translate: [0, 0, 0]
+        },
+        {
+          outName: `subpax_${designName}_plates`,
+          face: `${designName}_faceTop`,
+          extrudeMethod: EExtrude13.eLinearOrtho,
+          length: param.E2,
+          rotate: [Math.PI / 2, 0, 0],
+          translate: [0, param.E2 + param.H1, 0]
+        }
+      ],
+      volumes: [
+        {
+          outName: `pax_${designName}`,
+          boolMethod: EBVolume16.eUnion,
+          inList: [`subpax_${designName}_rod`, `subpax_${designName}_plates`]
+        }
+      ]
+    };
+    rGeome.sub = {};
+    rGeome.logstr += "heliostat-rod drawn successfully!\n";
+    rGeome.calcErr = false;
+  } catch (emsg) {
+    rGeome.logstr += emsg;
+    console.log(emsg);
+  }
+  return rGeome;
+}
+var rodDef = {
+  pTitle: "Heliostat rod",
+  pDescription: "The rod of an heliostat-surface",
+  pDef: pDef16,
+  pGeom: pGeom16
+};
+
+// src/heliostat/trapeze.ts
+import {
+  contour as contour17,
+  contourCircle as contourCircle15,
+  figure as figure17,
+  radToDeg as radToDeg9,
+  ffix as ffix19,
+  pNumber as pNumber17,
+  pSectionSeparator as pSectionSeparator16,
+  initGeom as initGeom17,
+  EExtrude as EExtrude14,
+  EBVolume as EBVolume17
+} from "geometrix";
+var pDef17 = {
+  partName: "trapeze",
+  params: [
+    //pNumber(name, unit, init, min, max, step)
+    pNumber17("L1", "mm", 1600, 10, 4e3, 1),
+    pNumber17("L2", "mm", 1e3, 10, 4e3, 1),
+    pNumber17("L3", "mm", 400, 5, 800, 1),
+    pNumber17("L4", "mm", 300, 5, 800, 1),
+    pSectionSeparator16("outer frame"),
+    pNumber17("N1", "", 7, 1, 20, 1),
+    pNumber17("N2", "", 4, 1, 20, 1),
+    pNumber17("D1", "mm", 10, 1, 40, 1),
+    pNumber17("L5", "mm", 100, 1, 400, 1),
+    pNumber17("L6", "mm", 20, 1, 400, 1),
+    pNumber17("R1", "mm", 60, 1, 400, 1),
+    pNumber17("R2", "mm", 20, 1, 400, 1),
+    pSectionSeparator16("inner pad"),
+    pNumber17("N3", "", 2, 1, 20, 1),
+    pNumber17("N4", "", 2, 1, 20, 1),
+    pNumber17("D2", "mm", 10, 1, 40, 1),
+    pNumber17("L7", "mm", 20, 1, 400, 1),
+    pNumber17("R3", "mm", 20, 1, 400, 1),
+    pSectionSeparator16("diagonal shaft"),
+    pNumber17("D3", "mm", 30, 1, 100, 1),
+    pNumber17("D4", "mm", 26, 1, 100, 1),
+    pNumber17("H1", "mm", 300, 0.5, 800, 0.5),
+    pNumber17("H2", "mm", 2, 0.5, 800, 0.5),
+    pNumber17("H3", "mm", 5, 0.5, 800, 0.5)
+  ],
+  paramSvg: {
+    L1: "trapeze_top.svg",
+    L2: "trapeze_top.svg",
+    L3: "trapeze_top.svg",
+    L4: "trapeze_top.svg",
+    N1: "trapeze_top.svg",
+    N2: "trapeze_top.svg",
+    N3: "trapeze_top.svg",
+    N4: "trapeze_top.svg",
+    L5: "trapeze_top.svg",
+    L6: "trapeze_top.svg",
+    L7: "trapeze_top.svg",
+    D1: "trapeze_top.svg",
+    D2: "trapeze_top.svg",
+    D3: "trapeze_rod.svg",
+    D4: "trapeze_rod.svg",
+    R1: "trapeze_top.svg",
+    R2: "trapeze_top.svg",
+    R3: "trapeze_top.svg",
+    H1: "trapeze_side.svg",
+    H2: "trapeze_side.svg",
+    H3: "trapeze_side.svg"
+  },
+  sim: {
+    tMax: 180,
+    tStep: 0.5,
+    tUpdate: 500
+    // every 0.5 second
+  }
+};
+function pGeom17(t, param, suffix = "") {
+  const rGeome = initGeom17(pDef17.partName + suffix);
+  let ctrRodFootprint;
+  let ctrRod;
+  const figFrame = figure17();
+  const figPlate = figure17();
+  const figRod = figure17();
+  const figRodHollow = figure17();
+  const figCutRod = figure17();
+  rGeome.logstr += `${rGeome.partName} simTime: ${t}
+`;
+  try {
+    if (param.L3 > param.L1 - param.L5) {
+      throw `err595: L3 ${param.L3} too large compare to L1 ${param.L1} and L5 ${param.L5}`;
+    }
+    if (param.L4 > param.L2 - param.L5) {
+      throw `err596: L4 ${param.L4} too large compare to L2 ${param.L2} and L5 ${param.L5}`;
+    }
+    if (param.H1 - param.H2 - param.H3 < 4 * param.D3) {
+      throw `err597: H1 ${param.H1} too small compare to H2 ${param.H2}, H3 ${param.H3} and D3 ${param.D3}`;
+    }
+    const pad1 = param.R1 * (1 - 1 / Math.sqrt(2));
+    const pad3 = param.R3 * (1 - 1 / Math.sqrt(2));
+    const rod_x = param.L2 / 2 - pad1 - (param.L4 / 2 - pad3);
+    const rod_y = param.L1 / 2 - pad1 - (param.L3 / 2 - pad3);
+    const rod_xy = Math.sqrt(rod_x ** 2 + rod_y ** 2);
+    const rod_z = param.H1 - param.H2 - param.H3;
+    const rod_slope_length = Math.sqrt(rod_xy ** 2 + rod_z ** 2);
+    const rod_slope_angle = Math.atan2(rod_z, rod_xy);
+    const rod_xy_angle = Math.atan2(rod_y, rod_x);
+    rGeome.logstr += `rod-slope:  length: ${ffix19(rod_slope_length)} mm,  angle: ${ffix19(
+      radToDeg9(rod_slope_angle)
+    )} degree
+`;
+    rGeome.logstr += `rod-xy-angle: ${ffix19(radToDeg9(rod_xy_angle))} degree
+`;
+    const rodFootprintLength = param.D3 / Math.cos(Math.PI / 2 - rod_slope_angle);
+    rGeome.logstr += `rod-footprint-length: ${ffix19(rodFootprintLength)} mm
+`;
+    const rodFPl = Math.sqrt((rodFootprintLength / 2) ** 2 + (param.D3 / 2) ** 2);
+    const rodFPa = Math.atan2(param.D3, rodFootprintLength);
+    ctrRodFootprint = function(px, py, angle) {
+      const rCtr = 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);
+      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();
+      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);
+    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);
+    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);
+    figFrame.addMain(ctrFrameExt);
+    figFrame.addMain(ctrFrameInt);
+    figFrame.addSecond(ctrPlate);
+    const step1 = param.L1 / (param.N1 + 1);
+    const step2 = param.L2 / (param.N2 + 1);
+    const step3 = param.L3 / (param.N3 + 1);
+    const step4 = param.L4 / (param.N4 + 1);
+    if (param.L5 < param.D1 / 2 + param.L6) {
+      throw `err658: L5 ${param.L5} too small compare to D1 ${param.D1} or L6 ${param.L6}`;
+    }
+    if (step3 < param.D2 / 2 + param.L7) {
+      throw `err661: D2 ${param.D2} or L7 ${param.L7} too large compare to L3 ${param.l3}`;
+    }
+    if (step4 < param.D2 / 2 + param.L7) {
+      throw `err664: D2 ${param.D2} or L7 ${param.L7} too large compare to L4 ${param.l4}`;
+    }
+    const lFrameHole = [];
+    for (let i = 1; i < param.N1 + 1; i++) {
+      lFrameHole.push(
+        contourCircle15(param.L2 / 2 - param.L6, -param.L1 / 2 + i * step1, param.D1 / 2)
+      );
+      lFrameHole.push(
+        contourCircle15(-param.L2 / 2 + param.L6, -param.L1 / 2 + i * step1, param.D1 / 2)
+      );
+    }
+    for (let i = 1; i < param.N2 + 1; i++) {
+      lFrameHole.push(
+        contourCircle15(-param.L2 / 2 + i * step2, param.L1 / 2 - param.L6, param.D1 / 2)
+      );
+      lFrameHole.push(
+        contourCircle15(-param.L2 / 2 + i * step2, -param.L1 / 2 + param.L6, param.D1 / 2)
+      );
+    }
+    const lPlateHole = [];
+    for (let i = 1; i < param.N3 + 1; i++) {
+      lPlateHole.push(
+        contourCircle15(param.L4 / 2 - param.L7, -param.L3 / 2 + i * step3, param.D2 / 2)
+      );
+      lPlateHole.push(
+        contourCircle15(-param.L4 / 2 + param.L7, -param.L3 / 2 + i * step3, param.D2 / 2)
+      );
+    }
+    for (let i = 1; i < param.N4 + 1; i++) {
+      lPlateHole.push(
+        contourCircle15(-param.L4 / 2 + i * step4, param.L3 / 2 - param.L7, param.D2 / 2)
+      );
+      lPlateHole.push(
+        contourCircle15(-param.L4 / 2 + i * step4, -param.L3 / 2 + param.L7, param.D2 / 2)
+      );
+    }
+    lFrameHole.forEach((ctr) => {
+      figFrame.addMain(ctr);
+    });
+    lPlateHole.forEach((ctr) => {
+      figFrame.addSecond(ctr);
+    });
     const lRodFP = [];
     lRodFP.push(ctrRodFootprint(param.L2 / 2 - pad1, param.L1 / 2 - pad1, rod_xy_angle));
     lRodFP.push(ctrRodFootprint(param.L4 / 2 - pad3, param.L3 / 2 - pad3, rod_xy_angle));
@@ -4166,17 +5054,17 @@ function pGeom13(t, param, suffix = "") {
     if (param.D4 >= param.D3) {
       throw `err218: D4 ${param.D4} larger than D3 ${param.D3}`;
     }
-    figRod.addMain(contourCircle11(0, 0, param.D3 / 2));
-    figRod.addSecond(contourCircle11(0, 0, param.D4 / 2));
-    figRodHollow.addMain(contourCircle11(0, 0, param.D4 / 2));
-    figRodHollow.addSecond(contourCircle11(0, 0, param.D3 / 2));
+    figRod.addMain(contourCircle15(0, 0, param.D3 / 2));
+    figRod.addSecond(contourCircle15(0, 0, param.D4 / 2));
+    figRodHollow.addMain(contourCircle15(0, 0, param.D4 / 2));
+    figRodHollow.addSecond(contourCircle15(0, 0, param.D3 / 2));
     const rodFootprintHeight = param.D3 * Math.cos(rod_slope_angle);
     const rodFootprintBack = rodFootprintHeight / Math.tan(rod_slope_angle);
     const pad3x = pad3 + (rodFootprintLength / 2 + rodFootprintBack) * Math.cos(rod_xy_angle);
     const pad3y = pad3 + (rodFootprintLength / 2 + rodFootprintBack) * Math.sin(rod_xy_angle);
     const rodExtrudeLength = rod_slope_length + 2 * (rodFootprintLength + rodFootprintBack + rodFootprintHeight);
     const cutL = rodExtrudeLength + param.L3 + param.L4 + rodFootprintHeight;
-    const ctrCutRod = contour12(cutL, cutL).addSegStrokeA(-cutL, cutL).addSegStrokeA(-cutL, -cutL).addSegStrokeA(cutL, -cutL).closeSegStroke();
+    const ctrCutRod = contour17(cutL, cutL).addSegStrokeA(-cutL, cutL).addSegStrokeA(-cutL, -cutL).addSegStrokeA(cutL, -cutL).closeSegStroke();
     figCutRod.addMain(ctrCutRod);
     rGeome.fig = {
       faceFrame: figFrame,
@@ -4191,7 +5079,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_frame`,
           face: `${designName}_faceFrame`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: param.H2,
           rotate: [0, 0, 0],
           translate: [0, 0, param.H1 - param.H2]
@@ -4199,7 +5087,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_plate`,
           face: `${designName}_facePlate`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: param.H3,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
@@ -4207,7 +5095,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rod1`,
           face: `${designName}_faceRod`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, rod_xy_angle],
           translate: [
@@ -4219,7 +5107,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rod2`,
           face: `${designName}_faceRod`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, Math.PI - rod_xy_angle],
           translate: [
@@ -4231,7 +5119,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rod3`,
           face: `${designName}_faceRod`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, Math.PI + rod_xy_angle],
           translate: [
@@ -4243,7 +5131,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rod4`,
           face: `${designName}_faceRod`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, -rod_xy_angle],
           translate: [
@@ -4255,7 +5143,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rodH1`,
           face: `${designName}_faceRodHollow`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, rod_xy_angle],
           translate: [
@@ -4267,7 +5155,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rodH2`,
           face: `${designName}_faceRodHollow`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, Math.PI - rod_xy_angle],
           translate: [
@@ -4279,7 +5167,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rodH3`,
           face: `${designName}_faceRodHollow`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, Math.PI + rod_xy_angle],
           translate: [
@@ -4291,7 +5179,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_rodH4`,
           face: `${designName}_faceRodHollow`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: rodExtrudeLength,
           rotate: [0, Math.PI / 2 - rod_slope_angle, -rod_xy_angle],
           translate: [
@@ -4303,7 +5191,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_cut1`,
           face: `${designName}_faceCutRod`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: cutL,
           rotate: [0, 0, 0],
           translate: [0, 0, -cutL]
@@ -4311,7 +5199,7 @@ function pGeom13(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_cut2`,
           face: `${designName}_faceCutRod`,
-          extrudeMethod: EExtrude10.eLinearOrtho,
+          extrudeMethod: EExtrude14.eLinearOrtho,
           length: cutL,
           rotate: [0, 0, 0],
           translate: [0, 0, param.H1]
@@ -4320,7 +5208,7 @@ function pGeom13(t, param, suffix = "") {
       volumes: [
         {
           outName: `ipax_${designName}_rawRod`,
-          boolMethod: EBVolume13.eUnion,
+          boolMethod: EBVolume17.eUnion,
           inList: [
             `subpax_${designName}_rod1`,
             `subpax_${designName}_rod2`,
@@ -4330,7 +5218,7 @@ function pGeom13(t, param, suffix = "") {
         },
         {
           outName: `ipax_${designName}_rodHollow`,
-          boolMethod: EBVolume13.eUnion,
+          boolMethod: EBVolume17.eUnion,
           inList: [
             `subpax_${designName}_rodH1`,
             `subpax_${designName}_rodH2`,
@@ -4340,17 +5228,17 @@ function pGeom13(t, param, suffix = "") {
         },
         {
           outName: `ipax_${designName}_halfRods`,
-          boolMethod: EBVolume13.eSubstraction,
+          boolMethod: EBVolume17.eSubstraction,
           inList: [`ipax_${designName}_rawRod`, `subpax_${designName}_cut1`]
         },
         {
           outName: `ipax_${designName}_rods`,
-          boolMethod: EBVolume13.eSubstraction,
+          boolMethod: EBVolume17.eSubstraction,
           inList: [`ipax_${designName}_halfRods`, `subpax_${designName}_cut2`]
         },
         {
           outName: `ipax_${designName}_plus`,
-          boolMethod: EBVolume13.eUnion,
+          boolMethod: EBVolume17.eUnion,
           inList: [
             `subpax_${designName}_frame`,
             `subpax_${designName}_plate`,
@@ -4359,7 +5247,7 @@ function pGeom13(t, param, suffix = "") {
         },
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume13.eSubstraction,
+          boolMethod: EBVolume17.eSubstraction,
           inList: [`ipax_${designName}_plus`, `ipax_${designName}_rodHollow`]
         }
       ]
@@ -4376,49 +5264,54 @@ function pGeom13(t, param, suffix = "") {
 var trapezeDef = {
   pTitle: "Heliostat trapeze",
   pDescription: "The support of one solar panel. Made out of aluminium for lightness and cooling",
-  pDef: pDef13,
-  pGeom: pGeom13
+  pDef: pDef17,
+  pGeom: pGeom17
 };
 
 // src/heliostat/surface.ts
 import {
-  contour as contour13,
-  figure as figure14,
-  ffix as ffix15,
-  pNumber as pNumber14,
+  contour as contour18,
+  figure as figure18,
+  ffix as ffix20,
+  pNumber as pNumber18,
   pCheckbox as pCheckbox3,
   pDropdown as pDropdown2,
-  initGeom as initGeom14,
-  EExtrude as EExtrude11,
-  EBVolume as EBVolume14
+  pSectionSeparator as pSectionSeparator17,
+  initGeom as initGeom18,
+  EExtrude as EExtrude15,
+  EBVolume as EBVolume18
 } from "geometrix";
-var pDef14 = {
+var pDef18 = {
   partName: "surface",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber14("LH", "mm", 1600, 10, 4e3, 1),
-    pNumber14("LV", "mm", 1e3, 10, 4e3, 1),
-    pNumber14("LZ", "mm", 40, 0, 100, 1),
-    pNumber14("nx", "", 9, 1, 40, 1),
-    pNumber14("ny", "", 9, 1, 40, 1),
+    pNumber18("LH", "mm", 1600, 10, 4e3, 1),
+    pNumber18("LV", "mm", 1e3, 10, 4e3, 1),
+    pNumber18("LZ", "mm", 40, 0, 100, 1),
+    pNumber18("nx", "", 9, 1, 40, 1),
+    pNumber18("ny", "", 9, 1, 40, 1),
+    pSectionSeparator17("main fantasia"),
     pDropdown2("main_direction", ["horizontal", "vertical"]),
     pCheckbox3("crenel", false),
-    pNumber14("first_row", "", 9, 1, 40, 1),
-    pNumber14("second_row", "", 9, 1, 40, 1),
-    pNumber14("EH", "mm", 10, 0, 1e3, 1),
+    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),
-    pNumber14("EH_sup", "mm", 500, 0, 1e3, 1),
-    pNumber14("EH_cycle", "", 1, 0, 3, 0.05),
-    pNumber14("EH_start", "", 0, 0, 1, 0.05),
+    pNumber18("EH_sup", "mm", 500, 0, 1e3, 1),
+    pNumber18("EH_cycle", "", 1, 0, 3, 0.05),
+    pNumber18("EH_start", "", 0, 0, 1, 0.05),
     pDropdown2("EH_shape", ["sinusoid", "triangle", "sawUp", "sawDown"]),
-    pNumber14("EV", "mm", 10, 0, 1e3, 1),
+    pSectionSeparator17("vertical spacing"),
+    pNumber18("EV", "mm", 10, 0, 1e3, 1),
     pCheckbox3("EV_gradient", false),
-    pNumber14("EV_sup", "mm", 500, 0, 1e3, 1),
-    pNumber14("EV_cycle", "", 1, 0, 3, 0.05),
-    pNumber14("EV_start", "", 0, 0, 1, 0.05),
+    pNumber18("EV_sup", "mm", 500, 0, 1e3, 1),
+    pNumber18("EV_cycle", "", 1, 0, 3, 0.05),
+    pNumber18("EV_start", "", 0, 0, 1, 0.05),
     pDropdown2("EV_shape", ["sinusoid", "triangle", "sawUp", "sawDown"]),
-    pNumber14("power_efficiency", "%", 16, 0, 100, 0.1),
-    pNumber14("solar_power", "W/m2", 816, 100, 2e3, 1)
+    pSectionSeparator17("solar power"),
+    pNumber18("power_efficiency", "%", 16, 0, 100, 0.1),
+    pNumber18("solar_power", "W/m2", 816, 100, 2e3, 1)
     // 1361*0.6=816 W/m2
   ],
   paramSvg: {
@@ -4453,26 +5346,26 @@ var pDef14 = {
     // every 0.5 second
   }
 };
-function pGeom14(t, param, suffix = "") {
-  const rGeome = initGeom14(pDef14.partName + suffix);
+function pGeom18(t, param, suffix = "") {
+  const rGeome = initGeom18(pDef18.partName + suffix);
   let ctrPanelProfile;
-  const figSurface = figure14();
-  const figOnePanel = figure14();
+  const figSurface = figure18();
+  const figOnePanel = figure18();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
     const panel_surface = param.LH * param.LV / 10 ** 6;
     const panel_power = param.solar_power * panel_surface * param.power_efficiency / 100;
-    rGeome.logstr += `panel surface: ${ffix15(panel_surface)} m2
+    rGeome.logstr += `panel surface: ${ffix20(panel_surface)} m2
 `;
-    rGeome.logstr += `panel power: ${ffix15(panel_power)} W
+    rGeome.logstr += `panel power: ${ffix20(panel_power)} W
 `;
     const max_panel_nb = param.nx * param.ny;
     rGeome.logstr += `max panel number: ${max_panel_nb}
 `;
-    rGeome.logstr += `max panel surface: ${ffix15(max_panel_nb * panel_surface)} m2
+    rGeome.logstr += `max panel surface: ${ffix20(max_panel_nb * panel_surface)} m2
 `;
-    rGeome.logstr += `max panel power: ${ffix15(max_panel_nb * panel_power)} W
+    rGeome.logstr += `max panel power: ${ffix20(max_panel_nb * panel_power)} W
 `;
     const lenMain = param.main_direction === 1 ? param.ny : param.nx;
     const lenLateral = param.main_direction === 1 ? param.nx : param.ny;
@@ -4505,13 +5398,13 @@ function pGeom14(t, param, suffix = "") {
     lenRow.forEach((oneRow) => {
       panelNb += oneRow;
     });
-    rGeome.logstr += `actual panel number: ${panelNb} (${ffix15(
+    rGeome.logstr += `actual panel number: ${panelNb} (${ffix20(
       100 * panelNb / max_panel_nb
     )} %)
 `;
-    rGeome.logstr += `actual panel surface: ${ffix15(panelNb * panel_surface)} m2
+    rGeome.logstr += `actual panel surface: ${ffix20(panelNb * panel_surface)} m2
 `;
-    rGeome.logstr += `actual panel power: ${ffix15(panelNb * panel_power)} W
+    rGeome.logstr += `actual panel power: ${ffix20(panelNb * panel_power)} W
 `;
     const eMain = [];
     for (let i = 0; i < lenMain - 1; i++) {
@@ -4587,18 +5480,18 @@ function pGeom14(t, param, suffix = "") {
       gLenVertical = lenMain * param.LV + eMainTotal;
     }
     const gArea = gLenHorizontal * gLenVertical / 10 ** 6;
-    rGeome.logstr += `global horizontal width: ${ffix15(gLenHorizontal / 1e3)} m
+    rGeome.logstr += `global horizontal width: ${ffix20(gLenHorizontal / 1e3)} m
 `;
-    rGeome.logstr += `global vertical height: ${ffix15(gLenVertical / 1e3)} m
+    rGeome.logstr += `global vertical height: ${ffix20(gLenVertical / 1e3)} m
 `;
-    rGeome.logstr += `global area: ${ffix15(gArea)} m2
+    rGeome.logstr += `global area: ${ffix20(gArea)} m2
 `;
-    rGeome.logstr += `area efficiency: ${ffix15(100 * panelNb * panel_surface / gArea)} %
+    rGeome.logstr += `area efficiency: ${ffix20(100 * panelNb * panel_surface / gArea)} %
 `;
     const ox = -gLenHorizontal / 2;
     const oy = -gLenVertical / 2;
     ctrPanelProfile = function(px, py) {
-      const rPanelProfile = contour13(px, py).addSegStrokeA(px + param.LH, py).addSegStrokeA(px + param.LH, py + param.LV).addSegStrokeA(px, py + param.LV).closeSegStroke();
+      const rPanelProfile = contour18(px, py).addSegStrokeA(px + param.LH, py).addSegStrokeA(px + param.LH, py + param.LV).addSegStrokeA(px, py + param.LV).closeSegStroke();
       return rPanelProfile;
     };
     const panelPositions = [];
@@ -4638,7 +5531,7 @@ function pGeom14(t, param, suffix = "") {
         const rElem = {
           outName: `subpax_${designName}_panel_${idx}`,
           face: `${designName}_faceOnePanel`,
-          extrudeMethod: EExtrude11.eLinearOrtho,
+          extrudeMethod: EExtrude15.eLinearOrtho,
           length: param.LZ,
           rotate: [0, 0, 0],
           translate: [elem[0], elem[1], 0]
@@ -4649,7 +5542,7 @@ function pGeom14(t, param, suffix = "") {
         {
           outName: `pax_${designName}`,
           //boolMethod: EBVolume.eIdentity,
-          boolMethod: EBVolume14.eUnion,
+          boolMethod: EBVolume18.eUnion,
           inList: panelPositions.map((elem, idx) => {
             const subElem = `subpax_${designName}_panel_${idx}`;
             return subElem;
@@ -4669,19 +5562,19 @@ function pGeom14(t, param, suffix = "") {
 var surfaceDef = {
   pTitle: "Heliostat panel-surface",
   pDescription: "The surface collecting the solar power",
-  pDef: pDef14,
-  pGeom: pGeom14
+  pDef: pDef18,
+  pGeom: pGeom18
 };
 
 // src/dummy/circles.ts
-import { degToRad as degToRad4, point as point3, figure as figure15, pNumber as pNumber15, initGeom as initGeom15 } from "geometrix";
-var pDef15 = {
+import { degToRad as degToRad6, point as point5, figure as figure19, pNumber as pNumber19, initGeom as initGeom19 } from "geometrix";
+var pDef19 = {
   partName: "circles",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber15("angle", "degree", 15, 5, 45, 1),
-    pNumber15("amplitude-offset", "mm", 1, 0.5, 4, 0.1),
-    pNumber15("amplitude-scale", "scalar", 0.2, 0.1, 0.5, 0.01)
+    pNumber19("angle", "degree", 15, 5, 45, 1),
+    pNumber19("amplitude-offset", "mm", 1, 0.5, 4, 0.1),
+    pNumber19("amplitude-scale", "scalar", 0.2, 0.1, 0.5, 0.01)
   ],
   paramSvg: {
     angle: "circles_angle.svg",
@@ -4694,18 +5587,18 @@ var pDef15 = {
     tUpdate: 500
   }
 };
-function pGeom15(t, param, suffix = "") {
-  const rGeome = initGeom15(pDef15.partName + suffix);
+function pGeom19(t, param, suffix = "") {
+  const rGeome = initGeom19(pDef19.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure15();
-    const p1 = point3(10, 10);
-    const p2 = point3(10, 30);
+    const figOne = figure19();
+    const p1 = point5(10, 10);
+    const p2 = point5(10, 30);
     figOne.addPoint(p2);
     for (let i = 0; i < 20; i++) {
       figOne.addPoint(
-        p1.scale(p2, param["amplitude-offset"] + param["amplitude-scale"] * i).rotate(p2, i * degToRad4(param.angle) + t * Math.PI / 2 / pDef15.sim.tMax)
+        p1.scale(p2, param["amplitude-offset"] + param["amplitude-scale"] * i).rotate(p2, i * degToRad6(param.angle) + t * Math.PI / 2 / pDef19.sim.tMax)
       );
     }
     rGeome.fig = { one: figOne };
@@ -4720,18 +5613,18 @@ function pGeom15(t, param, suffix = "") {
 var circlesDef = {
   pTitle: "Circles",
   pDescription: "A spiral made by points.",
-  pDef: pDef15,
-  pGeom: pGeom15
+  pDef: pDef19,
+  pGeom: pGeom19
 };
 
 // src/dummy/rectangle.ts
-import { point as point4, figure as figure16, pNumber as pNumber16, initGeom as initGeom16 } from "geometrix";
-var pDef16 = {
+import { point as point6, figure as figure20, pNumber as pNumber20, initGeom as initGeom20 } from "geometrix";
+var pDef20 = {
   partName: "rectangle",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber16("width", "mm", 15, 3, 40, 0.5),
-    pNumber16("height", "mm", 10, 3, 40, 0.5)
+    pNumber20("width", "mm", 15, 3, 40, 0.5),
+    pNumber20("height", "mm", 10, 3, 40, 0.5)
   ],
   paramSvg: {
     width: "rectangle_width.svg",
@@ -4743,16 +5636,16 @@ var pDef16 = {
     tUpdate: 500
   }
 };
-function pGeom16(t, param, suffix = "") {
-  const rGeome = initGeom16(pDef16.partName + suffix);
+function pGeom20(t, param, suffix = "") {
+  const rGeome = initGeom20(pDef20.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure16();
-    const p1 = point4(10, 10);
-    const p2 = point4(10 + param.width, 10);
-    const p3 = point4(10 + param.width, 10 + param.height);
-    const p4 = point4(10, 10 + param.height);
+    const figOne = figure20();
+    const p1 = 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 angle = t * Math.PI / 180;
     figOne.addPoint(p1);
     figOne.addPoint(p2.rotate(p1, angle));
@@ -4770,25 +5663,25 @@ function pGeom16(t, param, suffix = "") {
 var rectangleDef = {
   pTitle: "Rectangle",
   pDescription: "Just a rectangle.",
-  pDef: pDef16,
-  pGeom: pGeom16
+  pDef: pDef20,
+  pGeom: pGeom20
 };
 
 // src/dummy/pole_static.ts
 import {
-  contour as contour14,
-  contourCircle as contourCircle12,
-  figure as figure17,
-  pNumber as pNumber17,
-  initGeom as initGeom17
+  contour as contour19,
+  contourCircle as contourCircle16,
+  figure as figure21,
+  pNumber as pNumber21,
+  initGeom as initGeom21
 } from "geometrix";
-var pDef17 = {
+var pDef21 = {
   partName: "pole_static",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber17("H1", "mm", 4e3, 100, 4e4, 10),
-    pNumber17("H2", "mm", 5e3, 100, 4e4, 10),
-    pNumber17("radius", "mm", 1e3, 100, 4e4, 10)
+    pNumber21("H1", "mm", 4e3, 100, 4e4, 10),
+    pNumber21("H2", "mm", 5e3, 100, 4e4, 10),
+    pNumber21("radius", "mm", 1e3, 100, 4e4, 10)
   ],
   paramSvg: {
     H1: "dummy_pole_static_face.svg",
@@ -4802,15 +5695,15 @@ var pDef17 = {
     // every 0.5 second
   }
 };
-function pGeom17(t, param, suffix = "") {
-  const rGeome = initGeom17(pDef17.partName + suffix);
-  const figFace = figure17();
+function pGeom21(t, param, suffix = "") {
+  const rGeome = initGeom21(pDef21.partName + suffix);
+  const figFace = figure21();
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const ctrPoleFace = contour14(-param.H1 / 2, -param.H2 / 2).addSegStrokeA(param.H1 / 2, -param.H2 / 2).addSegStrokeA(param.H1 / 2, param.H2 / 2).addSegStrokeA(-param.H1 / 2, param.H2 / 2).closeSegStroke();
+    const ctrPoleFace = 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();
     figFace.addMain(ctrPoleFace);
-    figFace.addMain(contourCircle12(0, 0, param.radius));
+    figFace.addMain(contourCircle16(0, 0, param.radius));
     rGeome.fig = {
       poleFace: figFace
     };
@@ -4826,22 +5719,22 @@ function pGeom17(t, param, suffix = "") {
 var dummyPoleStaticDef = {
   pTitle: "Dummy pole static",
   pDescription: "Testing two design with identical name",
-  pDef: pDef17,
-  pGeom: pGeom17
+  pDef: pDef21,
+  pGeom: pGeom21
 };
 
 // src/geometrix_verification/verify_point.ts
-import { degToRad as degToRad5, point as point5, figure as figure18, pNumber as pNumber18, initGeom as initGeom18 } from "geometrix";
-var pDef18 = {
+import { degToRad as degToRad7, point as point7, figure as figure22, pNumber as pNumber22, initGeom as initGeom22 } from "geometrix";
+var pDef22 = {
   partName: "verify_point",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber18("p1x", "mm", 30, -200, 200, 1),
-    pNumber18("p1y", "mm", 50, -200, 200, 1),
-    pNumber18("p2a", "degree", 30, -200, 200, 1),
-    pNumber18("p2l", "mm", 60, 0, 200, 1),
-    pNumber18("rotateOrig", "degree", 45, -200, 200, 1),
-    pNumber18("scaleOrig", "scalar", 1.5, 0.1, 2, 0.1)
+    pNumber22("p1x", "mm", 30, -200, 200, 1),
+    pNumber22("p1y", "mm", 50, -200, 200, 1),
+    pNumber22("p2a", "degree", 30, -200, 200, 1),
+    pNumber22("p2l", "mm", 60, 0, 200, 1),
+    pNumber22("rotateOrig", "degree", 45, -200, 200, 1),
+    pNumber22("scaleOrig", "scalar", 1.5, 0.1, 2, 0.1)
   ],
   paramSvg: {
     p1x: "verify_point_p1x.svg",
@@ -4858,15 +5751,15 @@ var pDef18 = {
     // every 0.5 second
   }
 };
-function pGeom18(t, param, suffix = "") {
-  const rGeome = initGeom18(pDef18.partName + suffix);
+function pGeom22(t, param, suffix = "") {
+  const rGeome = initGeom22(pDef22.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure18();
-    const p1 = point5(param.p1x, param.p1y + t);
-    const p2 = point5(0, 0).setPolar(degToRad5(param.p2a), param.p2l);
-    const p3 = p1.rotateOrig(degToRad5(param.rotateOrig));
+    const figOne = figure22();
+    const p1 = point7(param.p1x, param.p1y + t);
+    const p2 = point7(0, 0).setPolar(degToRad7(param.p2a), param.p2l);
+    const p3 = p1.rotateOrig(degToRad7(param.rotateOrig));
     const p4 = p1.scaleOrig(param.scaleOrig);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
@@ -4884,23 +5777,23 @@ function pGeom18(t, param, suffix = "") {
 var verifyPoint1Def = {
   pTitle: "Verify point",
   pDescription: "Debugging point.ts",
-  pDef: pDef18,
-  pGeom: pGeom18
+  pDef: pDef22,
+  pGeom: pGeom22
 };
 
 // src/geometrix_verification/verify_point_2.ts
-import { point as point6, figure as figure19, pNumber as pNumber19, initGeom as initGeom19 } from "geometrix";
-var pDef19 = {
+import { point as point8, figure as figure23, pNumber as pNumber23, initGeom as initGeom23 } from "geometrix";
+var pDef23 = {
   partName: "verify_point_2",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber19("p1x", "mm", 30, -200, 200, 1),
-    pNumber19("p1y", "mm", 50, -200, 200, 1),
-    pNumber19("p2x", "mm", -10, -200, 200, 1),
-    pNumber19("p2y", "mm", 60, -200, 200, 1),
-    pNumber19("p3x", "mm", 70, -200, 200, 1),
-    pNumber19("p3y", "mm", -20, -200, 200, 1),
-    pNumber19("dist", "mm", 50, 0, 200, 1)
+    pNumber23("p1x", "mm", 30, -200, 200, 1),
+    pNumber23("p1y", "mm", 50, -200, 200, 1),
+    pNumber23("p2x", "mm", -10, -200, 200, 1),
+    pNumber23("p2y", "mm", 60, -200, 200, 1),
+    pNumber23("p3x", "mm", 70, -200, 200, 1),
+    pNumber23("p3y", "mm", -20, -200, 200, 1),
+    pNumber23("dist", "mm", 50, 0, 200, 1)
   ],
   paramSvg: {
     p1x: "verify_line_p1x.svg",
@@ -4918,15 +5811,15 @@ var pDef19 = {
     // every 0.5 second
   }
 };
-function pGeom19(t, param, suffix = "") {
-  const rGeome = initGeom19(pDef19.partName + suffix);
+function pGeom23(t, param, suffix = "") {
+  const rGeome = initGeom23(pDef23.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure19();
-    const p1 = point6(param.p1x, param.p1y + t);
-    const p2 = point6(param.p2x, param.p2y);
-    const p3 = point6(param.p3x, param.p3y);
+    const figOne = figure23();
+    const p1 = point8(param.p1x, param.p1y + t);
+    const p2 = point8(param.p2x, param.p2y);
+    const p3 = point8(param.p3x, param.p3y);
     const mp1p2 = p1.middlePoint(p2);
     const ep1p2 = p1.equidistantPoint(p2, param.dist, p3);
     figOne.addPoint(p1);
@@ -4946,22 +5839,22 @@ function pGeom19(t, param, suffix = "") {
 var verifyPoint2Def = {
   pTitle: "Verify point 2",
   pDescription: "Debugging more point.ts",
-  pDef: pDef19,
-  pGeom: pGeom19
+  pDef: pDef23,
+  pGeom: pGeom23
 };
 
 // src/geometrix_verification/verify_line.ts
-import { point as point7, line, linePP, figure as figure20, pNumber as pNumber20, initGeom as initGeom20 } from "geometrix";
-var pDef20 = {
+import { point as point9, line, linePP, figure as figure24, pNumber as pNumber24, initGeom as initGeom24 } from "geometrix";
+var pDef24 = {
   partName: "verify_line",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber20("p1x", "mm", 30, -200, 200, 1),
-    pNumber20("p1y", "mm", 50, -200, 200, 1),
-    pNumber20("p2x", "mm", 40, -200, 200, 1),
-    pNumber20("p2y", "mm", -20, -200, 200, 1),
-    pNumber20("p3x", "mm", -30, -200, 200, 1),
-    pNumber20("p3y", "mm", 30, -200, 200, 1)
+    pNumber24("p1x", "mm", 30, -200, 200, 1),
+    pNumber24("p1y", "mm", 50, -200, 200, 1),
+    pNumber24("p2x", "mm", 40, -200, 200, 1),
+    pNumber24("p2y", "mm", -20, -200, 200, 1),
+    pNumber24("p3x", "mm", -30, -200, 200, 1),
+    pNumber24("p3y", "mm", 30, -200, 200, 1)
   ],
   paramSvg: {
     p1x: "verify_line_p1x.svg",
@@ -4978,25 +5871,25 @@ var pDef20 = {
     // every 0.5 second
   }
 };
-function pGeom20(t, param, suffix = "") {
-  const rGeome = initGeom20(pDef20.partName + suffix);
+function pGeom24(t, param, suffix = "") {
+  const rGeome = initGeom24(pDef24.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure20();
-    const p1 = point7(param.p1x, param.p1y + t);
-    const p2 = point7(param.p2x, param.p2y);
-    const p3 = point7(param.p3x, param.p3y);
+    const figOne = figure24();
+    const p1 = point9(param.p1x, param.p1y + t);
+    const p2 = point9(param.p2x, param.p2y);
+    const p3 = point9(param.p3x, param.p3y);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
     figOne.addPoint(p3);
     const l1 = line(0, 0, 0).setFromPoints(p1, p2);
     figOne.addLine(l1);
-    figOne.addPoint(point7(l1.getAxisXIntersection(), 0));
-    figOne.addPoint(point7(0, l1.getAxisYIntersection()));
+    figOne.addPoint(point9(l1.getAxisXIntersection(), 0));
+    figOne.addPoint(point9(0, l1.getAxisYIntersection()));
     const p4 = l1.projectOrig();
     figOne.addPoint(p4);
-    const p0 = point7(0, 0);
+    const p0 = point9(0, 0);
     if (!p0.isEqual(p4)) {
       const l2 = linePP(p0, p4);
       figOne.addLine(l2);
@@ -5018,24 +5911,24 @@ function pGeom20(t, param, suffix = "") {
 var verifyLine1Def = {
   pTitle: "Verify line",
   pDescription: "Debugging line.ts",
-  pDef: pDef20,
-  pGeom: pGeom20
+  pDef: pDef24,
+  pGeom: pGeom24
 };
 
 // src/geometrix_verification/verify_line_2.ts
-import { degToRad as degToRad6, point as point8, line as line2, figure as figure21, pNumber as pNumber21, initGeom as initGeom21 } from "geometrix";
-var pDef21 = {
+import { degToRad as degToRad8, point as point10, line as line2, figure as figure25, pNumber as pNumber25, initGeom as initGeom25 } from "geometrix";
+var pDef25 = {
   partName: "verify_line_2",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber21("l1cx", "mm", 10, -200, 200, 1),
-    pNumber21("l1cy", "mm", 20, -200, 200, 1),
-    pNumber21("l1ca", "degree", 15, -200, 200, 1),
-    pNumber21("l2cx", "mm", 30, -200, 200, 1),
-    pNumber21("l2cy", "mm", 50, -200, 200, 1),
-    pNumber21("l2ca", "degree", 35, -200, 200, 1),
-    pNumber21("p3x", "mm", -30, -200, 200, 1),
-    pNumber21("p3y", "mm", 30, -200, 200, 1)
+    pNumber25("l1cx", "mm", 10, -200, 200, 1),
+    pNumber25("l1cy", "mm", 20, -200, 200, 1),
+    pNumber25("l1ca", "degree", 15, -200, 200, 1),
+    pNumber25("l2cx", "mm", 30, -200, 200, 1),
+    pNumber25("l2cy", "mm", 50, -200, 200, 1),
+    pNumber25("l2ca", "degree", 35, -200, 200, 1),
+    pNumber25("p3x", "mm", -30, -200, 200, 1),
+    pNumber25("p3y", "mm", 30, -200, 200, 1)
   ],
   paramSvg: {
     l1cx: "verify_line_2_l1cx.svg",
@@ -5054,20 +5947,20 @@ var pDef21 = {
     // every 0.5 second
   }
 };
-function pGeom21(t, param, suffix = "") {
-  const rGeome = initGeom21(pDef21.partName + suffix);
+function pGeom25(t, param, suffix = "") {
+  const rGeome = initGeom25(pDef25.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure21();
-    const p1 = point8(param.l1cx, param.l1cy);
-    const p2 = point8(param.l2cx, param.l2cy);
-    const p3 = point8(param.p3x, param.p3y);
+    const figOne = figure25();
+    const p1 = point10(param.l1cx, param.l1cy);
+    const p2 = point10(param.l2cx, param.l2cy);
+    const p3 = point10(param.p3x, param.p3y);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
     figOne.addPoint(p3);
-    const l1 = line2(param.l1cx, param.l1cy, degToRad6(param.l1ca + t));
-    const l2 = line2(param.l2cx, param.l2cy, degToRad6(param.l2ca));
+    const l1 = line2(param.l1cx, param.l1cy, degToRad8(param.l1ca + t));
+    const l2 = line2(param.l2cx, param.l2cy, degToRad8(param.l2ca));
     figOne.addLine(l1);
     figOne.addLine(l2);
     figOne.addPoint(l1.intersection(l2));
@@ -5078,7 +5971,7 @@ function pGeom21(t, param, suffix = "") {
     rGeome.logstr += `dist(l2, p3) = ${l2.distanceToPoint(p3)}
 `;
     const bisector2 = l1.bisector(l2, p3);
-    const pBisec = point8(bisector2.cx, bisector2.cy).translatePolar(bisector2.ca, 30);
+    const pBisec = point10(bisector2.cx, bisector2.cy).translatePolar(bisector2.ca, 30);
     figOne.addPoint(pBisec);
     rGeome.fig = { one: figOne };
     rGeome.logstr += "verify_line_2 drawn successfully!\n";
@@ -5092,22 +5985,22 @@ function pGeom21(t, param, suffix = "") {
 var verifyLine2Def = {
   pTitle: "Verify line 2",
   pDescription: "Debugging more line.ts",
-  pDef: pDef21,
-  pGeom: pGeom21
+  pDef: pDef25,
+  pGeom: pGeom25
 };
 
 // src/geometrix_verification/verify_line_3.ts
-import { point as point9, bisector, circleCenter, figure as figure22, pNumber as pNumber22, initGeom as initGeom22 } from "geometrix";
-var pDef22 = {
+import { point as point11, bisector, circleCenter, figure as figure26, pNumber as pNumber26, initGeom as initGeom26 } from "geometrix";
+var pDef26 = {
   partName: "verify_line_3",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber22("p1x", "mm", 30, -200, 200, 1),
-    pNumber22("p1y", "mm", 50, -200, 200, 1),
-    pNumber22("p2x", "mm", 40, -200, 200, 1),
-    pNumber22("p2y", "mm", -20, -200, 200, 1),
-    pNumber22("p3x", "mm", -30, -200, 200, 1),
-    pNumber22("p3y", "mm", 30, -200, 200, 1)
+    pNumber26("p1x", "mm", 30, -200, 200, 1),
+    pNumber26("p1y", "mm", 50, -200, 200, 1),
+    pNumber26("p2x", "mm", 40, -200, 200, 1),
+    pNumber26("p2y", "mm", -20, -200, 200, 1),
+    pNumber26("p3x", "mm", -30, -200, 200, 1),
+    pNumber26("p3y", "mm", 30, -200, 200, 1)
   ],
   paramSvg: {
     p1x: "verify_line_p1x.svg",
@@ -5124,15 +6017,15 @@ var pDef22 = {
     // every 0.5 second
   }
 };
-function pGeom22(t, param, suffix = "") {
-  const rGeome = initGeom22(pDef22.partName + suffix);
+function pGeom26(t, param, suffix = "") {
+  const rGeome = initGeom26(pDef26.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure22();
-    const p1 = point9(param.p1x, param.p1y + t);
-    const p2 = point9(param.p2x, param.p2y);
-    const p3 = point9(param.p3x, param.p3y);
+    const figOne = figure26();
+    const p1 = point11(param.p1x, param.p1y + t);
+    const p2 = point11(param.p2x, param.p2y);
+    const p3 = point11(param.p3x, param.p3y);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
     figOne.addPoint(p3);
@@ -5152,24 +6045,24 @@ function pGeom22(t, param, suffix = "") {
 var verifyLine3Def = {
   pTitle: "Verify line 3",
   pDescription: "Debugging more more line.ts",
-  pDef: pDef22,
-  pGeom: pGeom22
+  pDef: pDef26,
+  pGeom: pGeom26
 };
 
 // src/geometrix_verification/verify_vector.ts
-import { degToRad as degToRad7, point as point10, vector, figure as figure23, pNumber as pNumber23, initGeom as initGeom23 } from "geometrix";
-var pDef23 = {
+import { degToRad as degToRad9, point as point12, vector, figure as figure27, pNumber as pNumber27, initGeom as initGeom27 } from "geometrix";
+var pDef27 = {
   partName: "verify_vector",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber23("p1x", "mm", 30, -200, 200, 1),
-    pNumber23("p1y", "mm", 50, -200, 200, 1),
-    pNumber23("p2x", "mm", 80, -200, 200, 1),
-    pNumber23("p2y", "mm", -30, -200, 200, 1),
-    pNumber23("v1a", "degree", 30, -200, 200, 1),
-    pNumber23("v1l", "mm", 60, 0, 200, 1),
-    pNumber23("v2a", "degree", 30, -200, 200, 1),
-    pNumber23("v2l", "mm", 60, 0, 200, 1)
+    pNumber27("p1x", "mm", 30, -200, 200, 1),
+    pNumber27("p1y", "mm", 50, -200, 200, 1),
+    pNumber27("p2x", "mm", 80, -200, 200, 1),
+    pNumber27("p2y", "mm", -30, -200, 200, 1),
+    pNumber27("v1a", "degree", 30, -200, 200, 1),
+    pNumber27("v1l", "mm", 60, 0, 200, 1),
+    pNumber27("v2a", "degree", 30, -200, 200, 1),
+    pNumber27("v2l", "mm", 60, 0, 200, 1)
   ],
   paramSvg: {
     p1x: "verify_vector_p1x.svg",
@@ -5188,16 +6081,16 @@ var pDef23 = {
     // every 0.5 second
   }
 };
-function pGeom23(t, param, suffix = "") {
-  const rGeome = initGeom23(pDef23.partName + suffix);
+function pGeom27(t, param, suffix = "") {
+  const rGeome = initGeom27(pDef27.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure23();
-    const p1 = point10(param.p1x, param.p1y + t);
-    const p2 = point10(param.p2x, param.p2y);
-    const v1 = vector(degToRad7(param.v1a), param.v1l, p1);
-    const v2 = vector(degToRad7(param.v2a), param.v2l, p1);
+    const figOne = figure27();
+    const p1 = point12(param.p1x, param.p1y + t);
+    const p2 = point12(param.p2x, param.p2y);
+    const v1 = vector(degToRad9(param.v1a), param.v1l, p1);
+    const v2 = vector(degToRad9(param.v2a), param.v2l, p1);
     figOne.addPoint(p1);
     figOne.addPoint(p2);
     figOne.addVector(v1);
@@ -5218,22 +6111,22 @@ function pGeom23(t, param, suffix = "") {
 var verifyVector1Def = {
   pTitle: "Verify vector",
   pDescription: "Debugging vector.ts",
-  pDef: pDef23,
-  pGeom: pGeom23
+  pDef: pDef27,
+  pGeom: pGeom27
 };
 
 // src/geometrix_verification/verify_contour_1.ts
-import { contour as contour15, contourCircle as contourCircle13, figure as figure24, pNumber as pNumber24, initGeom as initGeom24 } from "geometrix";
-var pDef24 = {
+import { contour as contour20, contourCircle as contourCircle17, figure as figure28, pNumber as pNumber28, initGeom as initGeom28 } from "geometrix";
+var pDef28 = {
   partName: "verify_contour_1",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber24("r1", "mm", 30, 10, 200, 1),
-    pNumber24("d1", "mm", 20, 10, 200, 1),
-    pNumber24("w1", "mm", 100, 10, 200, 1),
-    pNumber24("r2", "mm", 60, 10, 200, 1),
-    pNumber24("l1", "mm", 10, 5, 200, 1),
-    pNumber24("l2", "mm", 30, 5, 200, 1)
+    pNumber28("r1", "mm", 30, 10, 200, 1),
+    pNumber28("d1", "mm", 20, 10, 200, 1),
+    pNumber28("w1", "mm", 100, 10, 200, 1),
+    pNumber28("r2", "mm", 60, 10, 200, 1),
+    pNumber28("l1", "mm", 10, 5, 200, 1),
+    pNumber28("l2", "mm", 30, 5, 200, 1)
   ],
   paramSvg: {
     r1: "verify_contour_1_r1.svg",
@@ -5250,12 +6143,12 @@ var pDef24 = {
     // every 0.5 second
   }
 };
-function pGeom24(t, param, suffix = "") {
-  const rGeome = initGeom24(pDef24.partName + suffix);
+function pGeom28(t, param, suffix = "") {
+  const rGeome = initGeom28(pDef28.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure24();
+    const figOne = figure28();
     const r1 = param.r1;
     const d1 = param.d1;
     const w1 = param.w1;
@@ -5268,20 +6161,20 @@ function pGeom24(t, param, suffix = "") {
     const c12 = 2 * r1 + d1;
     const c2 = c1 + c12;
     const c3 = c1 + 2 * c12;
-    const ctr1 = contour15(0, 0);
+    const ctr1 = contour20(0, 0);
     ctr1.addSegStrokeA(w1, 0);
     ctr1.addSegStrokeA(w1, h1);
     ctr1.addSegStrokeA(0, h1);
     ctr1.closeSegStroke();
     ctr1.check();
     figOne.addMain(ctr1);
-    figOne.addMain(contourCircle13(w12, c1, r1));
-    figOne.addMain(contourCircle13(w12, c2, r1 + t));
-    figOne.addMain(contourCircle13(w12, c3, r1));
-    const ctr2 = contourCircle13(w1 + r2, 3 * c1, r2);
+    figOne.addMain(contourCircle17(w12, c1, r1));
+    figOne.addMain(contourCircle17(w12, c2, r1 + t));
+    figOne.addMain(contourCircle17(w12, c3, r1));
+    const ctr2 = contourCircle17(w1 + r2, 3 * c1, r2);
     ctr2.check();
     figOne.addSecond(ctr2);
-    const ctr3 = contour15(200 + l1, 200).addSegStrokeA(200 + l1 + l2, 200).addSegStrokeR(0, l1).addSegStrokeRP(0, l1).addSegStrokeRP(Math.PI / 2, l2).addSegStrokeAP(Math.PI / 4, Math.sqrt(2) * (200 + l1 + l2)).addSegStrokeA(200 + l1 + l2, 200 + 2 * l1 + l2).addSegStrokeR(-l2, 0).addSegStrokeR(0, -l1).addSegStrokeR(-l1, 0).addSegStrokeRP(-Math.PI / 2, l2).addSegStrokeR(l1, 0).closeSegStroke();
+    const ctr3 = 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();
     ctr3.check();
     figOne.addSecond(ctr3);
     rGeome.fig = { one: figOne };
@@ -5296,20 +6189,20 @@ function pGeom24(t, param, suffix = "") {
 var verifyContour1Def = {
   pTitle: "Verify contour 1",
   pDescription: "Debugging contour.ts",
-  pDef: pDef24,
-  pGeom: pGeom24
+  pDef: pDef28,
+  pGeom: pGeom28
 };
 
 // src/geometrix_verification/verify_contour_2.ts
-import { degToRad as degToRad8, contour as contour16, figure as figure25, pNumber as pNumber25, initGeom as initGeom25 } from "geometrix";
-var pDef25 = {
+import { degToRad as degToRad10, contour as contour21, figure as figure29, pNumber as pNumber29, initGeom as initGeom29 } from "geometrix";
+var pDef29 = {
   partName: "verify_contour_2",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber25("r1", "mm", 20, 5, 200, 1),
-    pNumber25("a1", "deg", 30, -200, 200, 1),
-    pNumber25("at1", "deg", 30, -200, 200, 1),
-    pNumber25("at2", "deg", 50, -200, 200, 1)
+    pNumber29("r1", "mm", 20, 5, 200, 1),
+    pNumber29("a1", "deg", 30, -200, 200, 1),
+    pNumber29("at1", "deg", 30, -200, 200, 1),
+    pNumber29("at2", "deg", 50, -200, 200, 1)
   ],
   paramSvg: {
     r1: "verify_contour_1_r1.svg",
@@ -5324,17 +6217,17 @@ var pDef25 = {
     // every 0.5 second
   }
 };
-function pGeom25(t, param, suffix = "") {
-  const rGeome = initGeom25(pDef25.partName + suffix);
+function pGeom29(t, param, suffix = "") {
+  const rGeome = initGeom29(pDef29.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure25();
+    const figOne = figure29();
     const r1 = param.r1 + t;
     const ata = param.a1 + t;
     const at1 = param.at1 + t;
     const at2 = param.at2 + t;
-    const ctr1 = contour16(20, 20);
+    const ctr1 = contour21(20, 20);
     ctr1.addSegStrokeA(40, 20);
     ctr1.addPointA(60, 20).addSegArc(r1, true, true);
     ctr1.addPointA(80, 20).addSegArc(r1, true, false);
@@ -5361,7 +6254,7 @@ function pGeom25(t, param, suffix = "") {
     ctr1.closeSegStroke();
     ctr1.check();
     figOne.addMain(ctr1);
-    const ctr2 = contour16(20, -20);
+    const ctr2 = contour21(20, -20);
     ctr2.addSegStrokeA(40, -40);
     ctr2.addPointA(60, -60).addSegArc(r1, true, true);
     ctr2.addPointA(80, -80).addSegArc(r1, true, false);
@@ -5371,17 +6264,17 @@ function pGeom25(t, param, suffix = "") {
     ctr2.addSegStrokeR(20, 20).addPointR(20, 20).addSegArc(r1, false, false).addPointRP(Math.PI / 4, 28).addSegArc(r1, false, true).addPointRP(Math.PI / 4, 28).addSegArc(r1, true, true).addPointRP(Math.PI / 4, 28).addSegArc(r1, true, false).addSegStrokeRP(Math.PI / 4, 20).addSegStrokeRP(-Math.PI / 4, 20).addPointR(10, -9).addPointR(20, -20).addSegArc2().addPointR(20, -9).addPointR(20, -20).addSegArc2().addPointR(9, -6).addPointR(20, -20).addSegArc2().addPointR(9, -14).addPointR(20, -20).addSegArc2().addPointR(9, 0).addPointR(20, -20).addSegArc2().addSegStrokeR(20, -20).addSegStrokeR(20, 20).addPointR(9, 20).addPointR(20, 20).addSegArc2().addPointR(20, 10).addPointR(20, 20).addSegArc2().addPointR(9, 6).addPointR(20, 20).addSegArc2().addPointR(9, 14).addPointR(20, 20).addSegArc2().addPointR(9, 0).addPointR(20, 20).addSegArc2().addSegStrokeR(20, 20).addSegStrokeR(0, 20).addPointR(15, 8).addPointR(0, 20).addSegArc2().addPointR(-15, 8).addPointR(0, 20).addSegArc2().addPointR(5, 8).addPointR(0, 20).addSegArc2().addPointR(-5, 8).addPointR(0, 20).addSegArc2().addSegStrokeR(0, 20).addSegStrokeR(20, 0).addPointR(8, 15).addPointR(20, 0).addSegArc2().addPointR(8, -15).addPointR(20, 0).addSegArc2().addPointR(8, 5).addPointR(20, 0).addSegArc2().addPointR(8, -5).addPointR(20, 0).addSegArc2().addSegStrokeR(20, 0).addSegStrokeR(0, -20).addPointR(15, -8).addPointR(0, -20).addSegArc2().addPointR(-15, -8).addPointR(0, -20).addSegArc2().addPointR(5, -8).addPointR(0, -20).addSegArc2().addPointR(-5, -8).addPointR(0, -20).addSegArc2().addSegStrokeR(0, -20).addSegStrokeR(-20, 0).addPointR(-8, 15).addPointR(-20, 0).addSegArc2().addPointR(-8, -15).addPointR(-20, 0).addSegArc2().addPointR(-8, 5).addPointR(-20, 0).addSegArc2().addPointR(-8, -5).addPointR(-20, 0).addSegArc2().addSegStrokeR(-20, 0).closeSegStroke();
     ctr2.check();
     figOne.addMain(ctr2);
-    const ctr3 = contour16(200, 200).addSegStrokeR(20, 0).addPointR(20, 0).addSegArc3(degToRad8(ata), true).addSegStrokeR(20, 0).addPointR(20, 0).addSegArc3(degToRad8(ata), false).addSegStrokeR(20, 0).addSegStrokeR(0, 20).addPointR(0, 20).addSegArc3(degToRad8(ata), true).addSegStrokeR(0, 20).addPointR(0, 20).addSegArc3(degToRad8(ata), false).addSegStrokeR(0, 20).addSegStrokeR(-20, 0).addPointR(-20, 0).addSegArc3(degToRad8(ata), true).addSegStrokeR(-20, 0).addPointR(-20, 0).addSegArc3(degToRad8(ata), false).addSegStrokeR(-20, 0).addSegStrokeR(0, -20).addPointR(0, -20).addSegArc3(degToRad8(ata), true).addSegStrokeR(0, -20).addPointR(0, -20).addSegArc3(degToRad8(ata), false).addSegStrokeR(0, -20);
+    const ctr3 = 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);
     ctr3.check();
     figOne.addMain(ctr3);
-    const ctr4 = contour16(600, 200).addSegStrokeR(20, 20).addPointR(20, 20).addSegArc3(degToRad8(ata), true).addSegStrokeR(20, 20).addPointR(20, 20).addSegArc3(degToRad8(ata), false).addSegStrokeR(20, 20).addSegStrokeR(-20, 20).addPointR(-20, 20).addSegArc3(degToRad8(ata), true).addSegStrokeR(-20, 20).addPointR(-20, 20).addSegArc3(degToRad8(ata), false).addSegStrokeR(-20, 20).addSegStrokeR(-20, -20).addPointR(-20, -20).addSegArc3(degToRad8(ata), true).addSegStrokeR(-20, -20).addPointR(-20, -20).addSegArc3(degToRad8(ata), false).addSegStrokeR(-20, -20).addSegStrokeR(20, -20).addPointR(20, -20).addSegArc3(degToRad8(ata), true).addSegStrokeR(20, -20).addPointR(20, -20).addSegArc3(degToRad8(ata), false).addSegStrokeR(20, -20);
+    const ctr4 = 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);
     ctr4.check();
     figOne.addMain(ctr4);
-    const ctr5 = contour16(100, 500);
+    const ctr5 = contour21(100, 500);
     for (let i = 0; i < 8; i++) {
       const adir = i * 45;
-      const adirRad = degToRad8(adir);
-      ctr5.addSegStrokeRP(adirRad, 20).addPointRP(adirRad, 20).addSeg2Arcs(degToRad8(adir + at1), degToRad8(180 + adir - at2)).addSegStrokeRP(adirRad, 20).addPointRP(adirRad, 20).addSeg2Arcs(degToRad8(adir - at1), degToRad8(180 + adir + at2)).addSegStrokeRP(adirRad, 20);
+      const adirRad = degToRad10(adir);
+      ctr5.addSegStrokeRP(adirRad, 20).addPointRP(adirRad, 20).addSeg2Arcs(degToRad10(adir + at1), degToRad10(180 + adir - at2)).addSegStrokeRP(adirRad, 20).addPointRP(adirRad, 20).addSeg2Arcs(degToRad10(adir - at1), degToRad10(180 + adir + at2)).addSegStrokeRP(adirRad, 20);
     }
     ctr5.check();
     figOne.addMain(ctr5);
@@ -5397,22 +6290,22 @@ function pGeom25(t, param, suffix = "") {
 var verifyContour2Def = {
   pTitle: "Verify contour 2",
   pDescription: "Debugging more contour.ts",
-  pDef: pDef25,
-  pGeom: pGeom25
+  pDef: pDef29,
+  pGeom: pGeom29
 };
 
 // src/geometrix_verification/verify_contour_3.ts
-import { degToRad as degToRad9, contour as contour17, figure as figure26, pNumber as pNumber26, initGeom as initGeom26 } from "geometrix";
-var pDef26 = {
+import { degToRad as degToRad11, contour as contour22, figure as figure30, pNumber as pNumber30, initGeom as initGeom30 } from "geometrix";
+var pDef30 = {
   partName: "verify_contour_3",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber26("r1", "mm", 10, 0, 200, 1),
-    pNumber26("r2", "mm", 10, 0, 200, 1),
-    pNumber26("r3", "mm", 10, 0, 200, 1),
-    pNumber26("r4", "mm", 10, 0, 200, 1),
-    pNumber26("r5", "mm", 10, 0, 200, 1),
-    pNumber26("r6", "mm", 5, 0, 200, 1)
+    pNumber30("r1", "mm", 10, 0, 200, 1),
+    pNumber30("r2", "mm", 10, 0, 200, 1),
+    pNumber30("r3", "mm", 10, 0, 200, 1),
+    pNumber30("r4", "mm", 10, 0, 200, 1),
+    pNumber30("r5", "mm", 10, 0, 200, 1),
+    pNumber30("r6", "mm", 5, 0, 200, 1)
   ],
   paramSvg: {
     r1: "verify_contour_1_r1.svg",
@@ -5429,32 +6322,32 @@ var pDef26 = {
     // every 0.5 second
   }
 };
-function pGeom26(t, param, suffix = "") {
-  const rGeome = initGeom26(pDef26.partName + suffix);
+function pGeom30(t, param, suffix = "") {
+  const rGeome = initGeom30(pDef30.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure26();
+    const figOne = figure30();
     const r1 = param.r1 + t;
     const r2 = param.r2 + t;
     const r3 = param.r3 + t;
     const r4 = param.r4 + t;
     const r5 = param.r5 + t;
     const r6 = param.r6 + t;
-    const ctr1 = contour17(100, 0).addSegStrokeR(30, 200).addCornerRounded(r1).addSegStrokeR(200, 30).addCornerRounded(r1).addSegStrokeR(-200, 30).addCornerRounded(r1).addSegStrokeR(-30, 200).addCornerRounded(r1).addSegStrokeR(-30, -200).addCornerRounded(r1).addSegStrokeR(-200, -30).addCornerRounded(r1).addSegStrokeR(200, -30).addCornerRounded(r1).closeSegStroke().addCornerRounded(r1);
+    const ctr1 = 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);
     rGeome.logstr += ctr1.check();
     figOne.addMain(ctr1);
     const l2 = 100;
-    const ctr2 = contour17(300, 0);
+    const ctr2 = contour22(300, 0);
     for (let i = 0; i < 4; i++) {
       const angle = 90 * (1 - i);
-      ctr2.addSegStrokeRP(degToRad9(angle), l2).addCornerRounded(r2).addSegStrokeRP(degToRad9(angle - 45), l2).addCornerRounded(r2).addSegStrokeRP(degToRad9(angle + 45), l2).addCornerRounded(r2).addSegStrokeRP(degToRad9(angle), l2).addCornerRounded(r2);
+      ctr2.addSegStrokeRP(degToRad11(angle), l2).addCornerRounded(r2).addSegStrokeRP(degToRad11(angle - 45), l2).addCornerRounded(r2).addSegStrokeRP(degToRad11(angle + 45), l2).addCornerRounded(r2).addSegStrokeRP(degToRad11(angle), l2).addCornerRounded(r2);
     }
     rGeome.logstr += ctr2.check();
     figOne.addMain(ctr2);
     const l3 = 100;
     const ra3 = 70;
-    const ctr3 = contour17(0, 600).addSegStrokeR(l3, l3);
+    const ctr3 = contour22(0, 600).addSegStrokeR(l3, l3);
     for (let i = 0; i < 3; i++) {
       const large = (i & 1) === 0 ? false : true;
       const ccw = (i & 2) === 0 ? false : true;
@@ -5470,70 +6363,70 @@ function pGeom26(t, param, suffix = "") {
     ctr3.addSegStrokeR(l3, 0).addSegStrokeR(l3, -l3).closeSegStroke();
     rGeome.logstr += ctr3.check();
     figOne.addMain(ctr3);
-    const ctr3b = contour17(0, 900).addCornerRounded(r3).addPointR(l3, l3).addSegArc(l3, false, true).addSegStrokeR(0, 2 * l3).addCornerRounded(r3).addPointR(l3, -l3).addSegArc(l3, false, true).addSegStrokeR(l3, 0).addCornerRounded(r3).addPointR(l3, l3).addSegArc(l3, false, false).addCornerRounded(r3).addSegStrokeR(0, 2 * l3).addCornerRounded(r3).addPointR(-l3, l3).addSegArc(l3, false, false).addPointR(l3, l3).addSegArc(l3, false, false).addCornerRounded(r3).addSegStrokeR(0, 3 * l3).addCornerRounded(r3).addPointR(-l3, -l3).addSegArc(l3, false, false).addPointR(-l3, l3).addSegArc(l3, false, false).addCornerRounded(r3).addSegStrokeR(0, -3 * l3).addCornerRounded(r3).addPointR(-l3, l3).addSegArc(l3, false, true).addSegStrokeR(-l3, 0).closeSegStroke();
+    const ctr3b = 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();
     rGeome.logstr += ctr3b.check();
     figOne.addMain(ctr3b);
     const l4 = 200;
     const ra4 = 180;
-    const ctr4 = contour17(0, 2e3).addPointR(l4, 0).addSegArc(ra4, false, true).addCornerRounded(r4).addPointR(0, l4).addSegArc(ra4, false, true).addCornerRounded(r4).addPointR(-l4, -l4).addSegArc(1.4 * ra4, false, true).addCornerRounded(r4);
+    const ctr4 = 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);
     rGeome.logstr += ctr4.check();
     figOne.addMain(ctr4);
-    const ctr4b = contour17(400, 2e3).addPointR(0, 1.7 * l4).addSegArc(2.3 * ra4, false, false).addCornerRounded(r4).addPointR(l4, -0.7 * l4).addSegArc(ra4, false, false).addCornerRounded(r4).addPointR(-l4, -l4).addSegArc(1.4 * ra4, false, false).addCornerRounded(r4);
+    const ctr4b = 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);
     rGeome.logstr += ctr4b.check();
     figOne.addMain(ctr4b);
-    const ctr4c = contour17(1e3, 2e3).addPointR(l4, 0).addSegArc(0.6 * ra4, true, true).addCornerRounded(r4).addPointR(0, l4).addSegArc(ra4, true, true).addCornerRounded(r4).addPointR(-l4, -l4).addSegArc(1.4 * ra4, true, true).addCornerRounded(r4);
+    const ctr4c = 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);
     rGeome.logstr += ctr4c.check();
     figOne.addMain(ctr4c);
-    const ctr4d = contour17(3e3, 2e3).addPointR(0, 1.7 * l4).addSegArc(2.3 * ra4, true, false).addCornerRounded(r4).addPointR(l4, -0.7 * l4).addSegArc(ra4, true, false).addCornerRounded(r4).addPointR(-l4, -l4).addSegArc(1.1 * ra4, true, false).addCornerRounded(r4);
+    const ctr4d = 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);
     rGeome.logstr += ctr4d.check();
     figOne.addMain(ctr4d);
     const l4b = 3 * l4;
     const ra4b = 3 * ra4;
-    const ctr4e = contour17(3800, 2e3).addPointR(l4b, 0).addSegArc(ra4b, false, false).addCornerRounded(r4).addPointR(0, l4b).addSegArc(ra4b, false, false).addCornerRounded(r4).addPointR(-l4b, 0).addSegArc(ra4b, false, false).addCornerRounded(r4).addPointR(0, -l4b).addSegArc(ra4b, false, false).addCornerRounded(r4);
+    const ctr4e = 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);
     rGeome.logstr += ctr4e.check();
     figOne.addMain(ctr4e);
-    const ctr4f = contour17(4500, 2e3).addPointR(l4, l4).addSegArc(l4, false, false).addPointR(l4, -l4).addSegArc(l4, false, false).addCornerRounded(r4).addPointR(-l4, 1.6 * l4).addSegArc(1.1 * ra4, false, true).addCornerRounded(r4).addPointR(-l4, -1.6 * l4).addSegArc(1.2 * ra4, false, true).addCornerRounded(r4);
+    const ctr4f = 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);
     rGeome.logstr += ctr4f.check();
     figOne.addMain(ctr4f);
-    const ctr4g = contour17(5200, 2e3).addPointR(l4, 0).addSegArc(0.9 * l4, false, false).addCornerRounded(r4).addPointR(l4, 0).addSegArc(0.9 * l4, false, false).addCornerRounded(r4).addPointR(-2 * l4, 0).addSegArc(1.3 * l4, true, true).addCornerRounded(r4);
+    const ctr4g = 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);
     rGeome.logstr += ctr4g.check();
     figOne.addMain(ctr4g);
     const c099 = 0.999;
-    const ctr4h = contour17(6e3, 2e3).addPointR(2 * l4, 2 * l4).addSegArc(1.5 * l4, false, false).addCornerRounded(r4).addPointR(2 * l4, -2 * l4).addSegArc(1.5 * l4, false, false).addCornerRounded(r4).addPointR(-l4, l4).addSegArc(l4, false, true).addPointR(-l4, -c099 * l4).addSegArc(l4, false, true).addCornerRounded(r4).addPointR(-l4, c099 * l4).addSegArc(l4, false, true).addPointR(-l4, -l4).addSegArc(l4, false, true).addCornerRounded(r4);
+    const ctr4h = 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);
     rGeome.logstr += ctr4h.check();
     figOne.addMain(ctr4h);
     const l5 = 200;
     const ra5 = 180;
-    const ctr5 = contour17(0, 3e3).addSegStrokeR(l5, 0).addCornerWidened(r5).addSegStrokeR(0, l5).addCornerWidened(r5).closeSegStroke().addCornerWidened(r5);
+    const ctr5 = contour22(0, 3e3).addSegStrokeR(l5, 0).addCornerWidened(r5).addSegStrokeR(0, l5).addCornerWidened(r5).closeSegStroke().addCornerWidened(r5);
     rGeome.logstr += ctr5.check();
     figOne.addMain(ctr5);
-    const ctr5b = contour17(400, 3e3).addSegStrokeR(l5, 0).addCornerWidened(r5).addPointR(0, l5).addSegArc(ra5, false, true).addCornerWidened(r5).addPointR(-l5, 0).addSegArc(ra5, false, false).addCornerWidened(r5).closeSegStroke().addCornerWidened(r5);
+    const ctr5b = 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);
     rGeome.logstr += ctr5b.check();
     figOne.addMain(ctr5b);
-    const ctr5d = contour17(3e3, 3e3).addPointR(0, 1.7 * l5).addSegArc(2.3 * ra5, true, false).addCornerWidened(r5).addPointR(l5, -0.7 * l5).addSegArc(ra5, true, false).addCornerWidened(r5).addPointR(-l5, -l5).addSegArc(1.1 * ra5, true, false).addCornerWidened(r5);
+    const ctr5d = 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);
     rGeome.logstr += ctr5d.check();
     figOne.addMain(ctr5d);
-    const ctr5e = contour17(3800, 3e3).addPointR(l5, 0).addSegArc(ra5, false, false).addCornerWidened(r5).addPointR(0, l5).addSegArc(ra5, false, false).addCornerWidened(r5).addPointR(-l5, 0).addSegArc(ra5, false, false).addCornerWidened(r5).addPointR(0, -l5).addSegArc(ra5, false, false).addCornerWidened(r5);
+    const ctr5e = 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);
     rGeome.logstr += ctr5e.check();
     figOne.addMain(ctr5e);
-    const ctr5f = contour17(4500, 3e3).addPointR(l5, l5).addSegArc(l5, false, false).addPointR(l5, -l5).addSegArc(l5, false, false).addCornerWidened(r5).addPointR(-l5, 1.6 * l5).addSegArc(1.1 * ra5, false, true).addCornerWidened(r5).addPointR(-l5, -1.6 * l5).addSegArc(1.2 * ra5, false, true).addCornerWidened(r5);
+    const ctr5f = 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);
     rGeome.logstr += ctr5f.check();
     figOne.addMain(ctr5f);
     const l6 = 200;
     const ra6 = 180;
-    const ctr6 = contour17(0, 4e3).addSegStrokeR(l6, 0).addCornerWideAcc(r6).addSegStrokeR(0, l6).addCornerWideAcc(r6).closeSegStroke().addCornerWideAcc(r6);
+    const ctr6 = contour22(0, 4e3).addSegStrokeR(l6, 0).addCornerWideAcc(r6).addSegStrokeR(0, l6).addCornerWideAcc(r6).closeSegStroke().addCornerWideAcc(r6);
     rGeome.logstr += ctr6.check();
     figOne.addMain(ctr6);
-    const ctr6b = contour17(400, 4e3).addSegStrokeR(l6, 0).addCornerWideAcc(r6).addPointR(0, l6).addSegArc(ra6, false, true).addCornerWideAcc(r6).addPointR(-l6, 0).addSegArc(ra6, false, false).addCornerWideAcc(r6).closeSegStroke().addCornerWideAcc(r6);
+    const ctr6b = 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);
     rGeome.logstr += ctr6b.check();
     figOne.addMain(ctr6b);
-    const ctr6d = contour17(3e3, 4e3).addPointR(0, 1.7 * l6).addSegArc(2.3 * ra6, true, false).addCornerWideAcc(r6).addPointR(l6, -0.7 * l6).addSegArc(ra6, true, false).addCornerWideAcc(r6).addPointR(-l6, -l6).addSegArc(1.1 * ra6, true, false).addCornerWideAcc(r6);
+    const ctr6d = 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);
     rGeome.logstr += ctr6d.check();
     figOne.addMain(ctr6d);
-    const ctr6e = contour17(3800, 4e3).addPointR(l6, 0).addSegArc(ra6, false, false).addCornerWideAcc(r6).addPointR(0, l6).addSegArc(ra6, false, false).addCornerWideAcc(r6).addPointR(-l6, 0).addSegArc(ra6, false, false).addCornerWideAcc(r6).addPointR(0, -l6).addSegArc(ra6, false, false).addCornerWideAcc(r6);
+    const ctr6e = 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);
     rGeome.logstr += ctr6e.check();
     figOne.addMain(ctr6e);
-    const ctr6f = contour17(4500, 4e3).addPointR(l6, l6).addSegArc(l6, false, false).addPointR(l6, -l6).addSegArc(l6, false, false).addCornerWideAcc(r6).addPointR(-l6, 1.6 * l6).addSegArc(1.1 * ra6, false, true).addCornerWideAcc(r6).addPointR(-l6, -1.6 * l6).addSegArc(1.2 * ra6, false, true).addCornerWideAcc(r6);
+    const ctr6f = 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);
     rGeome.logstr += ctr6f.check();
     figOne.addMain(ctr6f);
     rGeome.fig = { one: figOne };
@@ -5548,19 +6441,19 @@ function pGeom26(t, param, suffix = "") {
 var verifyContour3Def = {
   pTitle: "Verify contour 3",
   pDescription: "Debugging contour.ts for rounded corners and widened corners",
-  pDef: pDef26,
-  pGeom: pGeom26
+  pDef: pDef30,
+  pGeom: pGeom30
 };
 
 // src/geometrix_verification/verify_contour_4.ts
-import { contour as contour18, figure as figure27, pNumber as pNumber27, initGeom as initGeom27 } from "geometrix";
-var pDef27 = {
+import { contour as contour23, figure as figure31, pNumber as pNumber31, initGeom as initGeom31 } from "geometrix";
+var pDef31 = {
   partName: "verify_contour_4",
   params: [
     //pNumber(name, unit, init, min, max, step)
-    pNumber27("n1", "scalar", 16, 1, 50, 1),
-    pNumber27("n2", "scalar", 6, 3, 50, 1),
-    pNumber27("r1", "mm", 5, 0, 20, 1)
+    pNumber31("n1", "scalar", 16, 1, 50, 1),
+    pNumber31("n2", "scalar", 6, 3, 50, 1),
+    pNumber31("r1", "mm", 5, 0, 20, 1)
   ],
   paramSvg: {
     n1: "verify_contour_1_r1.svg",
@@ -5574,19 +6467,19 @@ var pDef27 = {
     // every 0.5 second
   }
 };
-function pGeom27(t, param, suffix = "") {
-  const rGeome = initGeom27(pDef27.partName + suffix);
+function pGeom31(t, param, suffix = "") {
+  const rGeome = initGeom31(pDef31.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure27();
+    const figOne = figure31();
     const n1 = param.n1;
     const n2 = param.n2;
     const r1 = param.r1;
     const l1 = 50 + t;
     const as = 2 * Math.PI / (n2 * 3);
-    const ctr2b = contour18(l1, 0).addSegStrokeAP(as, 1.5 * l1).addCornerRounded(r1).addPointAP(2 * as, l1).addSegArc(0.45 * l1, false, true).addCornerWidened(r1).addSegStrokeAP(3 * as, 1.2 * l1);
-    const ctr1 = contour18(l1, 0);
+    const ctr2b = 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 ctr1b = ctr2b.clone().addCornerRounded(r1);
     for (let i = 0; i < n1; i++) {
       const ctr1c = ctr1b.rotate(0, 0, i * 3 * as).scale(0, 0, 1 + i * 0.2, true);
@@ -5595,7 +6488,7 @@ function pGeom27(t, param, suffix = "") {
     ctr1.closeSegStroke();
     rGeome.logstr += ctr1.check();
     figOne.addMain(ctr1);
-    const ctr5 = contour18(l1, 0);
+    const ctr5 = contour23(l1, 0);
     for (let i = 0; i < n1; i++) {
       ctr5.addPartial(ctr1b.rotate(0, 0, i * 3 * as).scale(0, 0, 1 + i * 0.2, false));
     }
@@ -5626,29 +6519,29 @@ function pGeom27(t, param, suffix = "") {
 var verifyContour4Def = {
   pTitle: "Verify contour 4",
   pDescription: "Debugging contour.ts for addPartial",
-  pDef: pDef27,
-  pGeom: pGeom27
+  pDef: pDef31,
+  pGeom: pGeom31
 };
 
 // src/geometrix_verification/verify_exports_1.ts
 import {
-  contour as contour19,
-  contourCircle as contourCircle14,
-  figure as figure28,
-  pNumber as pNumber28,
+  contour as contour24,
+  contourCircle as contourCircle18,
+  figure as figure32,
+  pNumber as pNumber32,
   pCheckbox as pCheckbox4,
-  initGeom as initGeom28,
-  EExtrude as EExtrude12,
-  EBVolume as EBVolume15
+  initGeom as initGeom32,
+  EExtrude as EExtrude16,
+  EBVolume as EBVolume19
 } from "geometrix";
-var pDef28 = {
+var pDef32 = {
   partName: "verify_exports_1",
   params: [
     //pNumber(name, unit, init, min, max, step)
     pCheckbox4("circle", true),
-    pNumber28("circle-size", "mm", 100, 1, 1e3, 1),
+    pNumber32("circle-size", "mm", 100, 1, 1e3, 1),
     pCheckbox4("contour", true),
-    pNumber28("contour-size", "mm", 30, 1, 1e3, 1),
+    pNumber32("contour-size", "mm", 30, 1, 1e3, 1),
     pCheckbox4("contour-arc-large", false)
   ],
   paramSvg: {
@@ -5664,20 +6557,20 @@ var pDef28 = {
     tUpdate: 500
   }
 };
-function pGeom28(t, param, suffix = "") {
-  const rGeome = initGeom28(pDef28.partName + suffix);
+function pGeom32(t, param, suffix = "") {
+  const rGeome = initGeom32(pDef32.partName + suffix);
   rGeome.logstr += `${rGeome.partName} simTime: ${t}
 `;
   try {
-    const figOne = figure28();
+    const figOne = figure32();
     if (param.circle === 1) {
-      const theCircle = contourCircle14(0, 0, param["circle-size"]);
+      const theCircle = contourCircle18(0, 0, param["circle-size"]);
       figOne.addMain(theCircle);
     }
     if (param.contour === 1) {
       const csize = param["contour-size"];
       const carcl = param["contour-arc-large"] === 1 ? true : false;
-      const ctr1 = contour19(0, 0).addSegStrokeA(csize, 0).addPointA(csize, csize).addSegArc(csize * 0.8, carcl, true).closeSegStroke();
+      const ctr1 = contour24(0, 0).addSegStrokeA(csize, 0).addPointA(csize, csize).addSegArc(csize * 0.8, carcl, true).closeSegStroke();
       figOne.addMain(ctr1);
     }
     rGeome.fig = { one: figOne };
@@ -5687,7 +6580,7 @@ function pGeom28(t, param, suffix = "") {
         {
           outName: `subpax_${designName}_one`,
           face: `${designName}_one`,
-          extrudeMethod: EExtrude12.eLinearOrtho,
+          extrudeMethod: EExtrude16.eLinearOrtho,
           length: 10,
           rotate: [0, 0, 0],
           translate: [0, 0, 0]
@@ -5696,7 +6589,7 @@ function pGeom28(t, param, suffix = "") {
       volumes: [
         {
           outName: `pax_${designName}`,
-          boolMethod: EBVolume15.eIdentity,
+          boolMethod: EBVolume19.eIdentity,
           inList: [`subpax_${designName}_one`]
         }
       ]
@@ -5712,8 +6605,8 @@ function pGeom28(t, param, suffix = "") {
 var verifyExports1Def = {
   pTitle: "Verify exports 1",
   pDescription: "For dev & debug of Openscad export",
-  pDef: pDef28,
-  pGeom: pGeom28
+  pDef: pDef32,
+  pGeom: pGeom32
 };
 export {
   baseDef,
@@ -5722,17 +6615,21 @@ export {
   gearWheelWheelDef,
   heliostatDef,
   heliostat_2Def,
-  poleRotorDef,
   poleStaticDef,
   rakeDef,
   rakeStopperDef,
   rectangleDef,
+  ringDef,
+  ringGuidanceDef,
   rodDef,
   simplifiedGearWheelDef,
   spiderDef,
   surfaceDef,
   swingDef,
   trapezeDef,
+  vaxisDef,
+  vaxisGuidanceDef,
+  vaxisHolderDef,
   verifyContour1Def,
   verifyContour2Def,
   verifyContour3Def,