# TOPAS Kernel Data Structures (Schema)

TOPAS-Academic's kernel maintains its live object model as a tree of internal Txxx complex types -- distinct from the Technical Reference manual's own documented Data-structures section (browsed separately by the keyword-tree page). This page is that internal tree, made interactive, parsed directly from the kernel's own internal type dump (`exx.txt`) rather than the manual's prose, so it reflects the real, current object model exactly, including members the manual doesn't document. Regenerating this page re-parses `exx.txt` from scratch, so it always reflects whatever build produced that dump.

Each top-level box is one of these internal types, rooted at Tkernel, the kernel's own top-level object. A member can have literal children and/or inherit one or more other Txxx types (clickable, accent-colored) -- an inherited type's members nest underneath as a separate, second source of children, not the item's own literal structure. Because the same object can be reached through more than one real path in the kernel, a shown ancestry -- or a Path/Get result -- may not be the only valid path, and parents of a genuinely shared object may not be as shown.

Every top-level box is one of the kernel's internal Txxx complex types. Expanding a box shows its members top to bottom, in declared order.

A member (or a Txxx type's own box) can have literal children (nested sub-items declared directly inside it) and/or inherit one or more other Txxx types (clickable, accent-colored) -- an inherited type's members nest underneath, a separate, second source of children. +/− step nested detail a level at a time: + opens the shallowest still-closed level (literal children and every inherited type at once, if several are closed); − closes the deepest still-open level; each hides itself once there's nothing left to do. Each Txxx type block also has its own +/− pair next to its name, for the whole type at once.

Because the same object can be reached through more than one real path in the kernel, a shown ancestry -- or a Path/Get result -- may not be the only valid path, and parents of a genuinely shared object may not be as shown.

Click an item to set it as the search root, shown on the right, and to show its ancestry to the root. Get(xx) searches for an item named `xx` starting at that root, then its parent, and so on up to the top -- checking each ancestor's own name first (reported as `Parent(N)`), then its literal children plus directly inherited types' members (reported as `Parent(N).Child(xx)`), but never a nested/inherited item's own further inheritance. Get(xx, yy, ...) chains: equivalent to clicking `xx` once found, then typing Get(yy) from there -- each name is its own full walk-up search rooted at the previous match, not just inside its immediate contents, so `yy` can be a sibling of `xx` (found by walking back up) or nested inside it (e.g. inside a 'downed' item's own inherited type, invisible to a plain single-name search from higher up).

Each `Child(xx)` names just one of potentially several same-named items -- if `xx` is a genuine array member (flagged `_arr` in the dump), `Child(xx)` only ever lands on the first, with no way to tell which was meant; a warning names the ambiguity when that happens.

In Parents/Inherited by, clicking an item's name (leaf or ancestor) scrolls to and highlights it in the tree, leaving both panels untouched. Clicking a `: Txxx` tag instead shows that type in a closeable secondary view below the tree, without touching the tree's scroll position or either panel's content.

Clicking an item also fills Inherited by with every other place the closest Txxx type above it is used. Clicking a Txxx type's own name (a type-block header, or an inline inherited-type name) shows/hides its members and fills Inherited by with that type's own inheritance directly.

Filter doesn't search as you type -- press Enter. Comma-separate several terms. A term matches whole words first; substring matching only kicks in when no exact match exists anywhere. Case: ON/OFF sets case-sensitive vs. -insensitive matching (defaults ON, matching TOPAS's own case-sensitive syntax).

P pointer container · [] array.

Txxx -- an inherited type; click its name (turns accent-colored) to show/hide its members, and to show what else inherits it on the right. The bracketed label next to its expanded members is also clickable, and collapses it the same way.

Filter
Path
Click item to set search start
Parents
Click any item's own name to see its ancestry up to the root type here. Click a tree item's own name in this list to scroll to it in the tree and highlight it.
Inherited by
Shows what else inherits the closest Txxx type above whatever you last clicked -- or, for a Txxx type's own name (a type-block's own header, or an inherited-type name inline), that type's inheritance directly.
Secondary view ×