SCONE Guide
SCONE Verification Notice
SCONE is a research-oriented code with a smaller user base than MCNP, OpenMC, or SERPENT. Our examples are intended as educational guidance. For authoritative syntax, physics options, and nuclear data requirements, consult the official documentation.
Advanced SCONE Features
Universe nesting, axial layering, grid spacers, and visualization
For experienced users after Reactor Examples and BEAVRS — not a first stop.
Blocks on this page are structural excerpts (universes, surfaces, cells, viz, …) — not complete runnable files; not in run_all.ps1. For a byte-aligned latUniverse + pinUniverse listing, use tutorial_assembly_5x5_testlib on Geometry / Reactor Examples. Merge any sketch here into a full deck from Basics or scone-examples/verify/.
Multi-Level Universe Nesting
SCONE builds complex reactor cores from nested universes: rootUniverse fills the top-level boundary, cellUniverse groups cells, latUniverse arranges pins in a regular grid, and pinUniverse defines the pin structure (fuel, gap, clad, moderator). Full-core PWR models typically follow this pattern: root to cellUniverse (core/structure cells) to latUniverse (assembly map) to pinUniverse (radii and fills).
! Multi-level universe nesting
! rootUniverse -> cellUniverse -> latUniverse -> pinUniverse
universes {
root { id 1; type rootUniverse; border 1; fill u<9999>; }
coreAndStructures {
id 8888;
type cellUniverse;
cells (7 8 9 10 11 12 13 14 15 16 17);
}
assembly16 {
id 1631;
type latUniverse;
origin (0.0 0.0 0.0);
pitch (1.26 1.26 0.0);
shape (3 3 0);
padMat Water;
map (
31000 12000 31000
12000 14000 12000
31000 12000 31000
);
}
pin31 { id 31000; type pinUniverse;
radii (0.39218 0.40005 0.45720 0.0);
fills (UO2-31 Helium Zircaloy Water);
}
}Tutorial snippet — no separate file in examples repo
The root universe fills the core boundary with a cellUniverse. The cellUniverse references cells that may contain latUniverse or pinUniverse directly. The latUniverse map specifies lattice positions (universe IDs such as 31000 for a fuel pin universe). Each pinUniverse defines radii and material fills for fuel, gap, clad, and moderator.
Complex Axial Layering
PWR cores have multiple axial zones: lower plenum, active fuel, upper plenum, grid spacers, control rod guide tubes. Each zone is defined by plane surfaces at different z-elevations. Cells combine planes to form axial segments; each segment can contain a different universe (e.g. different pin types or materials at axial elevations).
! Complex axial layering using plane surfaces at different elevations
! Each plane defines a z-elevation; cells combine planes for axial segments
surfaces {
plane460 { id 120; type plane; coeffs (0.0 0.0 1.0 460.0); }
plane431876 { id 121; type plane; coeffs (0.0 0.0 1.0 431.876); }
plane423049 { id 122; type plane; coeffs (0.0 0.0 1.0 423.049); }
plane419704 { id 124; type plane; coeffs (0.0 0.0 1.0 419.704); }
plane150222 { id 138; type plane; coeffs (0.0 0.0 1.0 150.222); }
plane98 { id 140; type plane; coeffs (0.0 0.0 1.0 98.025); }
plane0 { id 149; type plane; coeffs (0.0 0.0 1.0 0.0); }
}
cells {
! Axial segment: between plane98 and plane150222
lowerActive { type simpleCell; id 200; surfaces (-140 138); filltype uni; universe 31000; }
! Axial segment: between plane419704 and plane423049
upperActive { type simpleCell; id 201; surfaces (-124 122); filltype uni; universe 31000; }
}Tutorial snippet — no separate file in examples repo
Plane surfaces use coeffs (c1 c2 c3 c4) for F = c1*x + c2*y + c3*z - c4 = 0. z-elevations use coeffs (0 0 1 z_value) so z = z_value. Cells combine planes with surface sense (-plane inside, +plane outside) to define bounded regions.
Grid Spacer Modeling
Grid spacers are Inconel sleeves that support fuel pins. SCONE models them with zSquareCylinder surfaces (square cross-section, infinite in z). At spacer elevations, cells are split: inside the square envelope, either the spacer material (Inconel) or the pin universe (pin inside the spacer hole). Thick and thin grid types use different halfwidth values.
! Grid spacer modeling using zSquareCylinder overlaid on pin cells
! Thick and thin Inconel sleeves at spacer elevations
surfaces {
pinThickGridInner { id 90; type zSquareCylinder; origin (0.0 0.0 0.0); halfwidth (0.61015 0.61015 0.0); }
pinThickGridOuter { id 91; type zSquareCylinder; origin (0.0 0.0 0.0); halfwidth (0.62992 0.62992 0.0); }
pinThinGridInner { id 92; type zSquareCylinder; origin (0.0 0.0 0.0); halfwidth (0.61049 0.61049 0.0); }
pinThinGridOuter { id 93; type zSquareCylinder; origin (0.0 0.0 0.0); halfwidth (0.62992 0.62992 0.0); }
}
cells {
thickGrid { type simpleCell; id 55; surfaces (90); filltype mat; material Inconel; }
thinGrid { type simpleCell; id 56; surfaces (92); filltype mat; material Inconel; }
! Pin inside thick grid envelope
gridThick31 { type simpleCell; id 1310; surfaces (-90); filltype uni; universe 31000; }
gridThin31 { type simpleCell; id 2310; surfaces (-92); filltype uni; universe 31000; }
}Tutorial snippet — no separate file in examples repo
zSquareCylinder uses origin and halfwidth (hx hy 0) for the square cross-section. Cells with surfaces (90) or (92) are pure spacer material. Cells with surfaces (-90) or (-92) contain the pin universe inside the spacer opening.
Visualization for Debugging
The viz block generates bitmap images of the geometry for debugging. Use it to verify material assignments, check for overlaps or gaps, and confirm axial layering. Output files are written at the specified resolution; centre and width define the view region.
! Visualization block for geometry debugging
! Generates material plots to verify geometry
viz {
bmpZ { type bmp; output imgZ; what material;
centre (0.0 0.0 0.0);
width (5.0 5.0);
axis z;
res (500 500);
}
bmpY { type bmp; output imgY; what material;
centre (0.0 0.0 0.0);
width (5.0 5.0);
axis y;
res (500 500);
}
}Tutorial snippet — no separate file in examples repo
type bmp with what material produces a material-colored slice. axis z gives an xy slice; axis y gives an xz slice. Run with low pop/active/inactive for quick smoke tests when debugging geometry.
Best Practices
Start with simple geometries and add complexity gradually. Use the viz block to verify each change. Validate against known benchmarks when possible. Document surface IDs and universe numbering to avoid conflicts. Test with low population counts before production runs.