designix 0.5.3

package/src/geometrix_verification/verify_line_2.ts

@@ -0,0 +1,76 @@
+// verify_line_2.ts
+
+import type { tParamDef, tParamVal, tGeom, tPageDef } from 'geometrix';
+import { degToRad, point, line, figure, pNumber, initGeom } from 'geometrix';
+
+const pDef: tParamDef = {
+	partName: 'verify_line_2',
+	params: [
+		//pNumber(name, unit, init, min, max, step)
+		pNumber('l1cx', 'mm', 10, -200, 200, 1),
+		pNumber('l1cy', 'mm', 20, -200, 200, 1),
+		pNumber('l1ca', 'degree', 15, -200, 200, 1),
+		pNumber('l2cx', 'mm', 30, -200, 200, 1),
+		pNumber('l2cy', 'mm', 50, -200, 200, 1),
+		pNumber('l2ca', 'degree', 35, -200, 200, 1),
+		pNumber('p3x', 'mm', -30, -200, 200, 1),
+		pNumber('p3y', 'mm', 30, -200, 200, 1)
+	],
+	paramSvg: {
+		l1cx: 'verify_line_2_l1cx.svg',
+		l1cy: 'verify_line_2_l1cx.svg',
+		l1ca: 'verify_line_2_l1cx.svg',
+		l2cx: 'verify_line_2_l1cx.svg',
+		l2cy: 'verify_line_2_l1cx.svg',
+		l2ca: 'verify_line_2_l1cx.svg',
+		p3x: 'verify_line_2_l1cx.svg',
+		p3y: 'verify_line_2_l1cx.svg'
+	},
+	sim: {
+		tMax: 100,
+		tStep: 0.1,
+		tUpdate: 500 // every 0.5 second
+	}
+};
+
+function pGeom(t: number, param: tParamVal): tGeom {
+	const rGeome = initGeom(pDef.partName);
+	rGeome.logstr += `${rGeome.partName} simTime: ${t}\n`;
+	try {
+		const figOne = figure();
+		const p1 = point(param.l1cx, param.l1cy);
+		const p2 = point(param.l2cx, param.l2cy);
+		const p3 = point(param.p3x, param.p3y);
+		figOne.addPoint(p1);
+		figOne.addPoint(p2);
+		figOne.addPoint(p3);
+		const l1 = line(param.l1cx, param.l1cy, degToRad(param.l1ca + t));
+		const l2 = line(param.l2cx, param.l2cy, degToRad(param.l2ca));
+		figOne.addLine(l1);
+		figOne.addLine(l2);
+		figOne.addPoint(l1.intersection(l2));
+		figOne.addPoint(l1.projectPoint(p3));
+		rGeome.logstr += `dist(l1, p3) = ${l1.distanceToPoint(p3)}\n`;
+		figOne.addPoint(l2.projectPoint(p3));
+		rGeome.logstr += `dist(l2, p3) = ${l2.distanceToPoint(p3)}\n`;
+		const bisector = l1.bisector(l2, p3);
+		const pBisec = point(bisector.cx, bisector.cy).translatePolar(bisector.ca, 30);
+		figOne.addPoint(pBisec);
+		rGeome.fig = { one: figOne };
+		rGeome.logstr += 'verify_line_2 draw successfully!\n';
+		rGeome.calcErr = false;
+	} catch (emsg) {
+		rGeome.logstr += emsg as string;
+		console.log(emsg as string);
+	}
+	return rGeome;
+}
+
+const verifyLine2Def: tPageDef = {
+	pTitle: 'Verify line 2',
+	pDescription: 'Debugging more line.ts',
+	pDef: pDef,
+	pGeom: pGeom
+};
+
+export { verifyLine2Def };

package/src/geometrix_verification/verify_line_3.ts

@@ -0,0 +1,64 @@
+// verify_line_3.ts
+
+import type { tParamDef, tParamVal, tGeom, tPageDef } from 'geometrix';
+import { point, bisector, circleCenter, figure, pNumber, initGeom } from 'geometrix';
+
+const pDef: tParamDef = {
+	partName: 'verify_line_3',
+	params: [
+		//pNumber(name, unit, init, min, max, step)
+		pNumber('p1x', 'mm', 30, -200, 200, 1),
+		pNumber('p1y', 'mm', 50, -200, 200, 1),
+		pNumber('p2x', 'mm', 40, -200, 200, 1),
+		pNumber('p2y', 'mm', -20, -200, 200, 1),
+		pNumber('p3x', 'mm', -30, -200, 200, 1),
+		pNumber('p3y', 'mm', 30, -200, 200, 1)
+	],
+	paramSvg: {
+		p1x: 'verify_line_p1x.svg',
+		p1y: 'verify_line_p1x.svg',
+		p2x: 'verify_line_p1x.svg',
+		p2y: 'verify_line_p1x.svg',
+		p3x: 'verify_line_p1x.svg',
+		p3y: 'verify_line_p1x.svg'
+	},
+	sim: {
+		tMax: 10,
+		tStep: 0.1,
+		tUpdate: 500 // every 0.5 second
+	}
+};
+
+function pGeom(t: number, param: tParamVal): tGeom {
+	const rGeome = initGeom(pDef.partName);
+	rGeome.logstr += `${rGeome.partName} simTime: ${t}\n`;
+	try {
+		const figOne = figure();
+		const p1 = point(param.p1x, param.p1y + t);
+		const p2 = point(param.p2x, param.p2y);
+		const p3 = point(param.p3x, param.p3y);
+		figOne.addPoint(p1);
+		figOne.addPoint(p2);
+		figOne.addPoint(p3);
+		const l1 = bisector(p1, p2);
+		figOne.addLine(l1);
+		const pCenter = circleCenter(p1, p2, p3);
+		figOne.addPoint(pCenter);
+		rGeome.fig = { one: figOne };
+		rGeome.logstr += 'verify_line_3 draw successfully!\n';
+		rGeome.calcErr = false;
+	} catch (emsg) {
+		rGeome.logstr += emsg as string;
+		console.log(emsg as string);
+	}
+	return rGeome;
+}
+
+const verifyLine3Def: tPageDef = {
+	pTitle: 'Verify line 3',
+	pDescription: 'Debugging more more line.ts',
+	pDef: pDef,
+	pGeom: pGeom
+};
+
+export { verifyLine3Def };

package/src/geometrix_verification/verify_point.ts

@@ -0,0 +1,62 @@
+// verify_point.ts
+
+import type { tParamDef, tParamVal, tGeom, tPageDef } from 'geometrix';
+import { degToRad, point, figure, pNumber, initGeom } from 'geometrix';
+
+const pDef: tParamDef = {
+	partName: 'verify_point',
+	params: [
+		//pNumber(name, unit, init, min, max, step)
+		pNumber('p1x', 'mm', 30, -200, 200, 1),
+		pNumber('p1y', 'mm', 50, -200, 200, 1),
+		pNumber('p2a', 'degree', 30, -200, 200, 1),
+		pNumber('p2l', 'mm', 60, 0, 200, 1),
+		pNumber('rotateOrig', 'degree', 45, -200, 200, 1),
+		pNumber('scaleOrig', 'scalar', 1.5, 0.1, 2, 0.1)
+	],
+	paramSvg: {
+		p1x: 'verify_point_p1x.svg',
+		p1y: 'verify_point_p1x.svg',
+		p2a: 'verify_point_p1x.svg',
+		p2l: 'verify_point_p1x.svg',
+		rotateOrig: 'verify_point_p1x.svg',
+		scaleOrig: 'verify_point_p1x.svg'
+	},
+	sim: {
+		tMax: 10,
+		tStep: 0.1,
+		tUpdate: 500 // every 0.5 second
+	}
+};
+
+function pGeom(t: number, param: tParamVal): tGeom {
+	const rGeome = initGeom(pDef.partName);
+	rGeome.logstr += `${rGeome.partName} simTime: ${t}\n`;
+	try {
+		const figOne = figure();
+		const p1 = point(param.p1x, param.p1y + t);
+		const p2 = point(0, 0).setPolar(degToRad(param.p2a), param.p2l);
+		const p3 = p1.rotateOrig(degToRad(param.rotateOrig));
+		const p4 = p1.scaleOrig(param.scaleOrig);
+		figOne.addPoint(p1);
+		figOne.addPoint(p2);
+		figOne.addPoint(p3);
+		figOne.addPoint(p4);
+		rGeome.fig = { one: figOne };
+		rGeome.logstr += 'verify_point draw successfully!\n';
+		rGeome.calcErr = false;
+	} catch (emsg) {
+		rGeome.logstr += emsg as string;
+		console.log(emsg as string);
+	}
+	return rGeome;
+}
+
+const verifyPoint1Def: tPageDef = {
+	pTitle: 'Verify point',
+	pDescription: 'Debugging point.ts',
+	pDef: pDef,
+	pGeom: pGeom
+};
+
+export { verifyPoint1Def };

package/src/geometrix_verification/verify_point_2.ts

@@ -0,0 +1,66 @@
+// verify_point_2.ts
+
+import type { tParamDef, tParamVal, tGeom, tPageDef } from 'geometrix';
+import { point, figure, pNumber, initGeom } from 'geometrix';
+
+const pDef: tParamDef = {
+	partName: 'verify_point_2',
+	params: [
+		//pNumber(name, unit, init, min, max, step)
+		pNumber('p1x', 'mm', 30, -200, 200, 1),
+		pNumber('p1y', 'mm', 50, -200, 200, 1),
+		pNumber('p2x', 'mm', -10, -200, 200, 1),
+		pNumber('p2y', 'mm', 60, -200, 200, 1),
+		pNumber('p3x', 'mm', 70, -200, 200, 1),
+		pNumber('p3y', 'mm', -20, -200, 200, 1),
+		pNumber('dist', 'mm', 50, 0, 200, 1)
+	],
+	paramSvg: {
+		p1x: 'verify_line_p1x.svg',
+		p1y: 'verify_line_p1x.svg',
+		p2x: 'verify_line_p1x.svg',
+		p2y: 'verify_line_p1x.svg',
+		p3x: 'verify_line_p1x.svg',
+		p3y: 'verify_line_p1x.svg',
+		dist: 'default_param_blank.svg'
+	},
+	sim: {
+		tMax: 10,
+		tStep: 0.1,
+		tUpdate: 500 // every 0.5 second
+	}
+};
+
+function pGeom(t: number, param: tParamVal): tGeom {
+	const rGeome = initGeom(pDef.partName);
+	rGeome.logstr += `${rGeome.partName} simTime: ${t}\n`;
+	try {
+		const figOne = figure();
+		const p1 = point(param.p1x, param.p1y + t);
+		const p2 = point(param.p2x, param.p2y);
+		const p3 = point(param.p3x, param.p3y);
+		const mp1p2 = p1.middlePoint(p2);
+		const ep1p2 = p1.equidistantPoint(p2, param.dist, p3);
+		figOne.addPoint(p1);
+		figOne.addPoint(p2);
+		figOne.addPoint(p3);
+		figOne.addPoint(mp1p2);
+		figOne.addPoint(ep1p2);
+		rGeome.fig = { one: figOne };
+		rGeome.logstr += 'verify_point_2 draw successfully!\n';
+		rGeome.calcErr = false;
+	} catch (emsg) {
+		rGeome.logstr += emsg as string;
+		console.log(emsg as string);
+	}
+	return rGeome;
+}
+
+const verifyPoint2Def: tPageDef = {
+	pTitle: 'Verify point 2',
+	pDescription: 'Debugging more point.ts',
+	pDef: pDef,
+	pGeom: pGeom
+};
+
+export { verifyPoint2Def };

package/src/geometrix_verification/verify_vector.ts

@@ -0,0 +1,70 @@
+// verify_vector.ts
+
+import type { tParamDef, tParamVal, tGeom, tPageDef } from 'geometrix';
+import { degToRad, point, vector, figure, pNumber, initGeom } from 'geometrix';
+
+const pDef: tParamDef = {
+	partName: 'verify_vector',
+	params: [
+		//pNumber(name, unit, init, min, max, step)
+		pNumber('p1x', 'mm', 30, -200, 200, 1),
+		pNumber('p1y', 'mm', 50, -200, 200, 1),
+		pNumber('p2x', 'mm', 80, -200, 200, 1),
+		pNumber('p2y', 'mm', -30, -200, 200, 1),
+		pNumber('v1a', 'degree', 30, -200, 200, 1),
+		pNumber('v1l', 'mm', 60, 0, 200, 1),
+		pNumber('v2a', 'degree', 30, -200, 200, 1),
+		pNumber('v2l', 'mm', 60, 0, 200, 1)
+	],
+	paramSvg: {
+		p1x: 'verify_vector_p1x.svg',
+		p1y: 'verify_vector_p1x.svg',
+		p2x: 'verify_vector_p1x.svg',
+		p2y: 'verify_vector_p1x.svg',
+		v1a: 'verify_vector_p1x.svg',
+		v1l: 'verify_vector_p1x.svg',
+		v2a: 'verify_vector_p1x.svg',
+		v2l: 'verify_vector_p1x.svg'
+	},
+	sim: {
+		tMax: 10,
+		tStep: 0.1,
+		tUpdate: 500 // every 0.5 second
+	}
+};
+
+function pGeom(t: number, param: tParamVal): tGeom {
+	const rGeome = initGeom(pDef.partName);
+	rGeome.logstr += `${rGeome.partName} simTime: ${t}\n`;
+	try {
+		const figOne = figure();
+		const p1 = point(param.p1x, param.p1y + t);
+		const p2 = point(param.p2x, param.p2y);
+		const v1 = vector(degToRad(param.v1a), param.v1l, p1);
+		const v2 = vector(degToRad(param.v2a), param.v2l, p1);
+		figOne.addPoint(p1);
+		figOne.addPoint(p2);
+		figOne.addVector(v1);
+		figOne.addVector(v2);
+		const v3 = v1.add(v2);
+		const p3 = v3.translatePoint(p2);
+		figOne.addVector(v3);
+		figOne.addPoint(p3);
+		rGeome.fig = { one: figOne };
+		rGeome.logstr += 'verify_vector draw successfully!\n';
+		rGeome.calcErr = false;
+	} catch (emsg) {
+		rGeome.logstr += emsg as string;
+		console.log(emsg);
+	}
+	return rGeome;
+}
+
+const verifyVector1Def: tPageDef = {
+	pTitle: 'Verify vector',
+	pDescription: 'Debugging vector.ts',
+	pDef: pDef,
+	pGeom: pGeom
+};
+
+export { verifyVector1Def };

package/src/heliostat/base.ts

@@ -0,0 +1,254 @@
+// base.ts
+
+import type {
+	tContour,
+	tParamDef,
+	tParamVal,
+	tGeom,
+	tExtrude,
+	tPageDef
+	//tSubInst
+	//tSubDesign
+} from 'geometrix';
+import {
+	contour,
+	contourCircle,
+	figure,
+	//degToRad,
+	//radToDeg,
+	ffix,
+	pNumber,
+	//pCheckbox,
+	//pDropdown,
+	initGeom,
+	EExtrude,
+	EBVolume
+} from 'geometrix';
+
+const pDef: tParamDef = {
+	partName: 'base',
+	params: [
+		//pNumber(name, unit, init, min, max, step)
+		pNumber('D1', 'mm', 600, 100, 4000, 10),
+		pNumber('D2', 'mm', 700, 100, 4000, 10),
+		pNumber('D3', 'mm', 400, 100, 4000, 10),
+		pNumber('D4', 'mm', 500, 100, 4000, 10),
+		pNumber('E1', 'mm', 30, 1, 80, 1),
+		pNumber('E2', 'mm', 30, 1, 80, 1),
+		pNumber('E3', 'mm', 30, 1, 80, 1),
+		pNumber('H1', 'mm', 800, 10, 4000, 10),
+		pNumber('H2', 'mm', 50, 10, 4000, 10),
+		pNumber('H3', 'mm', 400, 10, 4000, 10),
+		pNumber('N2', '', 12, 1, 100, 1),
+		pNumber('L2', 'mm', 100, 1, 400, 1),
+		pNumber('N1', '', 24, 3, 100, 1),
+		pNumber('D5', 'mm', 40, 1, 100, 1),
+		pNumber('L1', 'mm', 34, 1, 300, 1)
+	],
+	paramSvg: {
+		D1: 'base_cut.svg',
+		D2: 'base_cut.svg',
+		D3: 'base_cut.svg',
+		D4: 'base_cut.svg',
+		E1: 'base_cut.svg',
+		E2: 'base_cut.svg',
+		E3: 'base_cut.svg',
+		H1: 'base_cut.svg',
+		H2: 'base_hollow.svg',
+		H3: 'base_hollow.svg',
+		N2: 'base_hollow.svg',
+		L2: 'base_hollow.svg',
+		N1: 'base_top.svg',
+		D5: 'base_top.svg',
+		L1: 'base_top.svg'
+	},
+	sim: {
+		tMax: 180,
+		tStep: 0.5,
+		tUpdate: 500 // every 0.5 second
+	}
+};
+
+type tCtr1 = (orient: number) => tContour;
+
+function pGeom(t: number, param: tParamVal): tGeom {
+	let ctrBaseCut1: tCtr1;
+	let ctrBaseCut2: tCtr1;
+	let ctrHollow: tCtr1;
+	const rGeome = initGeom(pDef.partName);
+	const figCut = figure();
+	const figTop = figure();
+	const figHollow = figure();
+	rGeome.logstr += `${rGeome.partName} simTime: ${t}\n`;
+	try {
+		const R1 = param.D1 / 2;
+		const R2 = param.D2 / 2;
+		const R3 = param.D3 / 2;
+		const R4 = param.D4 / 2;
+		const R5 = param.D5 / 2;
+		const RL2 = param.L2 / 2;
+		if (R2 < R1) {
+			throw `err089: D2 ${param.D2} too small compare to D1 ${param.D1}`;
+		}
+		if (R4 > R1 - param.E2) {
+			throw `err189: D4 ${param.D4} too large compare to D1 ${param.D1} and E2 ${param.E2}`;
+		}
+		rGeome.logstr += `base-height: ${ffix(param.H1)} mm\n`;
+		rGeome.logstr += `base-external-diameter: ${ffix(param.D2)} mm\n`;
+		// figCut
+		ctrBaseCut1 = function (orient: number): tContour {
+			const rBaseCut1 = contour(orient * R2, 0)
+				.addSegStrokeA(orient * R2, param.E3)
+				.addSegStrokeA(orient * R1, param.E3)
+				.addSegStrokeA(orient * R1, param.H1)
+				.addSegStrokeA(orient * (R1 - param.E2), param.H1)
+				.addSegStrokeA(orient * (R1 - param.E2), param.E3)
+				.addSegStrokeA(orient * R4, param.E3)
+				.addSegStrokeA(orient * R4, 0)
+				.closeSegStroke();
+			return rBaseCut1;
+		};
+		ctrBaseCut2 = function (orient: number): tContour {
+			const rBaseCut2 = contour(orient * R2, 0)
+				.addSegStrokeA(orient * R2, param.E3)
+				.addSegStrokeA(orient * R1, param.E3)
+				.addSegStrokeA(orient * R1, param.H1)
+				.addSegStrokeA(orient * R3, param.H1)
+				.addSegStrokeA(orient * R3, param.H1 - param.E1)
+				.addSegStrokeA(orient * (R1 - param.E2), param.H1 - param.E1)
+				.addSegStrokeA(orient * (R1 - param.E2), param.E3)
+				.addSegStrokeA(orient * R4, param.E3)
+				.addSegStrokeA(orient * R4, 0)
+				.closeSegStroke();
+			return rBaseCut2;
+		};
+		if (param.H1 < param.E3 + param.H2 + param.H3 + param.E1) {
+			throw `err125: H1 ${param.H1} too small compare to E3 ${param.H3}, H2 ${param.H2}, H3 ${param.H3}, E1 ${param.E1}`;
+		}
+		if (param.D5 > param.H3) {
+			throw `err128: D5 ${param.D5} too large compare to H3 ${param.H3}`;
+		}
+		const hollowAngle = 2 * Math.asin(RL2 / (R1 - param.E2));
+		if (param.N2 * hollowAngle > 2 * Math.PI) {
+			throw `err132: N2 ${param.N2} too large compare to L2 ${param.L2}, D1 ${param.D1}, E2 ${param.E2}`;
+		}
+		const hollowH = param.E3 + param.H2 + RL2;
+		ctrHollow = function (orient: number): tContour {
+			const rHollow = contour(orient * RL2, hollowH)
+				.addSegStrokeA(orient * RL2, hollowH + param.H3 - param.L2)
+				.addPointA(-orient * RL2, hollowH + param.H3 - param.L2)
+				.addSegArc(RL2, false, true)
+				.addSegStrokeA(-orient * RL2, hollowH)
+				//.addPointA(orient * RL2, hollowH)
+				.closeSegArc(RL2, false, true);
+			return rHollow;
+		};
+		figCut.addMain(ctrBaseCut1(1));
+		figCut.addSecond(ctrBaseCut2(1));
+		figCut.addSecond(ctrBaseCut2(-1));
+		figCut.addSecond(ctrHollow(1));
+		// figTop
+		if (R3 + param.L1 + R5 > R1 - param.E2) {
+			throw `err127: D3 ${param.D3} too large compare to D1 ${param.D1}, E2 ${param.E2}, L1 ${param.L1}, R5 ${param.D5}`;
+		}
+		if (R5 > param.L1) {
+			throw `err130: D5 ${param.D5} too large compare to L1 ${param.L1}`;
+		}
+		const holeAngle = 2 * Math.asin(R5 / (R2 + param.L1));
+		if (param.N1 * holeAngle > 2 * Math.PI) {
+			throw `err134: N1 ${param.N1} too large compare to D5 ${param.D5}, L1 ${param.L1}, D2 ${param.D2}`;
+		}
+		figTop.addMain(contourCircle(0, 0, R1));
+		figTop.addMain(contourCircle(0, 0, R3));
+		const posR = R3 + param.L1;
+		const posA = (2 * Math.PI) / param.N1;
+		for (let i = 0; i < param.N1; i++) {
+			const posX = posR * Math.cos(i * posA);
+			const posY = posR * Math.sin(i * posA);
+			figTop.addMain(contourCircle(posX, posY, R5));
+		}
+		figTop.addSecond(contourCircle(0, 0, R1 - param.E1));
+		figTop.addSecond(contourCircle(0, 0, R2));
+		figTop.addSecond(contourCircle(0, 0, R4));
+		// figHollow
+		figHollow.addMain(ctrHollow(1));
+		figHollow.addSecond(ctrBaseCut2(1));
+		figHollow.addSecond(ctrBaseCut2(-1));
+		// final figure list
+		rGeome.fig = {
+			faceCut: figCut,
+			faceTop: figTop,
+			faceHollow: figHollow
+		};
+		const designName = rGeome.partName;
+		const hollowStep = (2 * Math.PI) / param.N2;
+		const lHollow = [...Array(param.N2).keys()];
+		const preExtrude = lHollow.map((idx) => {
+			const rHollow: tExtrude = {
+				outName: `subpax_${designName}_hollow_${idx}`,
+				face: `${designName}_faceHollow`,
+				extrudeMethod: EExtrude.eLinearOrtho,
+				length: R2 + param.E2,
+				rotate: [Math.PI / 2, 0, idx * hollowStep],
+				translate: [0, 0, 0]
+			};
+			return rHollow;
+		});
+		const lVolHollow = lHollow.map((idx) => `subpax_${designName}_hollow_${idx}`);
+		rGeome.vol = {
+			extrudes: [
+				{
+					outName: `subpax_${designName}_cut`,
+					face: `${designName}_faceCut`,
+					extrudeMethod: EExtrude.eRotate,
+					rotate: [0, 0, 0],
+					translate: [Math.PI / 2, 0, 0]
+				},
+				{
+					outName: `subpax_${designName}_top`,
+					face: `${designName}_faceTop`,
+					extrudeMethod: EExtrude.eLinearOrtho,
+					length: param.E1,
+					rotate: [0, 0, 0],
+					translate: [0, 0, param.H1 - param.E1]
+				},
+				...preExtrude
+			],
+			volumes: [
+				{
+					outName: `ipax_${designName}_hollows`,
+					boolMethod: EBVolume.eUnion,
+					inList: [...lVolHollow]
+				},
+				{
+					outName: `ipax_${designName}_cylinder`,
+					boolMethod: EBVolume.eSubstraction,
+					inList: [`subpax_${designName}_cut`, `ipax_${designName}_hollows`]
+				},
+				{
+					outName: `pax_${designName}`,
+					boolMethod: EBVolume.eUnion,
+					inList: [`ipax_${designName}_cylinder`, `subpax_${designName}_top`]
+				}
+			]
+		};
+		// sub-design
+		rGeome.sub = {};
+		// finalize
+		rGeome.logstr += 'heliostat-base draw successfully!\n';
+		rGeome.calcErr = false;
+	} catch (emsg) {
+		rGeome.logstr += emsg as string;
+		console.log(emsg as string);
+	}
+	return rGeome;
+}
+
+const baseDef: tPageDef = {
+	pTitle: 'Heliostat base',
+	pDescription: 'The base for the static-pole of the heliostat',
+	pDef: pDef,
+	pGeom: pGeom
+};
+
+export { baseDef };