VisRad interchange

VISRAD_PHASE_PLATES

VisRad's built-in phase-plate profiles (VR/powersources/phaseplateparams.html), keyed by the manual's names: (facility, major, minor, order, level) with radii in µm (the manual's "(mm)" header is a µ rendered in the Symbol font) measured where the intensity is level × peak — exp(-1) (1/e) for the OMEGA, OMEGA EP and GEKKO tables, 0.5 (HWHM) for NIF CPPs, 0.03 for LMJ. Circular plates have minor == major. order is the super-Gaussian exponent n of exp(-[(x/a)²+(y/b)²]^(n/2)) (VR/powersources/setlaserprofileprops.html). The NIF n = 2.0 entries are the manual's placeholder where no data were available. The GEKKO table does not state its radius definition; 1/e is an assumption. See `visradspot`.

VISRAD_SST_COLUMNS

Column headers of the NIF SST beam-pointing CSV, as VisRad maps them when importing an SST file (screenshot in VR/intro/revisionhistory.html, v21.0.0, and VR/powersources/importlaserbeamdatacsv.html): beam name, aim point x, y, z (mm, target-chamber Cartesian about TCC) and defocus (mm).

compare_visrad(kit_dir; elements = nothing, power_summary = nothing, observe = :capsule,
               names = Dict(), terms = (0, 2, 4), lmax = 4, io = nothing)
    -> Vector{NamedTuple}

Compare a kit written by write_visrad_kit with VisRad's results for the same case.

• elements: VisRad's Surface Element Properties export for the observed component (read_visrad_table). The polar and azimuthal columns (headers containing "polar"/"theta" and "azim"/"phi", degrees, in the component's own frame — for an unrotated sphere the chamber frame) and "Flux In" (TW/cm²; a TW/mm² header is converted) are fitted exactly as Briareus's elements were (visrad_legendre_fit over terms, visrad_ylm_fit to lmax).
• power_summary: VisRad's Power Summary, as a file (read_visrad_table; object names are row labels) or a Dict(object => Dict(column => value)) typed from the dialog, columns as in VisRad ("Laser Pwr Dep", "Incident Rad Pwr", "Emitted Rad Pwr", "Pwr Src Term", "Surface Area"; TW and cm²). names maps VisRad object names to Briareus component names, e.g. Dict("hohlraum_barrel" => "wall").

Returns rows (; quantity, unit, briareus, visrad, difference, relative) and prints them to io when given.

read_visrad_powers(path; template = nothing) -> Dict{String,PulseShape}

Read a VisRad time-dependent beam-power CSV: first column time (ns; a "(s)"/"(sec)" or "(ps)" unit in its header is converted), then one power column (TW) per beam headed by the beam name (VR/files/laserbeamdatafiles.html). Negative powers are set to zero as VisRad does on import (VR/powersources/importtdepbeam_powers.html).

Without a template the keys are the normalized beam names (BL115 → B115, Beam_10). With a template beam set the keys are the template's names: beams match by name, and a NIF quad gets the sum of its four beams' pulses (on the union of their knots). Build beams at time t with e.g. [remake(b; power = P[b.name](t)) for b in beams].

read_visrad_pulse_shape(path) -> PulseShape

Read one of VisRad's standard laser pulse-shape files (data/laser_pulse_shapes of the installation): a two-column ASCII table of power (W) versus time (s) (VR/files/laserpulseshape_files.html), returned in ns and TW. The column order is not stated; time first is an assumption, and a first column that is not sorted while the second is triggers the swap. Non-numeric lines are skipped.

read_visrad_sst(path; template = nif_beams(), missing = :off, units = nothing)
    -> Vector{Beam}

Read a NIF SST pointing CSV (written by VisRad's File | Export Laser Beam Data | NIF SST Beam Data, by the SST, or by write_visrad_sst) and apply it to template: each beam found gets the file's aim (mm, chamber Cartesian about TCC, defocus not applied) and defocus (mm); power and spot are kept. Following VisRad's import (VR/powersources/importlaserbeamdata_csv.html), template beams absent from the file are turned off (missing = :off, power 0); :keep leaves them unchanged and :error throws.

Beam names match case-insensitively, with BL115 read as B115. With a quad template (nif_quads()), each quad takes the mean aim and defocus of its four beams, with a warning if they differ by more than 1 µm. The header row is found by its "Beam Aim Point" columns; lines before it are skipped, extra columns ignored. Units come from the headers ("(mm)", "(cm)", "(um)"); units (mm per file unit) overrides them.

read_visrad_summary(path; template = nothing, missing = :off, spot_definition = :auto,
                    rotation_sense = :beam, angle_tol = 0.05) -> Vector{Beam}

Read a VisRad Laser Beam Summary CSV (Export Data in the Laser Beams Summary dialog, VR/powersources/lasersummarytable.html; also written by `writevisrad_summary`). Columns are recognized by header, so older layouts and extra columns are accepted.

Conversions:

• Pointing. "TC Pt Pos-x/y/z" (cm) is the beam's focus in the target-chamber frame: the Reference Point plus the focus offset along the beam. This follows from the manual's own example table (VR/powersources/images/lasersummary.jpg): beams pointed at the same foil-frame Reference Point with focus offset -0.215 cm have TC positions that differ by exactly 0.215 cm × the difference of their port vectors. So aim = 10·TC + defocus·port (mm) with defocus = 10·focus offset (cm → mm). When the TC columns are absent, the Reference Point is taken from "Pt Param-1/2/3" (cm; Cartesian, cylindrical (r, z, φ) or spherical (r, θ, φ), degrees), which works only for references in the target-chamber frame ("Target Chamber" or "TCC"). When both are present they are cross-checked.
• Power. "Power" (TW; for NIF the sum of the 3ω, 2ω and 1ω cones, VR/powersources/nifbeam_params.html). Time-dependent beams show their peak as "T-<peak>", read as the peak with a warning. Off beams get power 0.
• Spot. "R0" major/minor are radii (µm) at the spot-size definition level, "36.8% (1/e)", "50%" or "5%" of peak (VR/powersources/setlaserprofileprops.html); they become 1/e semi-axes a (major), b (minor) of the same super-Gaussian exp(-[(x/a)²+(y/b)²]^(n/2)), which is VisRad's focal profile. The definition comes from an "R0 Def" column if present, else spot_definition: :auto uses the level of a recognized built-in phase plate (VISRAD_PHASE_PLATES; NIF CPP radii are HWHM) and 1/e otherwise (VisRad's default for Custom Supergaussian, assumption for other models); :e, :hwhm, :pct5 or a number force it. The exponent n comes from an "SG Exponent" column, else the phase-plate table, else the template beam. A "Uniform" profile (flat across R0 at focus) is approximated by n = 50 with 1/e radius R0.
• Rotation. "Rot Angle" is the minor-axis rotation ρ (degrees, clockwise from vertical; ρ = 0 puts the major axis horizontal, i.e. along the port's φ̂). Briareus's angle of the major axis from θ̂ toward φ̂ is 90° − ρ for rotation_sense = :beam (spot seen looking along the beam) and 90° + ρ for :target (seen from TCC). The manual does not say which; :beam is an assumption to verify.
• DPR, halo, f-number and wavelength are not in the file: DPR "On" is warned about and ignored (VisRad splits such OMEGA beams into two cones 85 µm apart); the rest come from the template.

With a template, beams are matched by name (case-insensitive; "BL115" reads as "B115", "10" and "BL-10" as "Beam10"), port angles are checked against the file's "Polar Ang"/"Azm Ang" (warning beyond `angletoldegrees — a frame or naming mismatch), template beams absent from the file followmissing(:off,:keep,:error`; VisRad omits hidden unused beams), and NIF quads aggregate their four beams (mean aim and defocus, summed power). Without a template, beams are built from the file's port angles.

read_visrad_table(path; header = nothing) -> (; header, labels, data)

Read a multi-column ASCII table exported by VisRad — the Surface Element Properties table (File | Save Data for Object / All Objects / Selected Rows, and the *.sed files of a run; VR/results/displaysurfelemtable.html, VR/simulationtimes/configsimparams.html) or a Power Summary (*.psd). The manual shows the columns (e.g. "Z (cm)", "Azim. ang (deg)", "Radius (cm)", "Surf Index", "Emis T (eV)", "Rad T (eV)", "Flux In (TW/cm2)", "Flux Out (TW/cm2)", …; VR/results/images/surfelemtable.jpg) but not the file layout, so the reader is tolerant (assumption throughout): comma-, tab- or whitespace-separated; data rows are the most common shape of lines ending in numbers, with any leading non-numeric text kept as the row's label (an object name); the header is the last non-data line before the first data row, split on the delimiter, on runs of 2+ spaces, or by attaching "(unit)" tokens to the words before them. Pass header (a vector of names for the numeric columns) when that fails.

Returns the numeric column names, row labels (empty strings when none) and an nrows × ncols matrix.

visrad_legendre_fit(theta, values; terms = 0:4, weights = nothing) -> Vector

Least-squares fit f(θ) = Σₗ Aₗ Pₗ(cos θ) over the given terms, as in VisRad's Surface Element Statistics (coefficients up to A4, each term selected by a check box; VR/results/displaysurfelem_table.html). theta in degrees; returns A indexed l+1 (zero for unused terms), so A[3]/A[1] is P2/P0. Unweighted by default — VisRad's weighting is not documented (assumption); pass element areas as weights to weight. Apply the same fit to Briareus and VisRad element values for a like-for-like comparison.

visrad_spot(plate; rotation = 0.0, rotation_sense = :beam) -> SuperGaussianSpot

Briareus spot equivalent to a VisRad built-in phase plate (VISRAD_PHASE_PLATES name, or a CMT/summary-table spelling such as "Rev3 Inner Cone 2W CPP" or "OMEGA E-IDI-300 DPP"). The tabulated radii, defined at the table's intensity level, are converted to 1/e semi-axes (mm) of the same super-Gaussian: r_1/e = r_f / (ln(1/f))^(1/n). rotation is VisRad's minor-axis rotation (degrees, clockwise from vertical, 0 = major axis horizontal); see read_visrad_summary for rotation_sense.

visrad_ylm_fit(theta, phi, values; lmax = 4, weights = nothing) -> Vector

Least-squares fit to VisRad's real spherical harmonics (VR/results/displaysurfelemtable.html): `YLM = NLM PL^M(cos θ)for M = 0 and√2 NLM PL^|M|(cos θ)×cos Mφ(M > 0) orsin |M|φ(M < 0), withNLM = √((2L+1)(L−M)!/(L+M)!), soY00 = 1andA00` is the mean (the manual's example: mean 9.736, A00 = 9.739) and A_L0 = A_L/√(2L+1) for the Legendre A_L (its example: 1.143·√5 = 2.556 vs A2 = 2.563). Angles in degrees; coefficients in Briareus's flat `modeindexorder. These are Briareus's orthonormalylmmomentstimes√(4π). Whether VisRad'sPL^Mcarries the Condon–Shortley phase is not stated; none is assumed (signs of odd-M coefficients may flip);√(ΣM ALM²)/A_00` is unaffected.

write_visrad_kit(dir, target, beams; model = nothing, op = nothing, pulses = nothing,
                 time = 0.0, observe = :capsule, terms = (0, 2, 4), lmax = 4,
                 rotation_sense = :beam, notes = "") -> NamedTuple

Write everything needed to rebuild a Briareus case in VisRad, together with Briareus's results for comparison (compare_visrad), into directory dir:

• pointing_sst.csv — per-beam pointing in the NIF SST format (write_visrad_sst); import with File | Import Laser Beam Data | Pointing Data, Custom CSV, units mm.
• beam_summary.csv — the full beam set in Laser Beam Summary layout (write_visrad_summary): port angles, pointing, focus, power, 1/e spot radii, exponents and rotations.
• powers.csv — per-beam time-dependent powers (write_visrad_powers), when pulses is given (see write_visrad_powers for its forms); beam powers are then evaluated at time.
• briareus_beams.csv — the canonical Briareus beam table (write_beam_table).
• README.txt — target geometry (component shapes and dimensions in mm, cm and µm, materials, albedos and conversion efficiencies), beam settings, and the VisRad steps.
• briareus_results.csv — quantity,value,unit rows: per-component "Laser Pwr Dep", "Pwr Src Term" (conversion × laser), "Incident Rad Pwr" (Σ H·A), "Emitted Rad Pwr" (Σ B·A), all TW, and "Surface Area" (cm²), named as VisRad's Power Summary columns; the laser power that misses or strikes outer surfaces; and for observe the mean incident flux (TW/cm²), the VisRad-style Legendre fit (visrad_legendre_fit over terms) and per-L amplitudes of the VisRad spherical-harmonic fit (visrad_ylm_fit).
• briareus_<observe>_elements.csv — per-element polar/azimuthal angle about the component's center (degrees), area (cm²), incident flux and absorbed laser flux (TW/cm²).

The deposition uses op (default DepositionOperator(target, beams)) and the radiation model (default RadiationModel(target)). Returns (; dir, files, results) with results a Dict of the quantities in briareus_results.csv.

write_visrad_powers(path, beams, pulses; times = nothing) -> path
write_visrad_powers(path, pulses::AbstractDict{String,PulseShape}; times = nothing) -> path

Write a VisRad time-dependent beam-power CSV (VR/files/laserbeamdatafiles.html): header time (ns) then one column per beam named as VisRad names beams (B115 for NIF, `Beam10` for OMEGA), rows of time (ns) and power (TW per beam). Import it with File | Import Laser Beam Data | Time-Dependent Powers (VR/powersources/importtdepbeampowers.html); for NIF VisRad assigns the powers to the 3ω (blue) cones.

pulses is a PulseShape for every beam, a Dict/NamedTuple keyed by group (as in with_pulses), a Dict keyed by beam name, or a function beam -> PulseShape. NIF quads expand to their four beams at a quarter of the quad's power each. Times default to the union of all pulse knots, so piecewise-linear pulses are reproduced exactly when each starts and ends at zero power (a PulseShape is zero outside its table; a pulse that starts or ends at a finite power gets a ramp to its neighbors' knots instead). Briareus beam names that are not facility names (e.g. omega_beams()'s hohlraum-frame B01…) are written as they are; rename them first.

write_visrad_sst(path, beams; include_off = false) -> path

Write beam pointing as a NIF SST CSV (VISRAD_SST_COLUMNS): one row per NIF beam ("B111"–"B468"), aim point in target-chamber Cartesian coordinates about TCC (mm) without the defocus applied, and the defocus (mm, positive moves the focus along the propagation direction). This is VisRad's export format (VR/files/laserbeamdatafiles.html, "NIF SST Data Files") and imports into VisRad through File | Import Laser Beam Data | Pointing Data, "Custom" CSV, which recognizes these headers (VR/powersources/importlaserbeamdatacsv.html).

NIF quads (names "Q11T"…, e.g. nif_quads()) are written as their four beams with the quad's pointing. VisRad turns on exactly the beams that have pointing data, so beams with zero power are left out unless include_off.

The file carries no powers or spots: pair it with write_visrad_powers and set the spot model in VisRad (see write_visrad_kit).

write_visrad_summary(path, beams; rotation_sense = :beam, cluster = b -> string(b.group),
                     profile = "Custom Supergaussian", extras = true) -> path

Write beams in the layout of VisRad's Laser Beam Summary CSV, one row per VisRad beam (NIF quads expand to their four beams with a quarter of the power each): cluster, beam ID, on/off (power > 0), port polar/azimuth (degrees), pointing reference "Target Chamber"/"Cartesian" with the aim as Pt Param-1/2/3 (cm), focus offset (cm), focus position "TC Pt Pos" (cm, aim + defocus·k), power (TW), DPR "Off", spatial profile model, R0 major/minor as 1/e radii (µm), and the minor-axis rotation (degrees; see read_visrad_summary for rotation_sense). extras appends "SG Exponent" and "R0 Def" ("36.8% (1/e)") so that the file is self-contained.

Columns through "TC Pt Pos-z" reproduce the v21 dialog's headers; the names of the later columns are not shown in the manual (assumption), and halo parameters are not written (VisRad has none). Use this file for records and for read_visrad_summary; to set pointing in VisRad, import write_visrad_sst, whose format is documented.

VisRadObject

One target component of a VisRad workspace, as read by read_visrad_workspace.

Fields: name; VisRad's object type code and the kind Briareus recognizes (:mesh for CAD/generalized meshes, :sphere, :rectangle, :cylindrical_hohlraum, :other); the folder path in VisRad's component tree ("" at the top); params, every key = value line of the object verbatim; rotation and position (mm), the object's frame in the target-chamber frame (x_chamber = rotation * x_object + position); mesh, the surface in the chamber frame (mm) for meshes (one patch per VisRad surface element) and nothing otherwise; albedo, conversion (x-ray conversion efficiency) and reflectivity (laser); the flags radiosity, laser (direct laser deposition) and visible; and color (RGB in [0, 1]).

VisRadWorkspace

Contents of a VisRad workspace file (read_visrad_workspace): path, VisRad version string, objects (VisRadObjects in file order), beams (Beams), clusters (beam cluster names in file order), and rows, the raw beam records (one NamedTuple per beam with every column of the beam table, the reference frame name and any power tables).

read_visrad_workspace(path; template = nothing, missing = :off, spot_definition = :auto,
                      rotation_sense = :beam, angle_tol = 0.05) -> VisRadWorkspace

Read a VisRad workspace (.vrw, the text format of VisRad 20–21, "Workspace Format ID = 11"): its target components, including CAD imported as generalized meshes, and its laser beams. Lengths are converted from cm to mm; every object and beam frame is resolved to the target-chamber frame. Build a Briareus target from the components with visrad_target.

Components become VisRadObjects. CAD meshes keep VisRad's surface elements as patches (one per triangle). Spheres, rectangles and cylindrical hohlraums are meshed on VisRad's grid when converted by visrad_target. Objects are placed by VisRad's orientation angles and position (VR/grid/specifyingorientangles.html), relative to the chamber or to another component.

Beams. Port angles and f-number come from the file. Pointing at TCC or at a point given in the chamber's or a component's frame is supported; the point is the aim and the focus offset (cm) the defocus (mm), as in read_visrad_summary. Power is the 3ω (blue cone) power in TW for beams with 3ω on, and 0 otherwise: the power column times the beam's power multiplier when enabled and, under VisRad's "Fraction of Total Beam Power" red/green model (where that column is the total), times 1 − fG − fR. Spots are VisRad's super-Gaussian radii (µm), exponent and minor-axis rotation, converted as in read_visrad_summary: radii that match a built-in phase plate (VISRAD_PHASE_PLATES) are read at that plate's level (HWHM for NIF CPPs), others at spot_definition (:auto = 1/e). Unconverted light, time-dependent powers, energy normalization and DPR are warned about and not imported.

With a template (e.g. nif_beams()), the file's pointing, power and spots are applied to the template's beams by name and its other properties (halo, wavelength, quad, group) are kept; port angles are checked to angle_tol degrees and missing handles template beams absent from the file, as in read_visrad_summary. Without one, beams are built from the file, grouped by VisRad cluster.

visrad_component(object; material = nothing, two_sided = false, orient = false,
                 toward = (0, 0, 0), coarsen = nothing, remesh = nothing,
                 fit = false, primitive_h = nothing) -> Vector{Component}

Briareus components for one VisRadObject, in the chamber frame (mm). The material defaults to the object's albedo and x-ray conversion efficiency. CAD meshes give one component radiating from the front of VisRad's surface elements (counterclockwise winding, assumption), or from both sides when two_sided. VisRad does not let users edit the normals of imported CAD (VR/grid/importexportcadfiles.html), and tessellated CAD often faces the wrong way: in the NIF workspace this reader was built from, the inner hohlraum wall faces away from the cavity. orient = true repairs the winding with `orientmesh: consistent across shared edges, closed solids facing out of their material, open sheets facing the pointtoward(mm, chamber frame; by default the target chamber center).twosided = trueinstead radiates from both sides (thin shells are then modeled as two radiating sides). CAD needs fewer, compact elements before view factors:remesh(mm) divides the surface into near-planar elements of about that size whatever the facets' shapes (remeshmesh; long slivers are cut), whilecoarsen(mm) only merges whole near-coplanar facets up to that size (coarsenmesh; slivers longer than the size stay).fit = true(or a named tuple ofcurvedcomponentsandfitsurfaceskeywords) then splits a CAD part into its cylinders, cones and spheres, each with its exact surface fitted to the CAD facets, and the rest (curvedcomponents), so the radiation model integrates on the curved walls as it does for a primitive hohlraum. Rectangles give one component (normal +z before orientation), spheres one with aSphereSurface, and cylindrical hohlraums five —<name>wall,captop,capbottomand the apertureslehtop,lehbottom— with the curved surfaceshohlraumuses, all on VisRad's grid (Number of mesh pts, which reproduces VisRad's element table), or withprimitiveh(mm) on Briareus's grid for elements of about that size (hohlraumcounts,capsulecounts`), e.g. to resolve a spot on a foil that VisRad meshes coarsely. Other object types return no components (with a warning).

visrad_profile(workspace) -> VisRadProfile

VisRad's beam model with the workspace's parameters: the envelope ratio and the final optic distance (port radius, cm → mm) of the beams that are on (of all beams if none is on). Beams that differ in either are warned about, and the largest value is used. Pass it to DepositionOperator(target, beams; profile), or to a Scenario through deposition_kw = (; profile).

visrad_target(workspace; select = o -> o.radiosity || o.laser, materials = Dict(),
              two_sided = false, orient = false, toward = (0, 0, 0),
              coarsen = nothing, remesh = nothing, fit = false,
              inside = nothing) -> Target

Target built from the components of a VisRad workspace (read_visrad_workspace) for which select(object) is true — by default those VisRad includes in its radiosity or direct-laser calculation. materials maps object names to a Material overriding the file's albedo and conversion efficiency. two_sided (a Bool, or a function of the object) makes surfaces radiate from both sides; see visrad_component for why CAD meshes often need it, and for orient, toward, remesh, coarsen and fit (which apply to CAD meshes: repaired windings, elements of about remesh or coarsen mm, and exact cylinders, cones and spheres for the radiation model).

CAD meshes can hold hundreds of thousands of triangles, and each becomes a radiating element. That is fine for ray tracing (deposition, clearance, imaging) but too many for view factors; select the parts that matter for the radiation problem, e.g. select = o -> o.folder == "Hohlraum" or by name, and remesh them. inside, a point (mm, chamber frame) in the cavity, keeps only the elements that bound the free space around it (enclosure with its defaults; call it on the full target for the options and a per-component account of what was dropped). It needs consistent windings (orient = true). The selection runs on the CAD facets as oriented, remesh or coarsen then divide only the facets kept (much cheaper when most of the assembly lies outside the cavity), and a second selection on the resulting elements drops those that average too little flux. fit then applies to the elements kept, fitted on the kept facets. The CAD meshes go through these steps in cad_target, which takes the other components as they are (into the selection, but not remeshed or fitted); it does the same for CAD read from STL files.

write_visrad_workspace(path, template, beams; angle_tol = 0.05) -> path

A VisRad workspace with the pointing, focus, power and on/off of beams written into a copy of the workspace template (a .vrw file, e.g. the one a design was imported from with read_visrad_workspace). Each beam row of the template whose name matches a beam gets that beam's aim, as a Cartesian position in the row's own reference frame (cm), its focus offset defocus (cm), its power as the 3ω power column (divided by the row's power multipliers and, under the "Fraction of Total Beam Power" red/green model, by its blue fraction, so VisRad's blue cone carries the beam's power) and on (power > 0) or off. Everything else is copied byte for byte: the target components and their frames, the spots, pulse shapes and VisRad's settings stay VisRad's own. Numbers are written in place at the template's column widths and decimals (0.1 µm for positions).

Rows without a matching beam are left as they were, and beams without a row are reported in a warning: the template sets which beams exist. A beam whose port differs from its row's by more than angle_tol degrees is refused (ports cannot be changed). Time-dependent power tables and energy normalization in the template are left as they are, so a row that uses them does not take the constant power (warned).