Nuclear Radiation to Energy Conversion Simulation

Isotope Composition (kg)

Neutron Flux (n/cm²/s)

1e121e20

Current Neutron Flux: 1e14

Core Temperature (Kelvin)

300 K2000 K

Current Core Temperature: 1000 K

Conversion Efficiency (%)

5%50%

Current Conversion Efficiency: 33%

Simulation Time (seconds)

Simulation Status

Time Elapsed: 0 s

Total Energy Released: 0 Joules

Converted Power Output: 0

Reactor Status: Stopped

Isotope Details

Isotope	Quantity (kg)	Cross-Section (barns)	Energy Released (MeV)	Decay Products

Energy Conversion Charts

Nuclear Radiation to Energy Conversion README

Nuclear Radiation to Energy Conversion Simulation README

This web application simulates the process of converting nuclear radiation into usable energy through isotope reactions.

Isotope Composition: Users can input and adjust the composition of various isotopes like Uranium-235, Uranium-238, and Thorium-232.
Neutron Flux and Core Temperature: These variables affect the rate of nuclear reactions and energy output. Users can adjust the neutron flux and core temperature through sliders.
Energy Conversion: The simulation calculates the total energy released and converted based on the user-defined parameters and efficiency settings.

The interface is built using HTML5, Bootstrap, and Chart.js for dynamic graph plotting of energy, power output, and core temperature over time.

Project Structure

HTML Structure

The simulation is structured into sections for adjusting parameters (e.g., isotope composition, neutron flux, core temperature), simulation control (start/stop), and displaying simulation results. Charts show real-time energy output, power, and temperature changes during the simulation.

Scripts and Libraries

Bootstrap 5.3: Used for responsive styling and layout.
Chart.js: Used to plot dynamic charts for energy, power, and temperature outputs.

JavaScript functions handle the dynamic updates of simulation parameters and control the real-time simulation. Data is collected, and charts are updated at every step of the simulation.

Detailed Explanation of Code

1. HTML Structure

The HTML file starts with a <!DOCTYPE html> declaration and uses Bootstrap for layout and form controls. Various sliders and buttons are provided for user interaction, including neutron flux, core temperature, and conversion efficiency. A table displays isotope data, and Chart.js is used to show energy conversion charts.

2. Isotope Composition and Parameter Sliders

Users can define the isotope composition and adjust key parameters:

Isotope Composition: A set of predefined isotopes is provided, including Uranium-235, Uranium-238, and Thorium-232. Isotope quantities can be adjusted, and cross-sections and energy released during reactions are displayed in a table.
Neutron Flux: Controlled by a slider, neutron flux affects the reaction rate.
Core Temperature: Users can adjust the core temperature, which affects the energy output.
Conversion Efficiency: A slider allows users to adjust how much energy is converted into usable power.

3. Key Functions

initializeIsotopes(): Initializes the isotope composition inputs and sets default values for U-235 and U-238.
addIsotopeInput(): Dynamically adds isotope composition input fields for the user to modify.
startSimulation(): Starts the simulation by setting the time, energy data, and power data to 0 and updating charts at each step.
runSimulationStep(): Calculates the reaction rate, total energy released, power output, and updates the core temperature for each step of the simulation.
updateCharts(): Dynamically updates the energy, power, and temperature charts during the simulation using Chart.js.

4. Energy and Power Calculation

The simulation calculates the total energy released during the reactions, the reactor's power output based on conversion efficiency, and the temperature changes. The key formulae include:

Energy Released (Joules): This is based on the reaction rate and the energy released by each isotope. The reaction rate is calculated using the neutron flux and isotope cross-section:

reactionRate = crossSection * neutronFlux * numAtoms

Power Output (Watts): Calculated as the energy released per second multiplied by the conversion efficiency.
Core Temperature: The temperature is updated based on the total energy released and a simplified heat capacity calculation.

Explore the Code (Interactive)

The code below represents the backbone of the simulation, including isotope composition, simulation parameters, and chart updates.

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>Nuclear Radiation to Energy Conversion Simulation</title>
    
    
    
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
    
</head>

<body>
    <div class="container">
        <h1>Nuclear Radiation to Energy Conversion Simulation</h1>

<div class="mb-3">
            <label class="form-label">Isotope Composition (kg)</label>
            <div id="isotopeComposition">
                
            </div>
            <button class="btn btn-secondary" onclick="addIsotope()">Add Isotope</button>
        </div>

<div class="mb-3">
            <label class="form-label">Neutron Flux (n/cm²/s)</label>
            <div class="slider-label">
                <span>1e12</span><span>1e20</span>
            </div>
            <input type="range" class="form-range" id="neutronFluxSlider" min="1e12" max="1e20" step="1e12" value="1e14"
                oninput="updateNeutronFluxSlider(this.value)">
            <p>Current Neutron Flux: <span id="neutronFluxValue">1e14</span></p>
        </div>

<div class="mb-3">
            <label class="form-label">Core Temperature (Kelvin)</label>
            <div class="slider-label">
                <span>300 K</span><span>2000 K</span>
            </div>
            <input type="range" class="form-range" id="temperatureSlider" min="300" max="2000" step="10" value="1000"
                oninput="updateTemperatureSlider(this.value)">
            <p>Current Core Temperature: <span id="temperatureValue">1000</span> K</p>
        </div>

<div class="mb-3">
            <label class="form-label">Conversion Efficiency (%)</label>
            <div class="slider-label">
                <span>5%</span><span>50%</span>
            </div>
            <input type="range" class="form-range" id="efficiencySlider" min="5" max="50" step="1" value="33"
                oninput="updateEfficiencySlider(this.value)">
            <p>Current Conversion Efficiency: <span id="efficiencyValue">33</span>%</p>
        </div>

<div class="mb-3">
            <label for="simulationTime" class="form-label">Simulation Time (seconds)</label>
            <input type="number" class="form-control" id="simulationTime" value="3600" min="0" max="1e7" step="100"
                oninput="updateSimulationTime()">
        </div>

<div class="mb-3">
            <button class="btn btn-primary" onclick="startSimulation()">Start Simulation</button>
            <button class="btn btn-danger" onclick="stopSimulation()">Stop Simulation</button>
        </div>

<div class="mb-3">
            <h3>Simulation Status</h3>
            <p>Time Elapsed: <span id="timeElapsed">0</span> s</p>
            <p>Total Energy Released: <span id="totalEnergyReleased">0</span> Joules</p>
            <p>Converted Power Output: <span id="powerOutput">0</span></p>
            <p>Reactor Status: <span id="reactorStatus">Stopped</span></p>
        </div>

<div class="mb-3">
            <h3>Isotope Details</h3>
            <table class="table table-bordered" id="isotopeTable">
                <thead>
                    <tr>
                        <th>Isotope</th>
                        <th>Quantity (kg)</th>
                        <th>Cross-Section (barns)</th>
                        <th>Energy Released (MeV)</th>
                        <th>Decay Products</th>
                    </tr>
                </thead>
                <tbody>
                    
                </tbody>
            </table>
        </div>

<div class="mb-3">
            <h3>Energy Conversion Charts</h3>
            <canvas id="energyChart"></canvas>
            <canvas id="powerChart"></canvas>
            <canvas id="temperatureChart"></canvas>
        </div>
    </div>

// Simulation Parameters
        let simulationInterval;
        let simulationData = {
            timeElapsed: 0,
            totalEnergyReleased: 0,
            reactorStatus: 'Stopped',
            isotopeQuantities: {}, // { isotope: quantity in kg }
            neutronFlux: 1e14, // n/cm²/s
            coreTemperature: 1000, // Kelvin
            conversionEfficiency: 0.33, // Efficiency (33%)
            simulationTime: 3600, // seconds
            energyData: [],
            powerData: [],
            temperatureData: [],
        };

// Initialize Isotope Composition Inputs
        function initializeIsotopes() {
            const isotopeCompositionDiv = document.getElementById('isotopeComposition');
            isotopeCompositionDiv.innerHTML = '';
            // Default isotopes
            addIsotopeInput('U235', 1000); // 1000 kg of U-235
            addIsotopeInput('U238', 3000); // 3000 kg of U-238
        }

// Add Isotope Input Field
        function addIsotopeInput(isotopeSymbol = '', quantity = 0) {
            const isotopeCompositionDiv = document.getElementById('isotopeComposition');
            const isotopeSelect = document.createElement('select');
            isotopeSelect.className = 'form-select isotope-select';
            isotopeSelect.innerHTML = Object.keys(isotopeLibrary).map(isotope => {
                return `<option value="${isotope}" ${isotope === isotopeSymbol ? 'selected' : ''}>${isotope}</option>`;
            }).join('');

const quantityInput = document.createElement('input');
            quantityInput.type = 'number';
            quantityInput.className = 'form-control isotope-quantity';
            quantityInput.value = quantity;
            quantityInput.min = 0;

const inputGroup = document.createElement('div');
            inputGroup.className = 'input-group mb-1';
            inputGroup.appendChild(isotopeSelect);
            inputGroup.appendChild(quantityInput);

isotopeCompositionDiv.appendChild(inputGroup);
        }

// Add Isotope Button Handler
        function addIsotope() {
            addIsotopeInput();
        }

// Update Neutron Flux from Slider
        function updateNeutronFluxSlider(value) {
            simulationData.neutronFlux = parseFloat(value);
            document.getElementById('neutronFluxValue').textContent = value;
        }

// Update Core Temperature from Slider
        function updateTemperatureSlider(value) {
            simulationData.coreTemperature = parseFloat(value);
            document.getElementById('temperatureValue').textContent = value;
        }

// Update Conversion Efficiency from Slider
        function updateEfficiencySlider(value) {
            simulationData.conversionEfficiency = parseFloat(value) / 100;
            document.getElementById('efficiencyValue').textContent = value;
        }

// Update Simulation Time
        function updateSimulationTime() {
            simulationData.simulationTime = parseFloat(document.getElementById('simulationTime').value);
        }

// Update Isotope Table
        function updateIsotopeTable() {
            const tableBody = document.getElementById('isotopeTable').querySelector('tbody');
            tableBody.innerHTML = '';
            const isotopeSelects = document.querySelectorAll('.isotope-select');
            const isotopeQuantities = document.querySelectorAll('.isotope-quantity');
            simulationData.isotopeQuantities = {};
            isotopeSelects.forEach((select, index) => {
                const isotopeSymbol = select.value;
                const quantity = parseFloat(isotopeQuantities[index].value);
                simulationData.isotopeQuantities[isotopeSymbol] = quantity;

// Start Simulation
        function startSimulation() {
            updateIsotopeTable();
            simulationData.timeElapsed = 0;
            simulationData.totalEnergyReleased = 0;
            simulationData.energyData = [];
            simulationData.powerData = [];
            simulationData.temperatureData = [];
            simulationData.reactorStatus = 'Running';
            updateSimulationStatus();

simulationInterval = setInterval(runSimulationStep, 1000); // Update every second
        }

// Stop Simulation
        function stopSimulation() {
            clearInterval(simulationInterval);
            simulationData.reactorStatus = 'Stopped';
            updateSimulationStatus();
        }

// Run Simulation Step
        function runSimulationStep() {
            if (simulationData.timeElapsed >= simulationData.simulationTime) {
                stopSimulation();
                return;
            }

// Update Time
            simulationData.timeElapsed += 1;

// Calculate Reaction Rates and Energy Release
            let totalEnergyReleasedThisStep = 0;
            let powerOutputThisStep = 0;

for (const isotopeSymbol in simulationData.isotopeQuantities) {
                const isotope = isotopeLibrary[isotopeSymbol];
                const quantity = simulationData.isotopeQuantities[isotopeSymbol];

// Convert kg to number of atoms
                const molarMass = isotope.massNumber; // Approximate molar mass in g/mol
                const numMoles = (quantity * 1000) / molarMass; // Convert kg to grams
                const numAtoms = numMoles * 6.022e23; // Avogadro's number

// Reaction rate and energy released
                const crossSection = isotope.crossSection.thermal; // Using thermal cross-section for simplicity
                const reactionRate = crossSection * 1e-24 * simulationData.neutronFlux * numAtoms; // reactions per second
                const energyReleased = reactionRate * isotope.energyRelease * 1.60218e-13; // Convert MeV to Joules

totalEnergyReleasedThisStep += energyReleased;

// Power output (simplified as energy per second)
                powerOutputThisStep += energyReleased * simulationData.conversionEfficiency;
            }

// Update total energy and power output
            simulationData.totalEnergyReleased += totalEnergyReleasedThisStep;
            simulationData.energyData.push({ x: simulationData.timeElapsed, y: simulationData.totalEnergyReleased });
            simulationData.powerData.push({ x: simulationData.timeElapsed, y: powerOutputThisStep });

// Update core temperature (simplified)
            const heatCapacity = 1e5; // J/K, arbitrary value for the core
            const temperatureThisStep = totalEnergyReleasedThisStep / heatCapacity + simulationData.coreTemperature;
            simulationData.temperatureData.push({ x: simulationData.timeElapsed, y: temperatureThisStep });

// Update Simulation Status
            updateSimulationStatus();

// Update Charts
            updateCharts();
        }

// Update Simulation Status Display
        function updateSimulationStatus() {
            document.getElementById('timeElapsed').textContent = simulationData.timeElapsed;
            document.getElementById('totalEnergyReleased').textContent = simulationData.totalEnergyReleased.toExponential(3);
            document.getElementById('reactorStatus').textContent = simulationData.reactorStatus;

// Update Power Output
            const latestPower = simulationData.powerData.length > 0 ? simulationData.powerData[simulationData.powerData.length - 1].y : 0;
            document.getElementById('powerOutput').textContent = formatPowerOutput(latestPower);
        }

// Format Power Output
        function formatPowerOutput(powerWatts) {
            if (powerWatts >= 1e6) {
                return (powerWatts / 1e6).toFixed(2) + ' MW';
            } else if (powerWatts >= 1e3) {
                return (powerWatts / 1e3).toFixed(2) + ' kW';
            } else if (powerWatts >= 1) {
                return powerWatts.toFixed(2) + ' W';
            } else if (powerWatts >= 1e-3) {
                return (powerWatts * 1e3).toFixed(2) + ' mW';
            } else if (powerWatts >= 1e-6) {
                return (powerWatts * 1e6).toFixed(2) + ' μW';
            } else {
                return (powerWatts * 1e9).toFixed(2) + ' nW';
            }
        }

// Update Charts
        function updateCharts() {
            // Energy Chart
            if (!energyChart) {
                const ctxEnergy = document.getElementById('energyChart').getContext('2d');
                energyChart = new Chart(ctxEnergy, {
                    type: 'line',
                    data: {
                        datasets: [{
                            label: 'Total Energy Released (J)',
                            data: simulationData.energyData,
                            borderColor: 'blue',
                            parsing: false,
                        }]
                    },
                    options: {
                        scales: {
                            x: { type: 'linear', title: { display: true, text: 'Time (s)' } },
                            y: { title: { display: true, text: 'Energy (J)' } }
                        }
                    }
                });
            } else {
                energyChart.data.datasets[0].data = simulationData.energyData;
                energyChart.update();
            }

// Power Chart
            if (!powerChart) {
                const ctxPower = document.getElementById('powerChart').getContext('2d');
                powerChart = new Chart(ctxPower, {
                    type: 'line',
                    data: {
                        datasets: [{
                            label: 'Power Output (W)',
                            data: simulationData.powerData,
                            borderColor: 'green',
                            parsing: false,
                        }]
                    },
                    options: {
                        scales: {
                            x: { type: 'linear', title: { display: true, text: 'Time (s)' } },
                            y: { title: { display: true, text: 'Power (W)' } }
                        }
                    }
                });
            } else {
                powerChart.data.datasets[0].data = simulationData.powerData;
                powerChart.update();
            }

// Temperature Chart
            if (!temperatureChart) {
                const ctxTemp = document.getElementById('temperatureChart').getContext('2d');
                temperatureChart = new Chart(ctxTemp, {
                    type: 'line',
                    data: {
                        datasets: [{
                            label: 'Core Temperature (K)',
                            data: simulationData.temperatureData,
                            borderColor: 'red',
                            parsing: false,
                        }]
                    },
                    options: {
                        scales: {
                            x: { type: 'linear', title: { display: true, text: 'Time (s)' } },
                            y: { title: { display: true, text: 'Temperature (K)' } }
                        }
                    }
                });
            } else {
                temperatureChart.data.datasets[0].data = simulationData.temperatureData;
                temperatureChart.update();
            }
        }

// Initialize the simulation
        let energyChart = null;
        let powerChart = null;
        let temperatureChart = null;
        initializeIsotopes();
        updateIsotopeTable();
        updateNeutronFluxSlider(1e14);
        updateTemperatureSlider(1000);
        updateEfficiencySlider(33);
        updateSimulationTime();
    </script>
</body>

</html>

Running the Project

To run the simulation:

Download the full HTML code.
Open the file in a web browser.
Start the simulation by adjusting the isotope composition, neutron flux, core temperature, and conversion efficiency. The simulation will display energy and power outputs in real-time.