dev

benches/block.rs

@@ -1,7 +1,9 @@
 #![feature(test)]
 
 extern crate test;
-use automesh::{HexahedralFiniteElements, Octree, Smoothing, Tree, Voxels, NSD};
+use automesh::{
+    FiniteElementMethods, HexahedralFiniteElements, Octree, Smoothing, Tree, Voxels, NSD,
+};
 use std::{
     fs::{read_dir, remove_file},
     path::Path,

src/fem/py.rs

@@ -2,7 +2,7 @@ use super::{
     super::py::{IntoFoo, PyCoordinates, PyIntermediateError},
     finite_element_data_from_inp, write_finite_elements_metrics, write_finite_elements_to_abaqus,
     write_finite_elements_to_exodus, write_finite_elements_to_mesh, write_finite_elements_to_vtk,
-    Blocks, Connectivity, Smoothing, HEX, TRI,
+    Blocks, Connectivity, FiniteElementMethods, Smoothing, HEX, TRI,
 };
 use pyo3::prelude::*;
 

src/fem/test.rs

@@ -1,6 +1,6 @@
 use super::{
     calculate_element_volumes, calculate_maximum_edge_ratios, calculate_maximum_skews,
-    calculate_minimum_scaled_jacobians, Blocks, Connectivity, Coordinates,
+    calculate_minimum_scaled_jacobians, Blocks, Connectivity, Coordinates, FiniteElementMethods,
     HexahedralFiniteElements, Nodes, Smoothing, VecConnectivity, HEX,
 };
 use conspire::math::{Tensor, TensorVec};

src/lib.rs

@@ -18,8 +18,8 @@ mod tree;
 mod voxel;
 
 pub use fem::{
-    Blocks, Connectivity, FiniteElements, HexahedralFiniteElements, Smoothing,
-    TriangularFiniteElements,
+    Blocks, Connectivity, FiniteElementMethods, FiniteElementSpecifics, FiniteElements,
+    HexahedralFiniteElements, Smoothing, TriangularFiniteElements,
 };
 pub use tessellation::Tessellation;
 pub use tree::{Octree, Tree};

src/main.rs

@@ -1,6 +1,6 @@
 use automesh::{
-    FiniteElements, HexahedralFiniteElements, Nel, Octree, Scale, Smoothing, Tessellation,
-    Translate, Tree, Voxels,
+    FiniteElementMethods, FiniteElementSpecifics, HexahedralFiniteElements, Nel, Octree, Scale,
+    Smoothing, Tessellation, Translate, Tree, TriangularFiniteElements, Voxels,
 };
 use clap::{Parser, Subcommand};
 use ndarray_npy::{ReadNpyError, WriteNpyError};
@@ -418,15 +418,28 @@ enum InputTypes {
     Stl(Tessellation),
 }
 
-#[allow(clippy::large_enum_variant)]
-enum OutputTypes<const N: usize> {
-    Abaqus(FiniteElements<N>),
-    Exodus(FiniteElements<N>),
-    Mesh(FiniteElements<N>),
+// #[allow(clippy::large_enum_variant)]
+// enum OutputTypes<const N: usize> {
+//     Abaqus(FiniteElements<N>),
+//     Exodus(FiniteElements<N>),
+//     Mesh(FiniteElements<N>),
+//     Npy(Voxels),
+//     Spn(Voxels),
+//     Stl(Tessellation),
+//     Vtk(FiniteElements<N>),
+// }
+
+enum OutputTypes<const N: usize, T>
+where
+    T: FiniteElementMethods<N>,
+{
+    Abaqus(T),
+    Exodus(T),
+    Mesh(T),
     Npy(Voxels),
     Spn(Voxels),
     Stl(Tessellation),
-    Vtk(FiniteElements<N>),
+    Vtk(T),
 }
 
 fn invalid_output(file: &str, extension: Option<&str>) -> Result<(), ErrorWrapper> {
@@ -570,15 +583,23 @@ fn convert(
             Some("mesh") => write_output(output, OutputTypes::Mesh(finite_elements), quiet),
             Some("stl") => write_output(
                 output,
-                OutputTypes::<0>::Stl(finite_elements.into_tesselation()),
+                OutputTypes::<3, TriangularFiniteElements>::Stl(finite_elements.into_tesselation()),
                 quiet,
             ),
             Some("vtk") => write_output(output, OutputTypes::Vtk(finite_elements), quiet),
             _ => invalid_output(&output, output_extension),
         },
         InputTypes::Npy(voxels) | InputTypes::Spn(voxels) => match output_extension {
-            Some("spn") => write_output(output, OutputTypes::<0>::Spn(voxels), quiet),
-            Some("npy") => write_output(output, OutputTypes::<0>::Npy(voxels), quiet),
+            Some("spn") => write_output(
+                output,
+                OutputTypes::<8, HexahedralFiniteElements>::Spn(voxels),
+                quiet,
+            ),
+            Some("npy") => write_output(
+                output,
+                OutputTypes::<8, HexahedralFiniteElements>::Npy(voxels),
+                quiet,
+            ),
             _ => invalid_output(&output, output_extension),
         },
         InputTypes::Stl(tessellation) => {
@@ -589,7 +610,9 @@ fn convert(
                 Some("mesh") => write_output(output, OutputTypes::Mesh(finite_elements), quiet),
                 Some("stl") => write_output(
                     output,
-                    OutputTypes::<0>::Stl(finite_elements.into_tesselation()),
+                    OutputTypes::<3, TriangularFiniteElements>::Stl(
+                        finite_elements.into_tesselation(),
+                    ),
                     quiet,
                 ),
                 Some("vtk") => write_output(output, OutputTypes::Vtk(finite_elements), quiet),
@@ -620,7 +643,11 @@ fn defeature(
                 if !quiet {
                     println!("        \x1b[1;92mDone\x1b[0m {:?}", time.elapsed());
                 }
-                write_output(output, OutputTypes::<0>::Npy(voxels), quiet)
+                write_output(
+                    output,
+                    OutputTypes::<8, HexahedralFiniteElements>::Npy(voxels),
+                    quiet,
+                )
             }
             Some("spn") => {
                 let time = Instant::now();
@@ -631,7 +658,11 @@ fn defeature(
                 if !quiet {
                     println!("        \x1b[1;92mDone\x1b[0m {:?}", time.elapsed());
                 }
-                write_output(output, OutputTypes::<0>::Spn(voxels), quiet)
+                write_output(
+                    output,
+                    OutputTypes::<8, HexahedralFiniteElements>::Spn(voxels),
+                    quiet,
+                )
             }
             _ => invalid_output(&output, output_extension),
         },
@@ -903,7 +934,9 @@ fn smooth(
                 Some("mesh") => write_output(output, OutputTypes::Mesh(finite_elements), quiet),
                 Some("stl") => write_output(
                     output,
-                    OutputTypes::<0>::Stl(finite_elements.into_tesselation()),
+                    OutputTypes::<3, TriangularFiniteElements>::Stl(
+                        finite_elements.into_tesselation(),
+                    ),
                     quiet,
                 ),
                 Some("vtk") => write_output(output, OutputTypes::Vtk(finite_elements), quiet),
@@ -928,7 +961,9 @@ fn smooth(
                 Some("mesh") => write_output(output, OutputTypes::Mesh(finite_elements), quiet),
                 Some("stl") => write_output(
                     output,
-                    OutputTypes::<0>::Stl(finite_elements.into_tesselation()),
+                    OutputTypes::<3, TriangularFiniteElements>::Stl(
+                        finite_elements.into_tesselation(),
+                    ),
                     quiet,
                 ),
                 Some("vtk") => write_output(output, OutputTypes::Vtk(finite_elements), quiet),
@@ -942,16 +977,19 @@ fn smooth(
 }
 
 #[allow(clippy::too_many_arguments)]
-fn apply_smoothing_method<const N: usize>(
-    output_type: &mut FiniteElements<N>,
+fn apply_smoothing_method<const N: usize, T>(
+    output_type: &mut T,
     output: &str,
     iterations: usize,
     method: Option<String>,
     hierarchical: bool,
     pass_band: f64,
     scale: f64,
     quiet: bool,
-) -> Result<(), ErrorWrapper> {
+) -> Result<(), ErrorWrapper>
+where
+    T: FiniteElementMethods<N>,
+{
     let time_smooth = Instant::now();
     let smoothing_method = method.unwrap_or("Taubin".to_string());
     if matches!(
@@ -1066,11 +1104,14 @@ fn read_input(
     Ok(result)
 }
 
-fn write_output<const N: usize>(
+fn write_output<const N: usize, T>(
     output: String,
-    output_type: OutputTypes<N>,
+    output_type: OutputTypes<N, T>,
     quiet: bool,
-) -> Result<(), ErrorWrapper> {
+) -> Result<(), ErrorWrapper>
+where
+    T: FiniteElementMethods<N>,
+{
     let time = Instant::now();
     if !quiet {
         println!("     \x1b[1;96mWriting\x1b[0m {}", output);

src/tessellation/mod.rs

@@ -1,5 +1,5 @@
 use super::{
-    fem::{TriangularFiniteElements, NODE_NUMBERING_OFFSET},
+    fem::{FiniteElementMethods, TriangularFiniteElements, NODE_NUMBERING_OFFSET},
     Coordinate,
 };
 use conspire::math::TensorArray;

src/tree/mod.rs

@@ -2,7 +2,7 @@
 use std::time::Instant;
 
 use super::{
-    fem::{Blocks, HexahedralFiniteElements, HEX, NODE_NUMBERING_OFFSET},
+    fem::{Blocks, FiniteElementMethods, HexahedralFiniteElements, HEX, NODE_NUMBERING_OFFSET},
     voxel::{Nel, Scale, Translate, VoxelData, Voxels},
     Coordinate, Coordinates, NSD,
 };

src/voxel/mod.rs

@@ -8,7 +8,10 @@ pub mod test;
 use std::time::Instant;
 
 use super::{
-    fem::{Blocks, Connectivity, HexahedralFiniteElements, HEX, NODE_NUMBERING_OFFSET},
+    fem::{
+        Blocks, Connectivity, FiniteElementMethods, HexahedralFiniteElements, HEX,
+        NODE_NUMBERING_OFFSET,
+    },
     Coordinate, Coordinates, Octree, Tree, Vector, NSD,
 };
 use conspire::math::TensorArray;

tests/fem.rs

@@ -1,4 +1,4 @@
-use automesh::{Scale, Translate, Voxels, NSD};
+use automesh::{FiniteElementMethods, Scale, Translate, Voxels, NSD};
 use conspire::math::Tensor;
 use std::{
     fs::File,

tests/voxel.rs

@@ -1,4 +1,4 @@
-use automesh::{Nel, Scale, Translate, Voxels, NSD};
+use automesh::{FiniteElementMethods, Nel, Scale, Translate, Voxels, NSD};
 use conspire::math::{Tensor, TensorVec};
 
 const GOLD_DATA: [[[u8; 3]; 5]; 4] = [