designix 0.5.3

package/src/gears/gear_wheel_wheel.ts

@@ -0,0 +1,335 @@
+// gear_wheel_wheel.ts
+
+import type { tParamDef, tParamVal, tGeom, tPageDef } from 'geometrix';
+//import { contour, contourCircle, figure, degToRad } from 'geometrix';
+import {
+	contour,
+	figure,
+	degToRad,
+	ffix,
+	pNumber,
+	pCheckbox,
+	pDropdown,
+	initGeom,
+	EExtrude,
+	EBVolume
+} from 'geometrix';
+import * as gwHelper from './gearWheelProfile';
+import * as welem from './wheelElements';
+
+const pDef: tParamDef = {
+	partName: 'gear_wheel_wheel',
+	params: [
+		//pNumber(name, unit, init, min, max, step)
+		pNumber('module', 'mm', 10, 0.1, 100, 0.1),
+		pNumber('N1', 'scalar', 23, 3, 1000, 1),
+		pNumber('N2', 'scalar', 19, 3, 1000, 1),
+		pNumber('angleCenterCenter', 'degree', 0, -180, 180, 1),
+		pNumber('addInterAxis', 'mm', 0, 0, 100, 0.05),
+		pNumber('c1x', 'mm', 0, -200, 200, 1),
+		pNumber('c1y', 'mm', 0, -200, 200, 1),
+		pNumber('ah1', 'scalar', 1, 0.1, 2, 0.05),
+		pNumber('dh1', 'scalar', 1, 0.1, 2, 0.05),
+		pNumber('bh1', 'scalar', 0.25, 0.1, 2, 0.05),
+		pNumber('bRound1', 'mm', 2, 0, 50, 0.1),
+		pNumber('ah2', 'scalar', 1, 0.1, 2, 0.05),
+		pNumber('dh2', 'scalar', 1, 0.1, 2, 0.05),
+		pNumber('bh2', 'scalar', 0.25, 0.1, 2, 0.05),
+		pNumber('bRound2', 'mm', 2, 0, 50, 0.1),
+		pNumber('at1', '%', 50, 10, 90, 0.5),
+		pNumber('at2', '%', 50, 10, 90, 0.5),
+		pCheckbox('involSym', true),
+		pDropdown('involROpt', ['Optimum', 'Base-1', 'Base-2', 'PressureAngle', 'FreeBase-12']),
+		pDropdown('involLOpt', ['Optimum', 'Base-1', 'Base-2', 'PressureAngle', 'FreeBase-12']),
+		pNumber('brr1', 'mm', 50, 10, 2000, 0.05),
+		pNumber('brr2', 'mm', 50, 10, 2000, 0.05),
+		pNumber('blr1', 'mm', 50, 10, 2000, 0.05),
+		pNumber('blr2', 'mm', 50, 10, 2000, 0.05),
+		pNumber('involArcPairs1', 'scalar', 2, 1, 40, 1),
+		pNumber('involArcPairs2', 'scalar', 2, 1, 40, 1),
+		pNumber('skinThickness1', 'mm', 0, -3, 3, 0.01),
+		pNumber('skinThickness2', 'mm', 0, -3, 3, 0.01),
+		pNumber('initAngle1', 'degree', 0, -180, 180, 1),
+		pDropdown('gw2Position', ['right', 'left', 'center']),
+		pCheckbox('centralAxis', true),
+		pNumber('axisRadius', 'mm', 10, 0.1, 200, 0.1),
+		pNumber('ribNb', 'scalar', 5, 0, 32, 1),
+		pNumber('ribWidth', 'mm', 8, 1, 100, 0.1),
+		pNumber('ribHeight', 'mm', 8, 1, 100, 0.1),
+		pNumber('ribRound1', 'mm', 2, 0, 20, 0.1),
+		pNumber('ribRound2', 'mm', 2, 0, 20, 0.1),
+		pCheckbox('hollow', true),
+		pNumber('materialHeightExt', 'mm', 20, 1, 200, 0.5),
+		pNumber('materialHeightInt', 'mm', 15, 1, 200, 0.5),
+		pNumber('spokeNb', 'scalar', 5, 1, 18, 1),
+		pNumber('spokeWidth', 'mm', 15, 1, 200, 0.1),
+		pNumber('spokeRound', 'mm', 10, 0, 20, 0.1),
+		pCheckbox('wheelAxis', true),
+		pNumber('wheelHeight', 'mm', 40, 0.1, 400, 0.1),
+		pNumber('wheelMidExtra', 'mm', 6, 0, 10, 0.1),
+		pNumber('wheelAxisLength', 'mm', 40, 0, 400, 0.1),
+		pNumber('wheelAxisRadius', 'mm', 20, 0, 200, 0.1),
+		pNumber('wheelMidRadius', 'mm', 60, 0, 200, 0.1),
+		pNumber('wheelRadiusExtra', 'mm', 1, 0, 20, 0.1),
+		pNumber('wheelAxisExtRound', 'mm', 4, 0, 20, 0.1),
+		pNumber('wheelAxisIntRound', 'mm', 0, 0, 20, 0.1),
+		pNumber('wheelExtraRound', 'mm', 4, 0, 20, 0.1)
+	],
+	paramSvg: {
+		module: 'default_param_blank.svg',
+		N1: 'default_param_blank.svg',
+		N2: 'default_param_blank.svg',
+		angleCenterCenter: 'default_param_blank.svg',
+		addInterAxis: 'default_param_blank.svg',
+		c1x: 'default_param_blank.svg',
+		c1y: 'default_param_blank.svg',
+		ah1: 'default_param_blank.svg',
+		dh1: 'default_param_blank.svg',
+		bh1: 'default_param_blank.svg',
+		bRound1: 'default_param_blank.svg',
+		ah2: 'default_param_blank.svg',
+		dh2: 'default_param_blank.svg',
+		bh2: 'default_param_blank.svg',
+		bRound2: 'default_param_blank.svg',
+		at1: 'default_param_blank.svg',
+		at2: 'default_param_blank.svg',
+		involSym: 'default_param_blank.svg',
+		involROpt: 'default_param_blank.svg',
+		involLOpt: 'default_param_blank.svg',
+		brr1: 'default_param_blank.svg',
+		brr2: 'default_param_blank.svg',
+		blr1: 'default_param_blank.svg',
+		blr2: 'default_param_blank.svg',
+		involArcPairs1: 'default_param_blank.svg',
+		skinThickness1: 'default_param_blank.svg',
+		involArcPairs2: 'default_param_blank.svg',
+		skinThickness2: 'default_param_blank.svg',
+		initAngle1: 'default_param_blank.svg',
+		gw2Position: 'default_param_blank.svg',
+		centralAxis: 'default_param_blank.svg',
+		axisRadius: 'default_param_blank.svg',
+		ribNb: 'default_param_blank.svg',
+		ribWidth: 'default_param_blank.svg',
+		ribHeight: 'default_param_blank.svg',
+		ribRound1: 'default_param_blank.svg',
+		ribRound2: 'default_param_blank.svg',
+		hollow: 'default_param_blank.svg',
+		materialHeightExt: 'default_param_blank.svg',
+		materialHeightInt: 'default_param_blank.svg',
+		spokeNb: 'default_param_blank.svg',
+		spokeWidth: 'default_param_blank.svg',
+		spokeRound: 'default_param_blank.svg',
+		wheelAxis: 'default_param_blank.svg',
+		wheelHeight: 'default_param_blank.svg',
+		wheelMidExtra: 'default_param_blank.svg',
+		wheelAxisLength: 'default_param_blank.svg',
+		wheelAxisRadius: 'default_param_blank.svg',
+		wheelMidRadius: 'default_param_blank.svg',
+		wheelRadiusExtra: 'default_param_blank.svg',
+		wheelAxisExtRound: 'default_param_blank.svg',
+		wheelAxisIntRound: 'default_param_blank.svg',
+		wheelExtraRound: 'default_param_blank.svg'
+	},
+	sim: {
+		tMax: 100,
+		tStep: 0.5,
+		tUpdate: 500 // every 0.5 second
+	}
+};
+
+function pGeom(t: number, param: tParamVal): tGeom {
+	const rGeome = initGeom(pDef.partName);
+	const figOne = figure();
+	const figTwo = figure();
+	rGeome.logstr += `${rGeome.partName} simTime: ${t}\n`;
+	try {
+		// Figure One
+		// re-arrange parameters
+		const gp1 = gwHelper.gwProfile();
+		const gp2 = gwHelper.gwProfile();
+		gp1.set1ModuleToothNumber(param.module, param.N1);
+		gp2.set1ModuleToothNumber(param.module, param.N2);
+		gp1.set2CenterPosition(param.c1x, param.c1y);
+		const acc = degToRad(param.angleCenterCenter);
+		const [c2x, c2y, d12] = gwHelper.gw2center(gp1, gp2, acc, param.addInterAxis);
+		gp2.set2CenterPosition(c2x, c2y);
+		gp1.set3CircleRadius(param.ah1, param.dh1, param.bh1, param.bRound1);
+		gp2.set3CircleRadius(param.ah2, param.dh2, param.bh2, param.bRound2);
+		// base circles
+		const [brr1, blr1, brr2, blr2] = gwHelper.baseCircles(
+			gp1,
+			gp2,
+			param.brr1,
+			param.blr1,
+			param.brr2,
+			param.blr2,
+			param.involSym,
+			param.involROpt,
+			param.involROpt
+		);
+		gp1.set4BaseCircles(brr1, blr1);
+		gp2.set4BaseCircles(brr2, blr2);
+		gp1.set5AddendumThickness(param.at1);
+		gp2.set5AddendumThickness(param.at2);
+		const initAngle1 = degToRad(param.initAngle1) + (t * 3 * gp1.as) / 100; // sim.tMax=100
+		gp1.set6Angles(initAngle1, acc);
+		const gearAL = gwHelper.actionLine(gp1, gp2, initAngle1, acc, d12, param.gw2Position);
+		gearAL.prepare();
+		for (const laCtr of gearAL.getContours()) {
+			figOne.addDynamics(laCtr);
+		}
+		figOne.addPoints(gearAL.getContactPoint());
+		gp2.set6Angles(gearAL.getInitAngle2(), acc + Math.PI);
+		rGeome.logstr += gearAL.getMsg();
+		gp1.set7InvoluteDetails(param.involArcPairs1, param.skinThickness1);
+		gp2.set7InvoluteDetails(param.involArcPairs2, param.skinThickness2);
+		// construction lines and circles
+		for (const refCircle of gp1.getRefCircles()) {
+			figOne.addDynamics(refCircle);
+		}
+		for (const refCircle of gp2.getRefCircles()) {
+			figOne.addDynamics(refCircle);
+		}
+		figOne.addDynamics(gp1.getToothRef());
+		figOne.addDynamics(gp2.getToothRef());
+		// gearwheel-1
+		const gp1p = gp1.getProfile();
+		rGeome.logstr += gp1.getMsg();
+		rGeome.logstr += gp1p.check();
+		figOne.addMain(gp1p);
+		if (param.centralAxis === 1) {
+			const g1axis = welem.axisTorque(
+				gp1.cx,
+				gp1.cy,
+				param.axisRadius,
+				param.ribNb,
+				param.ribWidth,
+				param.ribHeight,
+				param.ribRound1,
+				param.ribRound2,
+				initAngle1
+			);
+			rGeome.logstr += g1axis.check();
+			figOne.addMain(g1axis);
+		}
+		if (param.hollow === 1) {
+			const materialHeightExtMax = gp1.br;
+			const materialHeightIntMin = param.axisRadius + param.ribHeight;
+			const hollowMaterialExt = materialHeightExtMax - param.materialHeightExt;
+			const hollowMaterialInt = materialHeightIntMin + param.materialHeightInt;
+			if (hollowMaterialInt > hollowMaterialExt) {
+				throw `err902: hollowMaterialInt ${ffix(
+					hollowMaterialInt
+				)} bigger than hollowMaterialExt ${ffix(hollowMaterialExt)}`;
+			}
+			const g1hollow = welem.hollowStraight(
+				gp1.cx,
+				gp1.cy,
+				hollowMaterialExt,
+				hollowMaterialInt,
+				param.spokeNb,
+				param.spokeWidth,
+				param.spokeRound,
+				initAngle1
+			);
+			for (const g1hollowE of g1hollow) {
+				rGeome.logstr += g1hollowE.check();
+				figOne.addMain(g1hollowE);
+			}
+		}
+		const gp2p = gp2.getProfile();
+		rGeome.logstr += gp2p.check();
+		figOne.addSecond(gp2p);
+		// Figure Two
+		const wheelRadius = gp1.ar + param.wheelRadiusExtra;
+		if (param.wheelAxis === 1) {
+			const ctrAxisProfile_right = welem.axisProfile(
+				param.wheelHeight,
+				param.wheelMidExtra,
+				param.wheelAxisLength,
+				param.wheelAxisRadius,
+				param.wheelMidRadius,
+				wheelRadius,
+				param.wheelAxisExtRound,
+				param.wheelAxisIntRound,
+				param.wheelExtraRound,
+				true
+			);
+			const ctrAxisProfile_left = welem.axisProfile(
+				param.wheelHeight,
+				param.wheelMidExtra,
+				param.wheelAxisLength,
+				param.wheelAxisRadius,
+				param.wheelMidRadius,
+				wheelRadius,
+				param.wheelAxisExtRound,
+				param.wheelAxisIntRound,
+				param.wheelExtraRound,
+				false
+			);
+			figTwo.addMain(ctrAxisProfile_right);
+			figTwo.addSecond(ctrAxisProfile_left);
+		} else {
+			const ctrAxisProfile_right = contour(0, -param.wheelHeight / 2)
+				.addSegStrokeR(0, param.wheelHeight)
+				.addSegStrokeR(wheelRadius, 0)
+				.addSegStrokeR(0, -param.wheelHeight)
+				.closeSegStroke();
+			const ctrAxisProfile_left = contour(0, -param.wheelHeight / 2)
+				.addSegStrokeR(0, param.wheelHeight)
+				.addSegStrokeR(-wheelRadius, 0)
+				.addSegStrokeR(0, -param.wheelHeight)
+				.closeSegStroke();
+			figTwo.addMain(ctrAxisProfile_right);
+			figTwo.addSecond(ctrAxisProfile_left);
+		}
+		rGeome.fig = { teethProfile: figOne, axisProfile: figTwo };
+		const designName = rGeome.partName;
+		const axisHLength =
+			param.wheelHeight / 2 + param.wheelMidExtra + param.wheelAxisLength + 10;
+		rGeome.vol = {
+			extrudes: [
+				{
+					outName: `subpax_${designName}_teethProfile`,
+					face: `${designName}_teethProfile`,
+					extrudeMethod: EExtrude.eLinearOrtho,
+					length: 2 * axisHLength,
+					rotate: [0, 0, 0],
+					translate: [0, 0, -axisHLength]
+				},
+				{
+					outName: `subpax_${designName}_axisProfile`,
+					face: `${designName}_axisProfile`,
+					extrudeMethod: EExtrude.eRotate,
+					rotate: [0, 0, 0],
+					translate: [0, 0, 0]
+				}
+			],
+			volumes: [
+				{
+					outName: `pax_${designName}`,
+					boolMethod: EBVolume.eIntersection,
+					inList: [
+						`subpax_${designName}_teethProfile`,
+						`subpax_${designName}_axisProfile`
+					]
+				}
+			]
+		};
+		rGeome.logstr += 'gear_wheel_wheel draw successfully!\n';
+		rGeome.calcErr = false;
+	} catch (emsg) {
+		rGeome.logstr += emsg as string;
+		console.log(emsg as string);
+	}
+	return rGeome;
+}
+
+const gearWheelWheelDef: tPageDef = {
+	pTitle: 'Gearwheel-gearwheel',
+	pDescription: 'Gear-system with two wheels',
+	pDef: pDef,
+	pGeom: pGeom
+};
+
+export { gearWheelWheelDef };

package/src/gears/involute.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import { involute } from './involute';
+
+function degToRad(deg: number): number {
+	return (deg / 180) * Math.PI;
+}
+
+describe('involute module', () => {
+	it('lFromU', () => {
+		expect(involute(0, 0, 50, degToRad(30), true).lFromU(0)).toBeCloseTo(50);
+		expect(involute(0, 0, 50, degToRad(30), true).lFromU(degToRad(10))).toBeCloseTo(50.7558307);
+	});
+	it('ptcta', () => {
+		expect(involute(0, 0, 50, degToRad(20), true).ptcta(degToRad(10))).toBeCloseTo(
+			degToRad(30)
+		);
+		expect(involute(0, 0, 50, degToRad(20), true).ptcta(degToRad(15))).toBeCloseTo(
+			degToRad(35)
+		);
+	});
+});

package/src/gears/involute.ts

@@ -0,0 +1,113 @@
+// involute.ts
+// the formula related to involute of circle
+
+class Involute {
+	base_center_x: number;
+	base_center_y: number;
+	base_radius: number;
+	initial_angle: number;
+	right_nleft: boolean;
+	constructor(cx: number, cy: number, br: number, ia: number, rnl: boolean) {
+		this.base_center_x = cx;
+		this.base_center_y = cy;
+		this.base_radius = br;
+		this.initial_angle = ia;
+		this.right_nleft = rnl;
+	}
+	// local polar coordinates (base circle center sets at x:0,y:0)
+	angleSign(): number {
+		const sign = this.right_nleft ? 1 : -1;
+		return sign;
+	}
+	lFromU(au: number): number {
+		const rl = this.base_radius * Math.sqrt(1 + au ** 2);
+		return rl;
+	}
+	wFromU(au: number): number {
+		if (au < 0) {
+			throw `err729: involute parameter au ${au} is negative`;
+		}
+		if (Math.abs(au) > Math.PI / 2) {
+			throw `err730: involute parameter au ${au} is larger than PI/2`;
+		}
+		const sign = this.angleSign();
+		const rw = sign * (au - Math.atan(au));
+		return rw;
+	}
+	w2FromU(au: number): number {
+		const rw2 = this.initial_angle + this.wFromU(au);
+		return rw2;
+	}
+	// Point C of the involute in cartesian coordinates
+	ptc(au: number): number[] {
+		const lcl = this.lFromU(au);
+		const lcw = this.w2FromU(au);
+		const ptcx = this.base_center_x + Math.cos(lcw) * lcl;
+		const ptcy = this.base_center_y + Math.sin(lcw) * lcl;
+		return [ptcx, ptcy];
+	}
+	// angle of the tangent inclination of the Point C of the involute
+	ptcta(au: number): number {
+		const rta = this.initial_angle + this.angleSign() * au;
+		return rta;
+	}
+	// get u from L
+	uFromL(ll: number): number {
+		const ru = Math.sqrt(ll ** 2 / this.base_radius ** 2 - 1);
+		return ru;
+	}
+	// get u from w
+	uFromWslow(lw: number): number {
+		const tolerance = 10 ** -4;
+		let itu = Math.PI / 3;
+		let itdu = itu / 2;
+		let itw = this.wFromU(itu);
+		let itcnt = 0;
+		while (Math.abs(itw - lw) > tolerance) {
+			if (itw < lw) {
+				itu += itdu;
+			} else {
+				itu -= itdu;
+			}
+			itw = this.wFromU(itu);
+			itdu = itdu / 2;
+			itcnt += 1;
+		}
+		console.log(`dbg072: uFromWslow itcnt ${itcnt}`);
+		return itu;
+	}
+	// line of action
+	// acc: angle of center-center line (rad)
+	// ap: angle of pressue relative to the center-center line (rad)
+	// aj: angle of rotation from the start of the line of action (rad)
+	// sJ: angular speed of rotations (rad/s)
+	// return
+	// x,y of point C
+	// vpx, vpy of speed vector of point C in line of pressure reference
+	laptc(acc: number, ap: number, aj: number, sJ: number): number[] {
+		if (Math.sign(ap) * this.angleSign() < 0) {
+			throw `err904: Invole.laptc angle-of-pressure ${ap} not compatible with right_nleft ${this.right_nleft}`;
+		}
+		const C0a = acc + ap;
+		const C0x = this.base_center_x + Math.cos(C0a) * this.base_radius;
+		const C0y = this.base_center_y + Math.sin(C0a) * this.base_radius;
+		const C2a = C0a - (this.angleSign() * Math.PI) / 2;
+		const lBC = aj * this.base_radius;
+		const C2x = C0x + Math.cos(C2a) * lBC;
+		const C2y = C0y + Math.sin(C2a) * lBC;
+		const lL = this.lFromU(aj);
+		const speed = lL * sJ;
+		const aspeed = aj;
+		const vpx = Math.cos(aspeed) * speed;
+		const vpy = Math.sin(aspeed) * speed;
+		return [C2x, C2y, vpx, vpy];
+	}
+}
+
+function involute(cx: number, cy: number, br: number, ia: number, rnl: boolean): Involute {
+	const rinvolute = new Involute(cx, cy, br, ia, rnl);
+	return rinvolute;
+}
+
+export type { Involute };
+export { involute };