gitronics 0.5.25__tar.gz → 0.6.0__tar.gz

{gitronics-0.5.25 → gitronics-0.6.0}/Cargo.lock

@@ -390,7 +390,7 @@ dependencies = [
 
 [[package]]
 name = "gitronics"
-version = "0.5.25"
+version = "0.6.0"
 dependencies = [
  "chrono",
  "clap",
@@ -636,14 +636,21 @@ dependencies = [
 
 [[package]]
 name = "migjorn"
-version = "0.1.8"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3f2fe960921f8c049fc7ac5536e96cba576e902cf040c258e8092eabb9eeaaf"
+checksum = "ce11924d4ef1f0496f0be14e68860ab11bbc0b63222057d03bc92b22b4084f3d"
 dependencies = [
- "clap",
- "memchr",
- "rayon",
- "thiserror",
+ "migjorn-syntax",
+ "rustc-hash",
+]
+
+[[package]]
+name = "migjorn-syntax"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42d3806f43fee8380cfaa0e26e9fee3a2dbece142e5314b6c7f9a0babf03fe05"
+dependencies = [
+ "rustc-hash",
 ]
 
 [[package]]
@@ -858,6 +865,12 @@ version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
 
+[[package]]
+name = "rustc-hash"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d"
+
 [[package]]
 name = "rustix"
 version = "1.1.4"

{gitronics-0.5.25 → gitronics-0.6.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gitronics"
-version = "0.5.25"
+version = "0.6.0"
 edition = "2024"
 description = "Build MCNP neutronics models from modular components"
 license = "EUPL-1.2"
@@ -16,7 +16,7 @@ crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 pyo3 = { version = "0.23", features = ["extension-module", "abi3-py39"] }
-migjorn = { version = "0.1.8" }
+migjorn = { version = "0.2.2" }
 walkdir = "2.5.0"
 serde = { version = "1.0.228", features = ["derive"] }
 serde-saphyr = "0.0.26"

{gitronics-0.5.25 → gitronics-0.6.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: gitronics
-Version: 0.5.25
+Version: 0.6.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 License-File: LICENSE
 Summary: Build MCNP neutronics models from modular components
-Requires-Python: >=3.8
+Requires-Python: >=3.9

{gitronics-0.5.25 → gitronics-0.6.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "maturin"
 name = "gitronics"
 dynamic = ["version"]
 description = "Build MCNP neutronics models from modular components"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 classifiers = [
     "Programming Language :: Rust",
     "Programming Language :: Python :: Implementation :: CPython",

{gitronics-0.5.25 → gitronics-0.6.0}/python/gitronics/__init__.py

@@ -11,9 +11,10 @@ from __future__ import annotations
 import sys
 
 from .gitronics import py_build_model as build_model  # type: ignore[import]
+from .gitronics import py_migrate_model as migrate_model  # type: ignore[import]
 from .gitronics import run  # type: ignore[import]
 
-__all__ = ["build_model", "run"]
+__all__ = ["build_model", "migrate_model", "run"]
 
 
 def _cli_main() -> None:

{gitronics-0.5.25 → gitronics-0.6.0}/python/gitronics/gitronics.pyi

@@ -43,3 +43,19 @@ def py_build_model(config_path: Path | str, output_path: Path | str) -> None:
         )
     """
     ...
+
+def py_migrate_model(mcnp_input: Path | str, output_path: Path | str) -> None:
+    """Migrate a monolithic MCNP model into a new gitronics project.
+
+    Splits the deck at *mcnp_input* into an envelope structure, per-universe
+    filler models, and a data-cards file, and writes a baseline configuration
+    that rebuilds the original model with :func:`build_model`.
+
+    Args:
+        mcnp_input: Path to the monolithic MCNP input file.
+        output_path: Directory where the new project will be created.
+
+    Raises:
+        RuntimeError: If any step of the migration fails.
+    """
+    ...

{gitronics-0.5.25 → gitronics-0.6.0}/src/build_model.rs

@@ -1,15 +1,15 @@
 use crate::build_report::{BuildReport, EnvelopeEntry, FillerEntry};
 use crate::project_manager::ProjectManager;
-use crate::types::{CellId, EnvelopeName, FillerName, UniverseId};
+use crate::types::{EnvelopeName, FillerName, UniverseId};
 use crate::utils::GitronicsError;
 
 use git2::Repository;
 use log::{info, warn};
-use migjorn::{Card, CellCard, CellParam, DataCard, Model, ParamType};
+use migjorn::Model;
 use regex::Regex;
 use std::collections::HashSet;
+use std::fs;
 use std::{collections::HashMap, path::Path, sync::LazyLock};
-use std::{env, fs};
 
 pub fn build_model(config_path: &Path, output_path: &Path) -> Result<(), GitronicsError> {
     info!(
@@ -19,34 +19,35 @@ pub fn build_model(config_path: &Path, output_path: &Path) -> Result<(), Gitroni
 
     let mut project_manager = ProjectManager::new(config_path, output_path)?;
 
-    // Load all files
+    // Load all files.
     let mut envelope_structure = project_manager.load_envelope_structure()?;
     let unordered_fillers = project_manager.load_fillers()?;
-    let unordered_transforms = project_manager.load_transforms()?;
-    let unordered_materials = project_manager.load_materials()?;
-    let unordered_tallies = project_manager.load_tallies()?;
+    let transforms = project_manager.load_transforms()?;
+    let materials = project_manager.load_materials()?;
+    let tallies = project_manager.load_tallies()?;
     let source = project_manager.load_source()?;
 
-    // Reorder by IDs
-    let fillers = order_models_by_cell_id(unordered_fillers)?;
-    let transforms = order_data_cards_groups_by_id(unordered_transforms);
-    let materials = order_data_cards_groups_by_id(unordered_materials);
-    let tallies = order_data_cards_groups_by_id(unordered_tallies);
+    // Order fillers by their first cell id for deterministic output.
+    let fillers = order_fillers_by_cell_id(unordered_fillers)?;
 
-    // Load metadata for each filler and cache it in the ProjectManager
-    project_manager.load_metadata_for_fillers(&fillers)?;
+    // Load metadata for each filler and cache it in the ProjectManager.
+    project_manager.load_metadata_for_fillers(fillers.iter().map(|(name, _)| name))?;
 
-    // Get the filler universe ID of every filler model
+    // Universe id of every filler (read from its first cell's `u=`).
     let universe_ids: HashMap<FillerName, UniverseId> = fillers
         .iter()
-        .map(|filler| Ok((FillerName::from(filler), get_universe_id_of_model(filler)?)))
+        .map(|(name, model)| {
+            let universe = filler_universe(model)
+                .ok_or_else(|| GitronicsError::FirstCellWithoutUniverseID(name.clone()))?;
+            Ok((name.clone(), universe))
+        })
         .collect::<Result<HashMap<_, _>, GitronicsError>>()?;
 
-    // Adapt envelope cells with the FILL cards
+    // Insert FILL cards into the placeholder envelope cells.
     info!("Adapting envelope structure with FILL cards");
     add_fill_cards_to_envelopes(&project_manager, &universe_ids, &mut envelope_structure)?;
 
-    // Collect build-report data before fillers are moved into the composed model
+    // Collect build-report data before the models are consumed by composition.
     let report = collect_build_report(
         config_path,
         &project_manager,
@@ -55,31 +56,51 @@ pub fn build_model(config_path: &Path, output_path: &Path) -> Result<(), Gitroni
         &universe_ids,
     )?;
 
-    // Compose model
+    // Compose: drop the ignored data blocks, then merge every filler's geometry
+    // into the envelope structure (collision-checked against the disjoint-range
+    // convention).
     info!("Composing model");
-    fillers.into_iter().for_each(|filler| {
-        envelope_structure.cells.extend(filler.cells);
-        envelope_structure.surfaces.extend(filler.surfaces);
-    });
-    envelope_structure.data_cards.extend(transforms);
-    envelope_structure.data_cards.extend(materials);
-    envelope_structure.data_cards.extend(tallies);
-    envelope_structure.data_cards.extend(source);
-
-    // Perform validation checks
-    info!("Performing validation checks on the assembled model");
+    envelope_structure.clear_data_cards();
+    let mut filler_models = fillers;
+    for (_, model) in filler_models.iter_mut() {
+        model.clear_data_cards();
+    }
+    let filler_refs: Vec<&Model> = filler_models.iter().map(|(_, model)| model).collect();
     envelope_structure
-        .validation_checks()
-        .map_err(|e| GitronicsError::ValidationError(e.to_string()))?;
+        .merge(&filler_refs)
+        .map_err(|conflicts| GitronicsError::MergeConflicts(format_conflicts(&conflicts)))?;
+
+    // Append the configured data cards to the data block.
+    let data_text = [transforms, materials, tallies, source]
+        .into_iter()
+        .filter(|s| !s.is_empty())
+        .collect::<Vec<_>>()
+        .join("\n");
+    let mut assembled_source = envelope_structure.to_source();
+    if !data_text.is_empty() {
+        if !assembled_source.ends_with('\n') {
+            assembled_source.push('\n');
+        }
+        assembled_source.push_str(&data_text);
+        assembled_source.push('\n');
+    }
+    let assembled_model = Model::parse(assembled_source);
+
+    // Validate the assembled model.
+    info!("Performing validation checks on the assembled model");
+    let problems = assembled_model.validate();
+    if !problems.is_empty() {
+        return Err(GitronicsError::ValidationError(problems.join("\n")));
+    }
 
-    // Write model
+    // Write the assembled model with the provenance banner.
     info!("Writing assembled model to file");
     let assembled_path = project_manager.output_path().join("assembled.mcnp");
-    write_assembled_header(&mut envelope_structure, config_path)?;
-    envelope_structure.write_to_file(&assembled_path)?;
+    let final_source = insert_banner(&assembled_model.to_source(), config_path);
+    fs::write(&assembled_path, final_source)?;
     fs::write(output_path.join(".gitignore"), "*\n")?;
 
-    // Write build report
+    // Write the HTML build report.
     info!("Writing HTML build report");
     let report_path = project_manager.output_path().join("build_report.html");
     fs::write(&report_path, report.generate_html())?;
@@ -94,17 +115,134 @@ pub fn build_model(config_path: &Path, output_path: &Path) -> Result<(), Gitroni
 static ENVELOPE_RE: LazyLock<Regex> =
     LazyLock::new(|| Regex::new(r"\$\s*@env:\s*([[:alnum:]_.-]+)\s*").unwrap());
 
+/// The directory that contains the configuration file — the anchor for git
+/// repository discovery (the project, not the process's working directory).
+fn project_dir(config_path: &Path) -> &Path {
+    config_path.parent().unwrap_or(Path::new("."))
+}
+
+/// The universe id declared by a filler's first cell (`u=`), if any.
+fn filler_universe(model: &Model) -> Option<UniverseId> {
+    let first = model.cells().next()?;
+    model
+        .cell_universe(first.card_index)
+        .map(|u| UniverseId::new(u as u32))
+}
+
+/// Order fillers by the id of their first cell, erroring on a filler with no
+/// cells.
+fn order_fillers_by_cell_id(
+    fillers: Vec<(FillerName, Model)>,
+) -> Result<Vec<(FillerName, Model)>, GitronicsError> {
+    let mut keyed: Vec<(i64, FillerName, Model)> = fillers
+        .into_iter()
+        .map(|(name, model)| {
+            let cell_id = model
+                .cells()
+                .next()
+                .map(|c| c.id)
+                .ok_or_else(|| GitronicsError::NoCellID(name.clone()))?;
+            Ok((cell_id, name, model))
+        })
+        .collect::<Result<Vec<_>, GitronicsError>>()?;
+    keyed.sort_by_key(|(cell_id, _, _)| *cell_id);
+    Ok(keyed
+        .into_iter()
+        .map(|(_, name, model)| (name, model))
+        .collect())
+}
+
+fn add_fill_cards_to_envelopes(
+    project_manager: &ProjectManager,
+    universe_ids: &HashMap<FillerName, UniverseId>,
+    envelope_structure: &mut Model,
+) -> Result<(), GitronicsError> {
+    let mut missing_envelopes_in_file: HashSet<EnvelopeName> =
+        project_manager.envelopes_in_config().cloned().collect();
+
+    // Collect cell card indices up front: FILL insertion is a token splice that
+    // leaves indices stable, so we can read then mutate by the same index.
+    let cell_indices: Vec<usize> = envelope_structure.cells().map(|c| c.card_index).collect();
+
+    for card_index in cell_indices {
+        let original_text = envelope_structure.card_source(card_index);
+        let Some(caps) = ENVELOPE_RE.captures(&original_text) else {
+            continue;
+        };
+        let envelope_name =
+            EnvelopeName::new(caps.get(1).map(|m| m.as_str()).ok_or_else(|| {
+                GitronicsError::FailedToExtractEnvelopeName(
+                    ENVELOPE_RE.to_string(),
+                    original_text.clone(),
+                )
+            })?);
+
+        let Some(env_config) = project_manager.filler_by_envelope(&envelope_name) else {
+            warn!(
+                "The envelope `{envelope_name}` is not considered in the configuration file. \
+                 It is better to explicitly set it as `{envelope_name}: null` if you want the \
+                 envelope to not be filled with any model."
+            );
+            continue;
+        };
+
+        // We found the envelope in the file.
+        missing_envelopes_in_file.remove(&envelope_name);
+
+        // Envelope explicitly set to null in config: leave it unfilled.
+        let Some(filler_name) = env_config.as_ref() else {
+            continue;
+        };
+
+        let universe_id = universe_ids
+            .get(filler_name)
+            .ok_or_else(|| GitronicsError::FillerUniverseIdMissing(filler_name.clone()))?;
+
+        let transform = project_manager
+            .transformation(filler_name, &envelope_name)?
+            .unwrap_or("");
+        let fill_card_text = if let Some(transform_without_star) = transform.strip_prefix('*') {
+            format!("*fill={universe_id} {transform_without_star}")
+        } else {
+            format!("fill={universe_id} {transform}")
+        };
+
+        envelope_structure
+            .add_cell_param(card_index, fill_card_text.trim())
+            .map_err(|e| GitronicsError::InvalidFillCard(fill_card_text, e.to_string()))?;
+    }
+
+    if !missing_envelopes_in_file.is_empty() {
+        warn!(
+            "The following envelopes were defined in the configuration file but not found in the envelope structure file: {}. \
+             Please check that the `$ @env:envelope_name` pattern is satisfied.",
+            missing_envelopes_in_file
+                .into_iter()
+                .map(|e| e.to_string())
+                .collect::<Vec<_>>()
+                .join(", ")
+        );
+    }
+    Ok(())
+}
+
 fn collect_build_report(
     config_path: &Path,
     project_manager: &ProjectManager,
     envelope_structure: &Model,
-    fillers: &[Model],
+    fillers: &[(FillerName, Model)],
     universe_ids: &HashMap<FillerName, UniverseId>,
 ) -> Result<BuildReport, GitronicsError> {
-    let total_cells =
-        envelope_structure.cells.len() + fillers.iter().map(|f| f.cells.len()).sum::<usize>();
-    let total_surfaces =
-        envelope_structure.surfaces.len() + fillers.iter().map(|f| f.surfaces.len()).sum::<usize>();
+    let total_cells = envelope_structure.cells().count()
+        + fillers
+            .iter()
+            .map(|(_, m)| m.cells().count())
+            .sum::<usize>();
+    let total_surfaces = envelope_structure.surfaces().count()
+        + fillers
+            .iter()
+            .map(|(_, m)| m.surfaces().count())
+            .sum::<usize>();
 
     let envelope_entries: Vec<EnvelopeEntry> = project_manager
         .envelopes_in_config()
@@ -146,16 +284,15 @@ fn collect_build_report(
 
     let filler_entries: Vec<FillerEntry> = fillers
         .iter()
-        .filter_map(|filler| {
-            let name = FillerName::from(filler);
-            let universe_id = *universe_ids.get(&name)?;
-            let envelope_count = *filler_envelope_counts.get(&name).unwrap_or(&0);
+        .filter_map(|(name, model)| {
+            let universe_id = *universe_ids.get(name)?;
+            let envelope_count = *filler_envelope_counts.get(name).unwrap_or(&0);
             Some(FillerEntry {
                 universe_id,
                 envelope_count,
-                cell_count: filler.cells.len(),
-                surface_count: filler.surfaces.len(),
-                name,
+                cell_count: model.cells().count(),
+                surface_count: model.surfaces().count(),
+                name: name.clone(),
             })
         })
         .collect();
@@ -163,7 +300,7 @@ fn collect_build_report(
     Ok(BuildReport {
         config_path: config_path.display().to_string(),
         gitronics_version: env!("CARGO_PKG_VERSION"),
-        commit_hash: get_hash_of_project(),
+        commit_hash: get_hash_of_project(project_dir(config_path)),
         date_time: chrono::Utc::now()
             .format("%Y-%m-%d %H:%M:%S UTC")
             .to_string(),
@@ -190,153 +327,43 @@ fn collect_build_report(
     })
 }
 
-fn add_fill_cards_to_envelopes(
-    project_manager: &ProjectManager,
-    universe_ids: &HashMap<FillerName, UniverseId>,
-    envelope_structure: &mut Model,
-) -> Result<(), GitronicsError> {
-    let mut missing_envelopes_in_file: HashSet<EnvelopeName> =
-        project_manager.envelopes_in_config().cloned().collect();
-
-    for cell in envelope_structure.cells.iter_mut() {
-        let original_text = cell.original_text();
-        let Some(caps) = ENVELOPE_RE.captures(original_text) else {
-            continue;
-        };
-
-        let envelope_name =
-            EnvelopeName::new(caps.get(1).map(|m| m.as_str()).ok_or_else(|| {
-                GitronicsError::FailedToExtractEnvelopeName(
-                    ENVELOPE_RE.to_string(),
-                    original_text.to_string(),
-                )
-            })?);
-
-        let Some(env_config) = project_manager.filler_by_envelope(&envelope_name) else {
-            warn!(
-                "The envelope `{envelope_name}` is not considered in the configuration file. \
-                 It is better to explicitly set it as `{envelope_name}: null` if you want the \
-                 envelope to not be filled with any model."
-            );
-            continue;
-        };
-
-        // Remove the envelope from the set of missing envelopes, as we have found it in the file
-        missing_envelopes_in_file.remove(&envelope_name);
-
-        // Envelope explicitly set to null in config, so we skip it
-        let Some(filler_name) = env_config.as_ref() else {
-            continue;
-        };
-
-        let universe_id = universe_ids
-            .get(filler_name)
-            .ok_or_else(|| GitronicsError::FillerUniverseIdMissing(filler_name.clone()))?;
-
-        let transform = project_manager.transformation(filler_name, &envelope_name)?;
-        let transform = transform.unwrap_or("");
-
-        let fill_card_text = if let Some(transform_without_star) = transform.strip_prefix('*') {
-            format!("*FILL={} {}", universe_id, transform_without_star)
-        } else {
-            format!("FILL={} {}", universe_id, transform)
-        };
-
-        cell.insert_param(
-            cell.params().len(),
-            CellParam::try_from(fill_card_text.clone())
-                .map_err(|e| GitronicsError::InvalidFillCard(fill_card_text, e.to_string()))?,
-        );
-    }
-
-    if !missing_envelopes_in_file.is_empty() {
-        warn!(
-            "The following envelopes were defined in the configuration file but not found in the envelope structure file: {}. \
-             Please check that the `$ @env:envelope_name` pattern is satisfied.",
-            missing_envelopes_in_file
-                .into_iter()
-                .map(|e| e.to_string())
-                .collect::<Vec<_>>()
-                .join(", ")
-        );
-    }
-    Ok(())
-}
-
-fn order_models_by_cell_id(models: Vec<Model>) -> Result<Vec<Model>, GitronicsError> {
-    let mut decorated: Vec<(CellId, Model)> = models
-        .into_iter()
-        .map(|filler| {
-            let cell_id = filler
-                .cells
-                .first()
-                .map(|cell| CellId::new(cell.cell_id()))
-                .ok_or_else(|| GitronicsError::NoCellID(FillerName::from(&filler)))?;
-            Ok((cell_id, filler))
-        })
-        .collect::<Result<Vec<_>, GitronicsError>>()?;
-    decorated.sort_by_key(|(cell_id, _)| *cell_id);
-    Ok(decorated.into_iter().map(|(_, filler)| filler).collect())
-}
-
-fn order_data_cards_groups_by_id(mut data_cards_groups: Vec<Vec<DataCard>>) -> Vec<DataCard> {
-    data_cards_groups.sort_by_key(|data_cards| data_cards.first().map(|card| card.card_id()));
-    data_cards_groups.into_iter().flatten().collect()
-}
-
-fn get_universe_id_of_model(model: &Model) -> Result<UniverseId, GitronicsError> {
-    model
-        .cells
-        .first()
-        .and_then(|cell| {
-            cell.params()
-                .iter()
-                .find_map(|param| match param.param_type {
-                    ParamType::U(id) => Some(UniverseId::new(id)),
-                    _ => None,
-                })
-        })
-        .ok_or_else(|| GitronicsError::FirstCellWithoutUniverseID(FillerName::from(model)))
+/// Render merge conflicts as a human-readable, newline-separated list.
+fn format_conflicts(conflicts: &[migjorn::MergeConflict]) -> String {
+    conflicts
+        .iter()
+        .map(|c| c.to_string())
+        .collect::<Vec<_>>()
+        .join("\n")
 }
 
-fn write_assembled_header(
-    assembled_model: &mut Model,
-    config_path: &Path,
-) -> Result<(), GitronicsError> {
+/// Insert the provenance banner as comment lines just after the model's title.
+fn insert_banner(source: &str, config_path: &Path) -> String {
     let configuration = config_path.display().to_string();
     let date_time = chrono::Utc::now().format("%Y-%m-%d %H:%M:%S").to_string();
     let gitronics_version = env!("CARGO_PKG_VERSION");
-    let commit_hash = get_hash_of_project();
+    let commit_hash = get_hash_of_project(project_dir(config_path));
 
     let banner = format!(
-        "C ============================================================
-C  Built by gitronics v{gitronics_version}
-C  Configuration : {configuration}
-C  Git commit    : {commit_hash}
-C  Date / time   : {date_time}
-C ============================================================"
+        "C ============================================================\n\
+         C  Built by gitronics v{gitronics_version}\n\
+         C  Configuration : {configuration}\n\
+         C  Git commit    : {commit_hash}\n\
+         C  Date / time   : {date_time}\n\
+         C ============================================================"
     );
-    let new_card_text = format!(
-        "{banner}\n{}",
-        assembled_model
-            .cells
-            .first()
-            .map(|c| c.original_text())
-            .unwrap_or_default()
-    );
-
-    let banner_card = CellCard::try_from(new_card_text.as_str())
-        .expect("Adding comments as header should not fail");
 
-    // Replace the first cell (previously a comment placeholder) with the banner card
-    assembled_model.cells[0] = banner_card;
-    Ok(())
+    match source.split_once('\n') {
+        Some((title, rest)) => format!("{title}\n{banner}\n{rest}"),
+        None => format!("{source}\n{banner}\n"),
+    }
 }
 
-fn get_hash_of_project() -> String {
-    let repo = env::current_dir()
-        .ok()
-        .and_then(|cwd| Repository::discover(cwd).ok());
+/// Describe the git state of the repository that contains `start_dir` (the
+/// project being built), not the process's current working directory — so the
+/// recorded commit reflects what was actually assembled regardless of where the
+/// binary was invoked from.
+fn get_hash_of_project(start_dir: &Path) -> String {
+    let repo = Repository::discover(start_dir).ok();
     repo.as_ref()
         .and_then(|r| {
             let mut opts = git2::DescribeOptions::new();