WitSweep reference

What WitSweep opens, what you can vary and what comes back. For a first study, start with Getting Started with WitSweep →.

Applies to WitSweep 1.7.

Contents

1. Supported inputs
2. CalculiX decks: what you can vary
3. CalculiX decks: response columns by analysis type
4. Nastran decks: the supported subset
5. OpenFOAM cases
6. Running a sweep and looking at results
7. Licenses, limits and updates
8. Limitations

1. Supported inputs

How a file is recognised

• A Nastran deck is recognised by its extension only (.nas, .bdf, .dat, any letter case). Any other single file is read as a CalculiX deck.
• An OpenFOAM case is a folder that holds system/controlDict. A stub stands for the folder it sits in, and its extension must be written .foam or .OpenFOAM exactly. A folder with exactly one case among its direct subfolders opens that case. A folder whose only subfolder is not a case is followed into it, up to two levels (the shape a .zip unpacks to).
• A deck set is built from the .inp files of the folder or .zip, subfolders included, whatever the letter case of the extension. A file that another deck of the set includes is part of that deck, not a variant: it is left out, and the Scenario stage says so (<file> left out — a deck of the set includes it). macOS metadata (__MACOSX/, ._name files) is skipped. Nastran files inside a folder or a .zip are not part of a set.
• Cases are recognised before a folder is treated as a set of decks.
• These open alone and are refused in a mixed drop: a .witsweep, a Nastran deck, an OpenFOAM case, an OpenFOAM case set.
• Deck sets and case sets cannot be saved as a .witsweep.

Command line. witsweep <path> [--source=<host>] opens a deck, a Nastran deck, a case, a case set, a folder, a .zip or a .witsweep. --source sets the provenance badge (Nastran · from Inventor). A second launch hands its file to the window that is already open.

A .witsweep finds its deck. A session looks for its deck or case beside itself first, at the place it was saved relative to the session, then at the path it was saved with. A project copied with its deck therefore opens that copy. The restore line says which one served when it is not the saved one: · the deck found beside the session, · the deck beside the session, not the one at its saved path, · the deck at its saved path, none beside the session, · the deck found under the session's folder. For a case it names the case (· the case found beside the session, and so on). The restore then compares the sweep's identity: · identity verified, or · ‼ the deck changed since this session was saved (· ‼ the case changed since this session was saved for a case).

File associations.

What is refused when a file opens

Problems inside a model (a *RESTART, READ, a transient heat step without starting temperatures, an OpenFOAM construct the pool refuses) do not stop it from opening. WitSweep opens the model and names each problem as a blocker, and Run stays closed until they are gone.

2. CalculiX decks: what you can vary

When a deck opens, WitSweep marks every value it can vary. You click a value, choose Sweep this value, and give it a list, a range or a column of values on the Scenario stage.

Values and combinations

• List: values typed or pasted (250, 300, 350). Commas, semicolons, tabs and line breaks separate them.
• Range: start, end, and a step or a count.
• CSV: a pasted column.
• Paired CSV rows: one row per variant, one value per parameter. Several parameters then move together, and the table is these rows verbatim.
• With several parameters you choose one-at-a-time (the default: each parameter varied around the base values) or full factorial (every combination).
• A table of more than 100,000 variants is refused: The combination yields more than 100000 variants.

Every value is checked the way ccx reads it, when it is entered and again when Run composes the sweep. A value ccx would misread is refused with a sentence:

What can be varied

A value is offered only when it is a plain number on a data line of one of these cards. The label is what the parameter card shows beside the line number. The parameter itself is named p1, p2, … on the Scenario stage and in the Results header.

A value that cannot change the solve is listed, not offered. It stays marked in the deck, so the deck reads complete, but it cannot be picked: its menu says Not sweepable — it changes nothing in the solve: and the reason. The deck stage's count of sweepable values leaves it out. The reasons, decided from the steps the deck runs:

The mass is read by a GRAV, CENTRIF or NEWTON load and by a *FREQUENCY, *DYNAMIC, *MODAL DYNAMIC, *STEADY STATE DYNAMICS, *COMPLEX FREQUENCY or transient thermal step. The nonlinear cards are *PLASTIC, *CREEP, *HYPERELASTIC, *HYPERFOAM, *DEFORMATION PLASTICITY, *CONTACT PAIR, *GAP, *CYCLIC HARDENING and *RATE DEPENDENT.

What cannot be varied

• The mesh and the geometry (*NODE, *ELEMENT), set membership (*NSET, *ELSET, *SURFACE), element types, the analysis type, the material model.
• Integer identifiers and degree-of-freedom numbers.
• Parameters on a keyword line (*STEP, INC=…, *EXPANSION, ZERO=…).
• The mode count of *FREQUENCY and *BUCKLE, and anything on cards not in the table above: *RADIATE, *SPRING, *MASS, *SOLID SECTION, *MODAL DYNAMIC, *STEADY STATE DYNAMICS, *VISCO and the others.
• Numbers written in the deck with a Fortran exponent (1.0D5). A value you type may use one.
• Values inside *INCLUDE files. The Deck stage says so. The deck itself runs: it travels to the pool with its includes spliced in. The sweep's identity covers the included files, so an edited include is a new study.
• One parameter cannot drive several places in the deck. Each picked value is its own parameter. To move several values together, give them paired CSV rows.

To vary geometry or a mesh, prepare the decks and open them as a deck set: every deck is a variant.

What stops a deck from running

Each of these is a blocker on the Deck stage, named with its file and line, and Run stays closed until the deck is fixed. WitSweep never writes into your deck.

Memory. Run refuses a sweep when no pool machine can hold a variant. WitSweep estimates a variant's memory peak only when every step is *STATIC or *HEAT TRANSFER and every element is a solid of the C3D4, C3D10, C3D8 or C3D20 family. For any other deck no estimate is made. A deck set takes the largest estimate of its decks, and has none when one of its decks has none. A machine fits when the estimate is at most 80% of its RAM. The Scenario stage says how many fit (fits N of M pool node(s)). When none fits, Run says ✗ est. peak ~… (…) exceeds every pool node (largest …), and for a single deck adds the largest mesh the pool could take (— largest feasible mesh on this pool: ~N nodes). Machines that have not reported their memory are not counted, and while none has, nothing is refused.

3. CalculiX decks: response columns by analysis type

How the columns are made. Every variant is solved by ccx on a pool machine, and the pool reads that variant's .frd and .dat right after the solve. A column appears only when the deck asks ccx for the output it is computed from. WitSweep adds no output requests to your deck. The pool adds some to its own copy only to recover the von Mises of shells and beams written with OUTPUT=2D (below).

Steps. Every column belongs to a step. A deck with one *STEP keeps the plain names below. A deck with more than one names the step in every column: max_von_mises[step 1], eigenfrequency_1[step 2], rf_sum_z@fix[step 1], max_temp@tip[step 3]. Each step's values come from that step's own last block of each field, so a static step followed by a frequency step reports the static stress under [step 1] and the mode-shape stress under [step 2]. The table, its sort and the exports carry the names as they are.

Units. WitSweep never interprets units. Values are shown exactly as the deck's unit system produces them, and eigenfrequencies are in cycles per time unit.

The analysis type is read from the procedure card of each *STEP. The Responses card on the Scenario stage lists what to expect.

Linear static (*STATIC)

Rows ccx printed in a node's local *TRANSFORM frame (the trailing L) are rotated back to the global frame through the deck's own *TRANSFORM, with a note. When they cannot be rotated, the set gets no rf_sum columns, and the note says to print with GLOBAL=YES or TOTALS=YES.

The Responses card lists reaction-force sum · <set> for every set the deck prints with RF, a TOTALS=ONLY print included. When a deck with a static or coupled step names a node set on a *BOUNDARY line and prints no reaction forces for it, the card says so: no reaction-force sum for … — needs *NODE PRINT, NSET=<set> with RF in the deck.

Frequency analysis (*FREQUENCY)

The reaction forces ccx prints per mode are mode shapes and are never summed. A *COMPLEX FREQUENCY table is read too. A table in a layout the pool does not know gives no column and a note.

Linear buckling (*BUCKLE)

Heat transfer (*HEAT TRANSFER)

Heat flux and reaction flux are not read. There is no column for the minimum over time. The Responses card of a transient step lists the final-state max / min and the peak over time.

Coupled thermo-mechanical (*COUPLED TEMPERATURE-DISPLACEMENT, and *UNCOUPLED TEMPERATURE-DISPLACEMENT)

The linear-static columns and the heat-transfer columns together, each family present when the deck writes its output: max_disp_magnitude, max_disp_x/y/z, max_von_mises, min_von_mises, rf_sum_*@<set>, max_temp, min_temp, and max_temp_any_step when the step wrote several temperature blocks.

Other procedures

*DYNAMIC, *MODAL DYNAMIC, *STEADY STATE DYNAMICS, *VISCO and the rest are not refused, and their decks run. The Responses card lists no response for them, only the facts every variant carries. The Results get whatever the pool finds in the step's files, typically the displacement and stress columns of its last block.

Shells and beams written with OUTPUT=2D

With OUTPUT=2D on its file cards, ccx writes a shell's stress as the mean through the thickness and a beam's as the mean over the section: the bending stress is gone (an S8R cantilever read 0.81 against 75). The Nastran converter writes OUTPUT=2D. The pool recovers the von Mises of such a deck from section forces. It adds the output the recovery reads to its own copy of the deck and says so in an ⓘ note on the variant:

• Beams (B31, B32, B32R with a RECT, PIPE or BOX section): *EL FILE, OUTPUT=2D, SECTION FORCES at the end of step 1. A beam node's von Mises is the largest over the section's corners, mid-sides and centre.
• Shells (S4, S6, S8, S8R): a *SECTION PRINT of every element edge in the *STATIC steps. The edge moments give the bending stress 6M/t², and a shell node's von Mises is the largest of the top face, the bottom face and the mid-surface.

Every von Mises column of such a deck then carries an ⓘ note naming the method. Measured by the pool on cantilevers, the analytic root stress in brackets: an S8R plate 75.0 (75), a B32 beam 60.1 (60), and a CQUAD4 strip converted from Nastran, on 20 × 2, 40 × 4, 80 × 8 and 160 × 16 elements, 5850, 5925, 5962.5 and 5981.25 (6000). The edge prints cost solver time: a 9,800-element S4 plate solved in 3.1 s instead of 1.5 s.

Where the recovery cannot run, the von Mises columns and every von Mises probe are left out with a ⚠ note that gives the reason (below). It does not run for S3 and S4R shells, B31R beams, CIRC sections, beam nodes that shell, membrane, plane or truss elements share, beams that meet at more than 5°, against each other's direction or with different sections, trusses beside beams, composite or NODAL THICKNESS shell sections, a material that is not linear elastic, a deck with *SECTION PRINT cards of its own, for shells a step that is not *STATIC, and a deck with more than 20,000 shell edges, among others. The controller's README lists every case: https://github.com/OmnibusCloud/Controllers/blob/main/CalculiX/OutWit.Controller.CalculiX/README.md.

On the Responses card such a deck (shell S… or beam B… elements, and OUTPUT=2D on the first step's file cards) reads max / min von Mises — on shell and beam models from section forces; a model the pool cannot recover reports the column as not reported, with the reason. The pool decides which models it recovers. The card does not guess.

Columns that are left out

A column that would carry a wrong number is not reported. The row carries a note on that column saying why:

• max_von_mises, min_von_mises and every von Mises probe of a shell or beam deck written with OUTPUT=2D whose stress the pool cannot recover (above): not reported: with OUTPUT=2D ccx maps shell and beam stresses onto the mid-surface or the beam axis, where the bending stress is gone (an S8R cantilever read 0.81 against 75 analytic), and the section-force recovery cannot run: …; remove OUTPUT=2D from the file cards to get the expanded-mesh stress.
• Every column of a field whose .frd block holds a value that is not a number (nan, inf, a solve that blew up). The note names the field and the node.
• rf_sum_*@<set> when local rows cannot be rotated (above).
• Eigenfrequencies of a table in an unknown layout (above).

Probes: your own columns

On the Scenario stage, + Probe adds a column built from three choices: an aggregate, a quantity and a node set.

• Aggregate: max, min, avg.
• Quantity: von Mises, displacement magnitude, temperature.
• Node set: any *NSET of the deck, or a *NODE, NSET= set.

The column is named {max|min|avg}_{von_mises|disp_magnitude|temp}@<set>, for example avg_temp@xmax. It is computed over the set's nodes in the step's last block of that quantity. A shell, beam, truss, membrane or plane-element deck written with the default OUTPUT=3D has its results on an expanded mesh under new node numbers. A deck node the .frd does not list then stands for the result nodes at its position, or the nearest ones. The column carries a note that counts them. A set with no result node at all gets no column and a note.

Probes are not available for deck sets. Element sets and single points are not offered. A probe added to a sweep that already ran is computed for its earlier variants too: the Scenario stage says … computed earlier — Run computes the new responses for all of them (or for N of them), and Run solves those variants again.

Notes from the pool

The pool notes how a value was obtained, why a column is missing, or how it changed the deck before the solve. A note marks its cell: ⓘ for information, ⚠ for a warning, ✗ for an error. The solve cell carries every note of its row. A note is read in full on hover, in the Results detail pane, on the Run stage tile and in the exports.

A variant whose results the node could not read is ✗ results unreadable, with the node's reason, never a success.

Always present

• variant (#N), one column per parameter, the responses, and solve: the solve time with ✓, ✗ exit N with the ccx exit code, or ✗ results unreadable (✗ not converted for a Nastran variant that did not convert). CalculiX results carry no warning count.
• In the CSV and XLSX exports the solve column is solve_seconds, and three columns are added: status (done, failed, extraction failed, or not converted for a Nastran variant that did not convert), exit_code, and notes (each note as KIND column: text, separated by |). The HTML report has a status column, and a notes column when any row carries a note.
• In a sweep extended by several builds, a row computed by another WitSweep build than the sweep's job on the stage carries the note computed by WitSweep <version> (with the Nastran converter's version for a Nastran sweep).

4. Nastran decks: the supported subset

WitSweep reads a Nastran bulk-data deck, lets you vary its values in Nastran terms, then converts every variant to a CalculiX deck on your workstation and solves it with CalculiX. The Results header says Nastran deck · solved by CalculiX.

The converter targets the decks Autodesk Inventor Nastran writes. It is strict by design: a deck that would convert into something different from what it says is refused, never converted halfway. Every refusal says why, most of them naming the card.

Solution sequences

Refused: 105 (buckling), 106 (nonlinear static), 159 (transient heat), nonlinear steady heat (the NONLINEAR STEADY STATE HEAT TRANSFER spelling, and a heat deck with temperature-dependent MATT4 properties), 200 (optimisation), the legacy 66 (NONLIN, nonlinear statics) and every other sequence, a deck with no SOL, and a case-control ANALYSIS that names another solution than SOL.

Elements

Refused by name: CPENTA (wedges), CBUSH, CELAS1, CMASS1–4, CONM1, CGAP, CSHEAR, CCABLE, RBE1, RROD, RSPLINE, RSSCON. Element cards not listed here (CPYRAM, axisymmetric elements and others) are refused as unknown cards: X is not a card this reader knows.

In heat transfer (153) only rods (CROD, CONROD) and 8-node CHEXA conduct. Any other structural element refuses the deck, tetrahedra, 20-node hexahedra and shells included.

Properties

Materials

Refused: MAT2 (anywhere in the deck), MATT1, MAT12, and MATT4 in heat. MATS1, CREEP and the tables TABLEM1, TABLEM2, TABLES1, TABLEST, TABLED1, TABLED2, TABLED4, TABDMP1, TABRND1 are ignored with a note. Other tables and material cards are refused as unknown.

Loads, constraints, case control

Refused: SPCD (enforced motion, and enforced temperatures in heat), PLOAD, EIGR, MPC, SUPORT1, SUPORT (in statics; ignored in modal analysis), DMI, DMIG, RESTART, superelements, surface contact, radiation, SUBCOM, SYMCOM, REPCASE, STATSUB (prestressed modes). TSTEP is ignored, with a note in SOL 101 and 103 and without one in SOL 153. A static subcase that selects no constraint, a static model whose constraints leave a rigid-body motion free, and a shell or beam model whose constraints change between subcases (or that enforces a nonzero SPC over several subcases) are refused.

Output requests in the case control are not read: the output is always displacements and stresses in statics, displacements (the mode shapes) in modal analysis, and temperatures in heat.

How a Nastran deck is checked

• At open, the whole deck is converted once and the Deck stage shows the outcome: ✓ converts to CalculiX · N accuracy classes · N notes, or ✗ does not convert — N named rejects, with every issue listed under conversion preflight — the converter's findings, verbatim. A deck that does not convert can be read and picked, but Run stays closed.
• A free-field (comma) line longer than one card line is a named error, so the deck does not convert: Line <n> of "<file>": a free-field SPC1 line carries 3 field(s) past the card line's 9 and its continuation marker, which Nastran reads no further: '…', '…', '…' would be dropped - put them on a continuation line (5 on a large-field line).
• Accuracy classes are converted constructs with a measured error band. Their line starts with the expected error, for example ≈78% · Linear tets (CTETRA-4 → C3D4) …. The straight-beam class (≈2% · Straight beams (CBAR/CBEAM → B31) …) ends on mesh the beams finer in the model to tighten it, or, for a project the Inventor add-in converts with subdivided beams, on these beams are split in two, as the Inventor add-in's Subdivide beams asked.
• Notes are ignored cards and fields.
• At Run, every new variant is written, read back and converted on your workstation, the same way as the base. A variant that does not convert is not sent: its Results row reads ✗ not converted (its tile ✗ did not convert), with the converter's reason, and the others run.
• A variant that enters an accuracy class the base deck is not in carries the note this variant enters an accuracy class the base deck is not in: …. A class is the converter's code, card and message, not how many members it has: a variant whose shells join a class the base deck is already in (a second PSHELL thinned into the gray band) enters nothing.
• A study is identified by its converted base deck and its picks, so an edited INCLUDE, or a converter release that converts the deck differently, is a new study.
• A .witsweep written by the Inventor add-in may ask for subdivided beams. The base and every variant then convert with each beam split in two, and the restore line ends · converted with subdivided beams, as Inventor checked it. WitSweep has no switch of its own for this.

What can be varied in a Nastran deck

These fields are listed when they are written in the deck:

Only values written in the deck are listed, as real numbers on comma- or fixed-format lines: an integer written in a real field (0, 200000) and values on tab-formatted lines are not. A value inside an INCLUDE file is listed but not offered: its line says included, not sweepable. A deck with MAT2 or SPCD does not convert at all, so their values never reach a run. The mode count (EIGRL ND) and TSTEP are not offered.

Every value is checked when the deck opens. For each value of the deck's own file, WitSweep converts the deck with that value moved by a tenth (from 0 to 1). A value whose move does nothing or cannot convert is listed, not offered: its menu says Not sweepable — and the reason, and its line says it too. The check converts the whole deck once per value, which takes minutes on a big deck, so it runs in the background, one value at a time and the first value of every card field first. Until it is done the status line reads N sweepable values, K of them still being checked, and N falls as values are marked. A value you pick before the check reaches it is checked on the spot. The check reads every moved deck back in memory and writes nothing, so a deck with INCLUDEs is not checked at open: each of its values is checked when you pick it, through a scratch copy written beside the deck so that the includes resolve and deleted right after, and its status line claims no check. The reasons:

The two converted decks are compared card by card: a card only one of them carries counts as a whole, and the value is listed with the CalculiX reason when every value of the change is one no step reads. A beam section (PBAR) cannot be swept: its values are listed with the converter's reason.

A value you type must be a finite number, in plain (2.1e5) or Nastran spelling (2.1+5, 2.+7, 1.5D7). Otherwise: 'x' is not a number — the value cannot be written into the deck, or 'x' is not a finite number — nothing can be written into the deck. A value is written at the field's own width. When the 8-character field (16 on a large-field line) holds fewer digits than you typed, the row carries a note: … written as <token> = <value> — the 8-character field holds fewer digits than <typed> (…% off). The parameter column shows the value you typed, and the note gives the value the deck holds.

Results of a Nastran sweep

• Columns: the CalculiX columns of section 3. A 101 sweep has the displacement columns and max_von_mises / min_von_mises. The converter writes OUTPUT=2D, so on a model with shells or beams the pool recovers the von Mises from section forces (section 3), and the Responses card says max / min von Mises — on shell and beam models from section forces; a model the pool cannot recover reports the column as not reported, with the reason. Of what the converter writes, composite (PCOMP) shells, beams on shell nodes, beams that meet at more than 5° or change section, rods beside beams and shell meshes of more than 20,000 edges are not recovered: their von Mises columns are left out with the reason. The converted deck prints no reaction forces, so there are no rf_sum columns. A 103 sweep has the eigenfrequencies and the last mode shape's columns (on shells without its von Mises: the recovery runs on *STATIC steps only). A 153 sweep has max_temp and min_temp. Probes use the node sets of the converted deck.
• Parameter columns are named in the deck's words: the card, its id and the field.
• Viewing a variant: the Open #N in… menu offers PrePoMax (Windows), ParaView, and Inventor Nastran (Windows, +Nastran).
• Inventor round trip: when the sweep was started from the Inventor add-in, WitSweep hands the chosen variant back to Inventor: its values, its responses and its result files. A deck opened directly has nothing to return to: this sweep was not handed off by Inventor — nothing to return to.
• No native Nastran result files (.f06, .op2) are written.

5. OpenFOAM cases

What the pool runs. OpenFOAM v2606 on Linux x64, macOS arm64 and Windows x64, each variant whole on one machine with at least 4 GB of RAM and 4 GB of free temporary storage. A case must be reconstructed (not decomposed only), name its application in controlDict, and have a mesh in constant/polyMesh or a step that makes one. Nothing checks the mesh before the run: a case with neither fails at its first step. The full rules (allowed utilities and function objects, refused constructs such as codeStream, coded boundary conditions, #include outside the case) are published at https://github.com/OmnibusCloud/Controllers/blob/main/OpenFOAM/SUPPORTED-INPUTS.md. The Case stage links to them (what the pool runs and refuses →).

Checked when the case opens. WitSweep applies the pool's rules to the case as it opens and names every finding with its file and line, and Run stays closed until they are gone. Among the findings (the empty-file rule is WitSweep's own, the others the pool's):

WitSweep walks the case folder by the pool's own rule, the one every client of the pool applies to the folder it opens: a link whose target lies inside the case is the file or folder it points to, under its own path (OpenFOAM's tutorials keep a region's fvSchemes as ../fvSchemes), and a link that points outside is refused, never entered. The pool never sees a link. Only the files' bytes travel, and the pool machine checks the size and SHA-256 of every file against what WitSweep read before the file lands in the case. A libs entry naming a library the pool's OpenFOAM does not have, and a solver or utility it does not have, are checked only on the pool machine: such a variant fails there.

What travels to the pool. The case's inputs. These stay home, and the Case stage lists them under Stays home with the reason: logs (log.*), later time folders, postProcessing/, processor* folders, dynamicCode/, scripts (Allrun*, Allclean*, *.sh at the root), reader stubs, backups and version-control files, documents (README*, .md, .pdf, images, .html). A 0.orig/ travels as 0/ when there is no 0/, and a 0.org/ when there is neither.

A file that changed is refused at Run. Every file that travels is hashed when the case, or the case set, opens, and a file changed or removed since then is refused when you press Run: case: path changed since the case was read - open the case again before you Run, so that the sweep runs the file as it is now. or case: path is gone since the case was read - open the case again before you Run. A file you picked values in is held against the text the picks were made in as well, so an edit never runs beside picks baked from the old text. A file that changes while it uploads is refused the same way.

What can be varied

A value OpenFOAM computes at run time (#eval, #calc, ${{ }}) is shown but not offered: OpenFOAM computes it at run time (#eval, #calc or ${{ }}); sweep the values it is computed from.

A reference speed can follow a swept speed. When the sweep varies U and a force object normalises by a magUInf the sweep leaves alone, the Scenario stage warns that the coefficients are right at that speed only. When magUInf equals the swept speed's base value and the speed is the only non-zero component of U, the warning offers Pair magUInf with pN, and magUInf then takes pN's value in every variant (✓ magUInf follows pN in every variant). Picking magUInf (or lRef, Aref, rhoInf) yourself works too: a response measured from the case's own object follows the value, and its card says magUInf follows p2 in every variant.

Responses

• The case's own forceCoeffs and forces objects become responses when it opens: blocks of functions, blocks of a file it #includes, and #includeFunc dictionaries of the case's own system/. Each must carry what OpenFOAM needs to start it: a centre (CofR, origin or a coordinateSystem); for coefficients magUInf, lRef, Aref and rhoInf, and liftDir and dragDir beside a CofR; for forces rhoInf when rho rhoInf. An object that lacks one is not offered. Report forces instead turns coefficients into forces on the same patches and keeps the density and the centre as the case wrote them: rho, rhoInf, and a CofR, an origin or the whole coordinateSystem.
• OpenFOAM stops the solve on a force function object without these values, so the pool refuses such a request before anything runs: Response '…': ForceCoeffs needs rhoInf - OpenFOAM does not start the function object without them.
• Every response is measured during the solve. The pool adds one line, #includeFunc <response>, to its copy of system/controlDict. Your files are not changed. The Recipe card shows that line before the solve, and the response's card says · measured during the solve. A case's own object that writes at every step is read from the case's own output.
• The add form offers the patches of polyMesh/boundary or blockMeshDict and the fields of the initial folder, leaving off the fields the turbulence model never reads: … are not offered: … does not read them, and a response on a field the solver does not read comes back empty. For a case meshed at run time it adds a selector ("<surface>.*") per refinementSurfaces entry of snappyHexMeshDict and every patchInfo group, and says that the patches listed are the background mesh's.
• Columns are named <response>.<column>, the column as the function object's header names it. A vector or tensor value is a column per component: a patch statistic of U is patchValue1.areaAverage(U)_x, _y, _z, a symmetric tensor's components are _xx, _xy, _xz, _yy, _yz, _zz. A probe column is <response>.<field>@probe<N>(x y z), N counting from 0, with _x, _y, _z for a vector. The pool's own field min/max measures magnitudes (fieldMinMax1.max(U)). A probe outside the mesh, or a function object that stopped writing before the run ended, is an empty cell whose note says why (below).
• Always shown for every variant, after its responses: cells, checkMesh, iterations (N · endTime for a steady variant that ran to endTime without residualControl stopping it, N time steps for a transient case), a residual <field> column per solved field with its final residual (residual Ux, residual p, …), warnings (the run's warning count), mesh (the time of the steps before the solve), and wall, the run's wall time, or the failed step with its exit code (✗ <step> · exit N). The CSV, XLSX and HTML exports carry them too, the times as mesh_seconds and wall_seconds in the CSV and XLSX. The Scenario stage's line names the same: always: cells · checkMesh · iterations ("endTime" when not converged) · final residuals · warnings · mesh time · wall time · exit code of a failed step.
• A case set gets the responses that every case of the set shares.
• An edited response (another Aref, probe point or patch) is a new study, so its column never mixes two definitions.

The pool's advice before the run. When a sweep would run without doing what was meant, the Scenario stage says so in the pool's own sentences, and follows the ranks and the recipe as they are edited:

• The task asks for N ranks, and no step of the recipe runs in parallel: every step runs serially on one rank, and the other N-1 do nothing. Mark the solve (and the steps that may) parallel, or ask for one thread.
• 0/T: internalField carries {{oc1}}, which the study sweeps, and the recipe's setFields step overwrites it everywhere (system/setFieldsDict defaultFieldValues names T): the swept value has no effect. (or … inside the regions of system/setFieldsDict: the swept value holds outside them only.)

Notes from the pool

The pool's notes reach the table as a CalculiX deck's do (section 3): a note marks its cell, ⓘ for information, ⚠ for a warning, ✗ for an error, and is read in full on hover, in the Results detail pane, on the Run stage tile and in the exports (notes):

A variant whose responses the node could not read is ✗ results unreadable, never a success; its detail line reads #N · every step exited 0, but the node could not read its responses.

Ranks and returned files

• Ranks: 1, 2, 4 or 8 per variant. The default is 4 when the recipe has a parallel step, 1 otherwise. A machine without MPI runs the parallel steps serially. When a variant does run in parallel, the pool writes its own decomposition, and a decomposeParDict the case carries is not used.
• What comes back of each variant: Responses only (the default), Final time + mesh or All written times, plus logs (on by default) and postProcessing (off by default). A pool machine keeps nothing: what is not returned is gone when the variant ends.

6. Running a sweep and looking at results

While a sweep runs

• The Run stage follows the server's plan. The tiles and chunk i of N show the chunk schedule the Sweep controller planned for this run, which opens as wide as the machines that can take the job. A job waiting for machines says so: N / M variants done · waiting for resources, the window title ends · waiting, and its Home card reads Waiting. Tiles number the variants of an extended sweep by their place in the whole sweep.
• A lost connection is retried. A failed poll is tried again after 2 to 30 seconds, and every second failure rebuilds the connection. After ten minutes without an answer the stage stops watching and says so: ✗ the server did not answer for … (N tries) — this window stopped watching; the job keeps running on the server, reopen the sweep from Home to watch it again.
• What was harvested stays. The rows a sweep has harvested never shrink while it runs. A job the engine failed by name keeps its harvested rows and shows the engine's message.
• Leaving a live sweep asks first. A Run, a scheduled Run or a Re-run while a sweep is live asks Are you sure you want to leave the running sweep of …? It keeps running on the server; Home reopens it.
• Accounts. Signing out, or switching accounts, detaches the live sweep: ✗ … — this window stopped watching the sweep; it keeps running on the server, sign in and reopen it from Home to watch it again. Home lists the sweeps of the account that is signed in.
• An offline start keeps the saved sign-in and tries again in the background, and the sweep in flight reattaches once the identity server answers.
• Downloads go straight to file. A download that fails says why: the server no longer holds this variant's artifacts — they were released after the run, the server refused the download — sign in again, or the download failed — …; the server may be unreachable, try again. A variant's files land in <deck name>-<sweep>/vNN (eight characters of the sweep's identity), the same name on every system. The folder is emptied before a case is unpacked into it. A returned case .zip is unpacked within the limits of section 1.

The Results stage

The Results stage shows one row per variant, sortable (numbers as numbers, text as text), and a scatter of a response against a parameter. A case sweep can also plot against the mesh's cell count, and a set, or a sweep of choices, against the variant number. A full-factorial sweep is drawn as small multiples, one panel per value of the first parameter that is not on the X axis. Export… offers Export CSV, Export XLSX, HTML report, the download of the deck and result files (or of the case), and the cloud render.

Open #N in…

A target that cannot open the variant stays in the menu, greyed, with its cause, for example not detected — locate it in Settings → General, not found at its path — locate it in Settings → General, the variant did not solve or the variant has no .frd on the server. A row whose application is not detected opens Settings to locate it.

OpenFOAM variants in ParaView. WitSweep downloads the variant's returned case, unpacks it and opens its case.foam. With the OmnibusCloud ParaView plugin installed, it goes through the plugin. Without it, ParaView opens the case.foam and you press Apply (opened case.foam · press Apply in ParaView to show it). To see fields, choose *Final time

• mesh* or All written times before you run. With the default Responses only the case comes back without its mesh and fields, and the ParaView row says so instead of opening it: the case came back without its mesh and fields — choose Final time + mesh before you run, or the variant returned no case zip — its artifacts were responses only. In an extended sweep each variant follows the artifacts of the job that ran it.

Open all N in ParaView

The last row of the Open menu, Open all N in ParaView, opens every solved variant side by side. N counts the variants that have something to open: an .frd (CalculiX and Nastran) or a case returned with its mesh and fields (OpenFOAM). A CalculiX variant whose .frd could not be downloaded is fetched by the plugin from the cloud. An OpenFOAM case that could not be downloaded is left out, and the result line says how many were.

It needs ParaView located in Settings and the OmnibusCloud ParaView plugin installed for that ParaView. On Linux and macOS the plugin must be 1.2.7 or newer. Without it the row is greyed with its cause: the OmnibusCloud ParaView plugin is not installed for this ParaView — it is what reads the hand-offs, or the OmnibusCloud ParaView plugin … does not read hand-offs on Linux and macOS — update it to 1.2.7 or newer. WitSweep writes one hand-off per variant, and the plugin opens them. A ParaView that is not running is started. A running ParaView that does not take the files within 5 seconds is reported, not claimed: ✗ ParaView is running but did not pick up the hand-off within 5 s — is the OmnibusCloud plugin loaded in it? the N file(s) wait in ….

Render on OmnibusCloud

Export… → Render #N on OmnibusCloud (with a variant selected) renders its .frd on the pool: a still image (the last time step), an orbit, rise, spiral, approach or rock video, or a time-series video of every time step. It is offered for solved CalculiX and Nastran variants. An OpenFOAM variant is not rendered from WitSweep: open it in ParaView and render it from the plugin.

Extending and re-running

• Extend sweep… reopens the sweep's deck or case with its picks, so you can add values, probes or responses. Rows already computed are not computed again. When nothing is new, Run says ✗ nothing new to compute — all N variant(s) of this sweep are already computed. When the deck changed since the sweep was submitted, the restore line says · ‼ the deck changed since this sweep was submitted (· ‼ the case changed … for a case), and Run computes a new study.
• A deck set or a case set is not extended in place: ✗ a deck set is not extended in place — open the old and new decks together as a new set; a changed set is a new study, every deck computes again (and the same for a case set).
• Re-run N failed submits the failed variants alone. On a deck set or a case set it reopens the set first. When the deck changed since the sweep was submitted, it refuses: ✗ the deck changed since this sweep was submitted — re-run needs the original deck (the decks, or the cases, for a set).
• A sweep without a local copy (after Clear in Settings → Storage & logs, on another machine, or when the local store could not be opened) opens from the server: its Home card says not on this machine — opens from the server, and its table and files come back, its deck and picks do not. Such a sweep cannot be extended: ✗ this sweep was rebuilt from the server: its table and files are here, its deck and picks are not — open the deck and pick again to extend it. The local store keeps the newest 200 response tables.

7. Licenses, limits and updates

• Running needs a sign-in (browser or API key): sign in to Run.
• A sweep over the cap is not cut down: Run is blocked and says demo cap 8 — Run blocked (licence cap N — Run blocked on a license). The cap counts the whole sweep a Run would leave, the rows computed earlier included: demo cap 8 — Run blocked (the sweep would hold N variants).
• An expired license or demo blocks only new computation (Run, Extend sweep…, Re-run N failed, Render on OmnibusCloud): licence restricted — starting new computation is paused. Finished sweeps stay open, with their tables, charts, exports and files, and Nastran decks and OpenFOAM cases still open.
• Without a module its inputs are not offered: no file patterns, no Open an OpenFOAM case… link. Opening such a file anyway names the missing module.

Updates. Settings · General opens on an Updates card: the version installed and the one the OmnibusCloud portal has. WitSweep checks 20 seconds after it starts and then every 24 hours, and Home names a newer build when there is one (· X is available).

A package is installed only when its size, its checksum and its signature match what the portal lists. Otherwise nothing is installed and the card says why, for example the download failed its signature check — nothing was installed. The updater checks the signature once more, on its own copy of the package, right before it installs. A package that fails is refused (the package failed its signature check — nothing was installed) and the old build starts again. The feed must be https: the update feed names an http address — only https is trusted; nothing was downloaded. A release published without signatures is offered as a download only: This build is not signed for in-app updates: it comes as a download.

8. Limitations

1. Values inside included files cannot be varied, in CalculiX (*INCLUDE) and in Nastran (INCLUDE) decks alike. The deck itself runs with its includes.
2. One parameter drives one value. To move several values together, give them paired CSV rows.
3. Probes are built on node sets only (not element sets or points) and are not available for deck sets.
4. CalculiX results carry no warning count. What the pool says about a variant is in its notes.
5. Heat flux and reaction flux are not read from CalculiX results.
6. Nastran beam sections cannot be swept: a PBAR value is listed with the converter's reason, and PBEAM and PBEAML values are not listed.
7. No Nastran sweep gets reaction-force sums (section 4, Results).
8. Some shell and beam models get no von Mises columns. The pool recovers them from section forces, but not for every model: S3 and S4R shells, composite shells, beams on shell nodes or meeting at an angle, more than 20,000 shell edges and others (section 3).
9. A Nastran deck with INCLUDEs has its values checked one pick at a time, not when it opens, and the check at open takes minutes on a big deck (section 4).
10. An OpenFOAM library, solver or utility the pool does not have is found on the pool machine, not when the case opens (section 5).