designix 0.5.3

package/src/heliostat/spider.ts

@@ -0,0 +1,238 @@
+// spider.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: 'spider',
+	params: [
+		//pNumber(name, unit, init, min, max, step)
+		pNumber('D1', 'mm', 100, 10, 400, 1),
+		pNumber('L1', 'mm', 400, 100, 1000, 10),
+		pNumber('L2', 'mm', 400, 100, 1000, 10),
+		pNumber('L3', 'mm', 100, 10, 400, 1),
+		pNumber('L4', 'mm', 3000, 500, 8000, 10),
+		pNumber('L5', 'mm', 2000, 100, 8000, 10),
+		pNumber('L6', 'mm', 30, 1, 100, 1),
+		pNumber('E1', 'mm', 3, 1, 80, 1),
+		pNumber('E2', 'mm', 50, 1, 200, 1),
+		pNumber('E3', 'mm', 3, 1, 80, 1),
+		pNumber('R2', 'mm', 100, 0, 400, 10),
+		pNumber('N1', '', 6, 1, 20, 1)
+	],
+	paramSvg: {
+		D1: 'spider_profile.svg',
+		L1: 'spider_profile.svg',
+		L2: 'spider_profile.svg',
+		L3: 'spider_profile.svg',
+		L4: 'spider_profile.svg',
+		L5: 'spider_lateral.svg',
+		L6: 'spider_lateral.svg',
+		E1: 'spider_profile.svg',
+		E2: 'spider_profile.svg',
+		E3: 'spider_profile.svg',
+		R2: 'spider_profile.svg',
+		N1: 'spider_lateral.svg'
+	},
+	sim: {
+		tMax: 360,
+		tStep: 0.5,
+		tUpdate: 500 // every 0.5 second
+	}
+};
+
+type tCtr1 = (sx: number, sy: number, sl: number) => tContour;
+type tCtr2 = (width: number, height: number, xpos: number, ypos: number) => tContour;
+
+function pGeom(t: number, param: tParamVal): tGeom {
+	let ctrSquare: tCtr1;
+	let ctrRect: tCtr2;
+	const rGeome = initGeom(pDef.partName);
+	const figLegs = figure();
+	const figTube = figure();
+	const figBody = figure();
+	rGeome.logstr += `${rGeome.partName} simTime: ${t}\n`;
+	try {
+		const R1 = param.D1 / 2;
+		if (param.D1 < param.E2) {
+			throw `err476: D1 ${param.D1} smaller then E2 ${param.E2}`;
+		}
+		const legE2 = param.E2 / 2;
+		const legStartY = Math.sqrt(R1 ** 2 - legE2 ** 2);
+		const legL2 = param.L1 + param.L2 * Math.sqrt(2);
+		const legL3 = param.L2 + param.L1 * Math.sqrt(2);
+		const legL4 = param.L4 - legL3;
+		if (legL4 < param.R2) {
+			throw `err984: L4 ${param.L4} too small compare to R2 ${param.R2}`;
+		}
+		const legL4x = legL4 * Math.cos(Math.PI / 4);
+		const legL4y = legL4 * Math.sin(Math.PI / 4);
+		const E2x = param.E2 * Math.cos(Math.PI / 4);
+		const E2y = param.E2 * Math.sin(Math.PI / 4);
+		const elbowx = param.E2 * Math.tan(Math.PI / 8);
+		if (R1 < param.E1) {
+			throw `err092: D1 ${param.D1} too small compare to E1 ${param.E1}`;
+		}
+		if (param.L3 < param.E2) {
+			throw `err994: L3 ${param.L3} smaller than E2 ${param.E2}`;
+		}
+		if (param.L3 < 2 * param.E3) {
+			throw `err997: L3 ${param.L3} too small compare to E3 ${param.E3}`;
+		}
+		const squareD = ((param.L3 - param.E2) / 2) * Math.cos(Math.PI / 4);
+		const squareX = legL2 + legL4x + squareD;
+		const squareY = -param.L1 - legL4y + squareD;
+		const squareY2 = squareY - param.E3 * Math.sqrt(2);
+		if (param.L5 < param.N1 * param.L6) {
+			throw `err110: L5 ${param.L5} too small compare to N1 ${param.N1} and L6 ${param.L6}`;
+		}
+		let legStep = 1;
+		if (param.N1 > 1) {
+			legStep = (param.L5 - param.L6) / (param.N1 - 1);
+		}
+		const legPos = [...Array(param.N1).keys()].map((i) => i * legStep);
+		ctrSquare = function (sx: number, sy: number, sl: number): tContour {
+			const rCtr = contour(sx, sy)
+				.addSegStrokeA(sx + sl * Math.cos(Math.PI / 4), sy - sl * Math.sin(Math.PI / 4))
+				.addSegStrokeA(sx, sy - 2 * sl * Math.sin(Math.PI / 4))
+				.addSegStrokeA(sx - sl * Math.cos(Math.PI / 4), sy - sl * Math.sin(Math.PI / 4))
+				.closeSegStroke();
+			return rCtr;
+		};
+		ctrRect = function (width: number, height: number, xpos: number, ypos: number): tContour {
+			const rCtr = contour(xpos, ypos)
+				.addSegStrokeA(xpos + width, ypos)
+				.addSegStrokeA(xpos + width, ypos + height)
+				.addSegStrokeA(xpos, ypos + height)
+				.closeSegStroke();
+			return rCtr;
+		};
+		const posAngle = (Math.sin((2 * Math.PI * t) / pDef.sim.tMax) * Math.PI) / 2;
+		rGeome.logstr += `spide leg number: ${param.N1}\n`;
+		rGeome.logstr += `spide position angle: ${ffix(radToDeg(posAngle))} degree\n`;
+		// figLegs
+		const ctrLeg = contour(legE2, -legStartY)
+			.addCornerRounded(param.R2)
+			.addSegStrokeA(legE2, -param.L1)
+			.addCornerRounded(param.R2)
+			.addSegStrokeA(legL2, -param.L1)
+			.addCornerRounded(param.R2 + param.E2)
+			.addSegStrokeA(legL2 + legL4x, -param.L1 - legL4y)
+			.addSegStrokeA(legL2 + legL4x - E2x, -param.L1 - legL4y - E2y)
+			.addSegStrokeA(legL2 - elbowx, -param.L1 - param.E2)
+			.addCornerRounded(param.R2)
+			.addSegStrokeA(-legL2 + elbowx, -param.L1 - param.E2)
+			.addCornerRounded(param.R2)
+			.addSegStrokeA(-legL2 - legL4x + E2x, -param.L1 - legL4y - E2y)
+			.addSegStrokeA(-legL2 - legL4x, -param.L1 - legL4y)
+			.addSegStrokeA(-legL2, -param.L1)
+			.addCornerRounded(param.R2 + param.E2)
+			.addSegStrokeA(-legE2, -param.L1)
+			.addCornerRounded(param.R2)
+			.addSegStrokeA(-legE2, -legStartY)
+			.addCornerRounded(param.R2)
+			.closeSegArc(R1, true, false);
+		figLegs.addMain(ctrLeg);
+		figLegs.addMain(contourCircle(0, 0, R1 - param.E1));
+		figLegs.addSecond(ctrSquare(squareX, squareY, param.L3));
+		figLegs.addSecond(ctrSquare(squareX, squareY2, param.L3 - 2 * param.E3));
+		figLegs.addSecond(ctrSquare(-squareX, squareY, param.L3));
+		figLegs.addSecond(ctrSquare(-squareX, squareY2, param.L3 - 2 * param.E3));
+		// figTube
+		figTube.addMain(contourCircle(0, 0, R1));
+		figTube.addMain(contourCircle(0, 0, R1 - param.E1));
+		figTube.addMain(ctrSquare(squareX, squareY, param.L3));
+		figTube.addMain(ctrSquare(squareX, squareY2, param.L3 - 2 * param.E3));
+		figTube.addMain(ctrSquare(-squareX, squareY, param.L3));
+		figTube.addMain(ctrSquare(-squareX, squareY2, param.L3 - 2 * param.E3));
+		figTube.addSecond(ctrLeg);
+		// figBody
+		figBody.addSecond(ctrRect(param.L5, param.D1, 0, -param.D1 / 2));
+		figBody.addSecond(ctrRect(param.L5, param.L3, 0, -param.L4 - param.L3));
+		for (const posx of legPos) {
+			figBody.addSecond(ctrRect(param.L6, param.L4, posx, -param.L4));
+		}
+		// final figure list
+		rGeome.fig = {
+			faceLegs: figLegs.rotate(0, 0, posAngle),
+			faceTube: figTube.rotate(0, 0, posAngle),
+			faceBody: figBody
+		};
+		const designName = rGeome.partName;
+		const preExtrude = legPos.map((posX, idx) => {
+			const rElem: tExtrude = {
+				outName: `subpax_${designName}_leg_${idx}`,
+				face: `${designName}_faceLegs`,
+				extrudeMethod: EExtrude.eLinearOrtho,
+				length: param.L6,
+				rotate: [0, 0, 0],
+				translate: [0, 0, posX]
+			};
+			return rElem;
+		});
+		const legList = legPos.map((elem, idx) => {
+			const subElem = `subpax_${designName}_leg_${idx}`;
+			return subElem;
+		});
+		rGeome.vol = {
+			extrudes: [
+				{
+					outName: `subpax_${designName}_tube`,
+					face: `${designName}_faceTube`,
+					extrudeMethod: EExtrude.eLinearOrtho,
+					length: param.L5,
+					rotate: [0, 0, 0],
+					translate: [0, 0, 0]
+				},
+				...preExtrude
+			],
+			volumes: [
+				{
+					outName: `pax_${designName}`,
+					boolMethod: EBVolume.eUnion,
+					inList: [`subpax_${designName}_tube`, ...legList]
+				}
+			]
+		};
+		// sub-design
+		rGeome.sub = {};
+		// finalize
+		rGeome.logstr += 'heliostat-spider draw successfully!\n';
+		rGeome.calcErr = false;
+	} catch (emsg) {
+		rGeome.logstr += emsg as string;
+		console.log(emsg as string);
+	}
+	return rGeome;
+}
+
+const spiderDef: tPageDef = {
+	pTitle: 'Heliostat spider',
+	pDescription: 'The spider part for the control of the inclination of the heliostat',
+	pDef: pDef,
+	pGeom: pGeom
+};
+
+export { spiderDef };

package/src/heliostat/surface.ts

@@ -0,0 +1,320 @@
+// surface.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: 'surface',
+	params: [
+		//pNumber(name, unit, init, min, max, step)
+		pNumber('LH', 'mm', 1600, 100, 4000, 1),
+		pNumber('LV', 'mm', 1000, 100, 4000, 1),
+		pNumber('LZ', 'mm', 40, 0, 100, 1),
+		pNumber('nx', '', 9, 1, 40, 1),
+		pNumber('ny', '', 9, 1, 40, 1),
+		pDropdown('main_direction', ['horizontal', 'vertical']),
+		pCheckbox('crenel', false),
+		pNumber('first_row', '', 9, 1, 40, 1),
+		pNumber('second_row', '', 9, 1, 40, 1),
+		pNumber('EH', 'mm', 10, 0, 1000, 1),
+		pCheckbox('EH_gradient', false),
+		pNumber('EH_sup', 'mm', 500, 0, 1000, 1),
+		pNumber('EH_cycle', '', 1, 0, 3, 0.05),
+		pNumber('EH_start', '', 0, 0, 1, 0.05),
+		pDropdown('EH_shape', ['sinusoid', 'triangle', 'sawUp', 'sawDown']),
+		pNumber('EV', 'mm', 10, 0, 1000, 1),
+		pCheckbox('EV_gradient', false),
+		pNumber('EV_sup', 'mm', 500, 0, 1000, 1),
+		pNumber('EV_cycle', '', 1, 0, 3, 0.05),
+		pNumber('EV_start', '', 0, 0, 1, 0.05),
+		pDropdown('EV_shape', ['sinusoid', 'triangle', 'sawUp', 'sawDown']),
+		pNumber('power_efficiency', '%', 16, 0, 100, 0.1),
+		pNumber('solar_power', 'W/m2', 816, 100, 2000, 1) // 1361*0.6=816 W/m2
+	],
+	paramSvg: {
+		LH: 'surface_main.svg',
+		LV: 'surface_main.svg',
+		LZ: 'surface_lz.svg',
+		nx: 'surface_main.svg',
+		ny: 'surface_main.svg',
+		main_direction: 'surface_crenel.svg',
+		crenel: 'surface_crenel.svg',
+		first_row: 'surface_extremities.svg',
+		second_row: 'surface_extremities.svg',
+		EH: 'surface_main.svg',
+		EH_gradient: 'surface_space_evolution.svg',
+		EH_sup: 'surface_space_evolution.svg',
+		EH_cycle: 'surface_space_evolution.svg',
+		EH_start: 'surface_space_evolution.svg',
+		EH_shape: 'surface_space_shape.svg',
+		EV: 'surface_main.svg',
+		EV_gradient: 'surface_space_evolution.svg',
+		EV_sup: 'surface_space_evolution.svg',
+		EV_cycle: 'surface_space_evolution.svg',
+		EV_start: 'surface_space_evolution.svg',
+		EV_shape: 'surface_space_shape.svg',
+		power_efficiency: 'surface_power.svg',
+		solar_power: 'surface_power.svg'
+	},
+	sim: {
+		tMax: 180,
+		tStep: 0.5,
+		tUpdate: 500 // every 0.5 second
+	}
+};
+
+// (px, py) coordinates of bottom-left of the panel in mm
+type tCtr1 = (px: number, py: number) => tContour;
+type tPositions = [number, number][];
+
+function pGeom(t: number, param: tParamVal): tGeom {
+	let ctrPanelProfile: tCtr1;
+	const rGeome = initGeom(pDef.partName);
+	const figSurface = figure();
+	const figOnePanel = figure();
+	rGeome.logstr += `${rGeome.partName} simTime: ${t}\n`;
+	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: ${ffix(panel_surface)} m2\n`;
+		rGeome.logstr += `panel power: ${ffix(panel_power)} W\n`;
+		const max_panel_nb = param.nx * param.ny;
+		rGeome.logstr += `max panel number: ${max_panel_nb}\n`;
+		rGeome.logstr += `max panel surface: ${ffix(max_panel_nb * panel_surface)} m2\n`;
+		rGeome.logstr += `max panel power: ${ffix(max_panel_nb * panel_power)} W\n`;
+		const lenMain = param.main_direction === 1 ? param.ny : param.nx;
+		const lenLateral = param.main_direction === 1 ? param.nx : param.ny;
+		const EMain = param.main_direction === 1 ? param.EV : param.EH;
+		const EMainGradient = param.main_direction === 1 ? param.EV_gradient : param.EH_gradient;
+		const EMainSup = param.main_direction === 1 ? param.EV_sup : param.EH_sup;
+		const EMainCycle = param.main_direction === 1 ? param.EV_cycle : param.EH_cycle;
+		const EMainStart = param.main_direction === 1 ? param.EV_start : param.EH_start;
+		const EMainShape = param.main_direction === 1 ? param.EV_shape : param.EH_shape;
+		const ELateral = param.main_direction === 0 ? param.EV : param.EH;
+		const ELateralGradient = param.main_direction === 0 ? param.EV_gradient : param.EH_gradient;
+		const ELateralSup = param.main_direction === 0 ? param.EV_sup : param.EH_sup;
+		const ELateralCycle = param.main_direction === 0 ? param.EV_cycle : param.EH_cycle;
+		const ELateralStart = param.main_direction === 0 ? param.EV_start : param.EH_start;
+		const ELateralShape = param.main_direction === 0 ? param.EV_shape : param.EH_shape;
+		const lenRow: number[] = [];
+		for (let i = 0; i < lenMain; i++) {
+			const iEven = (i + 1) % 2; // 0 or 1
+			const elemNb = param.crenel ? lenLateral - iEven : lenLateral;
+			lenRow.push(elemNb);
+		}
+		lenRow[0] = param.first_row;
+		lenRow[lenRow.length - 1] = param.first_row;
+		if (lenMain > 2) {
+			lenRow[1] = param.second_row;
+			lenRow[lenRow.length - 2] = param.second_row;
+		}
+		let panelNb = 0;
+		lenRow.forEach((oneRow) => {
+			panelNb += oneRow;
+		});
+		rGeome.logstr += `actual panel number: ${panelNb} (${ffix(
+			(100 * panelNb) / max_panel_nb
+		)} %)\n`;
+		rGeome.logstr += `actual panel surface: ${ffix(panelNb * panel_surface)} m2\n`;
+		rGeome.logstr += `actual panel power: ${ffix(panelNb * panel_power)} W\n`;
+		const eMain: number[] = [];
+		for (let i = 0; i < lenMain - 1; i++) {
+			let eSpace = EMain;
+			if (EMainGradient === 1) {
+				const gapNb = lenMain > 2 ? lenMain - 2 : 1; // -2 to get a complete cycle
+				const phase = (EMainStart + (i * EMainCycle) / gapNb) % 1;
+				switch (EMainShape) {
+					case 0: // sinusoid
+						eSpace += (EMainSup * (1 - Math.cos(phase * 2 * Math.PI))) / 2;
+						break;
+					case 1: // triangle
+						eSpace += EMainSup * (1 - 2 * Math.abs(phase - 0.5));
+						break;
+					case 2: // sawUp
+						eSpace += EMainSup * phase;
+						break;
+					case 3: // sawDown
+						eSpace += EMainSup * (1 - phase);
+						break;
+					default:
+						eSpace += EMainSup;
+				}
+			}
+			eMain.push(eSpace);
+		}
+		let eMainTotal = 0;
+		const eMainCumul: number[] = [];
+		eMainCumul.push(0);
+		eMain.forEach((eSpace) => {
+			eMainTotal += eSpace;
+			eMainCumul.push(eMainTotal);
+		});
+		const eLateral: number[] = [];
+		for (let i = 0; i < lenLateral - 1; i++) {
+			let eSpace = ELateral;
+			if (ELateralGradient === 1) {
+				const gapNb = lenLateral > 2 ? lenLateral - 2 : 1; // -2 to get a complete cycle
+				const phase = (ELateralStart + (i * ELateralCycle) / gapNb) % 1;
+				switch (ELateralShape) {
+					case 0: // sinusoid
+						eSpace += (ELateralSup * (1 - Math.cos(phase * 2 * Math.PI))) / 2;
+						break;
+					case 1: // triangle
+						eSpace += ELateralSup * (1 - 2 * Math.abs(phase - 0.5));
+						break;
+					case 2: // sawUp
+						eSpace += ELateralSup * phase;
+						break;
+					case 3: // sawDown
+						eSpace += ELateralSup * (1 - phase);
+						break;
+					default:
+						eSpace += ELateralSup;
+				}
+			}
+			eLateral.push(eSpace);
+		}
+		let eLateralTotal = 0;
+		const eLateralCumul: number[] = [];
+		eLateralCumul.push(0);
+		eLateral.forEach((eSpace) => {
+			eLateralTotal += eSpace;
+			eLateralCumul.push(eLateralTotal);
+		});
+		let gLenHorizontal = 0; // mm
+		let gLenVertical = 0; // mm
+		if (param.main_direction === 0) {
+			// horizontal
+			gLenHorizontal = lenMain * param.LH + eMainTotal;
+			gLenVertical = lenLateral * param.LV + eLateralTotal;
+		} else {
+			// vertical
+			gLenHorizontal = lenLateral * param.LH + eLateralTotal;
+			gLenVertical = lenMain * param.LV + eMainTotal;
+		}
+		const gArea = (gLenHorizontal * gLenVertical) / 10 ** 6; // m2
+		rGeome.logstr += `global horizontal width: ${ffix(gLenHorizontal / 1000)} m\n`;
+		rGeome.logstr += `global vertical height: ${ffix(gLenVertical / 1000)} m\n`;
+		rGeome.logstr += `global area: ${ffix(gArea)} m2\n`;
+		rGeome.logstr += `area efficiency: ${ffix((100 * panelNb * panel_surface) / gArea)} %\n`;
+		const ox = -gLenHorizontal / 2;
+		const oy = -gLenVertical / 2;
+		ctrPanelProfile = function (px: number, py: number): tContour {
+			const rPanelProfile = contour(px, py)
+				.addSegStrokeA(px + param.LH, py)
+				.addSegStrokeA(px + param.LH, py + param.LV)
+				.addSegStrokeA(px, py + param.LV)
+				.closeSegStroke();
+			return rPanelProfile;
+		};
+		// figSurface
+		const panelPositions: tPositions = [];
+		lenRow.forEach((oneRow, rowIdx) => {
+			const half = (lenLateral - oneRow) % 2;
+			const offset = Math.floor((lenLateral - oneRow) / 2);
+			for (let pIdx = 0; pIdx < oneRow; pIdx++) {
+				let dx = 0;
+				let dy = 0;
+				if (param.main_direction === 0) {
+					// horizontal
+					dx = ox + rowIdx * param.LH + eMainCumul[rowIdx];
+					dy = oy + (offset + pIdx) * param.LV + eLateralCumul[offset + pIdx];
+					if (half === 1) {
+						dy +=
+							(param.LV +
+								eLateralCumul[offset + pIdx + 1] -
+								eLateralCumul[offset + pIdx]) /
+							2;
+					}
+				} else {
+					// vertical
+					dy = oy + rowIdx * param.LV + eMainCumul[rowIdx];
+					dx = ox + (offset + pIdx) * param.LH + eLateralCumul[offset + pIdx];
+					if (half === 1) {
+						dx +=
+							(param.LH +
+								eLateralCumul[offset + pIdx + 1] -
+								eLateralCumul[offset + pIdx]) /
+							2;
+					}
+				}
+				panelPositions.push([dx, dy]);
+			}
+		});
+		for (const pos of panelPositions) {
+			figSurface.addMain(ctrPanelProfile(pos[0], pos[1]));
+		}
+		// figOnePanel
+		figOnePanel.addMain(ctrPanelProfile(0, 0));
+		// final figure list
+		rGeome.fig = {
+			faceSurface: figSurface,
+			faceOnePanel: figOnePanel
+		};
+		const designName = rGeome.partName;
+		rGeome.vol = {
+			extrudes: panelPositions.map((elem, idx) => {
+				const rElem: tExtrude = {
+					outName: `subpax_${designName}_panel_${idx}`,
+					face: `${designName}_faceOnePanel`,
+					extrudeMethod: EExtrude.eLinearOrtho,
+					length: param.LZ,
+					rotate: [0, 0, 0],
+					translate: [elem[0], elem[1], 0]
+				};
+				return rElem;
+			}),
+			volumes: [
+				{
+					outName: `pax_${designName}`,
+					//boolMethod: EBVolume.eIdentity,
+					boolMethod: EBVolume.eUnion,
+					inList: panelPositions.map((elem, idx) => {
+						const subElem = `subpax_${designName}_panel_${idx}`;
+						return subElem;
+					})
+				}
+			]
+		};
+		// sub-design
+		rGeome.sub = {};
+		// finalize
+		rGeome.logstr += 'panel-surface draw successfully!\n';
+		rGeome.calcErr = false;
+	} catch (emsg) {
+		rGeome.logstr += emsg as string;
+		console.log(emsg as string);
+	}
+	return rGeome;
+}
+
+const surfaceDef: tPageDef = {
+	pTitle: 'Heliostat panel-surface',
+	pDescription: 'The surface collecting the solar power',
+	pDef: pDef,
+	pGeom: pGeom
+};
+
+export { surfaceDef };