designix 0.5.11 → 0.5.12

package/src/heliostat/spider.ts

@@ -1,238 +0,0 @@
-// 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

@@ -1,320 +0,0 @@
-// 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 };