OutWit.Controller.Sweep 2.0.1

OutWit.Controller.Sweep

Host-side orchestration of parameter studies for every solver family the host knows: submit a study - the parameters, the variant table and what the variants run on - and the pool computes it chunk by chunk, with everything harvested so far observable while the sweep runs.

The study travels as SweepOptionsData (OutWit.Controller.Sweep.Model): the parameters, the variant table, the chunk bounds and exactly one family block. Everything else - the plan, the chunking, the state, the manifest, the result index - is one implementation for every family; a family is an ISweepFamily inside this controller (how its block is validated, how a chunk becomes its node activity's tasks, how a result becomes a manifest row, which artifacts a row offers).

Activities (all host-side)

Why chunks

A sweep chunk is a product checkpoint, not an algorithmic barrier: after every chunk the manifest holds all harvested variants, so a cancelled sweep keeps everything already computed, and a monitoring client sees per-variant states mid-run. Sizing is progressive - the first chunk small enough for fast feedback (a broken scenario burns a handful of variants, not the night), geometric growth to a cap (near-optimal allocator packing for the bulk; the cap bounds both cancellation loss and a failed node's recompute radius). A chunk is also a wave: the grid places its tasks on at most as many machines as the chunk has tasks, so the plan never opens narrower than the fleet - Sweep.Plan asks the engine how many machines can take a task of the job (local nodes and the handles other clouds offer) and raises the first chunk, and the cap with it, to that width. A client's larger first chunk stays as asked.

A variant that fails - a nonzero exit, a diverged solve - or that its node refuses before running (OpenFOAM: run-time code, a step outside the allow-list) is a row in the manifest with its verdict and reasons; it never fails the task, so one bad variant cannot poison its node batch.

Result document

The state variable is rendered for document clients (the ParaView plugin's cloud-open) as sweep.state@2: the counts by outcome, the manifest blob and the result index with each variant's artifacts by kind, so a client knows whether it downloads a CalculiX result file or an OpenFOAM case zip. The schema and the C++ and Python bindings are generated into OutWit.Controller.Sweep.Model/Documents/.

Module shape

Host-only (IWitControllerHost alone): never delivered to compute nodes, which is what makes the declared dependencies on the host-only Grid and on Special honest - dependency validation runs on nodes too, and a module that carried node activities alongside these declarations would be refused there. The families' node modules (CalculiX, OpenFOAM) are dependencies because their task and result types ride through the scripts; node-side work lives entirely in them.

Deploying Sweep 2.x: the host needs both family modules next to it - CalculiX (>= 1.1.0) and OpenFOAM (>= 1.0.0). The host loader refuses a module whose declared dependencies are missing, so a host without the OpenFOAM module refuses the whole Sweep module, and CalculiX sweeps stop with it, even though they never touch OpenFOAM. Install (or upgrade) the OpenFOAM module on the host before, or together with, Sweep 2.x.

Scripts

Scripts/SweepCalculiX.wit and Scripts/SweepOpenFOAM.wit (shipped via OutWit.Controller.Sweep.Scripts): plan → loop chunks { make → Grid.ForEach → harvest } → finish; the two differ only in the declared task and result collections and the node activity.