From c708a25f992e70493260c3307dac687c4fa3ac44 Mon Sep 17 00:00:00 2001 From: Jon Drobny Date: Wed, 11 Nov 2026 17:21:56 -0800 Subject: [PATCH 1/3] Draft particle input file version --- src/input.rs | 88 ++++++++++++++++++++++++++++++++++++++++++++++--- src/particle.rs | 44 +++++++++++++++++++++++++ 2 files changed, 127 insertions(+), 5 deletions(-) diff --git a/src/input.rs b/src/input.rs index ce14718..5c62e05 100644 --- a/src/input.rs +++ b/src/input.rs @@ -514,9 +514,6 @@ pub fn process_input_file(input: ::InputFileFormat) assert!(particle_parameters.interaction_index.iter().max().unwrap() < &options.interaction_potential.len(), "Input error: interaction matrix too small for particle interaction indices."); - //N is the number of distinct particles. - let N = particle_parameters.Z.len(); - //Determine the length, energy, and mass units for particle input let length_unit: f64 = match particle_parameters.length_unit.as_str() { "MICRON" => MICRON, @@ -546,9 +543,89 @@ pub fn process_input_file(input: ::InputFileFormat) .unwrap_or_else(|_| panic!("Input errror: could nor parse mass unit {}. Use a valid float or one of AMU, KG", &particle_parameters.mass_unit.as_str())), }; - let particle_input_array: Vec = { + let particle_input_array: Vec = if particle_parameters.particle_input_filename != "".to_string() { + + let mut particle_input_string = String::new(); + let mut particle_input_file = OpenOptions::new() + .read(true) + .write(false) + .create(false) + .open(&particle_parameters.particle_input_filename) + .unwrap_or_else(|_| panic!("Input error: cannot open particle input file {}", particle_parameters.particle_input_filename)); + particle_input_file.read_to_string(&mut particle_input_string).expect("Input error: failed to read particle input file to string."); + + let mut particle_input: Vec = Vec::new(); + + for (line_index, line) in particle_input_string.lines().enumerate() { + + let [ m, + Z, + energy, + Ec, + Es, + x, + y, + z, + ux, + uy, + uz, + i, + w, + t, + ] = line.split(',') + .map(|s| s.trim()) + .collect::>() + .as_slice() + .try_into() + .unwrap_or_else(|_| panic!( + "Input error: failed to read line {} of particle input file {}; ensure row has 14 values.", + line_index, + particle_parameters.particle_input_filename + )); + + assert!(i.parse::().unwrap() < options.interaction_potential.len(), + "Input error: interaction matrix too small for particle interaction indices."); + + particle_input.push( + particle::ParticleInput { + m: m.parse::() + .unwrap_or_else(|_| panic!("Input error: failed to parse mass on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename))*mass_unit, + Z: Z.parse() + .unwrap_or_else(|_| panic!("Input error: failed to parse atomic number on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename)), + E: energy.parse::() + .unwrap_or_else(|_| panic!("Input error: failed to parse energy on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename))*energy_unit, + Ec: Ec.parse::() + .unwrap_or_else(|_| panic!("Input error: failed to parse cutoff energy on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename))*energy_unit, + Es: Es.parse::() + .unwrap_or_else(|_| panic!("Input error: failed to parse SBE on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename))*energy_unit, + x: x.parse::() + .unwrap_or_else(|_| panic!("Input error: failed to parse x on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename))*length_unit, + y: y.parse::() + .unwrap_or_else(|_| panic!("Input error: failed to parse y on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename))*length_unit, + z: z.parse::() + .unwrap_or_else(|_| panic!("Input error: failed to parse z on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename))*length_unit, + ux: ux.parse() + .unwrap_or_else(|_| panic!("Input error: failed to parse ux on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename)), + uy: uy.parse() + .unwrap_or_else(|_| panic!("Input error: failed to parse uy on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename)), + uz: uz.parse() + .unwrap_or_else(|_| panic!("Input error: failed to parse uz on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename)), + interaction_index: i.parse() + .unwrap_or_else(|_| panic!("Input error: failed to parse interaction index on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename)), + weight: w.parse() + .unwrap_or_else(|_| panic!("Input error: failed to parse weight on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename)), + tag: t.parse() + .unwrap_or_else(|_| panic!("Input error: failed to parse tag on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename)), + } + ) + } + + particle_input + } else { + + let N = particle_parameters.Z.len(); - let mut particle_input: Vec = Vec::new(); + let mut particle_input: Vec = Vec::new(); for particle_index in 0..N { let N_ = particle_parameters.N[particle_index]; @@ -614,5 +691,6 @@ pub fn process_input_file(input: ::InputFileFormat) } particle_input }; + (particle_input_array, material, options, OutputUnits {length_unit, energy_unit, mass_unit}) } diff --git a/src/particle.rs b/src/particle.rs index f64f3b2..9201811 100644 --- a/src/particle.rs +++ b/src/particle.rs @@ -1,24 +1,68 @@ use super::*; +// These default_* functions are a workaround to +// this issue: https://github.com/serde-rs/serde/issues/368 +// in serde. Unimplemented since 2016! fn default_vec_zero() -> Vec { vec![0] } +fn default_vec_empty_f64() -> Vec { + vec![] +} + +fn default_vec_empty_distributions() -> Vec { + vec![] +} + +fn default_vec_empty_distributions_triple() -> Vec<(Distributions, Distributions, Distributions)> { + vec![] +} + +fn default_empty_string() -> String { + "".to_string() +} + +fn default_length_unit() -> String { + "ANGSTROM".to_string() +} + +fn default_energy_unit() -> String { + "EV".to_string() +} + +fn default_mass_unit() -> String { + "AMU".to_string() +} + #[derive(Deserialize, Clone)] pub struct ParticleParameters { + #[serde(default = "default_length_unit")] pub length_unit: String, + #[serde(default = "default_energy_unit")] pub energy_unit: String, + #[serde(default = "default_mass_unit")] pub mass_unit: String, + #[serde(default = "default_vec_zero")] pub N: Vec, + #[serde(default = "default_vec_empty_f64")] pub m: Vec, + #[serde(default = "default_vec_empty_f64")] pub Z: Vec, + #[serde(default = "default_vec_empty_distributions")] pub E: Vec, + #[serde(default = "default_vec_empty_f64")] pub Ec: Vec, + #[serde(default = "default_vec_empty_f64")] pub Es: Vec, + #[serde(default = "default_vec_empty_distributions_triple")] pub pos: Vec<(Distributions, Distributions, Distributions)>, + #[serde(default = "default_vec_empty_distributions_triple")] pub dir: Vec<(Distributions, Distributions, Distributions)>, #[serde(default = "default_vec_zero")] pub interaction_index: Vec, + #[serde(default = "default_empty_string")] + pub particle_input_filename: String } #[derive(Clone, PartialEq, Debug, Copy)] From c0225ca9fb18978eef2d75bf0a2e79dd2a3b4072 Mon Sep 17 00:00:00 2001 From: Jon Drobny Date: Wed, 11 Nov 2026 18:07:56 -0800 Subject: [PATCH 2/3] Improvements to particle input file handling. --- src/input.rs | 59 ++++++++++++++++++++++++++++------------------------ 1 file changed, 32 insertions(+), 27 deletions(-) diff --git a/src/input.rs b/src/input.rs index 5c62e05..8b4836c 100644 --- a/src/input.rs +++ b/src/input.rs @@ -492,28 +492,6 @@ pub fn process_input_file(input: ::InputFileFormat) } } - //Check that particle arrays are equal length - assert_eq!(particle_parameters.Z.len(), particle_parameters.m.len(), - "Input error: particle input arrays of unequal length."); - assert_eq!(particle_parameters.Z.len(), particle_parameters.E.len(), - "Input error: particle input arrays of unequal length."); - assert_eq!(particle_parameters.Z.len(), particle_parameters.pos.len(), - "Input error: particle input arrays of unequal length."); - assert_eq!(particle_parameters.Z.len(), particle_parameters.dir.len(), - "Input error: particle input arrays of unequal length."); - - if particle_parameters.interaction_index.len() <= 1 { - particle_parameters.interaction_index = vec![0; particle_parameters.Z.len()]; - } - - //Check that interaction indices are all within interaction matrices - assert!(material.interaction_index.iter().max().unwrap() < &options.interaction_potential.len(), - "Input error: interaction matrix too small for material interaction indices. If interaction - matrix is not specified, interaction_indices should be a vector of as many zeroes as there - are material species."); - assert!(particle_parameters.interaction_index.iter().max().unwrap() < &options.interaction_potential.len(), - "Input error: interaction matrix too small for particle interaction indices."); - //Determine the length, energy, and mass units for particle input let length_unit: f64 = match particle_parameters.length_unit.as_str() { "MICRON" => MICRON, @@ -556,7 +534,10 @@ pub fn process_input_file(input: ::InputFileFormat) let mut particle_input: Vec = Vec::new(); - for (line_index, line) in particle_input_string.lines().enumerate() { + let particle_input_lines: Vec<&str> = particle_input_string.lines().collect(); + assert!(particle_input_lines.len() > 0, "Input error: particle input file cannot have 0 lines."); + + for (line_index, line) in particle_input_lines.iter().enumerate() { let [ m, Z, @@ -579,11 +560,14 @@ pub fn process_input_file(input: ::InputFileFormat) .try_into() .unwrap_or_else(|_| panic!( "Input error: failed to read line {} of particle input file {}; ensure row has 14 values.", - line_index, + line_index + 1, particle_parameters.particle_input_filename )); - assert!(i.parse::().unwrap() < options.interaction_potential.len(), + let interaction_index = i.parse::() + .unwrap_or_else(|_| panic!("Input error: failed to parse interaction index on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename)); + + assert!(interaction_index < options.interaction_potential.len(), "Input error: interaction matrix too small for particle interaction indices."); particle_input.push( @@ -610,8 +594,7 @@ pub fn process_input_file(input: ::InputFileFormat) .unwrap_or_else(|_| panic!("Input error: failed to parse uy on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename)), uz: uz.parse() .unwrap_or_else(|_| panic!("Input error: failed to parse uz on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename)), - interaction_index: i.parse() - .unwrap_or_else(|_| panic!("Input error: failed to parse interaction index on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename)), + interaction_index: interaction_index, weight: w.parse() .unwrap_or_else(|_| panic!("Input error: failed to parse weight on line {} of particle input file {}", line_index + 1, particle_parameters.particle_input_filename)), tag: t.parse() @@ -622,6 +605,28 @@ pub fn process_input_file(input: ::InputFileFormat) particle_input } else { + + //Check that particle arrays are equal length + assert_eq!(particle_parameters.Z.len(), particle_parameters.m.len(), + "Input error: particle input arrays of unequal length."); + assert_eq!(particle_parameters.Z.len(), particle_parameters.E.len(), + "Input error: particle input arrays of unequal length."); + assert_eq!(particle_parameters.Z.len(), particle_parameters.pos.len(), + "Input error: particle input arrays of unequal length."); + assert_eq!(particle_parameters.Z.len(), particle_parameters.dir.len(), + "Input error: particle input arrays of unequal length."); + + if particle_parameters.interaction_index.len() <= 1 { + particle_parameters.interaction_index = vec![0; particle_parameters.Z.len()]; + } + + //Check that interaction indices are all within interaction matrices + assert!(material.interaction_index.iter().max().unwrap() < &options.interaction_potential.len(), + "Input error: interaction matrix too small for material interaction indices. If interaction + matrix is not specified, interaction_indices should be a vector of as many zeroes as there + are material species."); + assert!(particle_parameters.interaction_index.iter().max().unwrap() < &options.interaction_potential.len(), + "Input error: interaction matrix too small for particle interaction indices."); let N = particle_parameters.Z.len(); From 8aa46c57b4ce48eeafc1be38de5ef85436ed37cc Mon Sep 17 00:00:00 2001 From: Jon Drobny Date: Wed, 11 Nov 2026 18:15:48 -0800 Subject: [PATCH 3/3] Fixed non-propagation of weight/tag via particle input file. --- src/particle.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/particle.rs b/src/particle.rs index 9201811..dae7baf 100644 --- a/src/particle.rs +++ b/src/particle.rs @@ -148,8 +148,8 @@ impl Particle { number_collision_events: 0, backreflected: false, interaction_index: input.interaction_index, - weight: 1.0, - tag: 0, + weight: input.weight, + tag: input.tag, tracked_vector: Vector::new(0.0, 0.0, 0.0), } }