1use crate::geometry::Point;
84use crate::material::Material;
85use crate::section::Section;
86use crate::section_properties::SectionProperties;
87use thiserror::Error;
88
89#[derive(Debug, Clone, PartialEq, Error)]
91pub enum CompositeError {
92 #[error("invalid Young's modulus for material '{name}': E={value}")]
94 InvalidModulus { name: String, value: f64 },
95
96 #[error("degenerate section geometry in component {index}: {detail}")]
98 InvalidGeometry { index: usize, detail: String },
99
100 #[error("composite section must contain at least one component")]
102 NoComponents,
103
104 #[error("transformed section net area is zero or near-zero")]
106 ZeroTransformedArea,
107
108 #[error("invalid reference material modulus: E={value}")]
110 InvalidReferenceModulus { value: f64 },
111
112 #[error(
114 "non-finite modular ratio for component {index}: E={e_component:.6e} / E_ref={e_ref:.6e}"
115 )]
116 NonFiniteModularRatio {
117 index: usize,
118 e_component: f64,
119 e_ref: f64,
120 },
121
122 #[error("non-finite derived section property at stage '{stage}': {detail}")]
130 NonFiniteDerivedProperty { stage: &'static str, detail: String },
131}
132
133#[derive(Debug, Clone)]
145pub struct CompositeComponent {
146 section: Section,
147 material: Material,
148}
149
150impl CompositeComponent {
151 pub fn new(section: Section, material: Material) -> Result<Self, CompositeError> {
160 validate_modulus(material.youngs_modulus, material.name)?;
161 if !material.is_valid() {
162 return Err(CompositeError::InvalidModulus {
163 name: material.name.to_string(),
164 value: material.youngs_modulus,
165 });
166 }
167 let area = section.area();
168 if area.abs() <= f64::EPSILON {
169 return Err(CompositeError::InvalidGeometry {
170 index: 0,
171 detail: format!("net area = {area:.6e} (too small)"),
172 });
173 }
174 if !area.is_finite() {
175 return Err(CompositeError::InvalidGeometry {
176 index: 0,
177 detail: format!("net area = {area} (not finite)"),
178 });
179 }
180 Ok(Self { section, material })
181 }
182
183 pub fn youngs_modulus(&self) -> f64 {
185 self.material.youngs_modulus
186 }
187
188 pub fn area(&self) -> f64 {
190 self.section.area()
191 }
192
193 pub fn section(&self) -> &Section {
195 &self.section
196 }
197
198 pub fn material(&self) -> &Material {
200 &self.material
201 }
202}
203
204fn validate_modulus(e: f64, name: &str) -> Result<(), CompositeError> {
205 if !e.is_finite() || e <= 0.0 {
206 return Err(CompositeError::InvalidModulus {
207 name: name.to_string(),
208 value: e,
209 });
210 }
211 Ok(())
212}
213
214#[derive(Debug, Clone)]
219pub struct ComponentAnalysis {
220 pub material: Material,
222 pub modular_ratio: f64,
224 pub original_area: f64,
226 pub transformed_area: f64,
228 pub centroid: Point,
230}
231
232#[derive(Debug, Clone)]
237pub struct CompositeAnalysisResult {
238 pub area: f64,
240 pub centroid: Point,
242 pub ix: f64,
247 pub iy: f64,
252 pub ixy: f64,
257 pub principal_i11: f64,
259 pub principal_i22: f64,
261 pub principal_phi: f64,
263 pub reference_material: Material,
265 pub components: Vec<ComponentAnalysis>,
267}
268
269#[derive(Debug, Clone)]
283pub struct ElasticComposite {
284 components: Vec<CompositeComponent>,
285}
286
287impl ElasticComposite {
288 pub fn new(components: Vec<CompositeComponent>) -> Result<Self, CompositeError> {
293 if components.is_empty() {
294 return Err(CompositeError::NoComponents);
295 }
296 Ok(Self { components })
297 }
298
299 pub fn n_components(&self) -> usize {
301 self.components.len()
302 }
303
304 pub fn component(&self, index: usize) -> Option<&CompositeComponent> {
306 self.components.get(index)
307 }
308
309 pub fn analyze(
343 &self,
344 reference_material: &Material,
345 ) -> Result<CompositeAnalysisResult, CompositeError> {
346 validate_modulus(reference_material.youngs_modulus, reference_material.name).map_err(
347 |_| CompositeError::InvalidReferenceModulus {
348 value: reference_material.youngs_modulus,
349 },
350 )?;
351
352 for comp in &self.components {
357 if !comp.material.is_valid() {
358 return Err(CompositeError::InvalidModulus {
359 name: comp.material.name.to_string(),
360 value: comp.material.youngs_modulus,
361 });
362 }
363 }
364
365 let e_ref = reference_material.youngs_modulus;
366
367 let mut total_area = 0.0_f64;
371 let mut first_x = 0.0_f64;
372 let mut first_y = 0.0_f64;
373
374 let mut component_results: Vec<ComponentAnalysis> =
375 Vec::with_capacity(self.components.len());
376
377 let mut comp_data: Vec<(f64, f64, f64, f64, f64, f64, f64)> =
379 Vec::with_capacity(self.components.len());
380
381 for (i, comp) in self.components.iter().enumerate() {
382 let props = SectionProperties::try_from_section(&comp.section)
383 .map_err(|detail| CompositeError::InvalidGeometry { index: i, detail })?;
384
385 let n = comp.material.youngs_modulus / e_ref;
386 if !n.is_finite() {
387 return Err(CompositeError::NonFiniteModularRatio {
388 index: i,
389 e_component: comp.material.youngs_modulus,
390 e_ref,
391 });
392 }
393 let area = props.area;
394 let cx = props.centroid.x;
395 let cy = props.centroid.y;
396
397 let n_area = n * area;
398 if !n_area.is_finite() {
399 return Err(CompositeError::NonFiniteModularRatio {
400 index: i,
401 e_component: comp.material.youngs_modulus,
402 e_ref,
403 });
404 }
405 total_area += n_area;
406 first_x += n_area * cx;
407 first_y += n_area * cy;
408
409 comp_data.push((n, area, cx, cy, props.ix, props.iy, props.ixy));
410 component_results.push(ComponentAnalysis {
411 material: comp.material,
412 modular_ratio: n,
413 original_area: area,
414 transformed_area: n_area,
415 centroid: props.centroid,
416 });
417 }
418
419 if total_area.abs() <= f64::EPSILON {
420 return Err(CompositeError::ZeroTransformedArea);
421 }
422 if !total_area.is_finite() || !first_x.is_finite() || !first_y.is_finite() {
423 return Err(CompositeError::NonFiniteDerivedProperty {
424 stage: "weighted_accumulation",
425 detail: format!(
426 "total_area={}, first_x={}, first_y={}",
427 total_area, first_x, first_y
428 ),
429 });
430 }
431
432 let centroid = Point::new(first_x / total_area, first_y / total_area);
434 if !centroid.x.is_finite() || !centroid.y.is_finite() {
435 return Err(CompositeError::NonFiniteDerivedProperty {
436 stage: "centroid",
437 detail: format!(
438 "centroid = ({}, {}) from first_x={}, first_y={}, total_area={}",
439 centroid.x, centroid.y, first_x, first_y, total_area
440 ),
441 });
442 }
443
444 let mut ix_c = 0.0_f64;
450 let mut iy_c = 0.0_f64;
451 let mut ixy_c = 0.0_f64;
452 for &(n, area, cx, cy, ix_i, iy_i, ixy_i) in &comp_data {
453 let dx = cx - centroid.x;
454 let dy = cy - centroid.y;
455 ix_c += n * (ix_i + area * dy * dy);
456 iy_c += n * (iy_i + area * dx * dx);
457 ixy_c += n * (ixy_i + area * dx * dy);
458 }
459 if !ix_c.is_finite() || !iy_c.is_finite() || !ixy_c.is_finite() {
460 return Err(CompositeError::NonFiniteDerivedProperty {
461 stage: "centroidal_inertia",
462 detail: format!(
463 "ix_c={}, iy_c={}, ixy_c={} (centroid=({}, {}), total_area={})",
464 ix_c, iy_c, ixy_c, centroid.x, centroid.y, total_area
465 ),
466 });
467 }
468
469 let avg = (ix_c + iy_c) * 0.5;
471 let diff = (ix_c - iy_c) * 0.5;
472 let radius = (diff * diff + ixy_c * ixy_c).sqrt();
473 let i11 = avg + radius;
474 let i22 = avg - radius;
475 let phi = 0.5 * (2.0 * ixy_c).atan2(ix_c - iy_c);
476 if !i11.is_finite() || !i22.is_finite() || !phi.is_finite() {
477 return Err(CompositeError::NonFiniteDerivedProperty {
478 stage: "principal_axes",
479 detail: format!(
480 "i11={}, i22={}, phi={} (ix_c={}, iy_c={}, ixy_c={})",
481 i11, i22, phi, ix_c, iy_c, ixy_c
482 ),
483 });
484 }
485
486 Ok(CompositeAnalysisResult {
487 area: total_area,
488 centroid,
489 ix: ix_c,
490 iy: iy_c,
491 ixy: ixy_c,
492 principal_i11: i11,
493 principal_i22: i22,
494 principal_phi: phi,
495 reference_material: *reference_material,
496 components: component_results,
497 })
498 }
499
500 pub fn analyze_with_first_reference(&self) -> Result<CompositeAnalysisResult, CompositeError> {
506 let ref_mat = self
507 .components
508 .first()
509 .map(|c| c.material)
510 .ok_or(CompositeError::NoComponents)?;
511 self.analyze(&ref_mat)
512 }
513}
514
515#[cfg(test)]
516mod tests {
517 use super::*;
518 use crate::material::presets::*;
519 use crate::{Point, Polygon};
520
521 fn rect_section(x0: f64, y0: f64, w: f64, h: f64) -> Section {
522 Section::new(
523 Polygon::new(vec![
524 Point::new(x0, y0),
525 Point::new(x0 + w, y0),
526 Point::new(x0 + w, y0 + h),
527 Point::new(x0, y0 + h),
528 ]),
529 Vec::new(),
530 )
531 }
532
533 #[test]
534 fn single_material_degeneration() {
535 let sec = rect_section(0.0, 0.0, 0.3, 0.5);
536 let comp = ElasticComposite::new(vec![
537 CompositeComponent::new(sec.clone(), CONCRETE_C30_37).unwrap(),
538 ])
539 .unwrap();
540
541 let result = comp.analyze(&CONCRETE_C30_37).unwrap();
542 let homogeneous = SectionProperties::from_section(&sec);
543
544 let tol = 1e-10;
545 assert!((result.area - homogeneous.area).abs() < tol);
546 assert!((result.ix - homogeneous.ix).abs() < tol);
547 assert!((result.iy - homogeneous.iy).abs() < tol);
548 assert!((result.ixy - homogeneous.ixy).abs() < tol);
549 }
550
551 #[test]
552 fn two_material_rectangular_analytical() {
553 let e_ref = 30e9;
559 let e_bottom = 30e9;
560 let e_top = 60e9;
561
562 let mat_ref = Material::new(e_ref, 0.2, 2400.0, "ref");
563 let mat_bottom = Material::new(e_bottom, 0.2, 2400.0, "bottom");
564 let mat_top = Material::new(e_top, 0.2, 2400.0, "top");
565
566 let bottom = rect_section(0.0, 0.0, 0.2, 0.1);
567 let top = rect_section(0.0, 0.1, 0.2, 0.1);
568
569 let comp = ElasticComposite::new(vec![
570 CompositeComponent::new(bottom, mat_bottom).unwrap(),
571 CompositeComponent::new(top, mat_top).unwrap(),
572 ])
573 .unwrap();
574
575 let result = comp.analyze(&mat_ref).unwrap();
576
577 let a_bottom = 0.2 * 0.1_f64;
580 let a_top = 0.2 * 0.1_f64;
581 let n_bottom = e_bottom / e_ref;
582 let n_top = e_top / e_ref;
583 let a_transformed = n_bottom * a_bottom + n_top * a_top;
584 assert!((result.area - a_transformed).abs() < 1e-12);
585
586 let y_bar = (n_bottom * a_bottom * 0.05 + n_top * a_top * 0.15) / a_transformed;
588 assert!((result.centroid.y - y_bar).abs() < 1e-12);
589 assert!((result.centroid.x - 0.1).abs() < 1e-12);
590
591 let ix_bottom_local = 0.2 * 0.1_f64.powi(3) / 12.0;
594 let ix_top_local = 0.2 * 0.1_f64.powi(3) / 12.0;
595 let ix_analytical = n_bottom * (ix_bottom_local + a_bottom * (0.05 - y_bar).powi(2))
596 + n_top * (ix_top_local + a_top * (0.15 - y_bar).powi(2));
597 assert!((result.ix - ix_analytical).abs() < 1e-12);
598
599 let iy_bottom_local = 0.1 * 0.2_f64.powi(3) / 12.0;
601 let iy_top_local = 0.1 * 0.2_f64.powi(3) / 12.0;
602 let iy_analytical = n_bottom * iy_bottom_local + n_top * iy_top_local;
603 assert!((result.iy - iy_analytical).abs() < 1e-12);
604
605 assert!(result.ixy.abs() < 1e-12);
607 }
608
609 #[test]
610 fn steel_concrete_composite() {
611 let slab = rect_section(0.0, 0.0, 0.3, 0.15);
612 let steel = rect_section(0.05, 0.15, 0.2, 0.01);
613
614 let comp = ElasticComposite::new(vec![
615 CompositeComponent::new(slab, CONCRETE_C30_37).unwrap(),
616 CompositeComponent::new(steel, STEEL_S355).unwrap(),
617 ])
618 .unwrap();
619
620 let result = comp.analyze(&CONCRETE_C30_37).unwrap();
622
623 let n_steel = STEEL_S355.youngs_modulus / CONCRETE_C30_37.youngs_modulus;
624 let n_conc = 1.0_f64;
625
626 assert!((result.components[0].modular_ratio - n_conc).abs() < 1e-10);
628 assert!((result.components[1].modular_ratio - n_steel).abs() < 1e-10);
629
630 let a_conc = 0.3 * 0.15;
632 let a_steel = 0.2 * 0.01;
633 let expected_area = n_conc * a_conc + n_steel * a_steel;
634 assert!((result.area - expected_area).abs() / expected_area < 1e-10);
635
636 assert!((result.components[0].original_area - a_conc).abs() < 1e-12);
638 assert!((result.components[1].original_area - a_steel).abs() < 1e-12);
639
640 assert!((result.components[0].transformed_area - n_conc * a_conc).abs() < 1e-12);
642 assert!((result.components[1].transformed_area - n_steel * a_steel).abs() < 1e-12);
643 }
644
645 #[test]
646 fn reference_material_reversal() {
647 let slab = rect_section(0.0, 0.0, 0.3, 0.15);
650 let steel = rect_section(0.15, 0.15, 0.2, 0.01);
651
652 let comp = ElasticComposite::new(vec![
653 CompositeComponent::new(slab, CONCRETE_C30_37).unwrap(),
654 CompositeComponent::new(steel, STEEL_S355).unwrap(),
655 ])
656 .unwrap();
657
658 let r_conc = comp.analyze(&CONCRETE_C30_37).unwrap();
659 let r_steel = comp.analyze(&STEEL_S355).unwrap();
660
661 let ea_conc = CONCRETE_C30_37.youngs_modulus * r_conc.area;
664 let ea_steel = STEEL_S355.youngs_modulus * r_steel.area;
665 assert!((ea_conc - ea_steel).abs() / ea_conc < 1e-10);
666
667 let ei_conc = CONCRETE_C30_37.youngs_modulus * r_conc.ix;
669 let ei_steel = STEEL_S355.youngs_modulus * r_steel.ix;
670 assert!((ei_conc - ei_steel).abs() / ei_conc < 1e-10);
671
672 let eiy_conc = CONCRETE_C30_37.youngs_modulus * r_conc.iy;
674 let eiy_steel = STEEL_S355.youngs_modulus * r_steel.iy;
675 assert!((eiy_conc - eiy_steel).abs() / eiy_conc < 1e-10);
676
677 let eixy_conc = CONCRETE_C30_37.youngs_modulus * r_conc.ixy;
679 let eixy_steel = STEEL_S355.youngs_modulus * r_steel.ixy;
680 assert!((eixy_conc - eixy_steel).abs() < 1e-3);
681
682 assert!((r_conc.centroid.x - r_steel.centroid.x).abs() < 1e-10);
684 assert!((r_conc.centroid.y - r_steel.centroid.y).abs() < 1e-10);
685 }
686
687 #[test]
688 fn symmetric_composite() {
689 let left = rect_section(-0.15, -0.1, 0.1, 0.2);
699 let right = rect_section(0.05, -0.1, 0.1, 0.2);
700
701 let mat = Material::new(30e9, 0.2, 2400.0, "same");
702
703 let comp = ElasticComposite::new(vec![
704 CompositeComponent::new(left, mat).unwrap(),
705 CompositeComponent::new(right, mat).unwrap(),
706 ])
707 .unwrap();
708
709 let result = comp.analyze(&mat).unwrap();
710
711 assert!(result.centroid.x.abs() < 1e-12);
713 assert!(result.centroid.y.abs() < 1e-12);
714
715 assert!(result.ixy.abs() < 1e-12);
717 }
718
719 #[test]
720 fn material_position_sensitivity() {
721 let e_soft = 30e9;
727 let e_stiff = 200e9;
728 let mat_soft = Material::new(e_soft, 0.2, 2400.0, "soft");
729 let mat_stiff = Material::new(e_stiff, 0.2, 2400.0, "stiff");
730
731 let bottom = rect_section(0.0, 0.0, 0.2, 0.1);
732 let top = rect_section(0.0, 0.1, 0.2, 0.1);
733
734 let comp_a = ElasticComposite::new(vec![
736 CompositeComponent::new(bottom.clone(), mat_soft).unwrap(),
737 CompositeComponent::new(top.clone(), mat_stiff).unwrap(),
738 ])
739 .unwrap();
740 let result_a = comp_a.analyze(&mat_soft).unwrap();
741
742 let comp_b = ElasticComposite::new(vec![
744 CompositeComponent::new(bottom, mat_stiff).unwrap(),
745 CompositeComponent::new(top, mat_soft).unwrap(),
746 ])
747 .unwrap();
748 let result_b = comp_b.analyze(&mat_soft).unwrap();
749
750 assert!(
753 result_a.centroid.y > 0.1,
754 "centroid should shift towards stiff top"
755 );
756 assert!(
758 result_b.centroid.y < 0.1,
759 "centroid should shift towards stiff bottom"
760 );
761
762 assert!((result_a.centroid.y - result_b.centroid.y).abs() > 0.01);
764
765 assert!((result_a.ix - result_b.ix).abs() < 1e-10);
767
768 let total_transformed_area = result_a.area;
772 let single_mat_ix = 0.2 * 0.2_f64.powi(3) / 12.0 * (total_transformed_area / (0.2 * 0.2));
773 assert!((result_a.ix - single_mat_ix).abs() > 1e-6);
774 }
775
776 #[test]
777 fn geometric_scaling() {
778 let e1 = 30e9;
779 let e2 = 200e9;
780 let mat1 = Material::new(e1, 0.2, 2400.0, "m1");
781 let mat2 = Material::new(e2, 0.3, 7850.0, "m2");
782
783 let alpha = 2.5_f64;
784
785 let s1 = rect_section(0.0, 0.0, 0.2, 0.1);
787 let s2 = rect_section(0.1, 0.1, 0.1, 0.05);
788
789 let comp_orig = ElasticComposite::new(vec![
790 CompositeComponent::new(s1.clone(), mat1).unwrap(),
791 CompositeComponent::new(s2.clone(), mat2).unwrap(),
792 ])
793 .unwrap();
794 let r_orig = comp_orig.analyze(&mat1).unwrap();
795
796 let s1_scaled = rect_section(0.0, 0.0, 0.2 * alpha, 0.1 * alpha);
798 let s2_scaled = rect_section(0.1 * alpha, 0.1 * alpha, 0.1 * alpha, 0.05 * alpha);
799
800 let comp_scaled = ElasticComposite::new(vec![
801 CompositeComponent::new(s1_scaled, mat1).unwrap(),
802 CompositeComponent::new(s2_scaled, mat2).unwrap(),
803 ])
804 .unwrap();
805 let r_scaled = comp_scaled.analyze(&mat1).unwrap();
806
807 assert!((r_scaled.area / r_orig.area - alpha * alpha).abs() < 1e-10);
809 assert!((r_scaled.centroid.x / r_orig.centroid.x - alpha).abs() < 1e-10);
811 assert!((r_scaled.centroid.y / r_orig.centroid.y - alpha).abs() < 1e-10);
812 assert!((r_scaled.ix / r_orig.ix - alpha.powi(4)).abs() < 1e-10);
814 assert!((r_scaled.iy / r_orig.iy - alpha.powi(4)).abs() < 1e-10);
815 assert!((r_scaled.ixy / r_orig.ixy - alpha.powi(4)).abs() < 1e-10);
816 }
817
818 #[test]
819 fn invalid_modulus_zero() {
820 let sec = rect_section(0.0, 0.0, 0.1, 0.1);
821 let mat = Material::new(0.0, 0.2, 2400.0, "zero E");
822 assert!(CompositeComponent::new(sec, mat).is_err());
823 }
824
825 #[test]
826 fn invalid_modulus_negative() {
827 let sec = rect_section(0.0, 0.0, 0.1, 0.1);
828 let mat = Material::new(-1e9, 0.2, 2400.0, "negative E");
829 assert!(CompositeComponent::new(sec, mat).is_err());
830 }
831
832 #[test]
833 fn invalid_modulus_nan() {
834 let sec = rect_section(0.0, 0.0, 0.1, 0.1);
835 let mat = Material::new(f64::NAN, 0.2, 2400.0, "NaN E");
836 assert!(CompositeComponent::new(sec, mat).is_err());
837 }
838
839 #[test]
840 fn invalid_modulus_infinity() {
841 let sec = rect_section(0.0, 0.0, 0.1, 0.1);
842 let mat = Material::new(f64::INFINITY, 0.2, 2400.0, "inf E");
843 assert!(CompositeComponent::new(sec, mat).is_err());
844 }
845
846 #[test]
847 fn invalid_reference_material() {
848 let sec = rect_section(0.0, 0.0, 0.1, 0.1);
849 let mat = Material::new(200e9, 0.3, 7850.0, "steel");
850 let comp = ElasticComposite::new(vec![CompositeComponent::new(sec, mat).unwrap()]).unwrap();
851
852 let bad_ref = Material::new(0.0, 0.2, 2400.0, "zero");
853 assert!(comp.analyze(&bad_ref).is_err());
854
855 let nan_ref = Material::new(f64::NAN, 0.2, 2400.0, "nan");
856 assert!(comp.analyze(&nan_ref).is_err());
857 }
858
859 #[test]
860 fn empty_components_rejected() {
861 let result = ElasticComposite::new(Vec::new());
862 assert!(result.is_err());
863 }
864
865 #[test]
866 fn original_geometry_preserved() {
867 let sec = rect_section(0.0, 0.0, 0.3, 0.5);
868 let sec_clone = sec.clone();
869 let mat = Material::new(30e9, 0.2, 2400.0, "concrete");
870
871 let comp = ElasticComposite::new(vec![CompositeComponent::new(sec, mat).unwrap()]).unwrap();
872
873 let _ = comp.analyze(&mat).unwrap();
874
875 let stored = comp.component(0).unwrap();
877 assert_eq!(stored.section.area(), sec_clone.area());
878 assert_eq!(stored.section.centroid().x, sec_clone.centroid().x);
879 assert_eq!(stored.section.centroid().y, sec_clone.centroid().y);
880 }
881
882 #[test]
885 fn composite_with_holes() {
886 let outer = Polygon::new(vec![
888 Point::new(0.0, 0.0),
889 Point::new(0.4, 0.0),
890 Point::new(0.4, 0.3),
891 Point::new(0.0, 0.3),
892 ]);
893 let hole = Polygon::new(vec![
894 Point::new(0.1, 0.05),
895 Point::new(0.3, 0.05),
896 Point::new(0.3, 0.25),
897 Point::new(0.1, 0.25),
898 ]);
899 let section = Section::new(outer, vec![hole]);
900 let mat = Material::new(200e9, 0.3, 7850.0, "steel");
901
902 let comp =
903 ElasticComposite::new(vec![CompositeComponent::new(section.clone(), mat).unwrap()])
904 .unwrap();
905 let result = comp.analyze(&mat).unwrap();
906 let homogeneous = SectionProperties::from_section(§ion);
907
908 let tol = 1e-10;
910 assert!((result.area - homogeneous.area).abs() < tol);
911 assert!((result.ix - homogeneous.ix).abs() < tol);
912 assert!((result.iy - homogeneous.iy).abs() < tol);
913 assert!((result.ixy - homogeneous.ixy).abs() < tol);
914
915 assert!((result.area - 0.08).abs() < 1e-10);
917 }
918
919 #[test]
920 fn three_material_components() {
921 let mat1 = Material::new(30e9, 0.2, 2400.0, "concrete");
923 let mat2 = Material::new(200e9, 0.3, 7850.0, "steel");
924 let mat3 = Material::new(70e9, 0.33, 2700.0, "aluminum");
925
926 let s1 = rect_section(0.0, 0.0, 0.3, 0.1);
927 let s2 = rect_section(0.0, 0.1, 0.2, 0.05);
928 let s3 = rect_section(0.0, 0.15, 0.25, 0.08);
929
930 let comp = ElasticComposite::new(vec![
931 CompositeComponent::new(s1, mat1).unwrap(),
932 CompositeComponent::new(s2, mat2).unwrap(),
933 CompositeComponent::new(s3, mat3).unwrap(),
934 ])
935 .unwrap();
936
937 assert_eq!(comp.n_components(), 3);
938
939 let result = comp.analyze(&mat1).unwrap();
940 assert!(result.area > 0.0);
941 assert!(result.ix > 0.0);
942 assert_eq!(result.components.len(), 3);
943
944 assert!((result.components[0].modular_ratio - 1.0).abs() < 1e-10);
946 assert!((result.components[1].modular_ratio - 200.0 / 30.0).abs() < 1e-10);
947 assert!((result.components[2].modular_ratio - 70.0 / 30.0).abs() < 1e-10);
948
949 let expected_area =
951 1.0 * (0.3 * 0.1) + (200.0 / 30.0) * (0.2 * 0.05) + (70.0 / 30.0) * (0.25 * 0.08);
952 assert!((result.area - expected_area).abs() / expected_area < 1e-10);
953
954 let r2 = comp.analyze(&mat2).unwrap();
956 let ea1 = mat1.youngs_modulus * result.area;
957 let ea2 = mat2.youngs_modulus * r2.area;
958 assert!((ea1 - ea2).abs() / ea1 < 1e-10);
959 }
960
961 #[test]
962 fn reference_not_present_in_components() {
963 let mat1 = Material::new(30e9, 0.2, 2400.0, "concrete");
965 let mat2 = Material::new(200e9, 0.3, 7850.0, "steel");
966 let mat_ref = Material::new(100e9, 0.25, 5000.0, "reference");
967
968 let s1 = rect_section(0.0, 0.0, 0.2, 0.1);
969 let s2 = rect_section(0.0, 0.1, 0.2, 0.1);
970
971 let comp = ElasticComposite::new(vec![
972 CompositeComponent::new(s1, mat1).unwrap(),
973 CompositeComponent::new(s2, mat2).unwrap(),
974 ])
975 .unwrap();
976
977 let result = comp.analyze(&mat_ref).unwrap();
978
979 assert!((result.components[0].modular_ratio - 0.3).abs() < 1e-10);
981 assert!((result.components[1].modular_ratio - 2.0).abs() < 1e-10);
982
983 let r_conc = comp.analyze(&mat1).unwrap();
985 let ea_ref = mat_ref.youngs_modulus * result.area;
986 let ea_conc = mat1.youngs_modulus * r_conc.area;
987 assert!((ea_ref - ea_conc).abs() / ea_conc < 1e-10);
988 }
989
990 #[test]
991 fn asymmetric_principal_axes() {
992 let vert = rect_section(0.0, 0.0, 0.02, 0.2);
996 let horiz = rect_section(0.0, 0.0, 0.1, 0.02);
997
998 let mat_steel = Material::new(200e9, 0.3, 7850.0, "steel");
999 let mat_conc = Material::new(30e9, 0.2, 2400.0, "concrete");
1000
1001 let comp = ElasticComposite::new(vec![
1002 CompositeComponent::new(vert, mat_steel).unwrap(),
1003 CompositeComponent::new(horiz, mat_conc).unwrap(),
1004 ])
1005 .unwrap();
1006
1007 let result = comp.analyze(&mat_steel).unwrap();
1008
1009 assert!(
1011 result.ixy.abs() > 1e-8,
1012 "Ixy should be non-zero for asymmetric section"
1013 );
1014
1015 assert!(result.principal_i11 >= result.principal_i22);
1017
1018 let sum_principal = result.principal_i11 + result.principal_i22;
1021 let sum_centroidal = result.ix + result.iy;
1022 assert!((sum_principal - sum_centroidal).abs() < 1e-10);
1023
1024 assert!(
1026 result.principal_phi.abs() > 1e-6,
1027 "principal angle should be non-zero"
1028 );
1029
1030 let expected_phi = 0.5 * (2.0 * result.ixy).atan2(result.ix - result.iy);
1033 assert!((result.principal_phi - expected_phi).abs() < 1e-10);
1034 }
1035
1036 #[test]
1039 fn translation_invariance() {
1040 let mat1 = Material::new(30e9, 0.2, 2400.0, "concrete");
1043 let mat2 = Material::new(200e9, 0.3, 7850.0, "steel");
1044
1045 let s1 = rect_section(0.0, 0.0, 0.3, 0.15);
1046 let s2 = rect_section(0.05, 0.15, 0.2, 0.01);
1047
1048 let comp_orig = ElasticComposite::new(vec![
1049 CompositeComponent::new(s1, mat1).unwrap(),
1050 CompositeComponent::new(s2, mat2).unwrap(),
1051 ])
1052 .unwrap();
1053 let r_orig = comp_orig.analyze(&mat1).unwrap();
1054
1055 let dx = 1.7;
1057 let dy = -0.4;
1058
1059 let s1_t = rect_section(dx, dy, 0.3, 0.15);
1060 let s2_t = rect_section(0.05 + dx, 0.15 + dy, 0.2, 0.01);
1061
1062 let comp_t = ElasticComposite::new(vec![
1063 CompositeComponent::new(s1_t, mat1).unwrap(),
1064 CompositeComponent::new(s2_t, mat2).unwrap(),
1065 ])
1066 .unwrap();
1067 let r_t = comp_t.analyze(&mat1).unwrap();
1068
1069 assert!((r_t.centroid.x - (r_orig.centroid.x + dx)).abs() < 1e-10);
1071 assert!((r_t.centroid.y - (r_orig.centroid.y + dy)).abs() < 1e-10);
1072
1073 assert!((r_t.ix - r_orig.ix).abs() < 1e-10);
1075 assert!((r_t.iy - r_orig.iy).abs() < 1e-10);
1076 assert!((r_t.ixy - r_orig.ixy).abs() < 1e-10);
1077 assert!((r_t.principal_i11 - r_orig.principal_i11).abs() < 1e-10);
1078 assert!((r_t.principal_i22 - r_orig.principal_i22).abs() < 1e-10);
1079 }
1080
1081 #[test]
1082 fn multi_component_identical_material_degeneration() {
1083 let mat = Material::new(200e9, 0.3, 7850.0, "steel");
1086
1087 let s1 = rect_section(0.0, 0.0, 0.2, 0.1);
1089 let s2 = rect_section(0.3, 0.0, 0.15, 0.1);
1090
1091 let comp = ElasticComposite::new(vec![
1092 CompositeComponent::new(s1.clone(), mat).unwrap(),
1093 CompositeComponent::new(s2.clone(), mat).unwrap(),
1094 ])
1095 .unwrap();
1096 let r_comp = comp.analyze(&mat).unwrap();
1097
1098 use crate::geometry::{CompoundGeometry, Geometry};
1100 let g1 = Geometry::new(s1.outer, s1.holes);
1101 let g2 = Geometry::new(s2.outer, s2.holes);
1102 let compound = CompoundGeometry::new(vec![g1, g2]);
1103 let r_homogeneous = SectionProperties::from_compound(&compound);
1104
1105 let tol = 1e-10;
1106 assert!((r_comp.area - r_homogeneous.area).abs() < tol);
1107 assert!((r_comp.centroid.x - r_homogeneous.centroid.x).abs() < tol);
1108 assert!((r_comp.centroid.y - r_homogeneous.centroid.y).abs() < tol);
1109 assert!((r_comp.ix - r_homogeneous.ix).abs() < tol);
1110 assert!((r_comp.iy - r_homogeneous.iy).abs() < tol);
1111 assert!((r_comp.ixy - r_homogeneous.ixy).abs() < tol);
1112 assert!((r_comp.principal_i11 - r_homogeneous.principal.i11).abs() < tol);
1113 assert!((r_comp.principal_i22 - r_homogeneous.principal.i22).abs() < tol);
1114 }
1115
1116 #[test]
1117 fn reference_modulus_scaling() {
1118 let mat1 = Material::new(30e9, 0.2, 2400.0, "concrete");
1120 let mat2 = Material::new(200e9, 0.3, 7850.0, "steel");
1121
1122 let s1 = rect_section(0.0, 0.0, 0.3, 0.15);
1123 let s2 = rect_section(0.05, 0.15, 0.2, 0.01);
1124
1125 let comp = ElasticComposite::new(vec![
1126 CompositeComponent::new(s1, mat1).unwrap(),
1127 CompositeComponent::new(s2, mat2).unwrap(),
1128 ])
1129 .unwrap();
1130
1131 let r1 = comp.analyze(&mat1).unwrap();
1132
1133 let k = 1e6;
1135 let mat_scaled = Material::new(mat1.youngs_modulus * k, 0.2, 2400.0, "scaled");
1136 let r2 = comp.analyze(&mat_scaled).unwrap();
1137
1138 assert!((r2.area * k - r1.area).abs() / r1.area < 1e-10);
1140 assert!((r2.ix * k - r1.ix).abs() / r1.ix < 1e-10);
1142 assert!((r2.iy * k - r1.iy).abs() / r1.iy < 1e-10);
1143
1144 let ea1 = mat1.youngs_modulus * r1.area;
1146 let ea2 = mat_scaled.youngs_modulus * r2.area;
1147 assert!((ea1 - ea2).abs() / ea1 < 1e-10);
1148
1149 let ei1 = mat1.youngs_modulus * r1.ix;
1150 let ei2 = mat_scaled.youngs_modulus * r2.ix;
1151 assert!((ei1 - ei2).abs() / ei1 < 1e-10);
1152
1153 assert!((r1.centroid.x - r2.centroid.x).abs() < 1e-10);
1155 assert!((r1.centroid.y - r2.centroid.y).abs() < 1e-10);
1156 }
1157
1158 #[test]
1159 fn near_identical_materials_continuity() {
1160 let e = 200e9;
1163 let mat_base = Material::new(e, 0.3, 7850.0, "base");
1164
1165 let s1 = rect_section(0.0, 0.0, 0.2, 0.1);
1166 let s2 = rect_section(0.0, 0.1, 0.2, 0.1);
1167
1168 let comp_single = ElasticComposite::new(vec![
1170 CompositeComponent::new(s1.clone(), mat_base).unwrap(),
1171 CompositeComponent::new(s2.clone(), mat_base).unwrap(),
1172 ])
1173 .unwrap();
1174 let r_single = comp_single.analyze(&mat_base).unwrap();
1175
1176 let eps = 1e-12;
1178 let mat_near = Material::new(e * (1.0 + eps), 0.3, 7850.0, "near");
1179 let comp_near = ElasticComposite::new(vec![
1180 CompositeComponent::new(s1, mat_base).unwrap(),
1181 CompositeComponent::new(s2, mat_near).unwrap(),
1182 ])
1183 .unwrap();
1184 let r_near = comp_near.analyze(&mat_base).unwrap();
1185
1186 assert!((r_near.area - r_single.area).abs() / r_single.area < 1e-10);
1188 assert!((r_near.ix - r_single.ix).abs() / r_single.ix < 1e-10);
1189 assert!((r_near.centroid.y - r_single.centroid.y).abs() < 1e-10);
1190 }
1191
1192 #[test]
1193 fn p1_01_reproduce_modular_ratio_overflow() {
1194 let sec = rect_section(0.0, 0.0, 0.3, 0.5);
1195 let mat_huge = Material::new(1e308, 0.3, 7850.0, "huge");
1196 let mat_tiny = Material::new(1e-308, 0.3, 7850.0, "tiny");
1197 let comp =
1198 ElasticComposite::new(vec![CompositeComponent::new(sec, mat_huge).unwrap()]).unwrap();
1199 let result = comp.analyze(&mat_tiny);
1200 match result {
1201 Ok(r) => panic!(
1202 "P1-01 NOT fixed: expected Err but got Ok with area={}, ix={}",
1203 r.area, r.ix
1204 ),
1205 Err(e) => println!("P1-01 confirmed: got Err = {:?}", e),
1206 }
1207 }
1208
1209 #[test]
1210 fn p1_01_large_but_finite_modular_ratio() {
1211 let sec = rect_section(0.0, 0.0, 0.3, 0.5);
1212 let mat_huge = Material::new(1e20, 0.3, 7850.0, "huge");
1213 let mat_tiny = Material::new(1e-10, 0.3, 7850.0, "tiny");
1214 let comp =
1215 ElasticComposite::new(vec![CompositeComponent::new(sec, mat_huge).unwrap()]).unwrap();
1216 let result = comp.analyze(&mat_tiny).unwrap();
1217 assert!(result.area.is_finite(), "area should be finite");
1218 assert!(result.ix.is_finite(), "ix should be finite");
1219 assert!(result.principal_i11.is_finite(), "i11 should be finite");
1220 assert!(result.principal_i22.is_finite(), "i22 should be finite");
1221 }
1222
1223 #[test]
1224 fn p0_01_reproduce_principal_axis_overflow() {
1225 let mat = Material::new(1.0, 0.0, 1.0, "unit");
1226 let s1 = rect_section(0.0, 1e100, 0.1, 1e90);
1227 let s2 = rect_section(0.0, -1e100, 0.1, 1e90);
1228 let comp = ElasticComposite::new(vec![
1229 CompositeComponent::new(s1, mat).unwrap(),
1230 CompositeComponent::new(s2, mat).unwrap(),
1231 ])
1232 .unwrap();
1233 let result = comp.analyze(&mat);
1234 match result {
1235 Ok(r) => panic!(
1236 "P0-01 NOT fixed: expected Err but got Ok with i11={}, i22={}",
1237 r.principal_i11, r.principal_i22
1238 ),
1239 Err(CompositeError::NonFiniteDerivedProperty { stage, .. }) => {
1240 println!("P0-01 confirmed: stage = {stage}");
1241 assert!(stage == "principal_axes" || stage == "centroidal_inertia");
1242 }
1243 Err(e) => panic!("P0-01 unexpected error: {e:?}"),
1244 }
1245 }
1246
1247 #[test]
1248 fn p0_01_normal_composite_not_rejected() {
1249 let mat = Material::new(1.0, 0.0, 1.0, "unit");
1250 let s1 = rect_section(0.0, 1e10, 0.1, 0.1);
1251 let s2 = rect_section(0.0, -1e10, 0.1, 0.1);
1252 let comp = ElasticComposite::new(vec![
1253 CompositeComponent::new(s1, mat).unwrap(),
1254 CompositeComponent::new(s2, mat).unwrap(),
1255 ])
1256 .unwrap();
1257 let result = comp.analyze(&mat).unwrap();
1258 assert!(result.area.is_finite());
1259 assert!(result.ix.is_finite());
1260 assert!(result.iy.is_finite());
1261 assert!(result.ixy.is_finite());
1262 assert!(result.principal_i11.is_finite());
1263 assert!(result.principal_i22.is_finite());
1264 assert!(result.principal_phi.is_finite());
1265 assert!(result.centroid.x.is_finite());
1266 assert!(result.centroid.y.is_finite());
1267 }
1268
1269 #[test]
1270 fn p0_02_all_finite_results_invariant() {
1271 let mat1 = Material::new(30e9, 0.2, 2400.0, "concrete");
1272 let mat2 = Material::new(200e9, 0.3, 7850.0, "steel");
1273 let s1 = rect_section(0.0, 0.0, 0.3, 0.5);
1274 let s2 = rect_section(0.1, 0.1, 0.05, 0.3);
1275 let comp = ElasticComposite::new(vec![
1276 CompositeComponent::new(s1, mat1).unwrap(),
1277 CompositeComponent::new(s2, mat2).unwrap(),
1278 ])
1279 .unwrap();
1280 let r = comp.analyze(&mat1).unwrap();
1281 assert!(r.area.is_finite());
1282 assert!(r.centroid.x.is_finite());
1283 assert!(r.centroid.y.is_finite());
1284 assert!(r.ix.is_finite());
1285 assert!(r.iy.is_finite());
1286 assert!(r.ixy.is_finite());
1287 assert!(r.principal_i11.is_finite());
1288 assert!(r.principal_i22.is_finite());
1289 assert!(r.principal_phi.is_finite());
1290 }
1291
1292 #[test]
1293 fn p2_01_case_a_modular_ratio_overflow_variant() {
1294 let sec = rect_section(0.0, 0.0, 0.3, 0.5);
1295 let mat_huge = Material::new(1e308, 0.3, 7850.0, "huge");
1296 let mat_tiny = Material::new(1e-308, 0.3, 7850.0, "tiny");
1297 let comp =
1298 ElasticComposite::new(vec![CompositeComponent::new(sec, mat_huge).unwrap()]).unwrap();
1299 let result = comp.analyze(&mat_tiny);
1300 assert!(
1301 matches!(result, Err(CompositeError::NonFiniteModularRatio { .. })),
1302 "Case A: expected NonFiniteModularRatio, got {:?}",
1303 result
1304 );
1305 }
1306
1307 #[test]
1308 fn p2_01_case_b_accumulation_overflow_variant() {
1309 let mat = Material::new(1.0, 0.0, 1.0, "unit");
1310 let s = rect_section(0.0, 1e200, 1e-10, 1e190);
1311 let comp = ElasticComposite::new(vec![CompositeComponent::new(s, mat).unwrap()]).unwrap();
1312 let result = comp.analyze(&mat);
1313 assert!(
1314 matches!(
1315 result,
1316 Err(CompositeError::NonFiniteDerivedProperty {
1317 stage: "weighted_accumulation",
1318 ..
1319 })
1320 ),
1321 "Case B: expected NonFiniteDerivedProperty {{ stage: \"weighted_accumulation\" }}, got {:?}",
1322 result
1323 );
1324 }
1325
1326 #[test]
1327 fn p2_01_case_c_finite_input_ok() {
1328 let mat1 = Material::new(30e9, 0.2, 2400.0, "concrete");
1329 let mat2 = Material::new(200e9, 0.3, 7850.0, "steel");
1330 let s1 = rect_section(0.0, 0.0, 0.3, 0.5);
1331 let s2 = rect_section(0.1, 0.1, 0.05, 0.3);
1332 let comp = ElasticComposite::new(vec![
1333 CompositeComponent::new(s1, mat1).unwrap(),
1334 CompositeComponent::new(s2, mat2).unwrap(),
1335 ])
1336 .unwrap();
1337 let result = comp.analyze(&mat1);
1338 assert!(
1339 matches!(result, Ok(_)),
1340 "Case C: expected Ok for finite inputs, got {:?}",
1341 result
1342 );
1343 }
1344
1345 fn rect_ix_local(b: f64, h: f64) -> f64 {
1347 b * h * h * h / 12.0
1348 }
1349
1350 fn rect_iy_local(b: f64, h: f64) -> f64 {
1352 h * b * b * b / 12.0
1353 }
1354
1355 #[test]
1356 fn composite_centroidal_inertia_stable_at_large_translation() {
1357 let b = 0.1_f64;
1358 let h = 0.1_f64;
1359 let ix_true = rect_ix_local(b, h);
1360 let iy_true = rect_iy_local(b, h);
1361 let mat = Material::new(1.0, 0.0, 1.0, "unit");
1362
1363 let scales: [f64; 7] = [1e0, 1e2, 1e4, 1e6, 1e8, 1e10, 1e12];
1364
1365 for &y in &scales {
1366 let sec = rect_section(0.0, y, b, h);
1367 let comp =
1368 ElasticComposite::new(vec![CompositeComponent::new(sec, mat).unwrap()]).unwrap();
1369 let r = comp.analyze(&mat).unwrap();
1370
1371 let ix_relerr = (r.ix - ix_true).abs() / ix_true;
1372 let iy_relerr = (r.iy - iy_true).abs() / iy_true;
1373
1374 assert!(
1375 r.ix.is_finite() && r.ix > 0.0,
1376 "Y={:.0e}: Ix={} should be finite and positive",
1377 y,
1378 r.ix
1379 );
1380 assert!(
1381 r.iy.is_finite() && r.iy > 0.0,
1382 "Y={:.0e}: Iy={} should be finite and positive",
1383 y,
1384 r.iy
1385 );
1386
1387 let tol = if y <= 1e8 { 1e-3 } else { 1e-1 };
1388 assert!(
1389 ix_relerr < tol,
1390 "Y={:.0e}: Ix relative error {:.2e} should be < {:.0e}",
1391 y,
1392 ix_relerr,
1393 tol
1394 );
1395 assert!(
1396 iy_relerr < tol,
1397 "Y={:.0e}: Iy relative error {:.2e} should be < {:.0e}",
1398 y,
1399 iy_relerr,
1400 tol
1401 );
1402 }
1403 }
1404
1405 #[test]
1406 fn composite_translation_invariance_at_large_scales() {
1407 let b = 0.1_f64;
1408 let h = 0.1_f64;
1409 let mat = Material::new(1.0, 0.0, 1.0, "unit");
1410
1411 let s1_base = rect_section(0.0, 0.0, b, h);
1412 let s2_base = rect_section(0.05, 0.05, b, h);
1413 let comp_base = ElasticComposite::new(vec![
1414 CompositeComponent::new(s1_base, mat).unwrap(),
1415 CompositeComponent::new(s2_base, mat).unwrap(),
1416 ])
1417 .unwrap();
1418 let r_base = comp_base.analyze(&mat).unwrap();
1419
1420 for &dy in &[1e4, 1e6, 1e8] {
1421 let s1 = rect_section(0.0, dy, b, h);
1422 let s2 = rect_section(0.05, dy + 0.05, b, h);
1423 let comp = ElasticComposite::new(vec![
1424 CompositeComponent::new(s1, mat).unwrap(),
1425 CompositeComponent::new(s2, mat).unwrap(),
1426 ])
1427 .unwrap();
1428 let r = comp.analyze(&mat).unwrap();
1429
1430 let ix_relerr = (r.ix - r_base.ix).abs() / r_base.ix;
1431 let iy_relerr = (r.iy - r_base.iy).abs() / r_base.iy;
1432
1433 let tol = if dy <= 1e6 { 1e-6 } else { 1e-3 };
1434 assert!(
1435 ix_relerr < tol,
1436 "dy={:.0e}: Ix relative error {:.2e} should be < {:.0e}",
1437 dy,
1438 ix_relerr,
1439 tol
1440 );
1441 assert!(
1442 iy_relerr < tol,
1443 "dy={:.0e}: Iy relative error {:.2e} should be < {:.0e}",
1444 dy,
1445 iy_relerr,
1446 tol
1447 );
1448 }
1449 }
1450
1451 #[test]
1452 fn composite_symmetric_pair_at_large_scales() {
1453 let b = 0.1_f64;
1454 let h = 0.1_f64;
1455 let area = b * h;
1456 let ix_local = rect_ix_local(b, h);
1457 let mat = Material::new(1.0, 0.0, 1.0, "unit");
1458
1459 for &y in &[1e4, 1e8, 1e12] {
1460 let s1 = rect_section(0.0, y, b, h);
1461 let s2 = rect_section(0.0, -y - h, b, h);
1462 let comp = ElasticComposite::new(vec![
1463 CompositeComponent::new(s1, mat).unwrap(),
1464 CompositeComponent::new(s2, mat).unwrap(),
1465 ])
1466 .unwrap();
1467 let r = comp.analyze(&mat).unwrap();
1468
1469 assert!(
1470 r.centroid.y.abs() < 1e-6,
1471 "Y={:.0e}: centroid.y={} should be ~0",
1472 y,
1473 r.centroid.y
1474 );
1475 assert!(
1476 r.ix > 0.0 && r.iy > 0.0,
1477 "Y={:.0e}: Ix={} and Iy={} should be positive",
1478 y,
1479 r.ix,
1480 r.iy
1481 );
1482
1483 let d = y + h / 2.0;
1484 let ix_ref = 2.0 * (ix_local + area * d * d);
1485 let ix_relerr = (r.ix - ix_ref).abs() / ix_ref;
1486 let tol = if y <= 1e8 { 1e-6 } else { 1e-3 };
1487 assert!(
1488 ix_relerr < tol,
1489 "Y={:.0e}: Ix relative error {:.2e} should be < {:.0e}",
1490 y,
1491 ix_relerr,
1492 tol
1493 );
1494 }
1495 }
1496
1497 #[test]
1498 fn composite_independent_reference_comparison() {
1499 let b = 0.1_f64;
1500 let h = 0.1_f64;
1501 let area = b * h;
1502 let ix_local = rect_ix_local(b, h);
1503 let iy_local = rect_iy_local(b, h);
1504 let mat = Material::new(1.0, 0.0, 1.0, "unit");
1505
1506 for &y in &[1e0, 1e4, 1e8, 1e12] {
1507 let sec = rect_section(0.0, y, b, h);
1508 let comp =
1509 ElasticComposite::new(vec![CompositeComponent::new(sec, mat).unwrap()]).unwrap();
1510 let r = comp.analyze(&mat).unwrap();
1511
1512 let cy_component = y + h / 2.0;
1513 let cx_component = 0.0 + b / 2.0;
1514 let total_area_ref = area;
1515 let cy_ref = cy_component;
1516 let cx_ref = cx_component;
1517 let dy = cy_component - cy_ref;
1518 let dx = cx_component - cx_ref;
1519 let ix_ref = ix_local + area * dy * dy;
1520 let iy_ref = iy_local + area * dx * dx;
1521
1522 let area_tol = if y <= 1e6 {
1523 1e-10
1524 } else if y <= 1e10 {
1525 1e-6
1526 } else {
1527 1e-3
1528 };
1529 assert!(
1530 (total_area_ref - r.area).abs() / total_area_ref < area_tol,
1531 "Y={:.0e}: area mismatch: r.area={:.6e} vs ref={:.6e}",
1532 y,
1533 r.area,
1534 total_area_ref
1535 );
1536
1537 let ix_relerr = (r.ix - ix_local).abs() / ix_local;
1538 let iy_relerr = (r.iy - iy_local).abs() / iy_local;
1539 let tol = if y <= 1e8 { 1e-3 } else { 1e-1 };
1540 assert!(
1541 ix_relerr < tol,
1542 "Y={:.0e}: Ix relerr {:.2e} vs analytical {:.6e}",
1543 y,
1544 ix_relerr,
1545 ix_local
1546 );
1547 assert!(
1548 iy_relerr < tol,
1549 "Y={:.0e}: Iy relerr {:.2e} vs analytical {:.6e}",
1550 y,
1551 iy_relerr,
1552 iy_local
1553 );
1554 }
1555 }
1556}