@atmaticai/agent-tools 1.0.3 → 1.1.0

package/dist/structural/index.js

@@ -0,0 +1,608 @@
+'use strict';
+
+// src/structural/stress.ts
+function normalStress(force, area) {
+  if (area <= 0) throw new Error("Area must be positive");
+  const stress = force / area;
+  return { force, area, stress, unit: "Pa" };
+}
+function shearStress(force, area) {
+  if (area <= 0) throw new Error("Area must be positive");
+  const stress = force / area;
+  return { force, area, stress, unit: "Pa" };
+}
+function strain(deltaLength, originalLength) {
+  if (originalLength <= 0) throw new Error("Original length must be positive");
+  const s = deltaLength / originalLength;
+  return { deltaLength, originalLength, strain: s, unit: "dimensionless" };
+}
+function youngsModulus(stress, strainVal) {
+  if (strainVal === 0) throw new Error("Strain must be non-zero");
+  const E = stress / strainVal;
+  return { stress, strain: strainVal, youngsModulus: E, unit: "Pa" };
+}
+function factorOfSafety(ultimateStress, workingStress) {
+  if (workingStress === 0) throw new Error("Working stress must be non-zero");
+  if (ultimateStress < 0) throw new Error("Ultimate stress must be non-negative");
+  if (workingStress < 0) throw new Error("Working stress must be positive");
+  const fos = ultimateStress / workingStress;
+  return { ultimateStress, workingStress, factorOfSafety: fos };
+}
+function hoopStress(pressure, radius, thickness) {
+  if (pressure < 0) throw new Error("Pressure must be non-negative");
+  if (radius <= 0) throw new Error("Radius must be positive");
+  if (thickness <= 0) throw new Error("Thickness must be positive");
+  const hoop = pressure * radius / thickness;
+  const longitudinal = pressure * radius / (2 * thickness);
+  return { pressure, radius, thickness, hoopStress: hoop, longitudinalStress: longitudinal, unit: "Pa" };
+}
+
+// src/structural/beams.ts
+function simplySupported(length, load, loadType, E, I, loadPosition) {
+  if (length <= 0) throw new Error("Length must be positive");
+  if (load < 0) throw new Error("Load must be non-negative");
+  let reactionLeft;
+  let reactionRight;
+  let maxMoment;
+  let maxShear;
+  let maxDeflection = null;
+  const L = length;
+  const P = load;
+  switch (loadType) {
+    case "point-center": {
+      reactionLeft = P / 2;
+      reactionRight = P / 2;
+      maxMoment = P * L / 4;
+      maxShear = P / 2;
+      if (E && I) {
+        maxDeflection = P * L * L * L / (48 * E * I);
+      }
+      break;
+    }
+    case "point-custom": {
+      const a = loadPosition ?? L / 2;
+      if (a < 0 || a > L) throw new Error("Load position must be between 0 and length");
+      const b = L - a;
+      reactionLeft = P * b / L;
+      reactionRight = P * a / L;
+      maxMoment = P * a * b / L;
+      maxShear = Math.max(reactionLeft, reactionRight);
+      if (E && I) {
+        maxDeflection = P * a * b * (a + 2 * b) * Math.sqrt(3 * a * (a + 2 * b)) / (27 * E * I * L);
+      }
+      break;
+    }
+    case "uniform": {
+      const w = P / L;
+      reactionLeft = P / 2;
+      reactionRight = P / 2;
+      maxMoment = w * L * L / 8;
+      maxShear = P / 2;
+      if (E && I) {
+        maxDeflection = 5 * w * L * L * L * L / (384 * E * I);
+      }
+      break;
+    }
+    case "triangular": {
+      const wMax = 2 * P / L;
+      reactionLeft = P / 3;
+      reactionRight = 2 * P / 3;
+      const xMax = L / Math.sqrt(3);
+      maxMoment = wMax * xMax * xMax * xMax / (6 * L) + reactionLeft * xMax - wMax * xMax * xMax / (6 * L);
+      maxMoment = wMax * L * L / (9 * Math.sqrt(3));
+      maxShear = 2 * P / 3;
+      if (E && I) {
+        maxDeflection = P * L * L * L / (60 * E * I);
+      }
+      break;
+    }
+    default:
+      throw new Error(`Unknown load type: ${loadType}. Use: point-center, point-custom, uniform, triangular`);
+  }
+  return {
+    length,
+    load,
+    loadType,
+    reactionLeft,
+    reactionRight,
+    maxMoment,
+    maxShear,
+    maxDeflection,
+    momentUnit: "N\xB7m",
+    shearUnit: "N",
+    deflectionUnit: maxDeflection !== null ? "m" : null
+  };
+}
+function cantilever(length, load, loadType, E, I, loadPosition) {
+  if (length <= 0) throw new Error("Length must be positive");
+  if (load < 0) throw new Error("Load must be non-negative");
+  let reactionForce;
+  let reactionMoment;
+  let maxMoment;
+  let maxShear;
+  let maxDeflection = null;
+  const L = length;
+  const P = load;
+  switch (loadType) {
+    case "point-end": {
+      reactionForce = P;
+      reactionMoment = P * L;
+      maxMoment = P * L;
+      maxShear = P;
+      if (E && I) {
+        maxDeflection = P * L * L * L / (3 * E * I);
+      }
+      break;
+    }
+    case "point-custom": {
+      const a = loadPosition ?? L;
+      if (a < 0 || a > L) throw new Error("Load position must be between 0 and length");
+      reactionForce = P;
+      reactionMoment = P * a;
+      maxMoment = P * a;
+      maxShear = P;
+      if (E && I) {
+        maxDeflection = P * a * a * (3 * L - a) / (6 * E * I);
+      }
+      break;
+    }
+    case "uniform": {
+      const w = P / L;
+      reactionForce = P;
+      reactionMoment = w * L * L / 2;
+      maxMoment = w * L * L / 2;
+      maxShear = P;
+      if (E && I) {
+        maxDeflection = w * L * L * L * L / (8 * E * I);
+      }
+      break;
+    }
+    default:
+      throw new Error(`Unknown load type: ${loadType}. Use: point-end, point-custom, uniform`);
+  }
+  return {
+    length,
+    load,
+    loadType,
+    reactionForce,
+    reactionMoment,
+    maxMoment,
+    maxShear,
+    maxDeflection,
+    momentUnit: "N\xB7m",
+    shearUnit: "N",
+    deflectionUnit: maxDeflection !== null ? "m" : null
+  };
+}
+
+// src/structural/columns.ts
+var K_FACTORS = {
+  "pinned-pinned": 1,
+  "fixed-free": 2,
+  "fixed-pinned": 0.7,
+  "fixed-fixed": 0.5
+};
+function eulerBuckling(E, I, length, endCondition) {
+  if (E <= 0) throw new Error("Elastic modulus must be positive");
+  if (I <= 0) throw new Error("Moment of inertia must be positive");
+  if (length <= 0) throw new Error("Length must be positive");
+  const K = K_FACTORS[endCondition];
+  if (K === void 0) {
+    throw new Error(`Unknown end condition: ${endCondition}. Use: pinned-pinned, fixed-free, fixed-pinned, fixed-fixed`);
+  }
+  const Le = K * length;
+  const Pcr = Math.PI * Math.PI * E * I / (Le * Le);
+  return {
+    elasticModulus: E,
+    momentOfInertia: I,
+    length,
+    endCondition,
+    effectiveLengthFactor: K,
+    effectiveLength: Le,
+    criticalLoad: Pcr,
+    unit: "N"
+  };
+}
+function slendernessRatio(effectiveLength, radiusOfGyration) {
+  if (effectiveLength <= 0) throw new Error("Effective length must be positive");
+  if (radiusOfGyration <= 0) throw new Error("Radius of gyration must be positive");
+  const ratio = effectiveLength / radiusOfGyration;
+  let classification;
+  if (ratio < 30) {
+    classification = "short";
+  } else if (ratio <= 120) {
+    classification = "intermediate";
+  } else {
+    classification = "long";
+  }
+  return {
+    effectiveLength,
+    radiusOfGyration,
+    slendernessRatio: ratio,
+    classification
+  };
+}
+
+// src/structural/sections.ts
+function rectangleSection(width, height) {
+  if (width <= 0) throw new Error("Width must be positive");
+  if (height <= 0) throw new Error("Height must be positive");
+  const area = width * height;
+  const Ixx = width * height * height * height / 12;
+  const Iyy = height * width * width * width / 12;
+  const Sx = width * height * height / 6;
+  const Sy = height * width * width / 6;
+  const rx = height / Math.sqrt(12);
+  const ry = width / Math.sqrt(12);
+  return { width, height, area, Ixx, Iyy, Sx, Sy, rx, ry };
+}
+function circularSection(diameter) {
+  if (diameter <= 0) throw new Error("Diameter must be positive");
+  const r2 = diameter / 2;
+  const area = Math.PI * r2 * r2;
+  const I = Math.PI * diameter * diameter * diameter * diameter / 64;
+  const S = Math.PI * diameter * diameter * diameter / 32;
+  const r = diameter / 4;
+  return { diameter, area, I, S, r };
+}
+function hollowCircularSection(outerDiameter, innerDiameter) {
+  if (outerDiameter <= 0) throw new Error("Outer diameter must be positive");
+  if (innerDiameter < 0) throw new Error("Inner diameter must be non-negative");
+  if (innerDiameter >= outerDiameter) throw new Error("Inner diameter must be less than outer diameter");
+  const D = outerDiameter;
+  const d = innerDiameter;
+  const area = Math.PI / 4 * (D * D - d * d);
+  const I = Math.PI / 64 * (D * D * D * D - d * d * d * d);
+  const S = Math.PI / (32 * D) * (D * D * D * D - d * d * d * d);
+  const r = Math.sqrt(I / area);
+  return { outerDiameter, innerDiameter, area, I, S, r };
+}
+function iBeamSection(flangeWidth, flangeThickness, webHeight, webThickness) {
+  if (flangeWidth <= 0) throw new Error("Flange width must be positive");
+  if (flangeThickness <= 0) throw new Error("Flange thickness must be positive");
+  if (webHeight <= 0) throw new Error("Web height must be positive");
+  if (webThickness <= 0) throw new Error("Web thickness must be positive");
+  const totalHeight = webHeight + 2 * flangeThickness;
+  const flangeArea = flangeWidth * flangeThickness;
+  const webArea = webHeight * webThickness;
+  const area = 2 * flangeArea + webArea;
+  const IxxWeb = webThickness * webHeight * webHeight * webHeight / 12;
+  const IxxFlangeSelf = flangeWidth * flangeThickness * flangeThickness * flangeThickness / 12;
+  const flangeCenterDist = (webHeight + flangeThickness) / 2;
+  const IxxFlangeParallel = flangeArea * flangeCenterDist * flangeCenterDist;
+  const Ixx = IxxWeb + 2 * (IxxFlangeSelf + IxxFlangeParallel);
+  const IyyFlanges = 2 * (flangeThickness * flangeWidth * flangeWidth * flangeWidth) / 12;
+  const IyyWeb = webHeight * webThickness * webThickness * webThickness / 12;
+  const Iyy = IyyFlanges + IyyWeb;
+  const Sx = 2 * Ixx / totalHeight;
+  const Sy = 2 * Iyy / flangeWidth;
+  const rx = Math.sqrt(Ixx / area);
+  const ry = Math.sqrt(Iyy / area);
+  return {
+    flangeWidth,
+    flangeThickness,
+    webHeight,
+    webThickness,
+    totalHeight,
+    area,
+    Ixx,
+    Iyy,
+    Sx,
+    Sy,
+    rx,
+    ry
+  };
+}
+
+// src/structural/soils.ts
+function bearingCapacityFactors(frictionAngleDeg) {
+  const phi = frictionAngleDeg * Math.PI / 180;
+  const tan45half = Math.tan(Math.PI / 4 + phi / 2);
+  const Nq = tan45half * tan45half * Math.exp(Math.PI * Math.tan(phi));
+  let Nc;
+  if (frictionAngleDeg === 0) {
+    Nc = 5.14;
+  } else {
+    Nc = (Nq - 1) / Math.tan(phi);
+  }
+  const Ngamma = 2 * (Nq + 1) * Math.tan(phi);
+  return { Nc, Nq, Ngamma };
+}
+function terzaghiBearing(cohesion, depth, unitWeight, frictionAngle, foundationType) {
+  if (cohesion < 0) throw new Error("Cohesion must be non-negative");
+  if (depth < 0) throw new Error("Depth must be non-negative");
+  if (unitWeight <= 0) throw new Error("Unit weight must be positive");
+  if (frictionAngle < 0 || frictionAngle > 50) throw new Error("Friction angle must be between 0 and 50 degrees");
+  const { Nc, Nq, Ngamma } = bearingCapacityFactors(frictionAngle);
+  let sc;
+  let sgamma;
+  switch (foundationType) {
+    case "strip":
+      sc = 1;
+      sgamma = 1;
+      break;
+    case "square":
+      sc = 1.3;
+      sgamma = 0.8;
+      break;
+    case "circular":
+      sc = 1.3;
+      sgamma = 0.6;
+      break;
+    default:
+      throw new Error(`Unknown foundation type: ${foundationType}. Use: strip, square, circular`);
+  }
+  const bearingCapacity = cohesion * Nc * sc + unitWeight * depth * Nq + 0.5 * unitWeight * 1 * Ngamma * sgamma;
+  return {
+    cohesion,
+    depth,
+    unitWeight,
+    frictionAngle,
+    foundationType,
+    bearingCapacity,
+    Nc,
+    Nq,
+    Ngamma,
+    unit: "Pa"
+  };
+}
+function lateralEarthPressure(unitWeight, height, frictionAngle, pressureType) {
+  if (unitWeight <= 0) throw new Error("Unit weight must be positive");
+  if (height <= 0) throw new Error("Height must be positive");
+  if (frictionAngle < 0 || frictionAngle > 50) throw new Error("Friction angle must be between 0 and 50 degrees");
+  const phi = frictionAngle * Math.PI / 180;
+  let coefficient;
+  switch (pressureType) {
+    case "active":
+      coefficient = Math.pow(Math.tan(Math.PI / 4 - phi / 2), 2);
+      break;
+    case "passive":
+      coefficient = Math.pow(Math.tan(Math.PI / 4 + phi / 2), 2);
+      break;
+    case "at-rest":
+      coefficient = 1 - Math.sin(phi);
+      break;
+    default:
+      throw new Error(`Unknown pressure type: ${pressureType}. Use: active, passive, at-rest`);
+  }
+  const pressureAtBase = coefficient * unitWeight * height;
+  const totalForce = 0.5 * pressureAtBase * height;
+  return {
+    unitWeight,
+    height,
+    frictionAngle,
+    pressureType,
+    coefficient,
+    pressureAtBase,
+    totalForce,
+    pressureUnit: "Pa",
+    forceUnit: "N/m"
+  };
+}
+function settlement(load, area, elasticModulus, thickness) {
+  if (load < 0) throw new Error("Load must be non-negative");
+  if (area <= 0) throw new Error("Area must be positive");
+  if (elasticModulus <= 0) throw new Error("Elastic modulus must be positive");
+  if (thickness <= 0) throw new Error("Thickness must be positive");
+  const stress = load / area;
+  const settl = stress * thickness / elasticModulus;
+  return {
+    load,
+    area,
+    elasticModulus,
+    thickness,
+    stress,
+    settlement: settl,
+    unit: "m"
+  };
+}
+
+// src/structural/materials.ts
+var MATERIALS = [
+  {
+    name: "ASTM A36 Steel",
+    category: "steel",
+    E: 2e11,
+    fy: 25e7,
+    fu: 4e8,
+    density: 7850,
+    poissonsRatio: 0.26,
+    thermalExpansion: 12e-6,
+    Eunit: "Pa",
+    fyUnit: "Pa",
+    fuUnit: "Pa",
+    densityUnit: "kg/m\xB3",
+    thermalExpansionUnit: "1/\xB0C"
+  },
+  {
+    name: "ASTM A992 Steel",
+    category: "steel",
+    E: 2e11,
+    fy: 345e6,
+    fu: 45e7,
+    density: 7850,
+    poissonsRatio: 0.26,
+    thermalExpansion: 12e-6,
+    Eunit: "Pa",
+    fyUnit: "Pa",
+    fuUnit: "Pa",
+    densityUnit: "kg/m\xB3",
+    thermalExpansionUnit: "1/\xB0C"
+  },
+  {
+    name: "Stainless Steel 304",
+    category: "steel",
+    E: 193e9,
+    fy: 215e6,
+    fu: 515e6,
+    density: 7930,
+    poissonsRatio: 0.29,
+    thermalExpansion: 173e-7,
+    Eunit: "Pa",
+    fyUnit: "Pa",
+    fuUnit: "Pa",
+    densityUnit: "kg/m\xB3",
+    thermalExpansionUnit: "1/\xB0C"
+  },
+  {
+    name: "Aluminum 6061-T6",
+    category: "aluminum",
+    E: 689e8,
+    fy: 276e6,
+    fu: 31e7,
+    density: 2700,
+    poissonsRatio: 0.33,
+    thermalExpansion: 236e-7,
+    Eunit: "Pa",
+    fyUnit: "Pa",
+    fuUnit: "Pa",
+    densityUnit: "kg/m\xB3",
+    thermalExpansionUnit: "1/\xB0C"
+  },
+  {
+    name: "Aluminum 2024-T3",
+    category: "aluminum",
+    E: 731e8,
+    fy: 345e6,
+    fu: 483e6,
+    density: 2780,
+    poissonsRatio: 0.33,
+    thermalExpansion: 232e-7,
+    Eunit: "Pa",
+    fyUnit: "Pa",
+    fuUnit: "Pa",
+    densityUnit: "kg/m\xB3",
+    thermalExpansionUnit: "1/\xB0C"
+  },
+  {
+    name: "Concrete C20/25",
+    category: "concrete",
+    E: 3e10,
+    fy: 2e7,
+    fu: 25e6,
+    density: 2400,
+    poissonsRatio: 0.2,
+    thermalExpansion: 1e-5,
+    Eunit: "Pa",
+    fyUnit: "Pa",
+    fuUnit: "Pa",
+    densityUnit: "kg/m\xB3",
+    thermalExpansionUnit: "1/\xB0C"
+  },
+  {
+    name: "Concrete C30/37",
+    category: "concrete",
+    E: 33e9,
+    fy: 3e7,
+    fu: 37e6,
+    density: 2400,
+    poissonsRatio: 0.2,
+    thermalExpansion: 1e-5,
+    Eunit: "Pa",
+    fyUnit: "Pa",
+    fuUnit: "Pa",
+    densityUnit: "kg/m\xB3",
+    thermalExpansionUnit: "1/\xB0C"
+  },
+  {
+    name: "Concrete C40/50",
+    category: "concrete",
+    E: 35e9,
+    fy: 4e7,
+    fu: 5e7,
+    density: 2400,
+    poissonsRatio: 0.2,
+    thermalExpansion: 1e-5,
+    Eunit: "Pa",
+    fyUnit: "Pa",
+    fuUnit: "Pa",
+    densityUnit: "kg/m\xB3",
+    thermalExpansionUnit: "1/\xB0C"
+  },
+  {
+    name: "Douglas Fir",
+    category: "timber",
+    E: 124e8,
+    fy: 36e6,
+    fu: 52e6,
+    density: 530,
+    poissonsRatio: 0.29,
+    thermalExpansion: 36e-7,
+    Eunit: "Pa",
+    fyUnit: "Pa",
+    fuUnit: "Pa",
+    densityUnit: "kg/m\xB3",
+    thermalExpansionUnit: "1/\xB0C"
+  },
+  {
+    name: "Southern Pine",
+    category: "timber",
+    E: 137e8,
+    fy: 41e6,
+    fu: 59e6,
+    density: 560,
+    poissonsRatio: 0.33,
+    thermalExpansion: 36e-7,
+    Eunit: "Pa",
+    fyUnit: "Pa",
+    fuUnit: "Pa",
+    densityUnit: "kg/m\xB3",
+    thermalExpansionUnit: "1/\xB0C"
+  },
+  {
+    name: "Copper C11000",
+    category: "other",
+    E: 13e10,
+    fy: 69e6,
+    fu: 22e7,
+    density: 8940,
+    poissonsRatio: 0.33,
+    thermalExpansion: 173e-7,
+    Eunit: "Pa",
+    fyUnit: "Pa",
+    fuUnit: "Pa",
+    densityUnit: "kg/m\xB3",
+    thermalExpansionUnit: "1/\xB0C"
+  }
+];
+function getMaterial(name) {
+  const lower = name.toLowerCase();
+  const found = MATERIALS.find((m) => m.name.toLowerCase().includes(lower));
+  if (!found) {
+    const available = MATERIALS.map((m) => m.name).join(", ");
+    throw new Error(`Material "${name}" not found. Available: ${available}`);
+  }
+  return { ...found };
+}
+function listMaterials(category) {
+  if (!category) return MATERIALS.map((m) => ({ ...m }));
+  const lower = category.toLowerCase();
+  const filtered = MATERIALS.filter((m) => m.category.toLowerCase() === lower);
+  if (filtered.length === 0) {
+    const categories = [...new Set(MATERIALS.map((m) => m.category))].join(", ");
+    throw new Error(`No materials found in category "${category}". Available categories: ${categories}`);
+  }
+  return filtered.map((m) => ({ ...m }));
+}
+
+exports.cantilever = cantilever;
+exports.circularSection = circularSection;
+exports.eulerBuckling = eulerBuckling;
+exports.factorOfSafety = factorOfSafety;
+exports.getMaterial = getMaterial;
+exports.hollowCircularSection = hollowCircularSection;
+exports.hoopStress = hoopStress;
+exports.iBeamSection = iBeamSection;
+exports.lateralEarthPressure = lateralEarthPressure;
+exports.listMaterials = listMaterials;
+exports.normalStress = normalStress;
+exports.rectangleSection = rectangleSection;
+exports.settlement = settlement;
+exports.shearStress = shearStress;
+exports.simplySupported = simplySupported;
+exports.slendernessRatio = slendernessRatio;
+exports.strain = strain;
+exports.terzaghiBearing = terzaghiBearing;
+exports.youngsModulus = youngsModulus;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map