SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Wave 277/509: Tapped holes: Rc and NPT take the tap maker's tabulated drill
jyvikoe98cd0a0e26a
diff --git a/assets/locales/pending/pipe-threads.json b/assets/locales/pending/pipe-threads.jsonindex c95eb7b9b4..1d4862775c 100644--- a/assets/locales/pending/pipe-threads.json+++ b/assets/locales/pending/pipe-threads.json@@ -4,48 +4,48 @@"thread.form_bspt": "Pipe taper R, Rc (ISO 7-1)","thread.form_npt": "Pipe taper NPT (ASME B1.20.1)","thread.form_rp": "Pipe Rp (ISO 7-1)",- "thread.taper_drill_exact": "The standard's minor diameter where the thread ends is {exact} mm; this is the stocked drill under it"+ "thread.taper_drill_exact": "The standard's minor diameter where the thread ends is {exact} mm; the drill is the tap maker's recommendation"},"ar": {"thread.form_bspp": "سن أنابيب G (ISO 228-1)","thread.form_bspt": "سن أنابيب مخروطي R، Rc (ISO 7-1)","thread.form_npt": "سن أنابيب مخروطي NPT (ASME B1.20.1)","thread.form_rp": "سن أنابيب داخلي متوازٍ Rp (ISO 7-1)",- "thread.taper_drill_exact": "القطر الأصغر القياسي عند نهاية السن {exact} مم؛ هذا هو المثقاب المتوفر الأصغر منه مباشرة"+ "thread.taper_drill_exact": "القطر الأصغر القياسي عند نهاية السن {exact} مم؛ المثقاب هو ما يوصي به صانع اللقمة"},"he": {"thread.form_bspp": "תבריג צנרת G (ISO 228-1)","thread.form_bspt": "תבריג צנרת קוני R, Rc (ISO 7-1)","thread.form_npt": "תבריג צנרת קוני NPT (ASME B1.20.1)","thread.form_rp": "תבריג צנרת פנימי מקביל Rp (ISO 7-1)",- "thread.taper_drill_exact": "הקוטר הקטן התקני בסוף התבריג הוא {exact} מ\"מ; זהו המקדח המלאי שמתחתיו"+ "thread.taper_drill_exact": "הקוטר הקטן התקני בסוף התבריג הוא {exact} מ\"מ; המקדח הוא המלצת יצרן המברז"},"ja": {"thread.form_bspp": "管用平行ねじ G(ISO 228-1)","thread.form_bspt": "管用テーパねじ R、Rc(ISO 7-1)","thread.form_npt": "管用テーパねじ NPT(ASME B1.20.1)","thread.form_rp": "管用平行めねじ Rp(ISO 7-1)",- "thread.taper_drill_exact": "ねじ終端での規格の谷径は {exact} mm です。これはそれ以下で最も近い市販ドリルです"+ "thread.taper_drill_exact": "ねじ終端での規格の谷径は {exact} mm です。下穴ドリルはタップメーカーの推奨値です"},"zh": {"thread.form_bspp": "管螺纹 G(ISO 228-1)","thread.form_bspt": "圆锥管螺纹 R、Rc(ISO 7-1)","thread.form_npt": "圆锥管螺纹 NPT(ASME B1.20.1)","thread.form_rp": "圆柱内管螺纹 Rp(ISO 7-1)",- "thread.taper_drill_exact": "螺纹终端处的标准小径为 {exact} mm;这是不大于它的常备钻头"+ "thread.taper_drill_exact": "螺纹终端处的标准小径为 {exact} mm;钻头为丝锥制造商的推荐值"},"de": {"thread.form_bspp": "Rohrgewinde G (ISO 228-1)","thread.form_bspt": "Kegeliges Rohrgewinde R, Rc (ISO 7-1)","thread.form_npt": "Kegeliges Rohrgewinde NPT (ASME B1.20.1)","thread.form_rp": "Zylindrisches Innenrohrgewinde Rp (ISO 7-1)",- "thread.taper_drill_exact": "Der genormte Kerndurchmesser am Gewindeende ist {exact} mm; dies ist der nächstkleinere Lagerbohrer"+ "thread.taper_drill_exact": "Der genormte Kerndurchmesser am Gewindeende ist {exact} mm; der Bohrer ist die Empfehlung des Gewindebohrerherstellers"},"ko": {"thread.form_bspp": "관용 평행나사 G (ISO 228-1)","thread.form_bspt": "관용 테이퍼나사 R, Rc (ISO 7-1)","thread.form_npt": "관용 테이퍼나사 NPT (ASME B1.20.1)","thread.form_rp": "관용 평행 암나사 Rp (ISO 7-1)",- "thread.taper_drill_exact": "나사 끝에서의 규격 골지름은 {exact} mm이며, 이는 그 이하의 가장 가까운 상용 드릴입니다"+ "thread.taper_drill_exact": "나사 끝에서의 규격 골지름은 {exact} mm이며, 드릴은 탭 제조사의 권장값입니다"}}diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rsindex a6de45e77f..994d1840e9 100644--- a/crates/doc/src/lib.rs+++ b/crates/doc/src/lib.rs@@ -53,7 +53,7 @@ mod points;mod profile_refs;pub mod progress;mod thread_catalog;-pub use thread_catalog::{TappedThread, TappedThreadFamily, parse_tapped_thread, tapped_thread_sizes};+pub use thread_catalog::{TaperDrill, TappedThread, TappedThreadFamily, parse_tapped_thread, tapped_thread_sizes, untabulated_taper_tap};mod walk;pub use profile_refs::{capture_profile_selection, profile_fallback_notes, profile_selection_indices, profile_selection_indices_lenient};pub mod plastic;diff --git a/crates/doc/src/thread_catalog.rs b/crates/doc/src/thread_catalog.rsindex eec847aadc..5906b8a7a1 100644--- a/crates/doc/src/thread_catalog.rs+++ b/crates/doc/src/thread_catalog.rs@@ -46,138 +46,108 @@ fn pipe_size(size: crate::pipe_thread_catalog::PipeThread) -> TappedThread {}}-/// The drill of an internal taper thread (Rc, NPT): `exact` is the standard's internal minor-/// diameter where the thread ends (mm), the reference plane's minor at the face (d - 2h for ISO-/// 7-1, E1 - h for NPT) less the 1 in 16 taper over the thread's length (ISO 7-1's useful thread,-/// NPT's effective thread L2), so a tap cuts full form over the whole length. The hole is-/// drilled with the largest stocked drill not larger than that (`name`, `diameter`): metric for-/// Rc, inch for NPT. Above the drill series it is bored to `exact` (no `name`).+/// The drill of an internal taper thread (Rc, NPT). `diameter` is the tap maker's tabulated+/// drill for a straight (not reamed) hole; `exact` is the standard's internal minor diameter where+/// the thread ends (mm), the reference plane's minor at the face (d - 2h for ISO 7-1, E1 - h for+/// NPT) less the 1 in 16 taper over the thread's length (ISO 7-1's useful thread, NPT's effective+/// thread L2), which the dialog shows beside it.#[derive(Clone, Debug, PartialEq)]pub struct TaperDrill {pub exact: f64,pub diameter: f64,- pub name: Option<String>,}-/// Metric twist drill diameters (mm), DIN 345:2006 (taper shank twist drills, the series up to-/// 100 mm), as reproduced at <https://www.fasten.it/en/Norms/Norm/DIN%20345>; three digits that-/// reproduction drops are restored from their neighbours (15.25, 34.5, 54).-const DIN_345: &[f64] = &[- 3.0, 3.2, 3.5, 3.8, 4.0, 4.2, 4.5, 4.8, 5.0, 5.2, 5.5, 5.8, 6.0, 6.2, 6.5, 6.8, 7.0, 7.2, 7.5, 7.8, 8.0, 8.2, 8.5, 8.8, 9.0, 9.2, 9.5, 9.8, 10.0,- 10.2, 10.5, 10.8, 11.0, 11.2, 11.5, 11.8, 12.0, 12.2, 12.5, 12.8, 13.0, 13.2, 13.5, 13.8, 14.0, 14.25, 14.5, 14.75, 15.0, 15.25, 15.5, 15.75,- 16.0, 16.25, 16.5, 16.75, 17.0, 17.25, 17.5, 17.75, 18.0, 18.25, 18.5, 18.75, 19.0, 19.25, 19.5, 19.75, 20.0, 20.25, 20.5, 20.75, 21.0, 21.25,- 21.5, 21.75, 22.0, 22.25, 22.5, 22.75, 23.0, 23.25, 23.5, 23.75, 24.0, 24.25, 24.5, 24.75, 25.0, 25.25, 25.5, 25.75, 26.0, 26.25, 26.5, 26.75,- 27.25, 27.5, 27.75, 28.0, 28.25, 28.5, 28.75, 29.0, 29.25, 29.5, 29.75, 30.0, 30.25, 30.5, 30.75, 31.0, 31.25, 31.5, 31.75, 32.0, 32.5, 33.0,- 33.5, 34.5, 35.0, 35.5, 36.0, 36.5, 37.0, 37.5, 38.0, 38.5, 39.0, 39.5, 40.0, 40.5, 41.0, 41.5, 42.0, 42.5, 43.0, 43.5, 44.0, 44.5, 45.0, 45.5,- 46.0, 46.5, 47.0, 47.5, 48.0, 48.5, 49.0, 49.5, 50.0, 50.5, 51.0, 52.0, 53.0, 54.0, 55.0, 56.0, 57.0, 58.0, 59.0, 60.0, 61.0, 62.0, 63.0, 64.0,- 65.0, 66.0, 67.0, 68.0, 69.0, 70.0, 71.0, 72.0, 73.0, 74.0, 76.0, 77.0, 78.0, 79.0, 80.0, 81.0, 82.0, 83.0, 84.0, 85.0, 86.0, 87.0, 88.0, 89.0,- 90.0, 91.0, 92.0, 93.0, 94.0, 95.0, 96.0, 97.0, 98.0, 99.0, 100.0,+/// Rc (ISO 7-1, "PT") drills: Yamawa YEU23, printed p.709 ("Taper Internal Pipe Threads -+/// Rc(BSPT)-PT"), the maximum size of a straight bored hole when the threads have non-full+/// threads (the same values as the Rc tap's bored hole A on printed p.121), for the sizes of+/// ISO 7-1's table it lists (1/16 to 4).+/// <https://www.yamawa.eu/files/Yamawa_European_Catalogue_YEU23.pdf>+const RC_DRILLS: &[(&str, f64)] = &[+ ("1/16", 6.1),+ ("1/8", 8.1),+ ("1/4", 10.7),+ ("3/8", 14.2),+ ("1/2", 17.6),+ ("3/4", 23.0),+ ("1", 29.0),+ ("1 1/4", 37.6),+ ("1 1/2", 43.5),+ ("2", 55.0),+ ("2 1/2", 70.3),+ ("3", 82.8),+ ("4", 107.6),];-/// Letter drill sizes (in), ASME B94.11M (twist drills).-const LETTER_DRILLS: &[(char, f64)] = &[- ('A', 0.234),- ('B', 0.238),- ('C', 0.242),- ('D', 0.246),- ('E', 0.250),- ('F', 0.257),- ('G', 0.261),- ('H', 0.266),- ('I', 0.272),- ('J', 0.277),- ('K', 0.281),- ('L', 0.290),- ('M', 0.295),- ('N', 0.302),- ('O', 0.316),- ('P', 0.323),- ('Q', 0.332),- ('R', 0.339),- ('S', 0.348),- ('T', 0.358),- ('U', 0.368),- ('V', 0.377),- ('W', 0.386),- ('X', 0.397),- ('Y', 0.404),- ('Z', 0.413),+/// NPT drills: Yamawa YEU23, printed p.710 ("American Taper Pipe Threads (NPT)", referring to+/// ASME B1.20.1), the maximum size of a straight bored hole, 1/16 to 3.+const NPT_DRILLS: &[(&str, f64)] = &[+ ("1/16", 6.05),+ ("1/8", 8.39),+ ("1/4", 10.85),+ ("3/8", 14.27),+ ("1/2", 17.60),+ ("3/4", 22.91),+ ("1", 28.78),+ ("1 1/4", 37.50),+ ("1 1/2", 43.57),+ ("2", 55.58),+ ("2 1/2", 66.28),+ ("3", 82.05),];-/// Fractional drill sizes by 64ths of an inch up to this many 64ths (1 1/2 in), ASME B94.11M.-const FRACTIONAL_64THS: u32 = 96;--/// A fraction of an inch in lowest terms: `11/16 in`, `1 1/4 in`.-fn inch_fraction(n64: u32) -> String {- let (whole, mut num, mut den) = (n64 / 64, n64 % 64, 64);- while num > 0 && num % 2 == 0 {- num /= 2;- den /= 2;- }- match (whole, num) {- (0, _) => format!("{num}/{den} in"),- (w, 0) => format!("{w} in"),- (w, _) => format!("{w} {num}/{den} in"),- }-}--/// The largest stocked drill not larger than `exact` mm: metric (DIN 345) or inch (letter and-/// fractional drills, ASME B94.11M). None past the series.-fn stocked_drill(exact: f64, inch: bool) -> Option<(f64, String)> {- let fits = |d: f64| d <= exact + 1e-9;- if !inch {- let max = DIN_345.iter().copied().fold(0.0, f64::max);- if exact > max + 1.0 {- return None;- }- return DIN_345- .iter()- .copied()- .filter(|d| fits(*d))- .fold(None, |a: Option<f64>, d| Some(a.map_or(d, |a| a.max(d))))- .map(|d| (d, format!("{d} mm")));- }- if exact > f64::from(FRACTIONAL_64THS) / 64.0 * 25.4 + 25.4 / 64.0 {- return None;- }- let letters = LETTER_DRILLS.iter().map(|(c, d)| (d * 25.4, format!("{c} ({d:.3} in)")));- let fractions = (1..=FRACTIONAL_64THS).map(|n| (f64::from(n) / 64.0 * 25.4, inch_fraction(n)));- letters.chain(fractions).filter(|(d, _)| fits(*d)).max_by(|a, b| a.0.total_cmp(&b.0))+/// The drill of an Rc or NPT size the tap maker tabulates; none for the others.+fn taper_drill(family: TappedThreadFamily, size: &crate::pipe_thread_sizes::PipeSize) -> Option<TaperDrill> {+ let (table, h) = match family {+ TappedThreadFamily::Npt => (NPT_DRILLS, crate::pipe_thread_sizes::NPT_HEIGHT * size.pitch()),+ _ => (RC_DRILLS, 0.640327 * size.pitch()),+ };+ let diameter = table.iter().find(|(n, _)| *n == size.nominal)?.1;+ Some(TaperDrill { exact: size.major - 2.0 * h - size.length / 16.0, diameter })}-/// The drill of an Rc or NPT size ([`TaperDrill`]).-fn taper_drill(family: TappedThreadFamily, size: &crate::pipe_thread_sizes::PipeSize) -> TaperDrill {- let p = size.pitch();- let h = if family == TappedThreadFamily::Npt { crate::pipe_thread_sizes::NPT_HEIGHT * p } else { 0.640327 * p };- let exact = size.major - 2.0 * h - size.length / 16.0;- match stocked_drill(exact, family == TappedThreadFamily::Npt) {- Some((diameter, name)) => TaperDrill { exact, diameter, name: Some(name) },- None => TaperDrill { exact, diameter: (exact * 1000.0).floor() / 1000.0, name: None },+/// The pipe sizes of a taper family.+fn taper_sizes(family: TappedThreadFamily) -> Vec<crate::pipe_thread_sizes::PipeSize> {+ match family {+ TappedThreadFamily::Rc => crate::pipe_thread_sizes::iso_7_1().collect(),+ TappedThreadFamily::Npt => crate::pipe_thread_sizes::npt().collect(),+ _ => Vec::new(),}}impl TappedThread {- /// An Rc or NPT size's drill: the standard's exact value and the stocked drill it is.+ /// An Rc or NPT size's drill: the tap maker's and the standard's exact value.pub fn taper_drill(&self) -> Option<TaperDrill> {- let sizes = match self.family {- TappedThreadFamily::Rc => crate::pipe_thread_sizes::iso_7_1().collect::<Vec<_>>(),- TappedThreadFamily::Npt => crate::pipe_thread_sizes::npt().collect(),- _ => return None,- };- sizes.iter().find(|z| (z.major - self.major_diameter).abs() < 1e-9).map(|z| taper_drill(self.family, z))+ taper_sizes(self.family).iter().find(|z| (z.major - self.major_diameter).abs() < 1e-9).and_then(|z| taper_drill(self.family, z))}}+/// Why an Rc or NPT designation is no tapped hole's: a size of its standard the tap maker's table+/// has no drill for. None for any other text.+pub fn untabulated_taper_tap(text: &str) -> Option<String> {+ use crate::thread_forms::ThreadForm;+ let (family, form, listed) = match ThreadForm::of_designation(text) {+ Some(ThreadForm::Bspt) if ThreadForm::pipe_internal(text) => (TappedThreadFamily::Rc, ThreadForm::Bspt, "Rc 1/16 to Rc 4"),+ Some(ThreadForm::Npt) => (TappedThreadFamily::Npt, ThreadForm::Npt, "1/16 to 3 NPT"),+ _ => return None,+ };+ let size = form.parse(text, 1).ok()?;+ let z = taper_sizes(family).into_iter().find(|z| (z.major - size.major).abs() < 1e-9)?;+ taper_drill(family, &z).is_none().then(|| {+ format!("no tap drill is tabulated for `{}` (Yamawa's table, which the tapped-hole drills come from, lists {listed}): it is not offered as a tapped hole", text.trim())+ })+}+/// An internal taper thread (Rc, NPT) of the size tables a modelled thread cuts-/// ([`crate::pipe_thread_sizes`]), drilled with [`TaperDrill`]'s stocked drill.-fn taper_size(family: TappedThreadFamily, size: crate::pipe_thread_sizes::PipeSize) -> TappedThread {+/// ([`crate::pipe_thread_sizes`]), drilled with the tap maker's drill ([`TaperDrill`]); none for+/// a size without one.+fn taper_size(family: TappedThreadFamily, size: crate::pipe_thread_sizes::PipeSize) -> Option<TappedThread> {use crate::thread_forms::ThreadForm;let p = size.pitch();let form = if family == TappedThreadFamily::Npt { ThreadForm::Npt } else { ThreadForm::Bspt };let designation = form.format(size.major, p, p);let designation = if form == ThreadForm::Bspt { designation.replacen("R ", "Rc ", 1) } else { designation };- let tap_drill = taper_drill(family, &size).diameter;- TappedThread { family, designation, major_diameter: size.major, pitch: p, tap_drill }+ let tap_drill = taper_drill(family, &size)?.diameter;+ Some(TappedThread { family, designation, major_diameter: size.major, pitch: p, tap_drill })}// Diameter/pitch pairs verified against Guhring, plus Yamawa for M12x1.25.@@ -249,8 +219,7 @@ pub fn tapped_thread_sizes(family: TappedThreadFamily) -> Vec<TappedThread> {return crate::pipe_thread_catalog::pipe_thread_sizes().map(pipe_size).filter(|s| s.family == family).collect();}match family {- TappedThreadFamily::Rc => return crate::pipe_thread_sizes::iso_7_1().map(|z| taper_size(family, z)).collect(),- TappedThreadFamily::Npt => return crate::pipe_thread_sizes::npt().map(|z| taper_size(family, z)).collect(),+ TappedThreadFamily::Rc | TappedThreadFamily::Npt => return taper_sizes(family).into_iter().filter_map(|z| taper_size(family, z)).collect(),_ => {}}@@ -274,8 +243,8 @@ pub fn tapped_thread_sizes(family: TappedThreadFamily) -> Vec<TappedThread> {}/// Explicit metric custom sizes remain supported. Unified sizes must be in the verified-/// catalogue and include their UNC/UNF suffix. G/Rp use explicit process drills, Rc/NPT the drill-/// derived from their standards ([`taper_size`]).+/// catalogue and include their UNC/UNF suffix. G/Rp use explicit process drills, Rc/NPT the tap+/// maker's tabulated drills ([`TaperDrill`]); an Rc or NPT size without one is none.pub fn parse_tapped_thread(text: &str) -> Option<TappedThread> {if text.len() > 128 {return None;@@ -319,36 +288,35 @@ mod tests {}}- /// Rc and NPT holes: the size tables' diameters, and the stocked drill just under the internal- /// minor where the thread ends (Rc 1/2: d1 18.631 at the face less 13.2 mm of useful thread at- /// 1 in 16, 17.807, drilled 17.75 mm; 1/2 NPT: E1 - h = 0.77843 - 0.05714 in at the face less- /// L2 = 0.5337 in at 1 in 16, 0.6879 in, drilled 11/16 in), and no external R.+ /// Rc and NPT holes: the size tables' diameters, the tap maker's drill (Yamawa YEU23 pp.709+ /// and 710) and the standard's minor where the thread ends (Rc 1/2: d1 18.631 at the face less+ /// 13.2 mm of useful thread at 1 in 16; 1/2 NPT: E1 - h = 0.77843 - 0.05714 in at the face less+ /// L2 = 0.5337 in at 1 in 16), a size without a tabulated drill refused, and no external R.#[test]- fn internal_taper_threads_drill_to_their_minor_where_the_thread_ends() {+ fn internal_taper_threads_take_the_tap_makers_drill() {let rc = parse_tapped_thread("Rc1/2").unwrap();- assert_eq!((rc.family, rc.designation.as_str(), rc.major_diameter), (TappedThreadFamily::Rc, "Rc 1/2", 20.955));+ assert_eq!((rc.family, rc.designation.as_str(), rc.major_diameter, rc.tap_drill), (TappedThreadFamily::Rc, "Rc 1/2", 20.955, 17.6));let d = rc.taper_drill().unwrap();assert!((d.exact - (18.631 - 13.2 / 16.0)).abs() < 2e-3, "{d:?}");- assert_eq!((rc.tap_drill, d.name.as_deref()), (17.75, Some("17.75 mm")));let npt = parse_tapped_thread("1/2 NPT").unwrap();- assert_eq!((npt.family, npt.designation.as_str()), (TappedThreadFamily::Npt, "1/2-14 NPT"));+ assert_eq!((npt.family, npt.designation.as_str(), npt.tap_drill), (TappedThreadFamily::Npt, "1/2-14 NPT", 17.6));let d = npt.taper_drill().unwrap();assert!((d.exact - (0.77843 - 0.8 / 14.0 - 0.5337 / 16.0) * 25.4).abs() < 2e-3, "{d:?}");- assert_eq!((npt.tap_drill, d.name.as_deref()), (11.0 / 16.0 * 25.4, Some("11/16 in")));- // A letter drill where it is the closer stocked size (1/8 NPT), and a bore past the series.- let small = parse_tapped_thread("1/8 NPT").unwrap().taper_drill().unwrap();- assert!(small.diameter <= small.exact && small.name.is_some(), "{small:?}");- let large = parse_tapped_thread("Rc 6").unwrap().taper_drill().unwrap();- assert!(large.name.is_none() && (large.diameter - large.exact).abs() < 1e-3, "{large:?}");+ assert_eq!(rc.profile_degrees(), 55.0);+ assert_eq!(npt.profile_degrees(), 60.0);+ assert!(parse_tapped_thread("R 1/2").is_none(), "an external taper thread is no hole's");+ for untabulated in ["Rc 5", "Rc 6", "4-8 NPT", "12 NPT"] {+ assert!(parse_tapped_thread(untabulated).is_none(), "{untabulated}");+ assert!(untabulated_taper_tap(untabulated).is_some_and(|e| e.contains("no tap drill is tabulated")), "{untabulated}");+ }+ assert!(untabulated_taper_tap("Rc 1/2").is_none() && untabulated_taper_tap("M8").is_none());+ // Each tabulated drill lies within a pitch of the standard's minor where the thread ends.for family in [TappedThreadFamily::Rc, TappedThreadFamily::Npt] {for s in tapped_thread_sizes(family) {let d = s.taper_drill().unwrap();- assert!(d.diameter <= d.exact + 1e-9 && d.exact - d.diameter < 0.02 * d.exact + 0.4, "{}: {d:?}", s.designation);+ assert!((d.diameter - d.exact).abs() < s.pitch, "{}: {d:?}", s.designation);}}- assert_eq!(rc.profile_degrees(), 55.0);- assert_eq!(npt.profile_degrees(), 60.0);- assert!(parse_tapped_thread("R 1/2").is_none(), "an external taper thread is no hole's");}#[test]@@ -367,8 +335,8 @@ mod tests {let count = match family {TappedThreadFamily::Metric => sizes.len(),TappedThreadFamily::G | TappedThreadFamily::Rp => 6,- TappedThreadFamily::Rc => 15,- TappedThreadFamily::Npt => crate::pipe_thread_sizes::npt().count(),+ TappedThreadFamily::Rc => RC_DRILLS.len(),+ TappedThreadFamily::Npt => NPT_DRILLS.len(),_ => 14,};assert_eq!(sizes.len(), count, "{family:?}");diff --git a/crates/engine/src/cmd/features.rs b/crates/engine/src/cmd/features.rsindex c3dab105f5..144ce2f893 100644--- a/crates/engine/src/cmd/features.rs+++ b/crates/engine/src/cmd/features.rs@@ -69,7 +69,7 @@ pub static COMMANDS: &[CommandSpec] = &[.at("SOLID", "CREATE").icon("hole").key("H")- .params("position: [x,y,z] on a face (numbers, or length expressions the hole follows) | sketch + points: [sketch point ids] (one hole each, perpendicular to the sketch, into the material on whichever side of the sketch plane it is) | sketch alone (every sketch point: standalone points and circle centres); flip?: bool (sketch points: drill to the other side); single?: bool (with one sketch point: a Single hole that follows the point, drilled into the face there); direction?: [x,y,z] (default: into the face, against its outward normal; one that leaves the face is mirrored into it; ignored with sketch points unless single); diameter | thread (a tapped hole: metric major minus pitch or tabulated UNC/UNF, G or Rp cut-tap drill, or the Rc/NPT drill to the internal minor diameter where the thread ends) | clearance: \"M6\" with fit?: close|normal|loose (ISO 273); depth? (default through all) | to?: [x,y,z] (To Object: drill to that face or point); references?: [{edge: [x,y,z] on a straight edge of the face, distance: expr}] (at most two; the centre goes that far from each edge's line, in the face's plane, and follows the edges; with a numeric position only); type?: simple|drilled|counterbore|countersink; tip_angle?; cb_diameter?, cb_depth?; cs_diameter?, cs_angle?; thread?: \"M6\", \"1/4-20 UNC\", \"G 1/4\", \"Rp 1/4\", \"Rc 1/4\" or \"1/4-18 NPT\" (cosmetic unless modeled); hand?: right|left (the tapped thread's hand; default right; needs thread); thread_depth?: positive length independent of drill depth (default: full useful cylindrical wall; must fit that wall); modeled?: bool (needs thread: the tapped thread cut into the wall, the groove between its teeth, as solid.thread's modelled one; default false: listed only); ease_out?: expr|standard|short (modelled tapped threads: the inner end, towards the bottom, fades out over this length, ISO 3508's runout, standard 2.5 P, short 1.25 P; without it the groove stops square at thread_depth, or clear of a blind hole's bottom); targets?: [body] (the bodies to drill; holes at the points of a sketch on a body's face default to that body, found along the holes' direction on it alone; explicit targets or participants override, [\"*\"] every body)"),+ .params("position: [x,y,z] on a face (numbers, or length expressions the hole follows) | sketch + points: [sketch point ids] (one hole each, perpendicular to the sketch, into the material on whichever side of the sketch plane it is) | sketch alone (every sketch point: standalone points and circle centres); flip?: bool (sketch points: drill to the other side); single?: bool (with one sketch point: a Single hole that follows the point, drilled into the face there); direction?: [x,y,z] (default: into the face, against its outward normal; one that leaves the face is mirrored into it; ignored with sketch points unless single); diameter | thread (a tapped hole: metric major minus pitch or tabulated UNC/UNF, G or Rp cut-tap drill, or the Rc/NPT tap maker's tabulated drill, Rc 1/16 to 4 and NPT 1/16 to 3) | clearance: \"M6\" with fit?: close|normal|loose (ISO 273); depth? (default through all) | to?: [x,y,z] (To Object: drill to that face or point); references?: [{edge: [x,y,z] on a straight edge of the face, distance: expr}] (at most two; the centre goes that far from each edge's line, in the face's plane, and follows the edges; with a numeric position only); type?: simple|drilled|counterbore|countersink; tip_angle?; cb_diameter?, cb_depth?; cs_diameter?, cs_angle?; thread?: \"M6\", \"1/4-20 UNC\", \"G 1/4\", \"Rp 1/4\", \"Rc 1/4\" or \"1/4-18 NPT\" (cosmetic unless modeled); hand?: right|left (the tapped thread's hand; default right; needs thread); thread_depth?: positive length independent of drill depth (default: full useful cylindrical wall; must fit that wall); modeled?: bool (needs thread: the tapped thread cut into the wall, the groove between its teeth, as solid.thread's modelled one; default false: listed only); ease_out?: expr|standard|short (modelled tapped threads: the inner end, towards the bottom, fades out over this length, ISO 3508's runout, standard 2.5 P, short 1.25 P; without it the groove stops square at thread_depth, or clear of a blind hole's bottom); targets?: [body] (the bodies to drill; holes at the points of a sketch on a body's face default to that body, found along the holes' direction on it alone; explicit targets or participants override, [\"*\"] every body)"),CommandSpec::new("solid.pipe", "Pipe", pipe).at("SOLID", "CREATE").icon("pipe")@@ -2434,7 +2434,9 @@ fn hole(s: &mut Session, p: &Value) -> Result<Value> {{return Err(bad(cmd,- fine_only_hint(t).unwrap_or_else(|| format!("unknown tapped thread `{t}` (ISO metric or a catalogued UNC/UNF, G, Rp, Rc or NPT size)")),+ fine_only_hint(t)+ .or_else(|| solidcraft_doc::untabulated_taper_tap(t))+ .unwrap_or_else(|| format!("unknown tapped thread `{t}` (ISO metric or a catalogued UNC/UNF, G, Rp, Rc or NPT size)")),));}let thread_depth = match p.get("thread_depth") {diff --git a/crates/engine/src/thread_tests.rs b/crates/engine/src/thread_tests.rsindex d375298501..10710c0d47 100644--- a/crates/engine/src/thread_tests.rs+++ b/crates/engine/src/thread_tests.rs@@ -1216,8 +1216,8 @@ fn a_taper_pipe_thread_starts_at_a_free_end_and_is_named_for_its_side() {/// A tapped hole's thread cut into its wall (`modeled`), as the thread feature cuts one: an M8/// blind hole whose groove stops clear of the drill point's bottom, or fades out before it/// (`ease_out`, ISO 3508), which leaves more of the wall than the full form there; an Rc 1/2-/// through a plate, drilled with the stocked drill under its minor where the thread ends and cut-/// to its taper; each a valid body that reopens the same.+/// through a plate, drilled with the tap maker's drill and cut to its taper; each a valid body+/// that reopens the same. An Rc size with no tabulated drill is refused.#[test]fn a_modelled_tapped_hole_stops_clear_of_its_bottom_or_fades_out_before_it() {let blind = |extra: Value| {@@ -1243,9 +1243,8 @@ fn a_modelled_tapped_hole_stops_clear_of_its_bottom_or_fades_out_before_it() {run(&mut s, "solid.box", json!({"length":40,"width":40,"height":12,"body_name":"Plate"}));let out = run(&mut s, "solid.hole", json!({"position":[20,20,12],"direction":[0,0,-1],"thread":"Rc 1/2"}));let drilled = exact_volume(&s, "Plate");- // d1 at the face less 13.2 mm of useful thread at 1 in 16 is 17.807 mm: the stocked drill- // under it is 17.75 mm (DIN 345).- let drill: f64 = 17.75;+ // The tap maker's drill for a straight Rc 1/2 hole (Yamawa YEU23 p.709).+ let drill: f64 = 17.6;assert!((drilled - (40.0 * 40.0 * 12.0 - PI * (drill / 2.0).powi(2) * 12.0)).abs() < 1e-3, "{drilled}");let id = out["feature"].as_u64().unwrap();let redefine = json!({"position":[20,20,12],"direction":[0,0,-1],"thread":"Rc 1/2","modeled":true});@@ -1256,4 +1255,5 @@ fn a_modelled_tapped_hole_stops_clear_of_its_bottom_or_fades_out_before_it() {let err = |p: Value| Session::default().execute("solid.hole", &p).err().map(|e| e.to_string()).unwrap_or_default();assert!(err(json!({"position":[0,0,0],"diameter":5,"modeled":true})).contains("`modeled` needs `thread`"));assert!(err(json!({"position":[0,0,0],"thread":"M8","ease_out":"standard"})).contains("modelled thread"));+ assert!(err(json!({"position":[0,0,0],"thread":"Rc 5"})).contains("no tap drill is tabulated"));}diff --git a/crates/ui-egui/src/dialogs_thread.rs b/crates/ui-egui/src/dialogs_thread.rsindex d161a4f7fd..e7aa2bc1a2 100644--- a/crates/ui-egui/src/dialogs_thread.rs+++ b/crates/ui-egui/src/dialogs_thread.rs@@ -155,16 +155,12 @@ pub(crate) fn hole_rows(ui: &mut egui::Ui, doc: &Document, designation: &mut Str}form_row(ui, "Tap drill diameter", |ui| {match parse_tapped_thread(designation).filter(|_| custom.as_ref().is_none_or(|draft| draft.error.is_none())) {- // An Rc or NPT hole is drilled with the stocked drill under the standard's minor- // diameter where the thread ends; that exact value is the tooltip.+ // An Rc or NPT hole takes the tap maker's drill; the standard's minor diameter where+ // the thread ends is the tooltip.Some(size) => match size.taper_drill() {Some(d) => {- let shown = d- .name- .filter(|n| !n.ends_with(" mm"))- .map_or_else(|| format!("{} mm", size.tap_drill), |n| format!("{} mm ({n})", size.tap_drill));let exact = format!("{:.3}", d.exact);- ui.label(shown).on_hover_text(crate::i18n::format("thread.taper_drill_exact", &[("exact", &exact)]));+ ui.label(format!("{} mm", size.tap_drill)).on_hover_text(crate::i18n::format("thread.taper_drill_exact", &[("exact", &exact)]));}None => {ui.label(format!("{} mm", size.tap_drill));diff --git a/docs/thread-catalogue.md b/docs/thread-catalogue.mdindex e1de44ad35..641215a10f 100644--- a/docs/thread-catalogue.md+++ b/docs/thread-catalogue.md@@ -36,18 +36,16 @@ thread classes and sealing behaviour are outside this catalogue.## Taper Rc and NPT threads-An Rc or NPT hole is drilled with the largest stocked drill not larger than the-internal thread's minor diameter where the thread ends: the reference plane's-minor (d - 2h for ISO 7-1, E1 - h for NPT) at the face, less the 1 in 16 taper-over the thread's length (ISO 7-1's useful thread, NPT's effective thread L2), so-that the tap cuts full form over the whole length. Rc takes a metric drill of the-DIN 345 series (to 100 mm), NPT a letter or fractional inch drill (by 64ths to-1 1/2 in, ASME B94.11M); past the series the hole is bored to the exact value. The-Hole dialog shows the drill and, as its tooltip, the exact value: Rc 1/2 is-17.807 mm, drilled 17.75 mm; 1/2 NPT is 17.473 mm (0.6879 in), drilled 11/16 in-(17.4625 mm). This is derived from the standards, not a tap maker's-recommendation (which often allows for reaming); an explicit `diameter`-overrides it. Listed, the hole+An Rc or NPT hole takes the tap maker's drill for a straight (not reamed) hole:+Yamawa YEU23's "maximum size of straight bored hole", for Rc with non-full+threads (printed p.709, Rc 1/16 to 4) and for NPT (printed p.710, 1/16 to 3).+A size of ISO 7-1 or ASME B1.20.1 outside those (Rc 5 and 6, NPT 3 1/2 to 12) is+refused as a tapped hole. The Hole dialog shows the drill and, as its tooltip,+the standard's minor diameter where the thread ends: the reference plane's minor+(d - 2h for ISO 7-1, E1 - h for NPT) at the face less the 1 in 16 taper over the+thread's length (ISO 7-1's useful thread, NPT's effective thread L2). Rc 1/2:+drill 17.6 mm, minor 17.807 mm; 1/2 NPT: drill 17.60 mm, minor 17.473 mm. An+explicit `diameter` overrides the drill. Listed, the holeis that cylindrical drill; modelled, the thread's taper is cut into it (the tap'sminor cone and the helical groove).@@ -78,16 +76,11 @@ cylindrical pilot plus the designation; modelled, the helical groove is cut too.## Primary sources-- DIN 345:2006 (taper shank twist drills), the metric drill diameters to 100 mm as- reproduced at <https://www.fasten.it/en/Norms/Norm/DIN%20345>: the stocked drills- of Rc holes. Three digits that reproduction drops (15.25, 34.5, 54) are restored- from their neighbours.-- ASME B94.11M (twist drills): the letter drill sizes A to Z and fractional sizes- by 64ths of an inch, the stocked drills of NPT holes.- [Yamawa, YEU23 European catalogue](https://www.yamawa.eu/files/Yamawa_European_Catalogue_YEU23.pdf),printed page 668: basic G/Rp dimensions; page 707: separate G and Rp drill and- recommended bore columns. These supply the finite parallel-pipe entries above.+ recommended bore columns; page 709: Rc drills (maximum straight bored hole);+ page 710: NPT drills. These supply the finite parallel-pipe entries above.- [Guhring, Tap Drill Sizes](https://guhring.com/media/catalogs/lgbkp3ieki4.pdf),PDF page 2: UNC/UNF pitch and practical CUT TAPS approximately75% drills;