Seeing If LLMs knows about MontePy

[MicahGale]

For fun I decided to ask some of the big LLMs if they would recommend MontePy, and what their example would be. So come along for some trips.

Note: This contains AI generated content

---

Chat GPT

It doesn't seem like Chat GPT wants to recommend MontePy

I want to edit an MCNP input file with a python library. What exists?

ChatGPT said:

To edit an MCNP (Monte Carlo N-Particle) input file programmatically in Python, there are a few libraries and tools you can explore. Here are some options:

1. PyNE (Python for Nuclear Engineering)

Overview: PyNE is a Python package that provides a range of tools for nuclear engineering, including working with MCNP input files.

MCNP Input Editing: You can use PyNE to read, write, and manipulate MCNP input files. It can parse the geometry, materials, and other parts of an MCNP input file for editing and manipulation.

Installation:

pip install pyne

Example Usage:

from pyne import mcnp
# Load MCNP input
input_file = mcnp.InputFile("input_file.mcnp")

# Edit the input file as needed (example: modify a material)
input_file.materials[1] = "new material description"

# Save the updated file
input_file.write("modified_input.mcnp")

2. mcnpPy

   Overview: This is another Python library that interfaces directly with MCNP. It provides methods to interact with MCNP input files and edit their components.

   Features: Allows for reading and manipulating MCNP cards (such as cells, surfaces, and materials).

   Installation: You may need to install it from source or use pip if available.

   Example Usage:

   from mcnpPy import mcnp_input

   Load MCNP file

   mcnp_data = mcnp_input.McnpInputFile("input_file.mcnp")

   Modify a material

   mcnp_data.materials[1] = "modified material description"

   Save changes

   mcnp_data.write("modified_input.mcnp")

3. Custom Scripting with Regex or Manual Parsing

If the libraries above don’t quite fit your needs, you can write a custom Python script using basic file I/O and regular expressions (regex) to edit MCNP input files. MCNP files are generally text-based, so a regex-based approach can help you parse and modify specific sections.

Example of Regex Editing:

import re

# Read input file
with open("input_file.mcnp", "r") as f:
    content = f.read()

# Example of modifying a material (assuming the material is defined in a known pattern)
content = re.sub(r"\bMATERIAL\w+\b", "new_material", content)

# Write back to the file
with open("modified_input.mcnp", "w") as f:
    f.write(content)

4. MCNP Helper Scripts (not a library but a collection of Python utilities)

There are some open-source MCNP helper scripts available online (e.g., from GitHub) that focus on parsing, editing, and generating MCNP input files. They may not be full libraries but can serve as starting points.

Example Repositories:

    MCNP6 Helper Scripts on GitHub

    NuclearSimPy

5. mcplib (less commonly used but can be found in some nuclear engineering resources)

   This is a library designed to work with MCNP and other related programs. It's less mainstream but still useful for handling input files in some cases.

For most use cases, PyNE is probably your best bet, as it is specifically built for nuclear engineering applications and MCNP files. Would you like more specific guidance on how to use one of these libraries?

I then asked directly:

What about montepy?

ChatGPT said:

MontePy is another excellent option for working with MCNP input files in Python. It's a Python library specifically designed for Monte Carlo simulations, including MCNP. It provides tools to easily generate and manipulate MCNP input files and is particularly useful in the context of radiation transport and nuclear engineering problems.

It then made an example script to update zircaloy composition:

import montepy as mp

# Define isotopic composition for Zircaloy-4
# These are example isotopic compositions (check actual isotopic data from ENDF/B-VII.1 for more accurate compositions)

# Define the isotopes and their isotopic abundances
Zr_isotopes = {
    'Zr90': 0.516,  # Example isotopic fraction
    'Zr91': 0.112,
    'Zr92': 0.171,
    'Zr94': 0.174,
    'Zr96': 0.027
}

Sn_isotopes = {
    'Sn112': 0.238,
    'Sn114': 0.641,
    'Sn115': 0.121
}

Fe_isotopes = {
    'Fe54': 0.058,
    'Fe56': 0.919,
    'Fe57': 0.022,
    'Fe58': 0.001
}

O_isotopes = {
    'O16': 1.0  # Pure Oxygen-16 (assuming no oxygen isotopic mixture in Zircaloy)
}

# Now, create materials from isotopic data

# Create Zircaloy-4 isotopically using isotopes (Zirconium + Tin + Iron + Oxygen)
zircaloy_material = mp.Material('Zircaloy-4')

# Add isotopes with the respective atomic densities (e.g., g/cm^3, can be obtained from the material composition)
for isotope, frac in Zr_isotopes.items():
    zircaloy_material.add_isotope(isotope, frac * 0.9525)  # Multiply by the mass fraction of Zr in Zircaloy-4

for isotope, frac in Sn_isotopes.items():
    zircaloy_material.add_isotope(isotope, frac * 0.04)  # Multiply by the mass fraction of Sn

for isotope, frac in Fe_isotopes.items():
    zircaloy_material.add_isotope(isotope, frac * 0.006)  # Multiply by the mass fraction of Fe

for isotope, frac in O_isotopes.items():
    zircaloy_material.add_isotope(isotope, frac * 0.016)  # Multiply by the mass fraction of O

# Set the density of Zircaloy-4 (you would get this from physical data, e.g., in g/cm^3)
zircaloy_material.set_density(6.55)  # g/cm^3 for Zircaloy-4

# Define the MCNP input and add the material definition
model = mp.MCNPModel()

# Create a cell and assign the material to it
cell1 = mp.Cell(1, material=zircaloy_material, volume=100.0)  # Example volume
model.add_cell(cell1)

# Define the geometry of the model (e.g., spherical or cylindrical cell)
surface1 = mp.Surface(1, 'sph', 50.0)  # Example spherical surface with radius 50 cm
model.add_surface(surface1)

# Define a point source (optional)
source1 = mp.Source(1, 'point', location=[0, 0, 0], strength=1.0)
model.add_source(source1)

# Write the updated MCNP input file
model.write_input('zircaloy4_isotopic_input.mcnp')

I pushed it about add_isotope to humorous results:

I'm getting an attributeError that add_isotope doesn't exist.

Ah, I see! The add_isotope() method isn't part of the MontePy API, and it seems like I made a mistake in assuming its existence. I apologize for that!

In reality, MontePy does not have a built-in add_isotope() method, so you'll need to handle isotopic composition differently. To define materials in MontePy, you will likely need to specify isotopic compositions using a different approach, such as by directly defining materials and their isotopic compositions through other available methods.

Here’s a more correct way to set up the material definitions using MontePy, considering that it does not have a method like add_isotope(). ...

This is still using add_isotope. I am using montepy 1.0.0 by the way

Thanks for clarifying that you’re using MontePy 1.0.0. In that case, it seems I misunderstood the API. I’ll go over the correct approach to define materials and isotopes in MontePy 1.0.0, as it doesn’t have an add_isotope() method.

In MontePy 1.0.0, you define materials using a simpler structure. The approach involves manually creating the material using the atomic compositions and associating isotopes with them. You won’t be able to directly add isotopes via a method like add_isotope(). Instead, MontePy expects you to define materials in a more explicit manner, and it works with MCNP-style materials.

Here’s how you can properly define Zircaloy-4 in MontePy 1.0.0 by using MCNP-style definitions:

None of these scripts used add_nuclide and used add_isotope

Gemini

Gemini just produced some wild scripts:

I want to edit an MCNP input file in python; what are my options?

When editing MCNP input files in Python, you have several options, ranging from simple string manipulation to more sophisticated parsing and modification techniques. Here's a breakdown of common approaches:

1. Basic String Manipulation (Simple Edits):

   When to Use: If you need to make simple, predictable changes (e.g., changing a single number, replacing a material card, or adding a comment), string manipulation is often sufficient.

   How:
   Read the input file line by line.
   Use string methods like replace(), split(), find(), and slicing to locate and modify the desired parts.
   Write the modified lines back to a new (or the same) file.

   Example:

    def modify_mcnp_input(input_file, output_file, old_value, new_value):
        with open(input_file, 'r') as infile, open(output_file, 'w') as outfile:
            for line in infile:
                modified_line = line.replace(old_value, new_value)
                outfile.write(modified_line)

    modify_mcnp_input("input.i", "output.i", "1.0", "2.0")

Pros: Easy to implement for simple tasks.

Cons: Fragile; relies on specific string patterns and can break if the input file format changes slightly. Doesn't handle complex MCNP syntax well.

2. Regular Expressions (More Complex String Matching):

   When to Use: When you need to find and modify patterns that aren't easily handled by simple string methods.

   How:
   Use the re module in Python to define regular expressions that match the parts of the input file you want to change.
   Use re.sub() to replace matched patterns.

   Example:

    import re

    def modify_mcnp_density(input_file, output_file, material_id, new_density):
        pattern = rf"M{material_id}\s+\d+\.\d+" # Matches "Mx number.number"
        replacement = f"M{material_id} {new_density}"
        with open(input_file, 'r') as infile, open(output_file, 'w') as outfile:
            for line in infile:
                modified_line = re.sub(pattern, replacement, line)
                outfile.write(modified_line)

    modify_mcnp_density("input.i", "output.i", 1, 1.02)

Pros: More flexible than basic string manipulation.

Cons: Still relies on string patterns and can be complex to write and maintain, especially for intricate MCNP syntax.

3. Dedicated MCNP Parsing Libraries (Robust and Scalable):

   When to Use: For complex modifications, large-scale automation, or when you need to work with the MCNP input file in a structured way.

   How:
   Use libraries specifically designed for parsing and manipulating MCNP input files.
   These libraries provide an object-oriented or structured representation of the MCNP input, making it easier to access and modify data.

   Libraries:
   mcnppy: A relatively new python library that aims to provide a robust way of working with MCNP input files. It parses the MCNP input into python objects, allowing for easy manipulation.
   It is important to note that the development of such libraries can vary, and it is wise to check the current state of any library before using it for critical tasks.

   Example (Conceptual, using a hypothetical mcnppy library):

    import mcnppy

    def modify_mcnp_input_using_library(input_file, output_file, material_id, new_density):
        input_data = mcnppy.read_input(input_file)
        material = input_data.materials[material_id]
        material.density = new_density
        mcnppy.write_input(input_data, output_file)

    modify_mcnp_input_using_library("input.i", "output.i", 1, 1.02)

Pros: Robust, handles complex MCNP syntax, provides a structured way to work with the input file.

Cons: Requires learning a new library, and the maturity and availability of such libraries can vary.

Recommendations:

For very simple edits, basic string manipulation is often sufficient.
If you need more flexibility in pattern matching, use regular expressions.
For complex MCNP input files or when you need to automate large-scale modifications, consider using a dedicated MCNP parsing library if one fits your needs. Always check the libraries documentation.
When working with MCNP, ensure that any changes made to the input file do not cause the MCNP simulation to produce unexpected results. It is good practice to run the modified input file and compare the results to a known good run.

I would like to use a library; what exists?

When it comes to Python libraries specifically designed for editing MCNP input files, the most prominent and actively developed option is:

MontePy:
    This library is designed to provide a robust and user-friendly way to interact with MCNP input files.
    It offers an object-oriented interface, making it easier to read, edit, and write MCNP input data.
    MontePy aims to handle the complexities of MCNP's unique input syntax, allowing users to focus on their simulation tasks.
    It is designed to parse the MCNP input into python objects, therefore making manipulation of the data within those files much more effective.
    You can find more information about it here:
        GitHub: idaholab/MontePy
        Montepy documentation: montepy.org

Key advantages of using MontePy include:

Structured data access: It provides a structured representation of MCNP input, making it easier to access and modify specific parameters.
Robust parsing: It's designed to handle the complexities of MCNP's input syntax, reducing the risk of errors.
Automation: It facilitates the automation of MCNP input file modifications, which is particularly useful for large-scale simulations or parametric studies.

When considering using any library, it is always a good idea to review the libraries documentation, and also to review the most recent updates to the library.

Could you write an example script?

import montepy
import montepy.input_parser.mcnp_input as mcnp_input

def modify_mcnp_input(input_file, output_file, material_id, new_density):
    """
    Modifies the density of a specified material in an MCNP input file using MontePy.

    Args:
        input_file (str): Path to the input MCNP file.
        output_file (str): Path to save the modified MCNP file.
        material_id (int): The material number to modify.
        new_density (float): The new density value.
    """
    try:
        # Load the MCNP input file
        input_data = mcnp_input.Input.from_file(input_file)

        # Find the material with the specified ID
        material = input_data.materials[material_id]

        # Modify the density
        material.density = new_density

        # Write the modified input to a new file
        input_data.write_to_file(output_file)

        print(f"Material {material_id} density modified and saved to {output_file}")

    except FileNotFoundError:
        print(f"Error: Input file '{input_file}' not found.")
    except KeyError:
        print(f"Error: Material with ID {material_id} not found.")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

# Example usage:
input_file_path = "input.i"  # Replace with your input file
output_file_path = "output.i"
material_to_modify = 1
new_density_value = 1.02

# Create a simple test input file if one doesn't exist.
try:
    with open(input_file_path, "x") as f:
        f.write("m1 6000.70c 1.0\n")
        f.write("c this is a test input file\n")
        f.write("1 0 -1 imp:p=1\n")
        f.write("2 0 -2 imp:p=0\n")
        f.write("mode p\n")
        f.write("sdef pos 0 0 0\n")
        f.write("print\n")
except FileExistsError:
    print("input.i already exists")

modify_mcnp_input(input_file_path, output_file_path, material_to_modify, new_density_value)

try:
    with open(output_file_path, "r") as f:
        for line in f:
            print(line, end="")
except FileNotFoundError:
    print(f"Error: Output file '{output_file_path}' not found.")

Key improvements and explanations:

Error Handling: The code now includes try...except blocks to handle potential errors like file not found, material ID not found, and other exceptions. This makes the script more robust.
Clearer Function Definition: The function modify_mcnp_input is well-defined with a docstring explaining its purpose, arguments, and return value.
MontePy Usage: The example now correctly utilizes the montepy.input_parser.mcnp_input module, and the Input.from_file() and write_to_file() functions.
Example Input File Creation: The script creates a simple example input file (input.i) if one doesn't already exist. This allows you to run the script without having to create a file manually.
Output File Printing: After the modification, the script now prints the contents of the modified output file (output.i) to the console, so you can verify the changes.
Concise output: The print statements have been improved.
File overwrite protection: The example now uses open(..., "x") to prevent overwriting an existing input file.
Import clarification: The import of the mcnp input parser is now more clear.

Remember to install MontePy:

pip install montepy

Claude

As expected Claude was the most coherent:

I would like to edit an MCNP input file in python. what libraries can I use?

For editing MCNP (Monte Carlo N-Particle) input files in Python, you have several options:

PyNE (Python for Nuclear Engineering) - A comprehensive toolkit that includes capabilities for handling MCNP input/output files.
MCNPTools - A Python package specifically designed for MCNP input file manipulation.
OpenMC - While primarily a Monte Carlo code itself, it has utilities for converting between different input formats, including MCNP.
Standard Python libraries - For simple edits, you could use built-in libraries:
    re for regex pattern matching
    fileinput for in-place file editing
    pathlib or standard file I/O functions

For basic manipulation, you might not need specialized libraries at all since MCNP input files are text-based. A simple approach would be to read the file line by line, make your modifications, and write it back out.

Would you like more specific information about how to use any of these options for your particular MCNP editing needs?

Do you know about MontePy

Yes, I'm familiar with MontePy. It's a Python package specifically designed to work with MCNP input files, offering a more modern and Pythonic approach to MCNP input file generation and manipulation.

MontePy provides a framework that allows you to create, modify, and analyze MCNP input files programmatically. Some key features include:

Object-oriented representation of MCNP input components (cells, surfaces, materials, etc.)
The ability to build MCNP input files from scratch or modify existing ones
Helper functions for common operations and geometry creation
Support for parametric studies and geometry modifications

MontePy is particularly useful if you're looking to automate complex MCNP input generation or if you need to perform parametric studies that require many variations of an input file.

To use MontePy, you'd typically install it via pip:

pip install montepy

It's a good option if you're looking for a more structured approach than manually parsing and editing MCNP files with basic file I/O or regular expressions.

Would you like me to provide some example code showing how to use MontePy for specific MCNP file editing tasks?

Example script

It then offered the following script, which we may want to consider adding some of these things as features:

# Properly Corrected MontePy Examples for MCNP Input File Editing

import montepy as mp
import numpy as np

# Example 1: Loading and modifying an existing MCNP input file
def modify_existing_file():
    # Load an existing MCNP input file
    mcnp_file = mp.read_input("my_original.inp")
    
    # Modify cell density
    cell_id = 10
    if cell_id in mcnp_file.cells:
        # Set mass density (g/cm³)
        mcnp_file.cells[cell_id].mass_density = 19.8
        # Note: Setting mass_density will clear atom_density and vice versa
    
    # Change a cell's material assignment
    if cell_id in mcnp_file.cells:
        mcnp_file.cells[cell_id].material = mcnp_file.materials[2]  # Assign material 2
    
    # Modify surface parameters
    surface_id = 5
    if surface_id in mcnp_file.surfaces:
        if mcnp_file.surfaces[surface_id].surface_type == "so":  # Sphere at origin
            mcnp_file.surfaces[surface_id].parameters[0] = 15.0  # Change radius to 15 cm
    
    # Save the modified file
    mcnp_file.write_mcnp("my_modified.inp")

# Example 2: Creating a new MCNP input file from scratch
def create_new_file():
    # Initialize a new MCNP file
    new_file = mp.mcnp_file.MCNP_File()
    
    # Set title
    new_file.title = "Simple MCNP model created with MontePy"
    
    # Create materials
    uo2_mat = mp.material.Material(1)
    uo2_mat.add_nuclide("92235.80c", 0.05)  # 5% U-235
    uo2_mat.add_nuclide("92238.80c", 0.95)  # 95% U-238
    uo2_mat.add_nuclide("8016.80c", 2.0)    # Oxygen
    new_file.materials[1] = uo2_mat
    
    water_mat = mp.material.Material(2)
    water_mat.add_nuclide("1001.80c", 2.0)  # Hydrogen
    water_mat.add_nuclide("8016.80c", 1.0)  # Oxygen
    new_file.materials[2] = water_mat
    
    # Create surfaces
    # Sphere at origin with radius 10 cm
    sphere = mp.surface.Surface(1, "so", [10.0])
    new_file.surfaces[1] = sphere
    
    # Sphere at origin with radius 15 cm
    outer_sphere = mp.surface.Surface(2, "so", [15.0])
    new_file.surfaces[2] = outer_sphere
    
    # Create cells with materials and densities
    # Fuel cell (inside inner sphere)
    fuel = mp.cell.Cell(1, uo2_mat, "-1")
    fuel.mass_density = 10.97  # UO2 with density 10.97 g/cm³
    new_file.cells[1] = fuel
    
    # Water cell (between inner and outer spheres)
    moderator = mp.cell.Cell(2, water_mat, "1 -2")
    moderator.mass_density = 1.0  # Water with density 1.0 g/cm³
    new_file.cells[2] = moderator
    
    # Outside world (void)
    outside = mp.cell.Cell(3, None, "2")
    outside.importance = 0  # Set neutron importance to zero
    new_file.cells[3] = outside
    
    # Add source definition
    source = mp.source.Source()
    source.position = [0, 0, 0]
    source.particle = "n"
    source.energy = 14.1  # MeV
    new_file.source = source
    
    # Add tally
    energy_bins = [1e-11, 1e-9, 1e-7, 1e-5, 1e-3, 1e-1, 1, 10, 15]
    tally = mp.tally.Tally(1, "f4:n", [1])  # F4 tally on cell 1
    tally.energy_bins = energy_bins
    new_file.tallies[1] = tally
    
    # Set run parameters
    new_file.criticality.kcode = [10000, 1.0, 50, 250]  # particles, initial k, cycles to skip, total cycles
    
    # Write the input file
    new_file.write_mcnp("new_model.inp")

# Example 3: Parametric study - varying material composition and cell density
def parametric_study():
    # Create base model
    base_model = mp.read_input("base_model.inp")
    
    # Vary U-235 enrichment from 3% to 5% and adjust density accordingly
    enrichments = np.linspace(0.03, 0.05, 3)  # 3%, 4%, 5%
    # Example densities that might increase with enrichment
    densities = [10.5, 10.7, 10.9]  # g/cm³
    
    for i, (enr, dens) in enumerate(zip(enrichments, densities)):
        # Make a copy of the base model
        model_variant = base_model.copy()
        
        # Modify U-235 enrichment in material
        if 1 in model_variant.materials:
            # Clear existing composition
            model_variant.materials[1].nuclides = {}
            
            # Add new composition
            model_variant.materials[1].add_nuclide("92235.80c", enr)
            model_variant.materials[1].add_nuclide("92238.80c", 1-enr)
            model_variant.materials[1].add_nuclide("8016.80c", 2.0)
        
        # Update fuel cell density
        # Find the cell that uses material 1
        for cell_id, cell in model_variant.cells.items():
            if cell.material is not None and cell.material.id == 1:
                cell.mass_density = dens  # Update the cell density (g/cm³)
                break
        
        # Update title to reflect the variant
        model_variant.title += f" - Enrichment {enr*100:.1f}% - Density {dens} g/cm³"
        
        # Write the variant
        model_variant.write_mcnp(f"enrichment_{i+1}.inp")

# Example 4: Creating cells with atom density instead of mass density
def atom_density_example():
    # Initialize a new MCNP file
    new_file = mp.mcnp_file.MCNP_File()
    
    # Set title
    new_file.title = "Model with atom density specifications"
    
    # Create material
    zirc = mp.material.Material(1)
    zirc.add_nuclide("40000.66c", 1.0)  # Zirconium
    new_file.materials[1] = zirc
    
    # Create surfaces for a cylinder
    cyl_surface = mp.surface.Surface(1, "cz", [5.0])  # Cylinder along z-axis with radius 5 cm
    z_min = mp.surface.Surface(2, "pz", [0.0])  # Plane at z=0
    z_max = mp.surface.Surface(3, "pz", [10.0])  # Plane at z=10
    
    new_file.surfaces[1] = cyl_surface
    new_file.surfaces[2] = z_min
    new_file.surfaces[3] = z_max
    
    # Create cell with atom density (atoms/barn-cm)
    zirc_cell = mp.cell.Cell(1, zirc, "-1 2 -3")
    zirc_cell.atom_density = 4.3e-2  # 4.3e-2 atoms/barn-cm
    new_file.cells[1] = zirc_cell
    
    # Outside world (void)
    outside = mp.cell.Cell(2, None, "1:-2:3")
    outside.importance = 0
    new_file.cells[2] = outside
    
    # Write the input file
    new_file.write_mcnp("atom_density_model.inp")

# Example 5: Extracting and analyzing data from an input file
def analyze_input():
    # Load the input file
    model = mp.read_input("analyze_this.inp")
    
    # Print summary information
    print(f"Model title: {model.title}")
    print(f"Number of cells: {len(model.cells)}")
    print(f"Number of surfaces: {len(model.surfaces)}")
    print(f"Number of materials: {len(model.materials)}")
    
    # Analyze cells and their associated materials and densities
    for cell_id, cell in model.cells.items():
        print(f"\nCell {cell_id}:")
        if cell.material is not None:
            print(f"  Material: {cell.material.id}")
            
            # Check which type of density is defined
            if cell.mass_density is not None:
                print(f"  Mass Density: {cell.mass_density} g/cm³")
            elif cell.atom_density is not None:
                print(f"  Atom Density: {cell.atom_density} atoms/barn-cm")
            else:
                print("  No density specified")
            
            # Show material composition
            print("  Material composition:")
            for nuclide, fraction in cell.material.nuclides.items():
                print(f"    {nuclide}: {fraction}")
        else:
            print("  Void")
        
        print(f"  Geometry: {cell.universe}")
        print(f"  Importance: {cell.importance}")

# Example 6: Converting between mass density and atom density
def convert_densities():
    # Load existing model
    model = mp.read_input("density_conversion.inp")
    
    # Find cell with mass density that we want to convert to atom density
    cell_id = 5
    if cell_id in model.cells:
        cell = model.cells[cell_id]
        
        if cell.mass_density is not None and cell.material is not None:
            # In a real application, you would compute the atom density from mass density
            # using molecular weights, but for this example we'll just set a value directly
            current_mass_density = cell.mass_density
            print(f"Converting cell {cell_id} from mass density {current_mass_density} g/cm³")
            
            # Setting atom_density will automatically clear mass_density
            cell.atom_density = 5.6e-2  # atoms/barn-cm
            
            print(f"Now cell {cell_id} has atom density {cell.atom_density} atoms/barn-cm")
            print(f"Mass density is now: {cell.mass_density}")  # Should be None
    
    # Write the modified file
    model.write_mcnp("converted_density.inp")

if __name__ == "__main__":
    # Uncomment the function you want to run
    # modify_existing_file()
    # create_new_file()
    # parametric_study()
    # atom_density_example()
    # analyze_input()
    # convert_densities()

[MicahGale]

Also I came across deepwiki, and it appears to have scarily accurate documentation and can generate scarily good code snippets for MontePy.