Table of Contents

Workflow: What the Run Reports

An optimization writes a fixed ladder of rows to the Shell tab of the Session Info panel as it runs, and, when a thermal stress target is on, checks that target again on the feeds it is about to write. This page is those rows. The rest of the procedure — the options, the files and the logs — is NC Optimization.

What the Run Reports

An optimization reports itself to the Shell tab of the Session Info panel, as a fixed sequence of rows:

Row Stage
Start NC optimization. the pass opens, and the scan of the program begins
NC line to step segment mapped. Un-optable lines are filtered. the scan closed: each line matched to the steps it made, the lines that cannot be optimized left out of the solve
Computing Optimized Feed by indivisual step.. the per-step feed solve
Optimization Feedrate built. the feed solve closed
Constrain feedrate By expaneded segment.. the extended-distance constraint
Constrain Feedrate By Acceleration.. the acceleration constraint
Build Compensation.. the compensation build
Checking the thermal stress ratio on the feeds to be written.. only with a thermal stress target on: the thermal stress check on the feeds to be written, with rows of its own — see The Thermal Stress Check on the Written Feeds
Regenerate NC commands.. the NC text is rewritten
File optimized: <path> one row per written file
Total N files optimized. the pass is over

When the session's steps were played across a reset of the NC pipeline — a script's PowerReset, a switch of the controller brand or preset, or a session ended (EndSession()) and begun again with its steps kept — the optimizer cannot match the programs played since the reset to their steps, so it writes nothing, and one error row stands in place of the whole ladder: The NC pipeline was reset while the strip held N positions … (OptimizeNc--StripSpansPipelineReset). Optimize before the reset, or clear the steps first — ResetRuntime in the script, or the transport's Reset — and play the programs to optimize again. The script or mission that asked for the optimization goes on.

With Feedback Mode on under a licence that includes it (its chip-stock truncation, EnableChipStockTruncation; Physics and Feedback Mode), the optimizer computes each step's forces from the chip table the play stored with it, and solves a step whose chip the stock shortened by trial. A step cache without that table for a step the solve needs — played with Feedback Mode off, under a cloud plan without it or before this version stored it, or rewritten by a step-physics recompute since — is refused before anything is written: one error row (NcOpt-Feed--ChipTruncationTableMissing, or NcOpt-Feed--ChipTruncationDivisionMismatch for a table sampled at another rotation division count) stands where Optimization Feedrate built. would, and the run closes on Total 0 files optimized.. Play the program again with Feedback Mode on, or turn it off. Under a cloud plan without Feedback Mode the optimizer computes as with the chip-stock truncation off and needs no chip table.

Other rows can join the ladder. While the program is scanned, a tool change to a tool the optimizer cannot use is a warning: Tool Not Found: <id> at each change to a tool the tool house holds no milling cutter for, and, once per tool, Tool <id>: its cutter carries no optimization limit; … or Tool <id>: optimization is off in its cutter's optimization limit; …. One error ends the pass at the scan, with no mapping row and straight to a green Total 0 files optimized.: NcOpt--Exception, when the scan itself threw. A subprogram or a macro called after a jump — a GOTO, or a loop going back to its head or out past its end — is optimized like any other line, and so is a program an NC-embedded script plays with PlayNc: that program is written to an output file of its own, and the feed words of the program that holds the script follow on across the script's line as if the nested program were not there, since the machine reads the script as a comment. During the feed solve, a step whose solve threw is an error row, NC optimization step <i> (<file and line>) failed; …, at most twenty of them in a run; a failed read of the step cache is an error row too (StepLuggage-Read--Fault or StepBrief-Read--Fault, below); and the spindle capability adds a warning (NcOpt-SpindleSpeed--Warning) once per run for each of its two wordings, Continuous condition not set in Spindle Capability. when it has no continuous torque or power contour, and The spindle limits and heat parameters cannot be read … when a contour cannot be read at some steps' speed. Two warnings come just before the feed solve's closing row: N step(s) failed while computing the optimized feed … when a step's solve threw (see When a Step Cannot Be Solved), and The source-feedrate floor holds N step(s) above a load target … (NcOpt-Feed--SourceFloorOverTarget) when the source-feedrate floor kept steps above a force or safety target, with the count per target. With a deflection compensation on, Build Compensation.. is followed by Deflection compensation built on N of M steps; … — with a thermal stress target on, that row comes once, after the thermal stress check, and counts the build the files are written with, since the check can build the compensation again after it slows lines. While Regenerate NC commands.. prepares the edits — before the first File optimized: row — a block whose text the optimizer cannot read when it decides whether to restate an F on it, or to put the file's first F on it, adds an error row (NcOpt-Parse--Error) each time it is asked: a block left out of the solve then keeps its text, and an optimized block is still edited as the solve decided — its F written or its own F dropped, a split block still cut into fragments — but the file's first F is not put on it and goes to the next block that can take it.

Two more warnings come while the files are written, on the NC Manipulation list rather than on Shell, each on the return it is about. A called program — a subprogram or a macro body — that its last execution left by an M99 (or M99 P) before the end of its file has the lines after that M99 copied into its output file as the source has them: its closing % and comment, and the blocks behind an early return. They are not optimized and their F words stay as written; where they hold code, NcOpt-File--LinesAfterReturnKept says how many lines, since a cutting line among them that carries no F word runs at the feed in force where the machine jumps to it, which can be an optimized one. Where the source file no longer holds, at their lines, the blocks its last pass played — edited since the play — or cannot be read, the lines are left out, with NcOpt-File--LinesAfterReturnLost. A program run more than once is written as each execution played it, one after another, and the lines after the return once, after the last; a line an earlier execution played can appear again among them. With a segmenter of several blocks a line, the blocks after the M99 on its own line are not among them.

A StepLuggage-Read--Fault or StepBrief-Read--Fault row means a stretch of the step cache could not be read: the steps' recorded engagement for the first, their recorded physics for the second. Either way the touched steps of that stretch are left at their simulated feed (still held within the feed limits) rather than being solved without that record, so the output can be used; the stretch is left unoptimized but for its non-cutting regions, whose feed is raised as usual. To have it optimized, optimize again, and if the row comes back, Reset and play again to rebuild the step cache before optimizing. With a deflection compensation on, the compensation build reads the step cache again — a step whose feed is still its simulated one when the build runs is compensated from its recorded physics, one whose feed the run changed (by the solve, or after it by the feed limits or the extended-distance and acceleration constraints) from its recorded engagement — so either row can also follow Build Compensation..: the steps of that stretch that needed the record it names then get no compensation, and their feeds are not changed by it. A step a StepLuggage-Read--Fault in the feed solve left at its simulated feed is therefore still compensated, unless a later constraint changed its feed and the compensation build cannot read its recorded engagement either; one a StepBrief-Read--Fault left there is compensated from its recorded physics only if the compensation build can read that record, or from its recorded engagement when a later constraint changed its feed.

Three of those stages tick while they work, and they are the only instrument for telling a slow optimization from a stopped one. The scan adds Scanning NC for optimization.. FileNo:<n>, LineNo:<m> every thousand blocks scanned; the feed solve adds Computing Optimized Feed by indivisual step.. FileNo:<n>, LineNo:<m> every thousand steps solved — StepIndex:<i> instead, for a step that carries no source line — and the writer adds Now optimizing to: FileNo.<n>, LineNo.<m> every thousand lines written. Each names the source file and line the run has reached, so a ladder whose last row keeps advancing is a run still moving through the program, and one that has gone quiet without reaching Total N files optimized. is not. A stage with fewer than a thousand blocks, steps or lines to get through adds no counting row between its first row and its last — for the scan, which has no opening row of its own, between Start NC optimization. and the mapping row — so a short program crosses the whole ladder in near-silence.

Stop reaches inside an optimization. The transport's Stop is tested before each block while the program is scanned, between steps during the per-step feed solve, and before each output file and each destination piece while files are written, so a stopped optimization halts at the next block, step or piece rather than running to the end. The stages between are not interrupted: a Stop that lands in the extended-distance constraint or the compensation build takes effect when that stage ends, and one that lands in the acceleration constraint lets the compensation build after it run too. One that lands after the compensation build — in the last constraint pass, which has no row of its own, or while Regenerate NC commands.. prepares the edits — is seen only at the first file, so Regenerate NC commands.. can still follow the Stop. With a thermal stress target on, the thermal stress check between them sees it first: the check looks at Stop before each of its passes, each tool and each line it walks, while it computes forces, and once more after its last run of the constraints, and a Stop it sees closes it on Thermal stress check canceled., writes no file and no check log, and the ladder goes on to optimization canceled. and Total 0 files optimized. The Shell ladder says so: an optimization canceled. row is added before the pass ends, and a Stop during the feed solve also closes the solve with Optimization Feed Process canceled. in place of Optimization Feedrate built..

Important

A stopped optimization still ends on the green Total N files optimized. row a completed one ends on. That row is not a statement that the optimization finished — read the row above it. N counts the files the run had begun writing, so a Stop before the writing begins ends on Total 0 files optimized., and a Stop during writing counts the file it was in the middle of, which is left short. The files after it are not begun: an output an earlier run wrote for one of them stays as that run left it.

An optimization that cannot write an output file — one held open by another program, or read-only — stops there, with no closing rows: the files written before it stay. Run as a mission's command or from a Post-Execution, the whole run ends with it, nothing below it in the mission runs, and Shell shows The play stopped on an error: … with the reason. Run from a Script, the script ends at that call, Shell shows Script […] faulted: …, and the mission goes on with its next command. A per-step log (Optimization Logs) that cannot be opened ends the optimization the same way, earlier: right after Computing Optimized Feed by indivisual step.., before any step is solved or any file written, with the logs opened before it closed again. Free the file, or turn the log off.

The Thermal Stress Check on the Written Feeds

With a thermal stress target on — OptThermalYieldSafetyFactor positive on the session, or in the options of any file the run optimizes — the optimizer checks that target once more before it rewrites the NC: it walks the cutter's temperatures again, step by step, at the feeds it is about to write, and slows a line that reads over the target there. Why the per-step solve alone does not hold the target, and what the check holds and does not, is in What One Optimization Holds of the Thermal Target. With no thermal stress target anywhere, none of this runs: no row, no log, and the output is the one the stages above write.

The check reports to Shell between Build Compensation.. and Regenerate NC commands..:

Row Meaning
Checking the thermal stress ratio on the feeds to be written.. the check opens
Thermal stress check, pass <k>: <n> step(s) checked, <m> over the target, <c> line(s) slowed. one row per pass, at most four; the passes end early once a pass slows nothing
Thermal stress check done: <n> step(s) checked, each under the thermal stress ratio target at the feed to be written (<c> line(s) slowed). … green: every step it checked reads under its target at the feed to be written. The row ends by saying where: in the optimizer's own model, tool wear left out, on the steps of the play — a replay splits the steps again at the new feeds and can still read over the target
Thermal stress check: of the <n> step(s) checked, <s> (<l> line(s)) still read over the thermal stress ratio target at the feeds to be written, at most <percentage>: … (NcOpt-ThermalChain--Residual) warning: steps left over the target, counted by reason — at the minimum feed (the check slows the line of such a step to it), not brought under the target by a lower feed, on a line whose F word is not a number the optimizer can rewrite (a variable or an expression), and other reasons, which the check's log names
Thermal stress check: <n> step(s) held to the thermal stress ratio target could not be checked … (NcOpt-ThermalChain--Unchecked) warning: steps whose physics failed in the check, or that a failed read of the step cache left unchecked — the read's own StepLuggage-Read--Fault or StepBrief-Read--Fault row comes with it. Such a read ends the check of that tool's run where the walk had reached, and no pass walks the run again. Of the run's held steps, a reading stands only where every cutting step of the run up to it is written at the feed it was walked at (the feed it was played at, where no pass walked it) and, past the step the check ended at, only where the walk the read ended had moved no feed before that step; the run's other held steps are not checked, and the run's ReadFault row in the check's log says from where. They are written at the feeds the per-step solve and the constraints gave them; a line the check slowed before the read stays slowed
Thermal stress check: no step is held to the thermal stress ratio target … (NcOpt-ThermalChain--NoStep) the target is on, but no step is held to it: the feed is not optimized where the target is on, the tool is not optimized, or the play gave no thermal stress ratio
Thermal stress check canceled. a Stop reached the check; no file is written
The thermal stress check on the written feeds did not finish (…); the feeds it lowered before are written. (NcOpt-ThermalChain--Failed) error: the check threw; the lines it had slowed stay slowed, and the files are written
The thermal stress check's log <path> could not be written: … (NcOpt-ThermalChain--LogUnwritable) warning: that file's check log is skipped; the optimized files are written as usual

The check only lowers feeds. It slows a line by giving it its own F word at the lower feed, so an optimized program written with the check can carry an F word on a line where the same run without it, under FeedrateAssignmentRatio (API), kept the feed of the line before. The steps' own record of what the check did is the .ThermalChain.log (Optimization Logs).

See Also

  • NC Optimization — the procedure this report belongs to: options, the optimized files and the logs