designix 0.5.10 → 0.5.12

package/src/gears/gear_wheel_wheel.ts

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

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

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