Class StepPhysicsRecomputeOptions
- Namespace
- Hi.MachiningProcs
- Assembly
- HiMech.dll
public sealed class StepPhysicsRecomputeOptions- Inheritance
-
StepPhysicsRecomputeOptions
- Inherited Members
- Extension Methods
Properties
AmendmentWriter
Required. Synchronous write of one chunk's amendments (StepPhysicsAmendment), one transaction for the list, committed before it returns: the force column of the luggage row of every step the force kernel reran on (the substraction and the engagement columns are not touched), and the briefs' row of every step the chunk rewrote – its force brief after the recompute and its new sequential physics state. Called once per chunk, after the chunk's resident briefs were assigned; a write that throws takes the chunk back out of memory (the resident briefs, the creation caches and the play-end fold as they were) and ends the recompute as a fault – as does any exception out of the chunk's chain – so the resident copies never run ahead of the store.
public Action<IReadOnlyList<StepPhysicsAmendment>> AmendmentWriter { get; init; }Property Value
BriefReader
Required. Reads the stored briefs' rows (StepBrief) of a step
index range, [begin, end): the chunk loop reads each chunk's range
once, on the driving thread, beside the luggage rows, and the chain's seed
row before the first chunk – the chain reads every step's stored force
brief, a brief rerun rebuilds from it, and the convergence stop compares
against the stored sequential physics state (the brief-into-DB chain's C4a; the
resident copies on the steps are not read).
What the store answers is authoritative; the one copy outside the store is
a step's creation cache the rendezvous has not cleared (a flush that
failed), which the chunk reads instead. A read that faults throws out of the
recompute, which then ends as a fault; the host reports the fault on the
way.
public ReadBulkDelegate<StepBrief> BriefReader { get; init; }Property Value
CancellationToken
Checked after every chunk; a cancelled recompute keeps what was written.
public CancellationToken CancellationToken { get; init; }Property Value
ChunkSize
Steps per chunk (brief phase in parallel, chain, commit, pace); non-positive means 1024.
public int ChunkSize { get; init; }Property Value
DrawingRefreshChunkStride
Flag the drawing for a refresh after every N-th chunk that replaced something, so the 3D workpiece and the path colors follow the recompute chunk by chunk instead of changing once at the end (the flag is cheap; the re-stamp runs on the render thread when it gets to it). 1 = every chunk (default); 0 = only at the end.
public int DrawingRefreshChunkStride { get; init; }Property Value
InspectingSlotRefill
Refills a rewritten step's inspecting slot (FillInspectingSlot(int, double) on the host's side) with the host's inspecting key computed on the step's new briefs: called once per rewritten step after the chunk's rows are committed, with the new briefs pinned on the calling thread (PinBriefs(int, MillingForceBrief, SeqPhysicsState)) so the key's getter reads them without a store read. Null for a host without slots (the brief-into-DB chain's C4b).
public Action<MachiningStep> InspectingSlotRefill { get; init; }Property Value
LuggageReader
Required. Reads the stored luggage rows of a step index range,
[begin, end), whole rows: the chunk loop reads each chunk's range
once, on the driving thread, before its parallel brief phase (the chain
wants the substraction and the engagement of every step, a brief rerun the
force; a force rerun writes the force column back through
AmendmentWriter). What the store answers is authoritative: a
step without a row is a step the store does not hold (no cache sits in front
of the store, so there is no stale absence to retry; a step whose flush failed
keeps its creation cache, which the chunk reads instead). A read that faults
throws out of the recompute, which then ends as a fault and rolls its forward
back; the host reports the fault on the way (StepLuggage-Read–Fault).
public ReadBulkDelegate<StepLuggage> LuggageReader { get; init; }Property Value
Pace
Called between chunks by Run() (a mission script's direct call paces through the player here, so Pause parks the recompute and Stop cancels it at the chunk boundary); may be null. A driver that calls TryRunNextChunk() itself — the player's pace-point queue — paces on its own and this is not called.
public Action Pace { get; init; }Property Value
Progress
User-facing messages (ids StepPhysics-Recompute–*); may be null. A sink that throws ends the recompute as a fault; a chunk whose chain it threw inside is taken back out of memory first.
public IProgress<IMessage> Progress { get; init; }Property Value
StoredLuggageKindsReader
Required. Reads which columns of the stored rows of a step index range,
[begin, end), are not NULL – step index to StepLuggageKinds
for the steps that have a row, no blob copied out or decoded. The
pre-scan asks it whether the engagement a force rerun needs and the force
a brief rerun needs are stored, over [SeqStart, LastModified] one
chunk at a time.
public Func<int, int, Dictionary<int, StepLuggageKinds>> StoredLuggageKindsReader { get; init; }Property Value
- Func<int, int, Dictionary<int, StepLuggageKinds>>
StoredStepBriefIndicesReader
Required. Reads which steps of a step index range, [begin, end), have
a stored briefs' row – the step indices alone, nothing decoded. The pre-scan
asks it whether every step of the sequential chain has its row (or a live
creation cache), one chunk at a time, before anything is touched: a store that
lost its rows since the play cannot be the chain's input.
public Func<int, int, HashSet<int>> StoredStepBriefIndicesReader { get; init; }Property Value
ToolId
Scope override: when set, only this tool's steps are in scope and they go through the force kernel again whatever changed (an explicit request is a force rerun). The other tools' steps keep their forces and results whatever changed on those tools — the sequential chain alone reads their inputs as they are now where it passes their steps — and those changes stay on record for the next recompute. The recorded environment follows the run: when the environment changed, the sequential chain reran every step from the first, whatever the scope. The workpiece of the moment is added to the record beside the earlier values: the scoped tool's results were rebuilt with its cutting parameter and material, the other tools' results were not, so a later recompute still finds the workpiece changed — for the tools that were left, and for an edit back to the earlier value. Null auto-detects the scope from the recorded fingerprints.
public int? ToolId { get; init; }Property Value
- int?