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