Skip to main content

Workflow node reference

Every block the API accepts in a workflow's graph, by kind. A node is {id, kind, ref, params}; rows flow along its wires, and each node reads columns that a node upstream wrote. The graph's JSON shape is in the API reference.

A row is a pass (one antenna's view of one satellite from AOS to LOS), a link (that view over the whole run), or, after sum_by, an antenna, satellite or ground station per day.

Inputs​

A graph has exactly one input.

NameReadsWritesNeeds
passesThe satellites and antennas in your network config, sampled every step_s over the run's windowOne pass row per pass, with max_elevationstep_s. Optional satellite_ids and antenna_ids; leave them out for all. Explore covers at most 2 satellites
linksThe sameOne link row per link, over all its passes in the runThe same. Optional window_s, the window a run covers from when it starts; rfi-watch sets an hour at 60 s steps

Lanes​

Each lane writes a column of its own name, with a p10, p50 and p90 at each step. quantile holds one of them at all three, such as p90 for the wet tail of weather.

NameReadsWritesNeeds
snrThe link budget from your network config's RF values; on Operator, the Link SNR model where it servessnr, in dBNothing: always runs
weatherA rain-fade climatology; on Operator, the Weather attenuation model where it serves. A scenario's extra fade adds to itweather, fade in dBNothing: always runs
demandThe Satellite demand modeldemand, the share of the pass the satellite can expect an antenna forOperator, and a deployment that serves the model
rfiThe RF interference modelrfi, the dB interference takes off the linkOperator, and a deployment that serves the model
ssaThe SSA pass forecast modelssa, the chance the antenna holds the satelliteOperator, and a deployment that serves the model

demand, rfi and ssa have no physics baseline. Where the model is not served, a run that reads the lane is refused with 422 lanes_not_served; below Operator, with 403 plan_required and feature: learned_corrections. Left out of a graph, each counts as no loss.

Transforms​

NameReadsWritesNeeds
sinrsnr; weather and rfi when upstreamsinr: SNR less fade and interference, in dB, at each stepweather and rfi before it, or they count as no loss
capacitysinrcapacity: the GB the pass carries at its SINR, from the radio's own MODCOD table or DVB-S2'sPass rows
successssa and demand when upstreamsuccess: the chance the pass happens as plannedssa and demand before it. Pass rows
expected_gbcapacity, successexpected_gb: capacity times successPass rows
modcod_schedulesinrmodcod_changes, and a time-tagged MODCOD series on the itemPass rows
lock_losssinr, rfirfi_db, the worst step; lock_loss_risk, the share of steps where interference alone drops the low case below the lowest MODCOD; and a recommendation to reroutePass or link rows
sum_byThe column you nameOne row per antenna, satellite or ground_station (by) per UTC day (per: day): passes, sellable minutes and the summed rangeNetwork: a graph with sum_by is the antenna-capacity template, which saving refuses below Network with 403 plan_required (a trial allows it). Waits for the whole run
swapThe column you name, usually expected_gbswap, the GB gained in the low case, and a recommendation to swap to a backup pass with its deadlineat_risk_share (0 to 1): a pass is at risk when the weather lane, at its p50, costs more than this share of its clear-sky GB (rain-fade-swap uses 0.3). backup_within_s, cancel_lead_s. Waits for the whole run
ledgerThe column you name, and the contacts logged in the run's datasetledger: GB possible, GB delivered and the outcome per pass; totals per ground station on the runA run with a past window and a dataset, such as audit. Waits for the whole run
policyA recommendation from a step upstreamThe recommendation's modemode: suggest sends it as advice; approve holds it for a person. See From trial to sending

Conditions​

NameReadsWritesNeeds
thresholdcolumn, at quantile for a column with a rangeNothing: matching rows leave by true, the rest by falseop (<, <=, >, >=) and value

Outputs​

Each output turns the rows that reach it into items: columns make each item's value, and sort orders them.

NameReadsWritesNeeds
predictionsThe rows that reach itThe items GET /predictions returnsExactly one per graph. Every plan
feedThe sameThe workflow results a connector in your network pulls, for its connectionmapping naming its system: yamcs, lattice, cosmos or custom. Delivers on Operator; Lattice and COSMOS on Enterprise; custom needs a connector you approved
destinationThe sameA push to one of your destinationsdestination_id, a destination your account has. Delivers on Operator

A test run or a scenario run sends nothing from feed and destination outputs. See Results out.

Graph rules​

The API refuses a graph that breaks one, naming the node or edge:

  • One input, one predictions output, no cycles, and every node past the input fed.
  • Only an output takes more than one incoming wire.
  • A lane goes before the transform that reads it (lane_after_reader), and never after a node that waits for the whole run (lane_after_whole_run).
  • Each node has the columns it reads on every path upstream (column_missing) and the row type it reads (type_mismatch).
  • No two mission control outputs name one connection, and no two destination outputs one destination.
  • A graph whose deciding step is lock_loss, as in rfi-watch, has no lattice or cosmos mission control output: those bridges drop reroutes (reroutes_not_delivered).
  • Once a graph has a policy in approve mode, every path to every output passes through one (output_around_approval), and through one placed after every step that suggests an action (swap, lock_loss) and every policy in suggest mode on that path. A policy before the step that suggests the action holds nothing.

Check a graph without saving it with POST /predictions/workflows/{slug}/validate; the builder does this as you edit.

Next: change a template with these blocks in Recipes.