Benjamin Admin
a8c61eb320
The generic hot-surface patterns HP016 (high_temperature) and HP018 (actuator burn) fire for dishwashers via broad tags and duplicate the precise warewashing pattern HP2201 (Boiler/Tank/Spuelkammer). Suppress HP016/HP018 only when dom_warewashing is present, so the specific pattern wins and the duplicate is dropped. Scoped to the domain tag -> Kistenhub/Bremse and every non-warewashing machine keep the generic patterns unchanged. Warewashing recall stays 100% (25/25), precision 90% -> 92.6% (2 dupes removed). Bremse 26 pins and Kistenhub benchmark unaffected. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
66 lines
2.8 KiB
Go
66 lines
2.8 KiB
Go
package iace
|
|
|
|
// Interlocked-enclosure model (EN ISO 14120 / EN ISO 12100).
|
|
//
|
|
// A contact or entanglement hazard from a moving part is removed during NORMAL
|
|
// operation when that part is inaccessible behind an interlocked guard. The
|
|
// hazard then remains only when the guard is open — maintenance, cleaning or
|
|
// fault clearing. Patterns flagged GuardableByEnclosure express this; a project
|
|
// emits the "interlocked_enclosure" tag (interlocked door/hood, see
|
|
// keyword_dictionary.go) to declare the guard.
|
|
//
|
|
// This is GENERIC: it applies to every enclosed machine (dishwasher spray arm,
|
|
// enclosed mixer, centrifuge ...) and is regression-safe — machines that do not
|
|
// emit interlocked_enclosure are unaffected.
|
|
|
|
const (
|
|
phaseMaintenance = "maintenance"
|
|
phaseCleaning = "cleaning"
|
|
phaseFaultClearing = "fault_clearing"
|
|
)
|
|
|
|
// suppressedByEnclosure reports whether a guardable hazard must be dropped: the
|
|
// part is enclosed AND none of the project's lifecycle phases opens the guard.
|
|
func suppressedByEnclosure(p HazardPattern, tagSet map[string]bool, lifecycles []string) bool {
|
|
if !p.GuardableByEnclosure || !tagSet["interlocked_enclosure"] || len(lifecycles) == 0 {
|
|
return false
|
|
}
|
|
for _, lc := range lifecycles {
|
|
if lc == phaseMaintenance || lc == phaseCleaning || lc == phaseFaultClearing {
|
|
return false // guard is open in some phase → hazard remains there
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// guardedLifecycles re-scopes a guardable hazard to the guard-open phases when
|
|
// the project declares an interlocked enclosure, so it is documented as a
|
|
// maintenance/cleaning hazard rather than a normal-operation one.
|
|
func guardedLifecycles(p HazardPattern, tagSet map[string]bool) []string {
|
|
if p.GuardableByEnclosure && tagSet["interlocked_enclosure"] {
|
|
return []string{phaseMaintenance, phaseCleaning}
|
|
}
|
|
return p.ApplicableLifecycles
|
|
}
|
|
|
|
// Domain-specific supersession.
|
|
//
|
|
// A generic pattern that fires via a broad tag (e.g. high_temperature) can
|
|
// duplicate a domain-specific pattern that describes the same hazard more
|
|
// precisely. When the domain is present, the specific pattern wins and the
|
|
// generic duplicate is dropped. Scoped to the domain tag, so machines outside
|
|
// the domain keep the generic pattern — regression-safe by construction.
|
|
//
|
|
// HP016 (generic hot surfaces) -> HP2201 (Boiler/Tank/Spuelkammer)
|
|
// HP018 (actuator burn) -> HP2201 (same contact-burn hazard)
|
|
var genericSupersededByWarewashing = map[string]bool{
|
|
"HP016": true,
|
|
"HP018": true,
|
|
}
|
|
|
|
// supersededByDomainSpecific reports whether a generic pattern is replaced by a
|
|
// more precise equivalent that the project's domain already provides.
|
|
func supersededByDomainSpecific(p HazardPattern, tagSet map[string]bool) bool {
|
|
return tagSet["dom_warewashing"] && genericSupersededByWarewashing[p.ID]
|
|
}
|