OpenSn User Guide (Draft)

• 1. Overview
• 2. Installation
• 3. OpenSn Basics
  • 3.1. The Core Model
  • 3.2. The Typical Workflow
  • 3.3. What Usually Goes Where
  • 3.4. The Three Most Important Practical Rules
  • 3.5. Good Default Habits
  • 3.6. What To Read Next
• 4. Geometry and Mesh
  • 4.1. Overview
  • 4.2. MeshContinuum
  • 4.3. Mesh Generators
  • 4.4. Coordinate Systems
  • 4.5. Partitioning
  • 4.6. Replicated Meshes
  • 4.7. Block IDs
  • 4.8. Boundary Naming and Boundary IDs
  • 4.9. Logical Volumes
  • 4.10. Practical Mesh Workflows
  • 4.11. Inspecting and Exporting Meshes
  • 4.12. Practical Guidance
• 5. Materials and Cross-Section Data
  • 5.1. Overview
  • 5.2. Materials, Block IDs, and xs_map
  • 5.3. Creating a Simple One-Group Cross Section
  • 5.4. Inspecting a MultiGroupXS Object
  • 5.5. Loading OpenSn Cross-Section Files
  • 5.6. Loading OpenMC MGXS Files
  • 5.7. Custom Cross Sections
  • 5.8. Combining Cross Sections
  • 5.9. Scaling Cross Sections
  • 5.10. Choosing Between OpenSn and OpenMC Inputs
  • 5.11. Practical Example
  • 5.12. Cautions and Best Practices
• 6. Angular Quadratures
  • 6.1. Overview
  • 6.2. How to Choose a Quadrature
• 7. Product Quadratures
  • 7.1. Selecting Enough Angular Resolution
  • 7.2. Angle Aggregation Compatibility
  • 7.3. Examples
  • 7.4. Inspecting a Quadrature
  • 7.5. Recommendations
• 8. Groupsets
  • 8.1. Overview
  • 8.2. What a Groupset Does
  • 8.3. Required Core Fields
  • 8.4. Writing a Minimal Groupset
  • 8.5. Common Optional Groupset Controls
  • 8.6. Single Groupset vs Multiple Groupsets
  • 8.7. Groupsets and AGS
  • 8.8. Example Patterns
  • 8.9. Practical Guidance
• 9. Iterative Methods
  • 9.1. Overview
  • 9.2. Where the Iteration Controls Live
  • 9.3. Inner Groupset Methods
  • 9.4. Convergence Controls
  • 9.5. Across-Groupset Iteration
  • 9.6. DSA Options
  • 9.7. Solver-Specific Outer Iteration
  • 9.8. Choosing a Method
  • 9.9. Examples
  • 9.10. Recommendations
• 10. CMFD Acceleration
  • 10.1. Basic Usage
  • 10.2. Common User Options
  • 10.3. Developer And Debug Options
  • 10.4. Multi-Groupset Behavior
  • 10.5. Diagnostics
  • 10.6. Correction Safeties And Warnings
  • 10.7. Supported Scope
  • 10.8. Limitations
• 11. Boundary Conditions and Sources
  • 11.1. Overview
  • 11.2. Boundary Conditions
  • 11.3. Point Sources
  • 11.4. Volumetric Sources
  • 11.5. Attaching Sources at Problem Construction
  • 11.6. Replacing Sources After Construction
  • 11.7. Transient Source and Boundary Behavior
  • 11.8. Boundary Names and Mesh Labels
  • 11.9. Best Practices
• 12. Discrete-Ordinates Problems
  • 12.1. Overview
  • 12.2. Constructor Summary
  • 12.3. Constructor Inputs
  • 12.4. Shared LBS Interface
  • 12.5. Problem Options
  • 12.6. sweep_type
  • 12.7. Problem Modes
  • 12.8. Field-Function Interface
  • 12.9. Angular-Flux Access
  • 12.10. Balance and Leakage
  • 12.11. Writing and Reading Transport State
  • 12.12. Updating the Problem In Place
  • 12.13. DiscreteOrdinatesCurvilinearProblem
  • 12.14. Typical Construction Patterns
  • 12.15. Practical Guidance
• 13. Solvers
• 14. Overview
• 15. Base Classes
• 16. LBS Problem
• 17. Discrete Ordinates Problem
  • 17.1. Time-Dependent and Steady-State Modes
  • 17.2. Angular-Flux-Specific Features
  • 17.3. DiscreteOrdinatesCurvilinearProblem
• 18. Steady-State Source Solver
  • 18.1. Constructor
  • 18.2. GPU support
  • 18.3. How It Operates
  • 18.4. Adjoint Steady-State Solves
• 19. Transient Solver
  • 19.1. GPU support
  • 19.2. Constructor
  • 19.3. Using Execute
  • 19.4. Using an Explicit Python Timestep Loop
  • 19.5. Balance Reporting
• 20. Power Iteration k-Eigen Solver
  • 20.1. Constructor
  • 20.2. GPU support
  • 20.3. How It Operates
• 21. Nonlinear k-Eigen Solver
  • 21.1. Constructor
  • 21.2. GPU support
  • 21.3. Groupsets and DSA
  • 21.4. Statuses and errors
• 22. Initialization Order and Common Patterns
• 23. Field Functions and Solver Output
• 24. Example Problems
  • 24.1. Common Input Structure
  • 24.2. Overview
  • 24.3. Common Building Blocks
  • 24.4. Example 1: Source-Driven Steady-State Problem
  • 24.5. Example 2: Multi-Material Fixed-Source Problem
  • 24.6. Example 3: Boundary-Driven Problem
  • 24.7. Example 4: Time-Dependent Source Problem
  • 24.8. Example 5: Explicit Python Time Loop
  • 24.9. Example 6: Power-Iteration k-Eigenvalue Problem
  • 24.10. Example 7: Nonlinear k-Eigenvalue Problem
  • 24.11. Example 8: Curvilinear Problem
  • 24.12. Example 9: Updating a Problem In Place
  • 24.13. Example 10: Field-Function Output
  • 24.14. Example 11: Balance and Leakage Checks
  • 24.15. Example 12: Reusing Flux Data
  • 24.16. Example 13: Writing and Reading Restart Dumps
  • 24.17. Example 14: Starting a Transient from a Steady-State Restart
  • 24.18. Choosing a Template
• 25. Post Processors
  • 25.1. Overview
  • 25.2. Updating Existing Field Functions
  • 25.3. Scalar Flux Field Functions
  • 25.4. Derived Field Functions
  • 25.5. Angular Flux Field Functions
  • 25.6. Exporting Field Functions
  • 25.7. Field-Function Interpolation
  • 25.8. Volume Postprocessor
  • 25.9. Other Useful Post-Processing Paths
  • 25.10. Transient Workflows
  • 25.11. Practical Guidance
• 26. Visualization
  • 26.1. Overview
  • 26.2. Visualizing the Mesh
  • 26.3. Visualizing Scalar Flux
  • 26.4. Visualizing Power
  • 26.5. Exporting Several Fields Together
  • 26.6. Transient Visualization
  • 26.7. Practical Advice
• 27. Running Problems
  • 27.1. Basic command-line usage
  • 27.2. Running under MPI
  • 27.3. Running with GPUs
  • 27.4. Typical execution pattern
  • 27.5. Inputs, logs, and outputs
  • 27.6. Restart and repeated solves
  • 27.7. Practical advice
• 28. Iterative Best Practices
  • 28.1. Overview
  • 28.2. Core Rules
  • 28.3. Upscatter Across Groupsets Must Be Converged
  • 28.4. Single Groupset First, Then Split Deliberately
  • 28.5. Choose the Inner Method Pragmatically
  • 28.6. Use DSA When the Physics Suggests It
  • 28.7. Watch Maximum Iteration Counts
  • 28.8. Be Careful with Nested Solver Expectations
  • 28.9. Transient Best Practices
  • 28.10. Eigenvalue Best Practices
  • 28.11. What to Check First When Convergence Looks Bad
  • 28.12. Recommended Starting Habits
• 29. Troubleshooting
  • 29.1. Start with the simplest question
  • 29.2. If the code fails immediately
  • 29.3. If the solution does not converge
  • 29.4. If the physics looks wrong
  • 29.5. If field functions are confusing
  • 29.6. If parallel behavior looks odd
  • 29.7. If imported cross sections behave unexpectedly
  • 29.8. General debugging workflow
  • 29.9. When to look elsewhere in the manual
• 30. FAQ
  • 30.1. Why is my problem split into a problem object and a solver object?
  • 30.2. Should I start with multiple groupsets?
  • 30.3. Why is my field function not updating?
  • 30.4. How do I get normalized power or XS-weighted outputs?
  • 30.5. When should I use Execute() and when should I use Advance()?
  • 30.6. What quadrature order should I use?
  • 30.7. Is single-angle aggregation always necessary when using unstructured meshes?
  • 30.8. What is the safest default sweep type?
  • 30.9. Do I need to export field functions during every run?