Build an instant-answer model of this case: Studio solves n variants (default 60, one at a time, in the background, surviving this client closing), holds some out to check the fit, then surrogate_predict answers in milliseconds with an error bar. parameters: 1 to 5 of {"path": "boundaries.x1.force", "min": 100, "max": 1000, "unit": "N"}; any number update_case can change (omit unit for a plain number such as materials.solid.nu). An imported CAD shape has no dimensions to vary: template dimensions (geometry.params.*) can vary, an imported STEP cannot. outputs: names in the results' metrics, e.g. max_vm_pa, max_disp_m, t_max_k, dp_pa; left out = the main ones for this physics. Below 60 solves the error bar is less reliable. mesh_checks: mesh convergence studies at that many design points (each takes about three solves). Poll surrogate_status.

Mesh convergence study: solve on coarse, normal and fine meshes, estimate the discretisation error with Roache's GCI and the Richardson-extrapolated value. For shapes without an analytic reference this is the third gate, mesh convergence (passes when GCI <= 5%). Takes about 3x a single run; returns a job_id when it does not finish in ~20 s.

Copy a case (geometry, face roles, materials, settings - not its runs) under a new case_id and apply optional changes ({dotted.path: value}, as in update_case). Use it to try a design variant without losing the original.

Side-by-side parameters, gates and key numbers of several cases (e.g. a parameter study).

Stop a build (finished points are kept), resume a stopped or interrupted one, or delete it (confirm = study_id).

Create a case from a template id (see list_templates). Optional changes = {dotted.path: value} applied at once, e.g. {"geometry.params.length": "300 mm", "boundaries.x1.force": "2 kN"}.

Delete a case and all its runs. Ask the user first. confirm must equal the case_id.

Summarize a case: revision, parameters, boundary roles per face, readiness, latest run. detail="full" adds the whole schema, the list of editable paths and allowed roles.

Find faces of different parts that face each other within search_mm (separately modelled parts of an assembly, a gap that may close). apply=true adds them as contact_pairs of type bonded; change a pair with update_case(changes={"contact_pairs..type": "frictionless" | "frictional" | "no-separation", "...mu": 0.2}). Static analysis only (small sliding).

List the solver engines available on this computer and how to install missing ones.

Write the case, its mesh and (by default) its latest finished result to a .nscase file that another Studio opens with import_case. Paths of this computer are removed from the file.

Export the latest results to the case's exports folder: VTU for ParaView (tet10 and all nodal fields), CSV (nodal fields or modal frequencies), or a self-contained printable HTML report with images and verification gates. Returns the file path.

Generate the mesh now (run_simulation also meshes automatically when needed). Returns node/element counts and quality.

Result of the latest (or given) Genesis run: kept volume, measured thinnest member, compliance or temperature rise, convergence, warnings, the convergence history and the STL download path.

Call first when the person says 'these faces', 'the faces I selected' or 選んだ面. Read the GUI selection, labels, descriptors in mm, roles and age; an empty or expired selection is a normal answer.

Key numbers of the latest (or given) run, the ran/converged gates, the third gate (gates.verified_by: mesh convergence or reference match) and the verification line. stale=true means the case changed after this run.

Open a .nscase file on this computer as a new case; a result inside it opens as the current result.

Create a case from a CAD file on this computer (STEP .step/.stp, IGES .iges/.igs, BREP .brep, or a mesh STL .stl such as a Blender export). STEP/IGES/BREP carry their own units; for STL say the units the file was written in (Blender exports metres unless the scene unit scale was changed; most CAD STL exports are mm). Returns the faces with number, surface type, area and centroid so you can pick which faces to fix, load, heat or cool (by position: e.g. the face with the lowest centroid z is the bottom). Then set roles with update_case using paths like boundaries.f12.role. physics: structural (free, fixed, symmetry = flat cut face normal to x/y/z: only the normal displacement is held, so a half/quarter/eighth model of a symmetric part needs far fewer elements; constraint = components "x"/"xy"/... held at zero on any face, e.g. a guide or slider; load = force + direction, pressure) | thermal (insulated, temperature, heat-flux, convection = h + tinf) | flow = internal flow, the solid is the fluid volume (wall, inlet = speed, outlet; one inlet and one outlet at least) | external = flow around the part (faces are wall; set flow.speed and flow.direction) | electrostatic = open, voltage, surface-charge (charge in C/m2); current = insulated, voltage, current (total A). At least one voltage face is required. Current optionally couples to Joule heating (physics.joule_heating, default true); set boundaries..thermal.role and its temperature/flux/h/tinf as in thermal. Set eps_r or sigma per material/body. conjugate = water through solids, two or more bodies (bodies..role fluid|solid, bodies..material; fluid faces water-wall, water-inlet = speed + temperature, water-outlet; solid faces as thermal).

NovaSolver Flash: peak stress or deflection, heat flow or busbar resistance of a standard shape in milliseconds, from a Gaussian process fitted to points Studio solved and checked, so dimensions never solved get an answer too, with an error bar (mesh + interpolation). No case, mesh or solve. Refuses outside the solved ranges. ratios by shape (nu may be left out: 0.3): l_bracket: h_over_L, t_over_L, w_over_L, r_over_t, nu; plate_hole: d_over_W, t_over_W, nu; stepped_shaft: D_over_d, r_over_h, nu; grooved_shaft: D_over_d, r_over_h, nu; flat_shoulder: D_over_d, r_over_h, t_over_d, nu; thick_cylinder: b_over_a, nu; sphere_cavity: a_over_R, nu; square_hole_thermal: d_over_W, H_over_W; strip_hole_current: d_over_W, e_over_W. size (optional; without it only the dimensionless answers come back): l_bracket: L_mm, F_N, E_GPa; plate_hole: W_mm, F_N; stepped_shaft, grooved_shaft, flat_shoulder: d_mm, F_N; thick_cylinder: p_MPa, a_mm, E_GPa; sphere_cavity: D_mm, F_N; square_hole_thermal: length_m, k_W_mK, dT_K; strip_hole_current: W_mm, t_mm, sigma_MS_m, I_A. Linear elastic, these supports and loads only: l_bracket has the back of the upright fixed and F as the total force spread evenly over the top of the flange beyond the fillet (not a force at the tip); thick_cylinder is plane strain (ends held axially; for open or capped ends run a simulation); the shafts and bars are in plain tension. square_hole_thermal: steady conduction, the hole wall and the whole outside each at one temperature (dT apart), ends insulated, H the taller side. strip_hole_current: steady DC, the current uniform again far from the hole, e the hole's offset from the centre line; extra_resistance is what the hole adds to the plain bar. The error bar covers the numerics, not the real part.

Progress of a job: state, progress 0..1, ETA, message, and gates when done (first_error when failed). Waits up to wait_s seconds (default 20, max 60) for the job to end before answering, so call it again right away while it is still running; no need to sleep between calls.

List existing cases (newest first).

List solved examples: verification cases already computed and checked against their closed-form reference, published with this Studio version on GitHub. open_example gives the case with its result in seconds, so you can show or inspect a result (get_results, verify_case, render_view, probe_results) before running anything.

List case templates (each has a reference solution for verification).

Open a solved example (name from list_examples) as a new case with its result (checked against the reference) already loaded. The download is checked against the published SHA-256. Editing the case marks the result stale; run it again.

3D-print strength check of a solved linear static case in PLA, PETG or ABS. FDM parts are weakest between layers, so for each print direction (layers normal to x, y or z) it compares the tension and shear on the layer plane with the layer-bond strength and the von Mises stress with the filament strength, and names the best orientation. Strengths default to conservative typical values (100 % infill); pass the filament datasheet values if known. Stresses within about two elements of fully fixed faces are left out and their peak is reported separately (support artefacts). Screening only: say so to the person.

Read result values where you ask, in mm: points = [[x, y, z], ...]; line = {"from": [x,y,z], "to": [x,y,z], "n": 50} (values along it, with min/max); faces = face keys (e.g. ["f3", "f7"]): area-weighted mean, min, max per quantity and, for flow, the volume flow out through the face (negative = into the fluid; exact solver fluxes on inlets and outlets, nodal estimate elsewhere). Quantities: structural disp ux uy uz (mm), vm, sxx syy szz sxy syz szx, s1 s3 (max/min principal) (MPa); thermal temp (°C); flow speed ux uy uz (m/s), p (Pa); conjugate temp, speed. Electric: v (V), ex/ey/ez/emag (V/m), jmag (A/m2), q (W/m3), temp (°C, when present). Electrode face statistics include charge_c or current_a from the solver (positive into the body). step selects a converged nonlinear frame (one-based, omitted = last); mode selects a modal shape. Values inside elements are interpolated (quadratic on tet10). A point outside the part gets inside=false and the nearest node's value. Up to 500 points in one call. Not available for 2D template grids or snappyHexMesh runs.

PNG with colour bar. quantity: disp|vm|uz|disp_x|disp_y|s1|s3|tresca|sxx|syy|szz|sxy|syz|szx (structural), speed|ux|psi (CFD), v|emag (electrostatic), temp|v|jmag|q (current/Joule heating). Empty = default. Numbers: get_results. quantity="faces" confirms setup with the person: numbered faces by role; highlight=face keys in accent. quantity="mode", mode=n: modal shape (one-based, max displacement 1). Nonlinear step=n: converged step (one-based, omitted=last). Contact: p_contact, contact_status, contact_gap, contact_slip; plasticity: peeq. Large deformation uses true scale.

Genesis topology optimisation of the case's part: the meshed part is the design space, its face conditions (fixed / symmetry / constraint / load / pressure / moment / bearing / remote-force, or temperature / heat-flux for heat cases) are the supports and loads. Minimises compliance (stiffest part, or lowest heat-weighted temperature) for the volume_fraction of material kept. Manufacturing options: symmetry planes (through the part's centre), extrusion direction (milling/casting: the shape is constant along that axis), overhang = build direction for 3D printing (no overhang beyond 45 degrees). min_member_mm sets the filter and the thinnest member aimed for; the result reports the measured one. Faces with conditions stay solid (keep_bc_faces) and keep_faces adds more. Symmetry planes that the supports and loads share are solved on the half model (same design, about half the time). refine=True adds a finishing pass: the part is re-optimised near its surface on a grid about twice as fine (same minimum member in mm), kept only when it is stiffer; about 2-3x the time, not with cells above ~400k. Returns a job_id when it does not finish in ~20 s: call job_status. The result is a closed STL (with extrusion also a flat-faced STEP); analyse it again (stress, CalculiX) before use.

Start the solver as a background job. Waits up to ~20 s: if finished, returns results and gates; otherwise returns job_id - then call job_status, which waits for the job. preview = built-in solver, final = CalculiX/OpenFOAM when offered by the template. Electrostatics and DC/Joule always use the built-in FEM.

Parameter study: one clone of the case per value of path (e.g. path="boundaries.f5.force", values=["100 N", "200 N", "400 N"]; or materials.solid.preset, mesh.size, boundaries.f2.speed), each started as a background job (they run one after another). study="convergence" runs a mesh study for each, so every variant gets a mesh convergence check. Up to 8 values. Poll each job_id with job_status, then compare_runs on the case_ids.

Stop a running job.

Answer from a finished surrogate in milliseconds, no solve: values = {parameter path: number} in the units given at build time. Refuses outside the built ranges. The error bar covers interpolation only; the answer also carries the mesh error of the solves (see mesh in the result), and nothing here checks the material, the supports or the real part.

Progress of a surrogate build, and once done the check on held-out points and any warnings. Without study_id: all of them.

Undo the latest change by anyone (person or AI), and tell what was undone. redo=True reapplies it.

Change case fields. changes = {dotted.path: value}. Paths: geometry.params. (templates), boundaries..role (faces x0..z1 for templates, f for imported shapes), boundaries..force + .direction (-z,+z,-y,+y,-x,+x,normal) | .pressure | .speed | .temperature | .flux | .h + .tinf, materials.solid.preset|E|nu|sy|k|eps_r|sigma, materials.fluid.preset|nu, mesh.size (coarse|normal|fine), run.mode (preview|final), boundaries..voltage|charge|current; physics.joule_heating (boolean); boundaries..thermal.role and thermal fields. face_groups. = [face keys] (null deletes); boundaries.@. applies to the whole named group. mesh.refine. = element size on that face of an imported part, e.g. "0.3 mm" for a small fillet or notch where the peak stress sits (scaled x1.6 / x1 / x0.625 for coarse / normal / fine; "none" removes it). Assemblies (STEP with several bodies, structural/thermal/electric): body_materials. = a preset (steel, aluminium, concrete, insulation, glass, wood, fr4, silicon, ptfe, alumina, ...), body_props..k|E|nu|eps_r|sigma overrides one value. Set the role first (same call is fine); value fields must match the role. Structural: physics.analysis=modal|static|nonlinear|buckling, physics.modes=1..30 (buckling: load factors and critical loads of the applied loads); materials.solid.alpha (1/K), rho; physics.nonlinear={large_deformation:true,steps:"auto" or n,max_iterations:25,path:[load fractions],face:key}. materials.solid.model and body_props..model=linear|elastoplastic|neo-hookean; sy and H (post-yield tangent, Pa). Elastoplastic supports small strain only; neo-hookean requires large deformation. Pressure follows deformation. contacts..type=bonded|frictionless|frictional|no-separation, .mu, .offset (positive interference, negative gap). Touching shared faces only. Missing contacts are bonded. displacement role: ux/uy/uz with length units, null = free. physics.T_ref (degC), physics.thermal_load.mode=none|uniform|solve and .temperature; solve uses thermal face fields. physics.gravity.enabled, .g (m/s2), .direction; physics.rotation.enabled, .rpm, .axis=x|y|z, .axis_point=[mm]. Roles moment (torque in N-m + direction), bearing (force + direction perpendicular to cylinder axis), beam-clamp (axis-aligned planar beam section: rigid motion held, lateral contraction free), remote-force (force + direction + point={value:[x,y,z],unit:mm}); body_props..alpha|rho. Values with units: "5 mm", "2 kN", "70 GPa" or {"value": 5, "unit": "mm"}. Returns the diff and new readiness.

Readiness check. red = cannot solve (fix first), orange = solvable with caveats, green = ready. Each item says which step to fix and suggests the update_case call. It also states the setup in words (which face carries what load and which way, what holds the part, the material): no check can tell a load pointing the wrong way or on the wrong face, so compare it with what the person asked for before solving.

Compare the latest result with the case's reference (analytic or literature), or report the mesh convergence study. Without either, the third gate is unchecked: offer check_convergence.