Physics and Engineering Actors
Physics and engineering actors are the fundamental building blocks of FUSE simulations:
- Actors operate exclusively on
IMAS.dd
data - Actors functionality is controlled via
act
parameters - Actors can be combined into other actors
Fidelity hierarchy is enabled by concept of generic Vs specific actors
- Generic actors define physics/component
- Specific actors implement a specific model for that physics/component
- For example:
ActorEquilibrium <-- generic ├─ ActorSolovev <-- specific └─ ActorCHEASE <-- specific
act.[ActorGeneric].model
selects specific actor being used- All specific actors will expect data and fill the same enties in
dd
- IMAS.jl expressions are key to make this work seamlessly
- Where possible actors should make use of generic actors and not hardcode use of specific actors
- Physics and Engineering Actors
- Balance plant (3 actors)
- Build (5 actors)
- Compound (3 actors)
- Control (1 actors)
- Costing (3 actors)
- Current (3 actors)
- Diagnostics (1 actors)
- Divertors (1 actors)
- Equilibrium (5 actors)
- Hcd (5 actors)
- Nuclear (2 actors)
- Pedestal (4 actors)
- Pf (3 actors)
- Sol (2 actors)
- Stability (2 actors)
- Transport (8 actors)
- Wall loading (2 actors)
Balance plant (3 actors)
BalanceOfPlant
FUSE.ActorBalanceOfPlant
— MethodActorBalanceOfPlant(dd::IMAS.dd, act::ParametersAllActors; kw...)
Orchestrates the complete balance of plant analysis by coordinating thermal plant efficiency calculations and electrical power needs assessment. Collects heat loads from various tokamak sources (blanket, divertor, wall), calculates thermal power generation, estimates plant electrical consumption, and determines net electrical power output.
Process flow
- Collects heat sources from blanket thermal extraction, divertor incident power, and radiation losses
- Runs thermal plant actor to calculate electrical power generation from heat loads
- Runs power needs actor to calculate plant electrical consumption (HCD, cryogenics, etc.)
- Provides framework for net power balance calculations
Key heat sources
- Breeder blanket thermal extraction (
dd.blanket.module[].power_thermal_extracted
) - Divertor heat loads (
dd.divertors.divertor[].power_incident
) - Wall radiation losses (from
dd.core_sources
)
Key outputs (via sub-actors)
- Thermal power generation and plant efficiency
- Breakdown of electrical power consumption by subsystem
- Data for net electrical power calculations
ActorBalanceOfPlant
ThermalPlant
FUSE.ActorThermalPlant
— MethodActorThermalPlant(dd::IMAS.dd, act::ParametersAllActors; kw...)
Calculates thermal plant efficiency and electrical power generation based on heat loads from the tokamak. Uses different models to convert thermal power from blanket, divertor, and wall heat loads into electrical power. Acts as a dispatcher to different thermal plant models based on the model
parameter.
Available models
:fixed_plant_efficiency
: Uses a constant overall efficiency factor:surrogate
: Uses BalanceOfPlantSurrogate.jl for heat cycle efficiency calculations:network
: Uses ThermalSystemModels.jl extension for detailed thermal modeling
Key inputs
- Heat loads from blanket thermal extraction (
dd.blanket.module[].power_thermal_extracted
) - Divertor power incident (
dd.divertors.divertor[].power_incident
) - Wall radiation losses (
dd.core_sources
radiation losses)
Key outputs
- Plant thermal efficiency (
thermal_efficiency_plant
) - Total heat supplied to thermal cycle (
total_heat_supplied
) - Net electrical power generated (
power_electric_generated
)
ActorThermalPlant
├─ model
├─ fixed_plant_efficiency
├─ do_plot
└─ verbose
PowerNeeds
FUSE.ActorPowerNeeds
— MethodActorPowerNeeds(dd::IMAS.dd, act::ParametersAllActors; kw...)
Power needs actor that calculates the needed power to operate the plant
model = :thermal_power_fraction
simply assumes that the power to balance a plant is a fraction of the gross electrical power generated by the thermal cycle.model = :EU_DEMO
subdivides the power plant electrical needs to [:cryostat, :tritium_handling, :pumping] using EU-DEMO numbers.model = :FUSE
subdivides power plant needs into subsystems and calculates their power needs.
ActorPowerNeeds
├─ model
├─ thermal_power_fraction
└─ do_plot
Build (5 actors)
CXbuild
FUSE.ActorCXbuild
— MethodActorCXbuild(dd::IMAS.dd, act::ParametersAllActors; kw...)
Generates 2D cross-sectional geometry of the tokamak build by converting the 1D radial build layers into full poloidal cross-sections. Creates detailed outlines for all build layers, divertor regions, blanket segments, and maintenance ports based on equilibrium geometry and engineering requirements.
Key functionality
- Converts 1D radial build to 2D poloidal cross-sections with proper shaping
- Generates first wall geometry from equilibrium boundary (or rebuilds if needed)
- Creates divertor regions based on magnetic X-points and private flux regions
- Defines blanket segments on the low-field side
- Generates maintenance port structures for plasma-facing component access
Geometry generation process
- Establishes first wall from equilibrium boundary and strike point locations
- Builds layer outlines from plasma outward using shape optimization
- Handles layer-to-layer clearances and PF coil obstruction avoidance
- Creates divertor slots and blanket regions based on physics constraints
- Adds maintenance port geometry for component access
Key outputs
- 2D layer outlines for all radial build components (
dd.build.layer[].outline
) - Divertor structure definitions (
dd.build.structure
for divertors) - Blanket structure segmentation for modular designs
- Updated wall geometry with strike point information
ActorCXbuild
├─ rebuild_wall
├─ layers_aware_of_pf_coils
├─ divertor_hfs_size_fraction
├─ divertor_lfs_size_fraction
├─ n_points
└─ do_plot
HFSsizing
FUSE.ActorHFSsizing
— MethodActorHFSsizing(dd::IMAS.dd, act::ParametersAllActors; kw...)
Optimizes the High Field Side (HFS) radial build dimensions to satisfy engineering constraints and performance requirements. Uses metaheuristic optimization to find the optimal thicknesses and steel fractions for the center stack components (plug, OH coils, TF coils) while respecting stress limits, current density limits, magnetic field requirements, and flattop duration targets.
Optimization variables
- TF coil thickness (normalized to available space)
- OH coil thickness (normalized to available space)
- OH steel fraction (within void fraction constraints)
- TF steel fraction (within void fraction constraints)
- TF nose thickness fraction (if not bucked configuration)
Engineering constraints
- Critical current density limits for superconducting coils (TF and OH)
- Mechanical stress limits (Von Mises stress vs yield strength)
- Magnetic field requirements (achieve target B₀)
- Flux swing capability for OH coil flattop duration
Key outputs
- Optimized radial build dimensions (
dd.build.layer
thicknesses) - Updated technology parameters (steel fractions)
- Stress analysis results via integrated ActorStresses
- Flux swing analysis via integrated ActorFluxSwing
ActorHFSsizing
├─ error_on_technology
├─ error_on_performance
├─ do_plot
└─ verbose
FluxSwing
FUSE.ActorFluxSwing
— MethodActorFluxSwing(dd::IMAS.dd, act::ParametersAllActors; kw...)
Analyzes OH coil flux swing capability and determines operating limits based on current density constraints and flattop duration requirements. Calculates flux consumption during different operational phases and determines maximum achievable flattop duration or required current levels.
Operating modes (controlled by operate_oh_at_j_crit
)
true
: Operates OH at critical current limit, calculates achievable flattop durationfalse
: Uses required flattop duration, calculates needed currents (may exceed limits)
Flux consumption analysis
- Rampup flux: Estimated using Ejima coefficient and plasma inductance calculations
- Flattop flux: Based on resistive current drive requirements from Ohmic heating
- PF flux: Vertical field contribution from poloidal field coils
Physics models
- Plasma inductance (internal + external components) for flux estimation
- Resistive flux consumption using conductivity profiles and current density
- Vertical field requirements based on plasma geometry and pressure
Key outputs
- OH flux swing components (
dd.build.flux_swing.rampup/flattop/pf
) - OH coil current and field limits (
dd.build.oh.max_j/max_b_field
) - TF coil current and field requirements (
dd.build.tf.max_j/max_b_field
) - Achievable flattop duration (
dd.build.oh.flattop_duration
)
ActorFluxSwing
└─ operate_oh_at_j_crit
LFSsizing
FUSE.ActorLFSsizing
— MethodActorLFSsizing(dd::IMAS.dd, act::ParametersAllActors; kw...)
Optimizes the low-field-side (LFS) radial build layout for toroidal field ripple and maintenance requirements.
This actor determines the optimal position of the outer toroidal field (TF) coil leg by balancing:
- TF ripple constraint: Ensures the TF coil outer radius provides acceptable magnetic field ripple
- Maintenance access: Accommodates vertical or horizontal maintenance port requirements
- Geometric modularity: Accounts for toroidal and poloidal blanket sector arrangements
Key calculations:
- Minimum TF leg radius for specified ripple tolerance using IMAS.Rtfripple()
- Vacuum port geometry for blanket module removal (vertical_maintenance())
- Balance between ripple minimization and maintenance accessibility
- Automatic radial build adjustment via vacuum gap resizing
Maintenance schemes supported:
- Vertical: Blanket sectors removed vertically through upper/lower ports
- Horizontal: Blanket sectors removed horizontally through side ports
- None: No maintenance access constraints
The actor modifies the first vacuum layer between vessel and plasma to accommodate the required TF coil repositioning while maintaining geometric consistency.
ActorLFSsizing
├─ maintenance
├─ tor_modularity
├─ pol_modularity
├─ do_plot
└─ verbose
Stresses
FUSE.ActorStresses
— MethodActorStresses(dd::IMAS.dd, act::ParametersAllActors; kw...)
Calculates mechanical stresses in the tokamak center stack (TF coils, OH coils, and plug) using 1D analytical solutions based on Leuer's solid mechanics equations. Analyzes both scenarios with OH coils on and off to find the worst-case stress conditions for structural design.
Physics approach
- Uses 1D cylindrical stress analysis with hoop, radial, and axial stress components
- Accounts for electromagnetic forces from TF and OH magnetic fields
- Handles different boundary conditions (bucked vs free-standing coils)
- Applies structural material fractions to calculate effective stresses
Key inputs
- TF and OH coil geometry from radial build (
dd.build.layer
) - Magnetic field values (
dd.equilibrium.vacuum_toroidal_field.b0
,dd.build.oh.max_b_field
) - Material properties and structural fractions (
dd.build.tf/oh.technology
) - Mechanical configuration flags (bucked, noslip, plug presence)
Key outputs
- Radial stress profiles for TF, OH, and plug components
- Hoop stress profiles for structural analysis
- Axial stress estimates based on field configurations
- Von Mises stress for failure analysis
ActorStresses
├─ do_plot
└─ n_points
Compound (3 actors)
DynamicPlasma
FUSE.ActorDynamicPlasma
— MethodActorDynamicPlasma(dd::IMAS.dd, act::ParametersAllActors; kw...)
Evolves plasma profiles forward in time using coupled physics models.
This compound actor advances the plasma state through time by coordinating multiple physics models with proper temporal splitting and time step management. It handles the complex coupling between transport, current evolution, heating, equilibrium, and magnetic control systems.
Time integration strategy:
- Uses second-order accurate time-stepping with sub-cycling
- Splits fast (equilibrium, PF) and slow (transport, pedestal) physics appropriately
- Handles time-dependent boundary conditions from pulse schedule
- Supports plasma current control via feedback systems
Evolution workflow (each time step):
- Phase 1: Current evolution and heating sources (δt steps)
- Phase 2: Pedestal and transport evolution (δt steps)
- Both phases: Sawteeth, equilibrium, and PF control (δt/2 sub-steps)
Key features:
- Configurable evolution of individual physics components
- Optional plasma current feedback control via loop voltage
- Time derivative sources for energy and particle balance
- Progress tracking and convergence monitoring
- Automatic cleanup of post-simulation time data
Physics models coordinated:
- ActorCurrent: Current density diffusion and resistive evolution
- ActorHCD: Time-dependent heating and current drive
- ActorPedestal: Pedestal evolution and L-H transitions
- ActorCoreTransport: Transport flux evolution
- ActorSawteeth: Sawtooth instability cycling
- ActorEquilibrium: MHD equilibrium with evolving profiles
- ActorPFactive: PF coil current control for plasma shape
Control options:
ip_controller
: Feedback control of plasma current via loop voltage- Individual physics component enable/disable switches
- Configurable time step size and number of steps
ActorDynamicPlasma
├─ Δt [s]
├─ Nt
├─ evolve_transport
├─ evolve_pedestal
├─ evolve_hcd
├─ evolve_current
├─ evolve_equilibrium
├─ evolve_pf_active
├─ ip_controller
├─ time_derivatives_sources
└─ verbose
StationaryPlasma
FUSE.ActorStationaryPlasma
— MethodActorStationaryPlasma(dd::IMAS.dd, act::ParametersAllActors; kw...)
Iteratively solves for self-consistent stationary plasma equilibrium and transport.
This compound actor finds steady-state plasma solutions by iterating between plasma physics models until convergence. It balances current drive, heating, transport, and equilibrium to achieve a consistent stationary state.
Core iteration workflow:
- Current Evolution: Updates current density from current drive and resistive diffusion
- Heating & Current Drive: Calculates power deposition and driven current from external sources
- Pedestal: Determines edge boundary conditions and pedestal profiles
- Core Transport: Evolves temperature and density profiles based on transport fluxes
- Sawteeth: Applies sawtooth mixing to maintain realistic q-profiles
- Equilibrium: Solves MHD equilibrium with updated pressure and current profiles
The iteration continues until the relative changes in current density and pressure profiles fall below the convergence threshold. Each iteration updates the flux surface geometry based on the latest equilibrium solution.
Key convergence criteria:
- Relative change in current density profile (volume-averaged)
- Relative change in pressure profile (volume-averaged)
- Combined error must be below
convergence_error
threshold - Maximum iterations limit prevents infinite loops
Actors coordinated:
- ActorCurrent: Current density evolution (Ohmic + driven + bootstrap)
- ActorHCD: Heating and current drive power deposition
- ActorPedestal: Edge pressure and temperature boundary conditions
- ActorCoreTransport: Core transport flux calculations
- ActorSawteeth: Sawtooth crash mixing and q-profile flattening
- ActorEquilibrium: MHD equilibrium solution with updated profiles
ActorStationaryPlasma
├─ max_iterations
├─ convergence_error
├─ do_plot
└─ verbose
WholeFacility
FUSE.ActorWholeFacility
— MethodActorWholeFacility(dd::IMAS.dd, act::ParametersAllActors; kw...)
Integrates all physics, engineering, and economic models for complete tokamak facility design.
This compound actor orchestrates the full workflow for designing and analyzing a complete tokamak power plant. It coordinates plasma physics modeling with engineering design and economic optimization to provide a comprehensive facility assessment.
Execution workflow:
- Plasma Design: Self-consistent plasma solutions with optimized PF coil positions
- Plasma Physics: Stationary plasma equilibrium with all transport and heating
- Engineering Design: Radial build optimization for all major tokamak systems
- Magnetic Systems: PF coil repositioning and passive structure analysis
- Nuclear Analysis: Neutronics, blanket optimization, and tritium breeding
- Plasma-Facing Components: Divertor heat loads and thermal management
- Power Systems: Balance of plant and thermal-to-electric conversion
- Economics: Complete facility costing and economic analysis
Key actors executed:
- ActorStationaryPlasma: Converged plasma equilibrium and transport solution
- ActorPlasmaLimits: Operational stability limits and MHD analysis
- ActorHFSsizing: High-field-side radial build optimization (TF, OH, structural)
- ActorLFSsizing: Low-field-side TF leg design for ripple and maintenance
- ActorCXbuild: 2D cross-sectional geometry generation
- ActorFluxSwing: Flux swing analysis for plasma scenarios
- ActorStresses: Structural and electromagnetic stress analysis
- ActorPFdesign: PF coil system design and optimization
- ActorPFactive: PF current optimization for equilibrium control
- ActorPassiveStructures: Passive conductor modeling
- ActorNeutronics: Neutron flux and nuclear heating analysis
- ActorBlanket: Tritium breeding blanket optimization
- ActorDivertors: Divertor heat flux and cooling analysis
- ActorBalanceOfPlant: Power conversion and auxiliary systems
- ActorCosting: Economic analysis and cost optimization
The actor handles complex interdependencies between systems, such as re-optimizing the PF coil layout after radial build changes and updating the first wall geometry based on the final equilibrium solution.
ActorWholeFacility
├─ update_plasma
└─ update_build
Control (1 actors)
ControllerIp
FUSE.ActorControllerIp
— MethodActorControllerIp(dd::IMAS.dd, act::ParametersAllActors; kw...)
Controls the loop voltage Vloop to obtain the target plasma cuurent Ip pulse_schedule
Algorithm names that have "PID" in their name will be considered linear and operate on dd.controllers.linear_controller
otherwise dd.controllers.nonlinear_controller
External controllers can be defined by dispatching on the controllers__linearcontroller functors (note, yes "PID" in the controlalgorithm)
function (controller::IMAS.controllers__linear_controller{T})(control_name::Val{:ip}, control_algorithm::Val{:my_PID}, setpoint::T, value::T, time0::Float64) where {T<:Real}
...
end
or controllers__nonlinearcontroller functors (note, no "PID" in the controlalgorithm)
function (controller::IMAS.controllers__nonlinear_controller{T})(control_name::Val{:ip}, control_algorithm::Val{:my_MPC}, setpoint::T, value::T, time0::Float64) where {T<:Real}
...
end
ActorControllerIp
├─ algorithm
├─ P
├─ I
├─ D
└─ Vloop_initial [V]
Costing (3 actors)
Costing
FUSE.ActorCosting
— MethodActorCosting(dd::IMAS.dd, act::ParametersAllActors; kw...)
Estimates the comprehensive cost of building, operating, and decommissioning a fusion power plant.
This actor provides a unified interface to different costing methodologies and handles:
- Direct capital costs for all major plant systems and components
- Operating and maintenance costs over the plant lifetime
- Decommissioning costs at end-of-life
- Economic parameters like inflation, learning rates, and financial factors
Available costing models:
:ARIES
: Based on ARIES tokamak reactor studies with detailed component breakdown:Sheffield
: Based on Sheffield & Milora generic magnetic fusion reactor methodology
The actor creates a separate data structure with uncertainty propagation (Measurement types) to handle cost uncertainties, then transfers final results back to the main data structure. Key economic outputs include levelized cost of electricity (LCOE) and lifetime plant costs.
ActorCosting
├─ model
├─ construction_start_year [year]
├─ future_inflation_rate
├─ plant_lifetime [year]
├─ availability
├─ production_increase
└─ learning_rate
CostingARIES
FUSE.ActorCostingARIES
— MethodActorCostingARIES(dd::IMAS.dd, act::ParametersAllActors; kw...)
Estimates fusion power plant costs using the ARIES (Advanced Reactor Innovation and Evaluation Study) methodology.
This costing model implements the detailed cost accounting framework developed for the ARIES tokamak reactor studies, as documented in UCSD-CER-13-01. The methodology provides component-level cost estimates with:
Direct Capital Costs:
- Tokamak systems: all build layers (TF, PF, OH coils, blanket, shields, vacuum vessel)
- Heating and current drive: ECH, ICRF, LHCD, NBI systems scaled by power
- Facility infrastructure: land, buildings, hot cells, heat transfer systems
- Balance of plant: power conversion equipment, electrical systems, fuel handling
Operating Costs:
- Tritium handling and fuel cycle operations
- Maintenance and operations scaled to plant capacity
- Component replacement (blanket modules based on lifetime parameters)
Decommissioning Costs:
- End-of-life plant dismantling and waste management
Key Features:
- Component-specific cost models based on material volumes and unit costs
- Power-scaling relationships for heating and current drive systems
- Economic modeling with interest rates, escalation, and indirect costs
- Detailed cost account structure matching ARIES studies
- Uncertainty propagation through all cost calculations
The model supports advanced tokamak designs with superconducting magnets and provides realistic cost estimates for commercial-scale fusion power plants.
ActorCostingARIES
├─ land_space [acres]
├─ building_volume [m³]
├─ interest_rate
├─ indirect_cost_rate
├─ escalation_fraction
└─ blanket_lifetime [year]
CostingSheffield
FUSE.ActorCostingSheffield
— MethodActorCostingSheffield(dd::IMAS.dd, act::ParametersAllActors; kw...)
Estimates fusion power plant costs using the Sheffield and Milora methodology from Fusion Science & Technology 70 (2016).
This costing model provides a comprehensive economic analysis based on the "Generic magnetic fusion reactor revisited" study, adapted for tokamak reactor designs. The methodology covers:
Direct Capital Costs:
- Tokamak systems: TF coils, shields, structure, blanket, divertor, auxiliary power systems
- Balance of plant: heat transfer systems, power conversion, electrical systems
- Facility costs: buildings, site preparation, infrastructure
Operating Costs:
- Fuel cycle costs including blanket and divertor replacement based on fluence limits
- Maintenance and operations scaled to plant electrical capacity
- Auxiliary power system operating costs
Key Features:
- Accounts for component replacement schedules based on neutron/thermal fluence
- Includes cost escalation and construction financing effects
- Provides detailed cost breakdown by system and subsystem
- Calculates levelized cost of electricity (LCOE)
The model uses scaling relationships derived from fusion power plant studies and incorporates realistic assumptions about component lifetimes, availability, and economic parameters.
ActorCostingSheffield
├─ construction_lead_time [year]
├─ fixed_charge_rate
├─ capitalize_blanket
├─ capitalize_divertor
├─ divertor_fluence_lifetime [MW*yr/m²]
└─ blanket_fluence_lifetime [MW*yr/m²]
Current (3 actors)
Current
FUSE.ActorCurrent
— MethodActorCurrent(dd::IMAS.dd, act::ParametersAllActors; kw...)
Provides a unified interface for current evolution using different current diffusion models.
This actor serves as a dispatcher for various current evolution methods including:
:SteadyStateCurrent
: Steady-state ohmic current with infinite relaxation time:QED
: Time-dependent current diffusion with sawteeth and realistic time constants:replay
: Replays current profiles from existing data:none
: No current evolution (no operation)
The actor manages the complete current evolution workflow including freezing of bootstrap and non-inductive currents during ohmic evolution, and updating all derived current quantities.
Updates to the data structure:
j_total
,j_ohmic
,j_tor
indd.core_profiles.profiles_1d[]
j_parallel
indd.equilibrium.time_slice[].profiles_1d
- Bootstrap and ohmic parallel current/heating sources in
dd.core_sources
ActorCurrent
├─ model
├─ ip_from
└─ vloop_from
QED
FUSE.ActorQED
— MethodActorQED(dd::IMAS.dd, act::ParametersAllActors; kw...)
Evolves plasma current using the QED (quasi-steady-state equilibrium diffusion) solver for realistic current diffusion.
This actor provides time-dependent current evolution with proper physics including:
- Finite current diffusion time constants based on plasma resistivity
- Sawtooth reconnection events that flatten current profiles inside q=1
- Non-inductive current drive from external sources
- Ability to solve for either specified plasma current or loop voltage
Key capabilities:
- Time-dependent evolution: finite time steps with realistic diffusion
- Steady-state solution: infinite time limit with equilibrium current distribution
- Current or voltage control: can target either Ip or Vloop
- Sawtooth modeling: automatic current profile flattening to maintain q≥1
The QED solver uses finite element methods on flux coordinates and can handle complex current drive scenarios including bootstrap current, ECCD, NBCD, and other sources.
ActorQED
├─ Δt [s]
├─ Nt
├─ solve_for
├─ qmin_desired
├─ ip_from
└─ vloop_from
SteadyStateCurrent
FUSE.ActorSteadyStateCurrent
— MethodActorSteadyStateCurrent(dd::IMAS.dd, act::ParametersAllActors; kw...)
Computes the steady-state ohmic current distribution using plasma conductivity and target plasma current.
This actor solves for the equilibrium current distribution assuming infinite current diffusion time, where the current profile is determined by the balance between ohmic heating and resistive dissipation. The solution uses the conductivity profile from dd.core_profiles
and can either target a specific plasma current or allow floating current based on non-inductive drive.
Key features:
- Computes steady-state ohmic current profile using plasma conductivity
- Supports current relaxation with adjustable radial extent
- Can float plasma current when non-inductive fraction exceeds 100%
- Updates
j_total
by combining ohmic and non-inductive current components
ActorSteadyStateCurrent
├─ allow_floating_plasma_current
├─ current_relaxation_radius
└─ ip_from
Diagnostics (1 actors)
FitProfiles
FUSE.ActorFitProfiles
— MethodActorFitProfiles(dd::IMAS.dd, act::ParametersAllActors; kw...)
Fits experimental diagnostic data from Thomson scattering and charge exchange recombination spectroscopy to create smooth plasma profiles.
This actor performs several key operations:
- Identifies and removes outliers from raw diagnostic data using adaptive algorithms
- Time-averages diagnostic measurements within specified windows
- Fits electron temperature (Te), electron density (ne), ion temperature (Ti), and ion density profiles
- Optionally scales Thomson scattering density based on interferometer measurements
- Enforces quasi-neutrality and provides smooth, consistent profiles on a common radial grid
The resulting fitted profiles are stored in dd.core_profiles.profiles_1d[]
and provide the foundation for physics modeling.
ActorFitProfiles
├─ time_averaging [s]
├─ rho_averaging
├─ rho_grid
├─ time_basis_ids
└─ use_interferometer
Divertors (1 actors)
Divertors
FUSE.ActorDivertors
— MethodActorDivertors(dd::IMAS.dd, act::ParametersAllActors; kw...)
Calculates divertor heat fluxes and power loads using reduced SOL transport models.
The actor evaluates the heat and particle fluxes striking divertor targets by tracing power flow from the main plasma through the scrape-off layer (SOL) to the material surfaces. It uses simplified two-point models calibrated for divertor physics.
Key physics modeled:
- Power flow from separatrix through SOL to divertor targets
- Heat flux spreading due to field line divergence and cross-field transport
- Strike point geometry and magnetic field angle effects
- Material surface heat loads and wetted area calculations
Heat flux models available:
:lengyel
: Simple exponential decay model with flux expansion:stangeby
: More sophisticated model including impurity effects
Analysis workflow:
- SOL Geometry: Identifies strike surfaces and field line connections
- Power Balance: Calculates SOL power from core sources minus radiation
- SOL Width: Estimates λq (heat flux width) at outer midplane using Eich scaling
- Field Line Mapping: Traces flux expansion from midplane to targets
- Heat Flux Calculation: Applies model-specific physics for target fluxes
- Surface Integration: Calculates total power loads and peak heat fluxes
Key outputs:
- Peak heat flux on each divertor target surface (W/m²)
- Total incident power on each target (W)
- Wetted area and flux expansion factors
- Strike angles and field line geometry parameters
- Thermal power extraction efficiency for cooling systems
Model parameters:
heat_spread_factor
: Additional flux spreading in private regionsimpurities
: Impurity species concentrations affecting radiationthermal_power_extraction_efficiency
: Cooling system effectiveness
ActorDivertors
├─ heat_flux_model
├─ impurities
├─ impurities_fraction
├─ heat_spread_factor
├─ thermal_power_extraction_efficiency
└─ verbose
Equilibrium (5 actors)
CHEASE
FUSE.ActorCHEASE
— MethodActorCHEASE(dd::IMAS.dd, act::ParametersAllActors; kw...)
Runs the CHEASE fixed-boundary equilibrium solver to compute a 2D equilibrium from the plasma boundary, pressure profile, and current density profile. The solver takes the R-Z boundary coordinates from the plasma time slice, extracts pressure and jtor from profiles1d, and generates a full 2D equilibrium solution including flux surfaces and safety factor profiles.
Optionally converts the fixed-boundary solution to a free-boundary equilibrium by using VacuumFields.jl to find PF coil currents that reproduce the same plasma shape and flux surfaces.
Key inputs (from dd.equilibrium.time_slice[])
- Boundary outline (r, z coordinates)
- Pressure profile on normalized flux surfaces
- Current density profile j_tor
- Global quantities (plasma current, magnetic axis location)
Key outputs
- Complete 2D equilibrium solution via gEQDSK format conversion to IMAS
- Optional free-boundary PF coil currents (if
free_boundary=true
) - Updated flux surface geometry and safety factor profiles
ActorCHEASE
├─ free_boundary
├─ clear_workdir
└─ rescale_eq_to_ip
EGGO
FUSE.ActorEGGO
— MethodActorEGGO(dd::IMAS.dd, act::ParametersAllActors; kw...)
Solves free-boundary tokamak MHD equilibria using the EGGO machine learning-based equilibrium reconstruction code.
EGGO (Equilibrium Grad-Shafranov Green's-function Optimizer) uses neural networks trained on experimental equilibrium databases to rapidly predict tokamak equilibria from plasma shape and profile constraints.
Key features:
- Neural network prediction: Fast equilibrium reconstruction using pre-trained models from experimental data
- Free-boundary capability: Includes external coil system effects and realistic machine constraints
- Profile fitting: Automatically fits pressure and current profiles using basis function decomposition
- Boundary adaptation: Accepts arbitrary plasma boundary shapes with configurable resolution
- Temporal averaging: Optional smoothing over multiple time slices for enhanced stability
Machine learning approach:
- Training data: Models trained on extensive experimental equilibrium databases (D3D, JET, etc.)
- Input features: Plasma boundary points, basis-fitted pressure/current profiles, plasma current
- Output: Complete equilibrium reconstruction including ψ(R,Z), geometric parameters, and profiles
- Green's functions: Uses precomputed vacuum field response for computational efficiency
Workflow:
- Profile preparation: Fits p'(ψ) and ff'(ψ) profiles to basis functions
- Boundary processing: Decimates and processes plasma boundary points
- Neural prediction: Generates equilibrium using trained ML model
- Post-processing: Extracts flux surfaces, magnetic axis, and geometric parameters
- Temporal smoothing: Optional averaging with previous time slices for robustness
The ML approach provides orders-of-magnitude speedup compared to traditional equilibrium solvers while maintaining good accuracy for scenarios within the training data domain.
ActorEGGO
├─ model
├─ use_vacuumfield_green
├─ decimate_boundary
├─ timeslice_average
├─ do_plot
└─ debug
Equilibrium
FUSE.ActorEquilibrium
— MethodActorEquilibrium(dd::IMAS.dd, act::ParametersAllActors; kw...)
Unified interface for tokamak MHD equilibrium solvers with automatic data preparation and postprocessing.
This compound actor coordinates different equilibrium solver codes through a single interface, handling data flow preparation and postprocessing while allowing flexible solver selection.
Supported equilibrium solvers:
- TEQUILA: Fixed-boundary equilibrium solver
- FRESCO: Free-boundary rectangular grid Grad-Shafranov solver
- EGGO: Machine learning-based free-boundary equilibrium reconstruction
- CHEASE: External fixed-boundary equilibrium solver
- Replay: Use equilibrium data from experimental or simulation archives
Key features:
- Automatic data preparation: Extracts pressure/current profiles, boundary shape, and control targets
- Flexible profile sources: Can use profiles from core_profiles (self-consistent) or equilibrium (re-solve)
- Control integration: Uses pulseschedule positioncontrol for boundary and X-point targets
- Geometric postprocessing: Adds flux surfaces, symmetrization, and consistency checks
- Error handling: Comprehensive error reporting with diagnostic plots
Data flow control:
- Profile sources: core_profiles (default) or equilibrium
- Scalar sources: pulseschedule, coreprofiles, or equilibrium
- Automatic zero-gradient boundary conditions on axis
- Geometric factors preservation across iterations
The actor handles the complete equilibrium workflow: data extraction → solver execution → flux surface reconstruction → validation and visualization.
ActorEquilibrium
├─ model
├─ symmetrize
├─ j_p_from
├─ ip_from
├─ vacuum_r0_b0_from
└─ do_plot
FRESCO
FUSE.ActorFRESCO
— MethodActorFRESCO(dd::IMAS.dd, act::ParametersAllActors; kw...)
Solves the tokamak MHD equilibrium using the FRESCO fixed-boundary equilibrium solver.
FRESCO (Free-boundary Reactor Equilibrium Solver for Comprehensive Optimization) solves the Grad-Shafranov equation for toroidal plasma equilibria with specified pressure and current profiles.
This actor performs:
- Free-boundary equilibrium reconstruction using pressure and current profiles from core_profiles
- Iterative solution of the Grad-Shafranov equation on a rectangular R-Z grid
- Vertical control options (vertical position, shape control, or magnetics-based)
- Updates to poloidal field coil currents for force balance
- Conversion of equilibrium solution back to IMAS equilibrium format
The solver supports:
- Configurable grid resolution (nR × nZ)
- Multiple control algorithms for vertical stability
- Active X-point specification
- Green's function table reuse for computational efficiency
- Relaxation and tolerance control for convergence
ActorFRESCO
├─ control
├─ number_of_iterations
├─ relax
├─ tolerance
├─ fixed_grid
├─ nR
├─ nZ
├─ active_x_points
├─ do_plot
└─ debug
TEQUILA
FUSE.ActorTEQUILA
— MethodActorTEQUILA(dd::IMAS.dd, act::ParametersAllActors; kw...)
Solves tokamak MHD equilibria using the TEQUILA fixed-boundary equilibrium solver with MXH flux surface representation.
TEQUILA is a fixed-boundary equilibrium solver that uses cubic-Hermite finite elements in the radial direction, Fourier modes in the poloidal angle, and a Miller extended harmonic (MXH) flux-surface parametrization [Arbon 2021]. MXH provides an efficient representation of flux surfaces.
Key features:
- MXH flux surface parametrization: Spectral representation using R₀(ρ), Z₀(ρ), ε(ρ), κ(ρ) and Fourier harmonics
- Free-boundary conversion: Solves with external coil currents and control constraints via VacuumFields.jl
- Adaptive grid refinement: Efficient spectral convergence with configurable Fourier mode resolution
- Control integration: Supports X-point, strike-point, and magnetic axis control with poloidal field coils
- Profile flexibility: Accepts pressure and current profiles on either poloidal or toroidal flux coordinates
Solver workflow:
- Fixed-boundary solve: Initial equilibrium with specified plasma boundary using TEQUILA core
- Free-boundary conversion: Couples plasma equilibrium with external coil system via Green's functions
- Control optimization: Adjusts coil currents to satisfy geometric and flux control targets
- Grid mapping: Converts spectral solution to rectangular R-Z grids for analysis
Grid options:
- Profile grids: :poloidal (√ψnorm) or :toroidal (ρtor_norm) flux coordinate systems
- Spatial resolution: Configurable radial points (31 default) and Fourier modes (8 default)
- Rectangular grid: Automatic sizing based on plasma geometry plus divertor margins
ActorTEQUILA
├─ free_boundary
├─ number_of_radial_grid_points
├─ number_of_fourier_modes
├─ number_of_MXH_harmonics
├─ number_of_iterations
├─ relax
├─ tolerance
├─ fixed_grid
├─ R [m]
├─ Z [m]
├─ do_plot
└─ debug
Hcd (5 actors)
HCD
FUSE.ActorHCD
— MethodActorHCD(dd::IMAS.dd, act::ParametersAllActors; kw...)
Unified heating, current drive, and fueling system coordinator for all auxiliary power systems.
This compound actor orchestrates multiple heating and current drive subsystem actors through a single interface, providing centralized control over all auxiliary power and particle sources.
Managed subsystems:
- Electron Cyclotron (EC): ECsimple, TORBEAM, or replay modes
- Ion Cyclotron (IC): ICsimple or replay modes
- Lower Hybrid (LH): LHsimple or replay modes
- Neutral Beam Injection (NB): NBsimple, RABBIT, or replay modes
- Pellet fueling: PLsimple or replay modes
- Neutral gas fueling: NEUCG model or replay modes
Key features:
- Model selection switches for each subsystem (simple physics, advanced codes, replay, or off)
- Automatic hardware setup and validation (launcher/antenna count consistency)
- Sequential execution with proper dependencies (neutral fueling runs last)
- Centralized source integration via IMAS.sources!()
- Unified replay capability for all subsystems
Execution order:
- EC heating/current drive
- IC heating
- LH current drive
- NB heating/current drive/momentum
- Pellet particle sources
- Neutral gas fueling (depends on energy confinement time from HCD)
- Source integration and consistency checks
ActorHCD
├─ ec_model
├─ ic_model
├─ lh_model
├─ nb_model
├─ pellet_model
└─ neutral_model
NeutralFueling
FUSE.ActorNeutralFueling
— MethodActorNeutralFueling(dd::IMAS.dd, act::ParametersAllActors; kw...)
Calculates neutral gas fueling particle source using the neucg model for wall recycling.
This actor models neutral atom transport and ionization in the plasma edge/scrape-off-layer using the neucg algorithm from Burrell (Journal of Computational Physics 27.1, 1978: 88-102).
The model computes:
- Neutral density profiles accounting for ionization and charge exchange
- Particle source from wall recycling based on particle confinement time
- Integral equation solution for neutral transport in toroidal geometry
- Ionization source profiles for maintaining particle balance
Key physics included:
- Electron impact ionization rates (Freeman & Jones, 1974)
- Charge exchange reactions between neutrals and ions
- Wall temperature effects on neutral injection velocity
- Toroidal geometry effects on neutral penetration
- Recycling coefficient based on particle confinement time scaling
The solver uses:
- Particle confinement time as fraction of energy confinement time (τp/τe)
- Wall temperature for neutral injection energy
- Iterative solution of integral transport equations
- Numerical integration over velocity space
ActorNeutralFueling
├─ τp_over_τe
└─ T_wall [eV]
SimpleIC
FUSE.ActorSimpleIC
— MethodActorSimpleIC(dd::IMAS.dd, act::ParametersAllActors; kw...)
Calculates ion cyclotron (IC) heating and current drive using simplified Gaussian deposition profiles. The actor models IC wave absorption with configurable power split between electrons and ions, typically optimized for minority heating scenarios.
The model includes:
- Gaussian power deposition profiles at user-specified locations
- Configurable electron/ion power fraction (default 80% to ions for minority heating)
- Current drive efficiency based on GASC formulae corrected for beta effects
- Multiple antenna support for different IC systems
- Beta-dependent current drive efficiency reduction
Current drive efficiency uses the G. Tonon formula modified for finite beta effects, suitable for reactor-relevant conditions with significant beta_toroidal.
ActorSimpleIC
└─ actuator
SimpleLH
FUSE.ActorSimpleLH
— MethodActorSimpleLH(dd::IMAS.dd, act::ParametersAllActors; kw...)
Calculates lower hybrid (LH) wave heating and current drive using a simplified Gaussian deposition model.
This actor models LH wave energy and current deposition through:
- Gaussian radial deposition profile with configurable location and width
- Current drive efficiency based on local plasma parameters (density, temperature, Zeff)
- All power deposited to electrons (no ion heating)
- Parallel current drive calculated using scaling from Tonon's reactor studies
The current drive efficiency formula used is: ηCD = ηscale × Te[keV] × 0.037 × B₀ / (5.0 + Zeff) / n_e[10²⁰]^0.33
Where the parallel current is: j∥ = ηCD / R₀ / ne[10²⁰] × Plaunched
ActorSimpleLH
└─ actuator
SimplePL
FUSE.ActorSimplePL
— MethodActorSimplePL(dd::IMAS.dd, act::ParametersAllActors; kw...)
Calculates pellet fueling particle deposition using a simplified deposition model.
This actor models pellet particle injection through:
- Calculation of pellet particle content based on geometry (spherical, cylindrical, or rectangular)
- Material density lookup for different species (DT, D, T, C, Ne)
- Frequency-based particle source calculation
- Beta-function radial deposition profile with configurable location and width
- Pure particle source (no heating or current drive)
The pellet volume and particle content are calculated based on:
- Spherical: V = (4/3)πr³
- Cylindrical: V = πr²h
- Rectangular: V = l×w×h
Particle rate = pelletvolume × materialdensity × injection_frequency
The deposition profile uses a beta function with parameters tuned for pellet-like deposition.
ActorSimplePL
└─ actuator
Nuclear (2 actors)
Blanket
FUSE.ActorBlanket
— MethodActorBlanket(dd::IMAS.dd, act::ParametersAllActors; kw...)
Calculates blanket performance including tritium breeding ratio (TBR), thermal power generation, and neutron leakage using 1D neutronics models. The actor optimizes blanket layer thicknesses to achieve target TBR while minimizing neutron leakage and respecting geometric constraints.
The calculations include:
- Tritium breeding from Li-6 reactions using neural network models
- Thermal power generation with configurable multiplication factor
- Neutron leakage assessment for radiation protection
- Layer thickness optimization to meet TBR requirements
- Li-6 enrichment optimization
Handles multiple blanket modules (e.g., inboard and outboard) with different geometric and material configurations.
ActorBlanket
├─ minimum_first_wall_thickness [m]
├─ blanket_multiplier
├─ thermal_power_extraction_efficiency
├─ max_Li6_enrichment_fraction
└─ verbose
Neutronics
FUSE.ActorNeutronics
— MethodActorNeutronics(dd::IMAS.dd, act::ParametersAllActors; kw...)
Calculates neutron wall loading on the first wall using Monte Carlo particle tracing. The actor defines neutron sources from fusion reactions, traces their paths to the first wall, and calculates the resulting neutron flux and power deposition.
The calculation includes:
- Neutron source definition from D-T and D-D fusion reactions
- Particle tracing from plasma to first wall
- Flux and power calculation on wall elements
- Normalization to match total fusion neutron power
ActorNeutronics
├─ N
└─ do_plot
Pedestal (4 actors)
Pedestal
FUSE.ActorPedestal
— MethodActorPedestal(dd::IMAS.dd, act::ParametersAllActors; kw...)
Comprehensive pedestal modeling with support for multiple models and L-H mode transitions.
This compound actor manages pedestal physics by selecting from available pedestal models and handling mode transitions between L-mode and H-mode operation. It coordinates multiple specialized pedestal actors and provides dynamic transition capabilities.
Available pedestal models:
:EPED
: EPED neural network model for pedestal predictions:WPED
: Width-based energy balance pedestal model:analytic
: Analytic scaling laws for spherical tokamaks:dynamic
: Time-dependent L-H transitions with smoothing:replay
: Replays pedestal data from experimental reference:none
: No pedestal modifications
Key features:
- Automatic L-H mode detection based on power threshold criteria
- Dynamic mode transitions with configurable time constants
- Density matching options (pedestal or line-averaged)
- Rotation profile modeling (linear, experimental replay)
- Consistent Ti/Te ratio handling across all models
Mode transition physics:
- Supports user-defined transition times or automatic power threshold detection
- Smooth temporal evolution using tanh functions with configurable time scales
- Separate evolution times for temperature and density transitions
- Configurable density and Zeff ratios between L-mode and H-mode
ActorPedestal
├─ rho_nml
├─ rho_ped
├─ T_ratio_pedestal
├─ Te_sep
├─ ip_from
├─ βn_from
├─ ne_from
├─ zeff_from
├─ mode_transitions [s]
├─ density_match
├─ model
├─ rotation_model
├─ tau_t [s]
├─ tau_n [s]
├─ density_ratio_L_over_H
├─ zeff_ratio_L_over_H
└─ do_plot
AnalyticPedestal
FUSE.ActorAnalyticPedestal
— MethodActorAnalyticPedestal(dd::IMAS.dd, act::ParametersAllActors; kw...)
Calculates pedestal pressure and width using analytic scaling laws for spherical tokamaks.
The actor computes pedestal boundary conditions using empirical scaling relationships based on machine parameters and plasma conditions. It supports multiple scaling models calibrated against experimental data from MAST and NSTX spherical tokamaks.
Available models:
:TE_MAST
: MAST-like scaling with wped ~ βpped^0.5:TE_NSTX
: NSTX-like scaling with wped ~ βpped^1.0:hiped_MASTU
: MAST-U scaling based on βn relationship
Key outputs:
- Pedestal pressure (pped) in EPED units (MPa)
- Pedestal width (wped) as half-width fraction of ψ_norm
- Scaling coefficients can be customized via heightcoefficient and widthcoefficient parameters
ActorAnalyticPedestal
├─ rho_nml
├─ rho_ped
├─ T_ratio_pedestal
├─ Te_sep
├─ ip_from
├─ βn_from
├─ ne_from
├─ zeff_from
├─ model
├─ width_coefficient
├─ height_coefficient
└─ ped_factor
EPED
FUSE.ActorEPED
— MethodActorEPED(dd::IMAS.dd, act::ParametersAllActors; kw...)
Predicts pedestal pressure and width using the EPED neural network model.
The actor utilizes the EPED (Edge Pedestal Equilibrium and Dynamics) model to predict pedestal height and width based on global plasma parameters. EPED combines physics-based scaling laws with neural network corrections trained on experimental pedestal data.
Model capabilities:
- Physics-based power-law scaling for robust extrapolation
- Optional neural network corrections for improved accuracy
- Calibrated against experimental data from multiple tokamaks
- Handles both conventional and spherical tokamak geometries
Key inputs (extracted from plasma state):
- Machine geometry (R, a, κ, δ, triangularity)
- Global parameters (βn, Ip, Bt, effective mass)
- Pedestal conditions (neped, Zeffped)
Outputs:
- Pedestal pressure height in MPa (pped)
- Pedestal width as fraction of normalized poloidal flux (wped)
- Automatic fallback to edge pressure + 10% if EPED prediction is too low
ActorEPED
├─ rho_nml
├─ rho_ped
├─ T_ratio_pedestal
├─ Te_sep
├─ ip_from
├─ βn_from
├─ ne_from
├─ zeff_from
├─ ped_factor
├─ only_powerlaw
└─ warn_nn_train_bounds
WPED
FUSE.ActorWPED
— MethodActorWPED(dd::IMAS.dd, act::ParametersAllActors; kw...)
Adjusts pedestal temperature profiles to match a target energy ratio between pedestal and core regions.
The actor optimizes temperature profiles at the plasma edge by finding the optimal boundary temperature and slope parameters that produce a specified pedestal-to-core stored energy fraction. It uses optimization to iteratively adjust the temperature gradient and boundary conditions until the energy balance criterion is satisfied.
Key operations:
- Calculates current core-to-edge energy ratio if target ratio is not specified
- Optimizes boundary temperature value to match target energy ratio
- Adjusts both electron and ion temperature profiles with consistent Ti/Te ratios
- Preserves separatrix temperature boundary conditions
- Updates temperature profiles through H-mode blending functions
ActorWPED
├─ rho_nml
├─ rho_ped
├─ T_ratio_pedestal
├─ Te_sep
├─ ip_from
├─ βn_from
├─ ne_from
├─ zeff_from
├─ ped_to_core_fraction
└─ do_plot
Pf (3 actors)
PFdesign
FUSE.ActorPFdesign
— MethodActorPFdesign(dd::IMAS.dd, act::ParametersAllActors; kw...)
Optimizes poloidal field (PF) coil placement and sizing to achieve target equilibrium configurations. Uses optimization algorithms to find coil positions that minimize current requirements while satisfying magnetic flux and force balance constraints for plasma control.
Design approaches (controlled by model
)
:none
: Uses existing coil configuration without modification:uniform
: Places coils uniformly on predefined rails:optimal
: Optimizes both coil placement and currents using least-squares minimization
Optimization process (for :optimal
mode)
- Initializes PF coil rails based on radial build geometry
- Uses nested optimization: outer loop optimizes coil positions, inner loop finds currents
- Minimizes flux/saddle constraint violations while penalizing large currents
- Includes coil spacing penalties to prevent overlapping
- Sizes coils based on current requirements and engineering margins
Key constraints
- Flux control points (boundary and internal flux surfaces)
- Saddle control points (X-points and magnetic axis)
- Current density limits and coil spacing requirements
- Up-down symmetry (if
symmetric=true
)
Key outputs
- Optimized PF coil positions and sizes (
dd.pf_active.coil[].element[].geometry
) - Coil currents that achieve target equilibrium
- Updated equilibrium solution (if
update_equilibrium=true
)
ActorPFdesign
├─ symmetric
├─ update_equilibrium
├─ model
├─ reset_rails
├─ do_plot
└─ verbose
PFactive
FUSE.ActorPFactive
— MethodActorPFactive(dd::IMAS.dd, act::ParametersAllActors; kw...)
Optimizes poloidal field coil currents to match target equilibrium constraints.
The actor solves for optimal PF coil currents that satisfy boundary shape, X-point positions, and strike point locations in a least-squares sense. It uses Green's functions to model electromagnetic coupling between coils and plasma, with optional regularization to prevent unrealistic current solutions.
Key features:
- Supports different Green's function calculation methods (quadrature, filament models)
- Handles boundary shape control through iso-flux control points
- Maintains X-point and strike point positions with configurable weights
- Includes automatic regularization parameter selection for stable solutions
- Can update target equilibrium with achievable coil configuration
Control points:
- Boundary iso-flux surfaces for plasma shape control
- X-point locations as saddle point constraints
- Strike point locations as flux surface constraints
- Magnetic axis position and flux value
ActorPFactive
├─ green_model
├─ update_equilibrium
├─ x_points_weight
├─ strike_points_weight
└─ do_plot
PassiveStructures
FUSE.ActorPassiveStructures
— MethodActorPassiveStructures(dd::IMAS.dd, act::ParametersAllActors; kw...)
Generates passive conducting structure models for electromagnetic analysis by discretizing vacuum vessel layers into quadrilateral current loops. These passive elements are essential for vertical stability analysis and disruption modeling as they represent the primary conducting structures that interact with changing magnetic fields.
Discretization process
- Identifies vacuum vessel layers from the radial build (
dd.build.layer
with type:vessel
) - Creates inner and outer boundaries of conducting walls
- Discretizes walls into quadrilateral elements based on precision requirements
- Assigns electrical properties (resistivity) based on vessel materials
Physics modeling
- Each quadrilateral represents a passive current loop with specific resistance
- Material properties determine resistivity (defaults to steel if not specified)
- Geometric discretization balances accuracy vs computational efficiency
- Accounts for wall thickness effects on electromagnetic coupling
Key inputs
- Vacuum vessel layer geometry (
dd.build.layer[].outline
) - Material specifications and electrical conductivity
- Discretization precision parameters
Key outputs
- Passive loop elements in
dd.pf_passive.loop[].element[]
- Loop resistivity values for electromagnetic calculations
- Geometric properties (outline coordinates) for each discretized element
ActorPassiveStructures
├─ wall_precision
├─ min_n_segments
└─ do_plot
Sol (2 actors)
SOL
FUSE.ActorSOL
— MethodActorSOL(dd::IMAS.dd, act::ParametersAllActors; kw...)
Provides a unified interface for different scrape-off layer (SOL) physics models. This compound actor selects and runs one of several available SOL models based on configuration:
:box
- Uses ActorSOLBox for 0D box model calculations:replay
- Uses ActorReplay to replay previously calculated data:none
- Uses ActorNoOperation for no SOL modeling
The selected SOL actor is instantiated and executed, providing consistent interface regardless of the underlying model complexity.
ActorSOL
└─ model
SOLBox
FUSE.ActorSOLBox
— MethodActorSOLBox(dd::IMAS.dd, act::ParametersAllActors; kw...)
Implements a 0D box model for scrape-off layer (SOL) physics to calculate upstream plasma conditions at the separatrix from target boundary conditions. Based on the model developed by X. Zhang et al. (https://doi.org/10.1016/j.nme.2022.101354).
The model calculates:
- Upstream electron and ion temperatures and densities
- Power flux densities for electrons and ions
- Connection length and flux expansion from field line tracing
- Target conditions using recycling coefficients and power balance
Handles both single-null and double-null configurations automatically based on magnetic balance assessment.
ActorSOLBox
├─ Te_t [eV]
├─ Ti_t [eV]
├─ frac_cond
├─ frac_mom
├─ κ0_e
├─ κ0_i
├─ recycling_coeff_i
├─ recycling_coeff_e
├─ λq [m]
├─ verbose
└─ do_plot
Stability (2 actors)
PlasmaLimits
FUSE.ActorPlasmaLimits
— MethodActorPlasmaLimits(dd::IMAS.dd, act::ParametersAllActors; kw...)
Evaluates plasma operational limits by running all selected limit models and checking for violations. The actor executes various stability and operational limit assessments based on the configured models and reports which limits are satisfied or exceeded.
The actor can be configured to raise errors when limits are breached or simply warn. It provides detailed reporting of the limit check results, showing the percentage of each limit threshold reached.
ActorPlasmaLimits
├─ models
├─ raise_on_breach
└─ verbose
VerticalStability
FUSE.ActorVerticalStability
— MethodActorVerticalStability(dd::IMAS.dd, act::ParametersAllActors; kw...)
Computes vertical stability metrics for tokamak plasmas using the equilibrium and coil configuration.
This actor calculates two key stability metrics:
- Stability margin: measures the plasma's resilience to vertical displacement events (VDEs)
- Normalized growth rate (γτ): quantifies how rapidly vertical instabilities develop
The analysis considers both active PF coils and passive conducting structures. Results are stored in dd.mhd_linear.time_slice[].toroidal_mode
where stability margin > 0.15 and γτ < 10 indicate stability.
ActorVerticalStability
├─ model
└─ do_plot
Transport (8 actors)
CoreTransport
FUSE.ActorCoreTransport
— MethodActorCoreTransport(dd::IMAS.dd, act::ParametersAllActors; kw...)
Provides a unified interface to run core transport evolution models.
This compound actor manages different approaches to core transport evolution:
Transport model options:
:FluxMatcher
: Self-consistent flux-matching transport evolution using turbulent and neoclassical models to evolve temperature and density profiles:EPEDProfiles
: Use EPED model predictions for pedestal and core profiles:replay
: Replay profiles from experimental data or previous simulations:none
: No core transport evolution (fixed profiles)
The selected model determines how the core plasma profiles (temperature, density, rotation) evolve in response to heating, particle sources, and transport processes.
ActorCoreTransport
└─ model
EPEDprofiles
FUSE.ActorEPEDprofiles
— MethodActorEPEDprofiles(dd::IMAS.dd, act::ParametersAllActors; kw...)
Constructs complete plasma profiles by blending EPED pedestal predictions with shaped core profiles.
This actor combines EPED-predicted pedestal conditions with parametrically shaped core profiles to create complete, consistent temperature and density profiles across the entire plasma. It maintains fixed on-axis values while ensuring smooth transitions between core and pedestal regions.
Key operations:
- Runs EPED model to predict pedestal pressure and width
- Applies H-mode profile functions with configurable shaping parameters
- Maintains ion-electron temperature ratio consistency (core vs. pedestal)
- Preserves particle density ratios between species
- Ensures proper pedestal positioning at ρ=0.9 reference location
Profile construction workflow:
- EPED Prediction: Calculates pedestal pressure and width from current plasma state
- Temperature Profiles: Constructs Te and Ti using H-mode functions with shaping
- Density Profiles: Updates ne and ni maintaining species fraction consistency
- Source Updates: Recalculates all power and particle sources for updated profiles
Shaping parameters:
Te_shaping
: Controls electron temperature profile curvaturene_shaping
: Controls electron density profile curvatureT_ratio_pedestal
: Ti/Te ratio in pedestal regionT_ratio_core
: Ti/Te ratio in core region
The actor preserves the on-axis plasma values while optimizing the profile shapes to match both EPED pedestal predictions and prescribed core-pedestal transitions.
ActorEPEDprofiles
├─ Te_shaping
├─ ne_shaping
├─ T_ratio_pedestal
└─ T_ratio_core
FluxCalculator
FUSE.ActorFluxCalculator
— MethodActorFluxCalculator(dd::IMAS.dd, act::ParametersAllActors; kw...)
Provides a unified interface to run turbulent and neoclassical transport model actors.
This compound actor manages the execution of both turbulent transport models (TGLF, QLGYRO, analytic, or none) and neoclassical transport models (neoclassical or none). The actor coordinates the calculation of transport fluxes from both physics mechanisms and ensures they are properly stored in dd.core_transport
.
Turbulence model options:
:TGLF
: TGLF-based models (TGLF, TGLFNN, GKNN, TJLF):QLGYRO
: Quasi-linear gyrokinetic transport via CGYRO:analytic
: Simple analytic transport models:none
: No turbulent transport
Neoclassical model options:
:neoclassical
: Collisional transport (Chang-Hinton, NEO, Hirshman-Sigmar):none
: No neoclassical transport
ActorFluxCalculator
├─ rho_transport
├─ turbulence_model
└─ neoclassical_model
FluxMatcher
FUSE.ActorFluxMatcher
— MethodActorFluxMatcher(dd::IMAS.dd, act::ParametersAllActors; kw...)
Performs self-consistent transport evolution by matching turbulent/neoclassical transport fluxes to source fluxes.
This actor solves the core transport equation ∇·Γ = S by iteratively adjusting plasma profile gradients until transport fluxes balance particle/energy sources. The process:
- Profile Evolution: Adjusts temperature/density/rotation profile gradients based on user configuration
- Transport Calculation: Evaluates turbulent and neoclassical transport fluxes using ActorFluxCalculator
- Source Calculation: Updates plasma heating, particle, and momentum sources
- Flux Matching: Minimizes residual (transportflux - sourceflux) using nonlinear solvers
- Pedestal Coupling: Optionally evolves pedestal conditions during the iteration process
Evolution options per channel:
:flux_match
: Evolve profile gradients to match transport and source fluxes:fixed
: Keep profiles fixed:replay
: Use profiles from experimental data
Advanced features include turbulence scaling to target confinement laws (H98, DS03), time-dependent evolution with ∂/∂t terms, and various nonlinear solver algorithms optimized for different transport model characteristics.
ActorFluxMatcher
├─ rho_transport
├─ evolve_Ti
├─ evolve_Te
├─ evolve_densities
├─ evolve_rotation
├─ evolve_pedestal
├─ evolve_plasma_sources
├─ find_widths
├─ max_iterations
├─ xtol
├─ algorithm
├─ custom_algorithm
├─ step_size
├─ Δt [s]
├─ relax
├─ scale_turbulence_law
├─ scale_turbulence_value
├─ do_plot
├─ verbose
└─ show_trace
AnalyticTurbulence
FUSE.ActorAnalyticTurbulence
— MethodActorAnalyticTurbulence(dd::IMAS.dd, act::ParametersAllActors; kw...)
Evaluates analytic turbulent transport models including GyroBohm and Bohm+gyro-Bohm (BgB) models.
The actor supports two transport models:
:GyroBohm
: Simple gyro-Bohm scaling returning unit fluxes:BgB
: Detailed Bohm + gyro-Bohm model calculating electron and ion energy diffusivities (χe, χi) and particle flux (Γe) based on local plasma parameters, pressure gradients, and magnetic geometry
The BgB model computes transport coefficients using local temperature and density gradients, safety factor profiles, and magnetic field geometry. Results are normalized to gyro-Bohm and stored in dd.core_transport
as anomalous transport fluxes.
ActorAnalyticTurbulence
├─ model
├─ αBgB
├─ χeB_coefficient
├─ χeGB_coefficient
├─ χiB_coefficient
├─ χiGB_coefficient
├─ rho_transport
└─ do_plot
Neoclassical
FUSE.ActorNeoclassical
— MethodActorNeoclassical(dd::IMAS.dd, act::ParametersAllActors; kw...)
Evaluates neoclassical (collisional) transport fluxes using established theoretical models.
Supported neoclassical models:
:changhinton
: Chang-Hinton model for ion heat transport in the banana/plateau regime:neo
: Full drift-kinetic NEO code for comprehensive neoclassical transport including bootstrap current, providing electron/ion energy, particle, and momentum fluxes:hirshmansigmar
: Hirshman-Sigmar analytical model for comprehensive neoclassical transport in various collisionality regimes
The models account for collisional effects, magnetic geometry, and trapped particle physics to calculate transport coefficients. Results are stored in dd.core_transport.model[:neoclassical]
and include contributions to bootstrap current, thermal transport, and particle transport.
ActorNeoclassical
├─ model
└─ rho_transport
QLGYRO
FUSE.ActorQLGYRO
— MethodActorQLGYRO(dd::IMAS.dd, act::ParametersAllActors; kw...)
Evaluates turbulent transport using the QLGYRO quasi-linear gyrokinetic model.
QLGYRO combines TGLF quasi-linear theory with CGYRO nonlinear gyrokinetic simulations to provide high-fidelity turbulent transport predictions. The model:
- Uses TGLF to identify the most unstable modes and calculate quasi-linear fluxes
- Runs CGYRO nonlinear gyrokinetic simulations to compute saturation levels
- Applies saturation rules to calibrate the quasi-linear transport predictions
Key parameters include ky spectral resolution, number of field components (electrostatic vs electromagnetic), simulation time parameters, and saturation rules. The model provides comprehensive electron/ion energy, particle, and momentum fluxes with gyrokinetic fidelity while being more computationally efficient than full nonlinear simulations.
ActorQLGYRO
├─ ky
├─ nky
├─ cpu_per_ky
├─ kygrid_model
├─ sat_rule
├─ n_field
├─ delta_t
├─ max_time
├─ rho_transport
└─ lump_ions
TGLF
FUSE.ActorTGLF
— MethodActorTGLF(dd::IMAS.dd, act::ParametersAllActors; kw...)
Evaluates turbulent transport fluxes using TGLF-based models including TGLF, TGLFNN, GKNN, and TJLF.
Supported models:
:TGLF
: Full TGLF gyrokinetic transport model:TGLFNN
: Neural network surrogate of TGLF for fast evaluation:GKNN
: Neural network surrogate with gyrokinetic fidelity:TJLF
: Weiland model for ITG/TEM turbulence with adaptive spectral widths
The actor creates input files for the selected model based on local plasma parameters, runs the transport calculation, and stores results as FluxSolution objects containing electron/ion energy fluxes, particle fluxes, and momentum flux. Results are normalized in gyro-Bohm units and written to dd.core_transport
as anomalous transport.
ActorTGLF
├─ model
├─ onnx_model
├─ sat_rule
├─ electromagnetic
├─ tglfnn_model
├─ rho_transport
├─ warn_nn_train_bounds
├─ custom_input_files
├─ lump_ions
└─ save_input_tglfs_to_folder
Wall loading (2 actors)
CoreRadHeatFlux
FUSE.ActorCoreRadHeatFlux
— MethodActorCoreRadHeatFlux(dd::IMAS.dd, act::ParametersAllActors; kw...)
Computes wall heat flux from core plasma radiation using Monte Carlo photon transport.
This actor calculates the heat flux deposited on plasma-facing components by electromagnetic radiation (bremsstrahlung, line radiation, synchrotron) emitted from the core plasma. Core radiation represents a significant fraction of total plasma power and directly impacts wall loading and cooling requirements.
Physical Modeling:
- Volume emission from all core radiation sources (impurity line radiation, bremsstrahlung)
- Line-of-sight photon transport from emission location to wall intersection
- Accounts for plasma opacity and absorption effects
- Integration over entire plasma volume and all wall surfaces
Computational Method:
Source Definition: Uses radiation source profiles from
dd.core_sources
including contributions from impurity radiation, bremsstrahlung, and other radiative lossesMonte Carlo Transport: Launches statistical photons from emission locations with:
- Proper spatial weighting based on local radiation source strength
- Random directional sampling to capture all emission angles
- Line-of-sight transport to first wall intersection
Wall Deposition: Accumulates photon energy deposition on wall mesh elements, accounting for geometric factors and surface orientations
Key Outputs:
q_core_rad
: Heat flux on wall surface from core radiation transport- Statistical convergence based on number of photons traced (parameter N)
- Wall mesh coordinates for spatial distribution analysis
This calculation provides essential data for first wall and blanket thermal design, complementing particle heat flux calculations for comprehensive wall loading analysis.
ActorCoreRadHeatFlux
├─ N
├─ r [m]
├─ q [W m⁻²]
├─ levels
├─ merge_wall
├─ step [m]
└─ do_plot
ParticleHeatFlux
FUSE.ActorParticleHeatFlux
— MethodActorParticleHeatFlux(dd::IMAS.dd, act::ParametersAllActors; kw...)
Computes wall heat flux from charged particle transport across the scrape-off layer (SOL).
This actor calculates the heat flux deposited on plasma-facing components by charged particles (ions and electrons) flowing along magnetic field lines from the plasma edge to the wall. The calculation accounts for:
Physical Modeling:
- Parallel heat conduction along magnetic field lines in the SOL
- Power density decay profiles from outer midplane to divertor/limiters
- Geometric projection effects from field-line-following to wall-normal flux
- Integration over the entire first wall and divertor surfaces
Computational Approach:
- Creates a computational mesh of the first wall incorporating SOL flux surfaces
- Traces open field lines from the separatrix to wall intersection points
- Applies prescribed power decay profiles along field lines
- Computes both parallel (field-line-following) and perpendicular (wall-normal) heat fluxes
Key Outputs:
q_part
: Heat flux perpendicular to wall surface from particle transportq_parallel
: Heat flux parallel to magnetic field lines- Wall mesh coordinates and curvilinear distance along the wall
The results provide essential input for material design, cooling system requirements, and component lifetime assessments in tokamak reactor studies.
ActorParticleHeatFlux
├─ r [m]
├─ q [W m⁻²]
├─ levels
├─ merge_wall
├─ step [m]
└─ do_plot