goad-py 0.4.1__tar.gz → 0.4.2__tar.gz

{goad_py-0.4.1 → goad_py-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: goad-py
-Version: 0.4.1
+Version: 0.4.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Physics

{goad_py-0.4.1 → goad_py-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "goad-py"
-version = "0.4.1"
+version = "0.4.2"
 description = "Physical optics light scattering computation"
 authors = [{name = "Harry Ballington", email = "ballington@uni-wuppertal.de"}]
 license = {text = "GPL-3.0"}

{goad_py-0.4.1 → goad_py-0.4.2}/src/beam.rs

@@ -360,7 +360,7 @@ fn get_ampl(
     let arg = dist * wavenumber * n1.re; // optical path length
     ampl *= Complex::new(arg.cos(), arg.sin()); //  apply distance phase factor
 
-    let dist_sqrt = dist.signum() * dist.abs().sqrt(); // TODO: improve this
+    let dist_sqrt = dist.abs().sqrt(); // TODO: improve this
 
     let absorbed_intensity = Field::ampl_intensity(&ampl)
         * (1.0 - (-2.0 * wavenumber * n1.im * dist_sqrt).exp().powi(2));

{goad_py-0.4.1 → goad_py-0.4.2}/src/geom.rs

@@ -721,6 +721,14 @@ impl Face {
     ) -> Result<Self> {
         Ok(Face::Simple(FaceData::new(exterior, parent_id, indices)?))
     }
+    
+    /// Get a reference to the exterior vertices of the face
+    pub fn exterior_ref(&self) -> &[Point3<f32>] {
+        match self {
+            Face::Simple(data) => &data.exterior,
+            Face::Complex { data, .. } => &data.exterior,
+        }
+    }
 
     pub fn new_complex(
         exterior: Vec<Point3<f32>>,
@@ -1156,11 +1164,16 @@ impl Geom {
             }
         }
 
-        Ok(Self {
+        let geom = Self {
             num_shapes: shapes.len(),
             shapes,
             containment_graph,
-        })
+        };
+        
+        // Validate the loaded geometry
+        geom.validate()?;
+        
+        Ok(geom)
     }
 
     fn shapes_from_models(models: Vec<Model>) -> Result<Vec<Shape>> {
@@ -1220,12 +1233,49 @@ impl Geom {
         (Point3::from(min), Point3::from(max))
     }
 
+    /// Computes the scale factor that would be used to rescale the geometry
+    /// so that the largest dimension is 1.0
+    pub fn compute_scale_factor(&self) -> f32 {
+        let bounds = self.bounds();
+        let max_dim = bounds.1.iter().fold(0.0, |acc: f32, &x| acc.max(x));
+        1.0 / max_dim
+    }
+
+    /// Validates the geometry to ensure all faces will work correctly after scaling
+    fn validate(&self) -> Result<()> {
+        // Compute the scale factor that will be applied
+        let scale_factor = self.compute_scale_factor();
+        
+        // Validate each shape and face
+        for (shape_idx, shape) in self.shapes.iter().enumerate() {
+            for (face_idx, face) in shape.faces.iter().enumerate() {
+                let vertices = face.exterior_ref();
+                
+                // Check that we have at least one valid vertex pair after scaling
+                validate_vertex_pair_exists(vertices, scale_factor)
+                    .map_err(|e| anyhow::anyhow!(
+                        "Shape {} Face {}: {}", 
+                        shape_idx, face_idx, e
+                    ))?;
+                
+                // Check planarity for faces with >3 vertices
+                if vertices.len() > 3 {
+                    validate_planarity(vertices)
+                        .map_err(|e| anyhow::anyhow!(
+                            "Shape {} Face {}: {}", 
+                            shape_idx, face_idx, e
+                        ))?;
+                }
+            }
+        }
+        
+        Ok(())
+    }
+
     /// Rescales the geometry so that the largest dimension is 1. Returns the
     /// scaling factor.
     pub fn rescale(&mut self) -> f32 {
-        let bounds = self.bounds();
-        let max_dim = bounds.1.iter().fold(0.0, |acc: f32, &x| acc.max(x));
-        let scale = 1.0 / max_dim;
+        let scale = self.compute_scale_factor();
 
         for shape in self.shapes.iter_mut() {
             shape.rescale(scale);
@@ -1522,3 +1572,64 @@ pub fn translate(verts: &[Point3<f32>], center_of_mass: &Point3<f32>) -> Vec<Vec
         .map(|point| point.coords - center_of_mass.coords)
         .collect()
 }
+
+/// Validates that a face has at least one pair of vertices with sufficient separation after scaling
+fn validate_vertex_pair_exists(vertices: &[Point3<f32>], scale_factor: f32) -> Result<()> {
+    let min_original_distance = settings::VEC_LENGTH_THRESHOLD / scale_factor;
+    
+    for i in 0..vertices.len() {
+        for j in (i + 1)..vertices.len() {
+            if (vertices[j] - vertices[i]).magnitude() > min_original_distance {
+                return Ok(());
+            }
+        }
+    }
+    
+    Err(anyhow::anyhow!(
+        "No vertex pair will have distance > {} after scaling by {} (minimum required: {})",
+        settings::VEC_LENGTH_THRESHOLD, scale_factor, min_original_distance
+    ))
+}
+
+/// Validates that all vertices of a face lie on the same plane (within tolerance)
+fn validate_planarity(vertices: &[Point3<f32>]) -> Result<()> {
+    let midpoint = vertices.iter().fold(Point3::origin(), |acc, v| acc + v.coords) / vertices.len() as f32;
+    
+    // Find first valid vertex pair (we know one exists from previous validation)
+    let mut v1 = None;
+    let mut v2 = None;
+    for i in 0..vertices.len() {
+        for j in (i + 1)..vertices.len() {
+            // Using a very small threshold just to avoid degenerate cases
+            if (vertices[j] - vertices[i]).magnitude() > 1e-6 {
+                v1 = Some(vertices[i]);
+                v2 = Some(vertices[j]);
+                break;
+            }
+        }
+        if v1.is_some() {
+            break;
+        }
+    }
+    
+    let v1 = v1.unwrap();
+    let v2 = v2.unwrap();
+    
+    let u = v2 - v1;
+    let v = midpoint - v1;
+    let normal = u.cross(&v).normalize();
+    
+    // Check all vertices are on the same plane
+    for (i, &vertex) in vertices.iter().enumerate() {
+        let distance = (vertex - v1).dot(&normal).abs();
+        
+        if distance > settings::COLINEAR_THRESHOLD {
+            return Err(anyhow::anyhow!(
+                "Non-planar face: vertex {} deviates {} from plane (threshold: {})",
+                i, distance, settings::COLINEAR_THRESHOLD
+            ));
+        }
+    }
+    
+    Ok(())
+}

{goad_py-0.4.1 → goad_py-0.4.2}/src/problem.rs

@@ -211,7 +211,10 @@ impl Problem {
 
         // TODO move this outside the function
         for (i, ampl) in ampl_far_field.iter().enumerate() {
-            total_ampl_far_field[i] += ampl;
+            // Check if any component of the amplitude matrix contains NaN
+            if ampl.iter().all(|c| c.re.is_finite() && c.im.is_finite()) {
+                total_ampl_far_field[i] += ampl;
+            }
         }
     }
 

{goad_py-0.4.1 → goad_py-0.4.2}/src/settings.rs

@@ -19,7 +19,7 @@ pub const CLIP_TOLERANCE: f32 = 1e6;
 /// Minimum absolute value of the dot product of two vectors to be considered colinear.
 pub const COLINEAR_THRESHOLD: f32 = 0.001;
 /// Minimum vector length (in geometry units) to be considered non-degenerate.
-pub const VEC_LENGTH_THRESHOLD: f32 = 0.01;
+pub const VEC_LENGTH_THRESHOLD: f32 = 0.001;
 /// Minimum distance traversed by ray to intersection. Intersections closer than this are ignored.
 pub const RAYCAST_MINIMUM_DISTANCE: f32 = 0.01;
 /// Tolerance for diffraction computations, used to avoid divide by zero errors.

{goad_py-0.4.1 → goad_py-0.4.2}/tests/fixed_orientation_tests.rs

@@ -11,7 +11,7 @@ use num_complex::Complex32;
 pub mod helpers;
 // Tolerance for comparing Mueller matrix elements
 const FRAC_TOL: f32 = 1e-4; // fractional error
-const ABS_TOL: f32 = 1e3; // absolute error
+const ABS_TOL: f32 = 1e4; // absolute error
 
 #[test]
 fn fixed_hex_30_30_30() {