26-Feb-88 22:08:06-EST,50935;000000000001
Mail-From: WNSLOAN created at 26-Feb-88 20:06:41
Date: Fri 26 Feb 88 20:06:41-EST
From: Bill Sloan <WNSloan@ELWOOD>
Subject: AC-ALL-FILES.LSP (Part II)  <-- new, improved formatting
To: dcbrown@ELWOOD
Message-ID: <12377927530.24.WNSLOAN@ELWOOD>

{; ---------------------------------------------------------------------}
{; !!!!!!!!!!! P I S T O N    D E S I G N    T A S K S !!!!!!!!!!!!!!!!!!!!}

(TASK
  (NAME PistonSize)
  (USED-BY PistonAndRodDP1 PistonAndRodDP2)
  (INITIAL-CONSTRAINTS None)
  (FINAL-CONSTRAINTS None)
  (REDESIGN NOT-POSSIBLE)
  (BODY 
    PistonDiameter
    PistonThickness))

(STEP
  (NAME PistonDiameter)
  (COMMENT "depends on sliding fit tables")
  (ATTRIBUTE-NAME PistonDiameter)
  (USED-BY PistonSize)
  (REDESIGN NOT-POSSIBLE)
  (BODY 
    (KNOWN
      TubeID          (KB-FETCH 'Tube 'TubeID)
      Clearance       (LNGTH 0.002 0.004 0.0 'ThreeDP))
    (DECISIONS
      PistonDiameter  (- TubeID Clearance)
      REPLY           (KB-STORE 'Piston 'PistonDiameter PistonDiameter))))

(STEP
  (NAME PistonThickness)
  (COMMENT "not sure how chosen, and note interactions")
  (ATTRIBUTE-NAME PistonThickness)
  (USED-BY PistonSize)
  (REDESIGN NOT-POSSIBLE)
  (BODY 
    (KNOWN
      Diameter        (KB-FETCH 'Piston 'PistonDiameter)
      Ratio           0.29)
    (DECISIONS
      Thickness       (STANDARDIZE-NEAREST
                        (* Ratio Diameter))
      REPLY           (TEST-CONSTRAINT PistonThickness)
      REPLY           (KB-STORE 'Piston 'PistonThickness Thickness))))

{; --------------------------------------------------}

(TASK
  (NAME PistonRodHole)
  (COMMENT "for connecting rod and piston")
  (USED-BY PistonAndRodDP1 PistonAndRodDP2)
  (INITIAL-CONSTRAINTS None)
  (FINAL-CONSTRAINTS None)
  (REDESIGN NOT-POSSIBLE)
  (BODY PistonRHole))

(STEP
  (NAME PistonRHole)
  (COMMENT "exact method not known")
  (ATTRIBUTE-NAME PistonRodHole)
  (USED-BY PistonRodHole)
  (BODY 
    (KNOWN
      RodDiam         (KB-FETCH 'Rod 'RodDiameter)
      Material        (KB-FETCH 'Rod 'RodMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISIONS
      RodHole         (STANDARDIZE-UP
                        (- RodDiam MinThickness))
      REPLY           (TEST-CONSTRAINT Hole<PDiameter)
      REPLY           (KB-STORE 'Piston 'PistonRodHole RodHole))))

{; -------------------------------------------------------}

(TASK
  (NAME PistonBrazeSeat)
  (COMMENT "to allow for solder")
  (USED-BY PistonAndRodDP1 PistonAndRodDP2)
  (INITIAL-CONSTRAINTS None)
  (FINAL-CONSTRAINTS None)
  (REDESIGN NOT-POSSIBLE)
  (BODY 
    BrazeSeatDiameter
    BrazeSeatDepth))

(STEP
  (NAME BrazeSeatDiameter)
  (COMMENT "exact method unknown")
  (ATTRIBUTE-NAME PistonBrazeSeatDiameter)
  (USED-BY PistonBrazeSeat)
  (BODY 
    (KNOWN
      RodDiam         (KB-FETCH 'Rod 'RodDiameter)
      PistonRodHole   (KB-FETCH 'Piston 'PistonRodHole)
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISIONS
      BrazeSeatDiameter (STANDARDIZE-NEAREST
                          (+ RodDiam MinThickness))
      REPLY           (KB-STORE
                        'Piston 'PistonBrazeSeatDiameter BrazeSeatDiameter))))

(STEP
  (NAME BrazeSeatDepth)
  (COMMENT "depth is min Thickness")
  (ATTRIBUTE-NAME PistonBrazeSeatDepth)
  (USED-BY PistonBrazeSeat)
  (BODY 
    (KNOWN
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISIONS
      BrazeSeatDepth  MinThickness
      REPLY           (KB-STORE 'Piston 'PistonBrazeSeatDepth BrazeSeatDepth))))

{; --------------------------------------------------------}

(TASK
  (NAME PistonSpringSeat)
  (COMMENT "depends on completion of spring specialist")
  (USED-BY PistonAndRodDP1 PistonAndRodDP2)
  (INITIAL-CONSTRAINTS None)
  (FINAL-CONSTRAINTS None)
  (REDESIGN NOT-POSSIBLE)
  (BODY 
    PistonSpringSeatID
    PistonSpringSeatOD
    PistonSpringSeatDepth))

(STEP
  (NAME PistonSpringSeatID)
  (COMMENT "assumes KB-FETCH waits for Spring completion")
  (ATTRIBUTE-NAME PistonSpringSeatID)
  (USED-BY PistonSpringSeat)
  (REDESIGN NOT-POSSIBLE)
  (BODY 
    (KNOWN
      Clearance       0.015625
      SpringID        (KB-FETCH 'Spring 'SpringID))
    (DECISIONS
      SpringSeatID    (- SpringID Clearance)
      REPLY           (KB-STORE 'Piston 'PistonSpringSeatID SpringSeatID))))

(STEP
  (NAME PistonSpringSeatOD)
  (ATTRIBUTE-NAME PistonSpringSeatOD)
  (USED-BY PistonSpringSeat)
  (REDESIGN NOT-POSSIBLE)
  (BODY 
    (KNOWN
      Clearance       0.015625
      SpringOD        (KB-FETCH 'Spring 'SpringOD))
    (DECISIONS
      SpringSeatOD    (+ SpringOD Clearance)
      REPLY           (KB-STORE 'Piston 'PistonSpringSeatOD SpringSeatOD))))

(STEP
  (NAME PistonSpringSeatDepth)
  (ATTRIBUTE-NAME PistonSpringSeatDepth)
  (USED-BY PistonSpringSeat)
  (REDESIGN NOT-POSSIBLE)
  (BODY 
    (KNOWN
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISIONS
      SpringSeatDepth (HALF MinThickness)
      REPLY           (KB-STORE
                        'Piston 'PistonSpringSeatDepth SpringSeatDepth))))

{; -------------------------------------------------------}

(TASK
  (NAME PistonBreakawayCut)
  (USED-BY PistonAndRodDP1 PistonAndRodDP2)
  (INITIAL-CONSTRAINTS None)
  (FINAL-CONSTRAINTS None)
  (REDESIGN NOT-POSSIBLE)
  (BODY 
    BreakawayCutDiameter
    BreakawayCutDepth))

(STEP
  (NAME BreakawayCutDepth)
  (COMMENT "guess method")
  (ATTRIBUTE-NAME PistonBreakawayCutDepth)
  (USED-BY PistonBreakawayCut)
  (BODY 
    (KNOWN
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness)
      PistonThickness (KB-FETCH 'Piston 'PistonThickness)
      Fraction        0.1)
    (DECISIONS
      HalfMinThickness (HALF MinThickness)
      PTFraction      (* PistonThickness Fraction)
      BreakawayCutDepth (THREE-DP
                          (SMALLER HalfMinThickness PTFraction))
      REPLY           (TEST-CONSTRAINT BreakawayCutDepth2)
      REPLY           (TEST-CONSTRAINT BreakawayCutDepth)
      REPLY           (KB-STORE
                        'Piston 'PistonBreakawayCutDepth BreakawayCutDepth))))

(STEP
  (NAME BreakawayCutDiameter)
  (COMMENT "make it less than seal seat depth")
  (ATTRIBUTE-NAME PistonBreakawayCutDiameter)
  (USED-BY PistonBreakawayCut)
  (BODY 
    (KNOWN
      SealSeatDiameter (KB-FETCH 'Piston 'PistonSealSeatDiameter)
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISIONS
      BreakawayCutDiameter (THREE-DP
                             (- SealSeatDiameter
                                (DOUBLE MinThickness)))
      REPLY           (TEST-CONSTRAINT BreakawayCutDiameter)
      REPLY           (TEST-CONSTRAINT BreakawayCutDiameter2)
      REPLY           (KB-STORE
                        'Piston
                        'PistonBreakawayCutDiameter
                        BreakawayCutDiameter))))

{; ----------------------------------------------------------------------}

(TASK
  (NAME PistonSealSmaller)
  (USED-BY PistonAndRodDP2)
  (INITIAL-CONSTRAINTS None)
  (FINAL-CONSTRAINTS None)
  (REDESIGN NOT-POSSIBLE)
  (BODY 
    PistonSealType
    PistonSealSeatWidthSmaller
    PistonSealSeatPosition
    PistonSealSeatDiameterSmaller))

(STEP
  (NAME PistonSealSeatWidthSmaller)
  (COMMENT "should use table lookup")
  (ATTRIBUTE-NAME PistonSealSeatWidth)
  (USED-BY PistonSealSmaller)
  (REDESIGNER PistonSSWRedesigner)
  (FAILURE-HANDLER USER-DECISION-CONSTRAINT-FH IS PistonSealSeatWidthFH)
  (FAILURE-SUGGESTIONS (SUGGEST (INCREASE PistonThickness)))
  (BODY 
    (KNOWN
      PistonThickness (KB-FETCH 'Piston 'PistonThickness)
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness)
      SpringSeatDepth (KB-FETCH 'Piston 'PistonSpringSeatDepth))
    (DECISIONS
      Available       (IF (> SpringSeatDepth MinThickness)
                       THEN (- PistonThickness
                               (+ SpringSeatDepth MinThickness))
                       ELSE (- PistonThickness
                               (DOUBLE MinThickness)))
      COMMENT         "use fixed size for now"
      Width           (LNGTH 0.109 0.01 0.01 'ThreeDP)
      REPLY           (TEST-CONSTRAINT Available>Width)
      REPLY           (KB-STORE 'Piston 'PistonSealSeatWidth Width))))

(STEP
  (NAME PistonSealSeatDiameterSmaller)
  (ATTRIBUTE-NAME PistonSealSeatDiameter)
  (USED-BY PistonSealSmaller)
  (REDESIGNER PistonSSDRedesigner)
  (FAILURE-HANDLER USER-DECISION-CONSTRAINT-FH IS PistonSSDiameterFH)
  (FAILURE-SUGGESTIONS 
    (SUGGEST (INCREASE PistonDiameter)) (SUGGEST (DECREASE PistonRodHole)) )
  (BODY 
    (KNOWN
      PistonRodHole   (KB-FETCH 'Piston 'PistonRodHole)
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISIONS
      COMMENT         "needs table lookup"
      SealSeatDiameter (LNGTH 0.618 0.0 0.001 'ThreeDP)
      SafeDiameter    (+ PistonRodHole MinThickness)
      REPLY           (TEST-CONSTRAINT SSD>SafeDiam)
      REPLY           (KB-STORE
                        'Piston 'PistonSealSeatDiameter SealSeatDiameter))))


{; ----------------------------------------------------------------------}

(TASK
  (NAME PistonSeal)
  (USED-BY PistonAndRodDP1)
  (INITIAL-CONSTRAINTS None)
  (FINAL-CONSTRAINTS None)
  (REDESIGNER PistonSealRedesigner)
  (FAILURE-HANDLER USER-STEP-FAILURE-FH IS PistonSealFH)
  (BODY 
    PistonSealType
    PistonSealSeatWidth
    PistonSealSeatPosition
    PistonSealSeatDiameter))

(STEP
  (NAME PistonSealType)
  (COMMENT "actually needs air pressure and temp for table lookup")
  (ATTRIBUTE-NAME PistonSealType)
  (USED-BY PistonSeal PistonSealSmaller)
  (REDESIGN NOT-POSSIBLE)
  (BODY 
    (KNOWN ***)
    (DECISIONS
      SealType        'UCup
      REPLY           (KB-STORE 'Piston 'PistonSealType SealType))))

(STEP
  (NAME PistonSealSeatWidth)
  (COMMENT "should use table lookup")
  (ATTRIBUTE-NAME PistonSealSeatWidth)
  (USED-BY PistonSeal)
  (REDESIGNER PistonSSWRedesigner)
  (FAILURE-HANDLER USER-DECISION-CONSTRAINT-FH IS PistonSealSeatWidthFH)
  (FAILURE-SUGGESTIONS (SUGGEST (INCREASE PistonThickness)))
  (BODY 
    (KNOWN
      PistonThickness (KB-FETCH 'Piston 'PistonThickness)
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness)
      SpringSeatDepth (KB-FETCH 'Piston 'PistonSpringSeatDepth))
    (DECISIONS
      Available       (IF (> SpringSeatDepth MinThickness)
                       THEN (- PistonThickness
                               (+ SpringSeatDepth MinThickness))
                       ELSE (- PistonThickness
                               (DOUBLE MinThickness)))
      COMMENT         "use fixed size for now"
      Width           (LNGTH 0.156 0.01 0.01 'ThreeDP)
      REPLY           (TEST-CONSTRAINT Available>Width)
      REPLY           (KB-STORE 'Piston 'PistonSealSeatWidth Width))))

(STEP
  (NAME PistonSealSeatPosition)
  (COMMENT "from spring face of piston to start of seal seat")
  (ATTRIBUTE-NAME PistonSealSeatPosition)
  (USED-BY PistonSeal PistonSealSmaller)
  (REDESIGNER PistonSSPRedesigner)
  (FAILURE-SUGGESTIONS 
    (SUGGEST (DECREASE PistonSealSeatWidth))
    (SUGGEST (DECREASE PistonSpringSeatDepth))
    (SUGGEST (INCREASE PistonThickness)))
  (BODY 
    (KNOWN
      PistonThickness (KB-FETCH 'Piston 'PistonThickness)
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness)
      SpringSeatDepth (KB-FETCH 'Piston 'PistonSpringSeatDepth)
      SealSeatWidth   (KB-FETCH 'Piston 'PistonSealSeatWidth))
    (DECISIONS
      Available       (IF (> SpringSeatDepth MinThickness)
                       THEN (- PistonThickness
                               (+ SpringSeatDepth MinThickness))
                       ELSE (- PistonThickness
                               (DOUBLE MinThickness)))
      Available       (HALF
                        (- Available SealSeatWidth))
      Position        (THREE-DP
                        (+ Available
                           (LARGER SpringSeatDepth MinThickness)))
      REPLY           (KB-STORE 'Piston 'PistonSealSeatPosition Position))))

(STEP
  (NAME PistonSealSeatDiameter)
  (ATTRIBUTE-NAME PistonSealSeatDiameter)
  (USED-BY PistonSeal)
  (REDESIGNER PistonSSDRedesigner)
  (FAILURE-HANDLER USER-DECISION-CONSTRAINT-FH IS PistonSSDiameterFH)
  (FAILURE-SUGGESTIONS 
    (SUGGEST (INCREASE PistonDiameter)) (SUGGEST (DECREASE PistonRodHole)) )
  (BODY 
    (KNOWN
      PistonRodHole   (KB-FETCH 'Piston 'PistonRodHole)
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISIONS
      COMMENT         "needs table lookup"
      SealSeatDiameter (LNGTH 0.885 0.0 0.001 'ThreeDP)
      SafeDiameter    (+ PistonRodHole MinThickness)
      REPLY           (TEST-CONSTRAINT SSD>SafeDiam)
      REPLY           (KB-STORE
                        'Piston 'PistonSealSeatDiameter SealSeatDiameter))))

{; ------------------------------------------------------}

(TASK
  (NAME PistonNotches)
  (USED-BY PistonAndRodDP1 PistonAndRodDP2)
  (INITIAL-CONSTRAINTS None)
  (FINAL-CONSTRAINTS None)
  (REDESIGN NOT-POSSIBLE)
  (BODY 
    PistonNotchCount
    PistonNotchWidth
    PistonNotchDepth))

(STEP
  (NAME PistonNotchCount)
  (COMMENT "assume fixed")
  (ATTRIBUTE-NAME PistonNotchCount)
  (USED-BY PistonNotches)
  (BODY 
    (KNOWN
      Count           4)
    (DECISIONS
      REPLY           (KB-STORE 'Piston 'PistonNotchCount Count))))

(STEP
  (NAME PistonNotchWidth)
  (ATTRIBUTE-NAME PistonNotchWidth)
  (USED-BY PistonNotches)
  (BODY 
    (KNOWN
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISIONS
      NotchWidth      MinThickness
      COMMENT         "Test for fraction of circumference"
      REPLY           (KB-STORE 'Piston 'PistonNotchWidth NotchWidth))))


(STEP
  (NAME PistonNotchDepth)
  (ATTRIBUTE-NAME PistonNotchDepth)
  (USED-BY PistonNotches)
  (BODY 
    (KNOWN
      PistonDiameter  (KB-FETCH 'Piston 'PistonDiameter)
      SealSeatDiameter (KB-FETCH 'Piston 'PistonSealSeatDiameter)
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISIONS
      Available       (HALF
                        (- PistonDiameter SealSeatDiameter))
      NotchDepth      (SMALLER Available MinThickness)
      REPLY           (KB-STORE 'Piston 'PistonNotchDepth NotchDepth))))

{; -----------------------------------------------------------------------}
{; !!!!!!!!!!!!!!!!!! R O D   T A S K S !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!}


(TASK
  (NAME RodSize)
  (USED-BY PistonAndRodDP1 PistonAndRodDP2)
  (INITIAL-CONSTRAINTS None)
  (FINAL-CONSTRAINTS None)
  (BODY 
    RodEndToHead
    RodLength))

(STEP
  (NAME RodEndToHead)
  (COMMENT "This is a FIX and may be wrong")
  (ATTRIBUTE-NAME RodEndOfRodToHead)
  (USED-BY RodSize)
  (BODY 
    (KNOWN
      Stroke          (KB-FETCH 'Requirements 'Stroke)
      ThreadLength    (KB-FETCH 'Requirements 'RodThreadLength))
    (DECISIONS
      EndOfRodToHead  (+ Stroke ThreadLength)
      REPLY           (KB-STORE 'Rod 'RodEndOfRodToHead EndOfRodToHead))))

(STEP
  (NAME RodLength)
  (COMMENT "overall length problems here")
  (ATTRIBUTE-NAME RodLength)
  (USED-BY RodSize)
  (BODY 
    (KNOWN
      HeadDepth       (KB-FETCH 'Head 'HeadDepth)
      PistonThickness (KB-FETCH 'Piston 'PistonThickness)
      EndOfRodToHead  (KB-FETCH 'Rod 'RodEndOfRodToHead))
    (DECISIONS
      Length          (THREE-DP
                        (+ EndOfRodToHead
                           (+ PistonThickness HeadDepth)))
      REPLY           (KB-STORE 'Rod 'RodLength Length))))

{; ----------------------------------------------------------------}

(TASK
  (NAME RodPistonMount)
  (USED-BY PistonAndRodDP1 PistonAndRodDP2)
  (INITIAL-CONSTRAINTS None)
  (FINAL-CONSTRAINTS None)
  (BODY 
    PistonSeatDiameter
    PistonSeatLength))

(STEP
  (NAME PistonSeatDiameter)
  (ATTRIBUTE-NAME RodPistonSeatDiameter)
  (USED-BY RodPistonMount)
  (BODY 
    (KNOWN
      PistonRodHole   (KB-FETCH 'Piston 'PistonRodHole)
      Clearance       (LNGTH 0.003 0.0005 0.0005))
    (DECISIONS
      PistonSeatDiameter (THREE-DP
                           (- PistonRodHole Clearance))
      REPLY           (KB-STORE
                        'Rod 'RodPistonSeatDiameter PistonSeatDiameter))))

(STEP
  (NAME PistonSeatLength)
  (ATTRIBUTE-NAME RodPistonSeatLength)
  (USED-BY RodPistonMount)
  (BODY 
    (KNOWN
      PistonThickness (KB-FETCH 'Piston 'PistonThickness)
      BreakawayCutDepth (KB-FETCH 'Piston 'PistonBreakawayCutDepth))
    (DECISIONS
      PistonSeatLength (THREE-DP
                         (- PistonThickness BreakawayCutDepth))
      REPLY           (KB-STORE 'Rod 'RodPistonSeatLength PistonSeatLength))))


{; ------------------------------------------------------------------}
{; !!!!!!!!!!!!!! B U M P E R   D E S I G N  T A S K S  !!!!!!!!!!!!!!}

(TASK
  (NAME BumperWall)
  (USED-BY BumperDP1 BumperDP2)
  (INITIAL-CONSTRAINTS None)
  (FINAL-CONSTRAINTS None)
  (BODY 
    BumperOD
    BumperID
    BumperLength))

(STEP
  (NAME BumperOD)
  (COMMENT "the diam for the barrel of the bumper")
  (ATTRIBUTE-NAME BumperOD)
  (USED-BY BumperWall)
  (BODY 
    (KNOWN
      SpringID        (KB-FETCH 'Spring 'SpringID)
      Clearance       0.08)
    (DECISIONS
      BumperOD        (- SpringID Clearance)
      REPLY           (KB-STORE 'Bumper 'BumperOD BumperOD))))

(STEP
  (NAME BumperID)
  (ATTRIBUTE-NAME BumperID)
  (USED-BY BumperWall)
  (BODY 
    (KNOWN
      BrazeSeatDiameter (KB-FETCH 'Piston 'PistonBrazeSeatDiameter))
    (DECISIONS
      BumperID        BrazeSeatDiameter
      REPLY           (KB-STORE 'Bumper 'BumperID BumperID))))

(STEP
  (NAME BumperLength)
  (COMMENT "this is overall length of bumper including flange")
  (ATTRIBUTE-NAME BumperLength)
  (USED-BY BumperWall)
  (BODY 
    (KNOWN ***)
    (DECISIONS ***)))

{; --------------------------------------------------------------}

(TASK
  (NAME BumperFlange)
  (USED-BY BumperDP1)
  (INITIAL-CONSTRAINTS None)
  (FINAL-CONSTRAINTS None)
  (FAILURE-HANDLER USER-STEP-FAILURE-FH IS BumperFlangeFH)
  (BODY 
    BumperFlangeDiameter
    BumperFlangeThickness))

(STEP
  (NAME BumperFlangeDiameter)
  (ATTRIBUTE-NAME BumperFlangeDiameter)
  (USED-BY BumperFlange)
  (REDESIGNER BumperFDRedesigner)
  (FAILURE-HANDLER USER-DECISION-CONSTRAINT-FH IS BumperFDFH)
  (FAILURE-SUGGESTIONS 
    (SUGGEST (DECREASE SpringOD)) (SUGGEST (INCREASE CapInternalDiameter)) )
  (BODY 
    (KNOWN
      SpringOD        (KB-FETCH 'Spring 'SpringOD)
      CapInternalDiameter (KB-FETCH 'Cap 'CapInternalDiameter)
      Clearance       0.03)
    (DECISIONS
      FlangeDiameter  (- CapInternalDiameter Clearance)
      REPLY           (TEST-CONSTRAINT BFD>SpringOD)
      REPLY           (KB-STORE 'Bumper 'BumperFlangeDiameter FlangeDiameter))))

(STEP
  (NAME BumperFlangeThickness)
  (COMMENT "already done in rough design *******")
  (ATTRIBUTE-NAME BumperFlangeThickness)
  (USED-BY BumperFlange BumperFlange2)
  (REDESIGN NOT-POSSIBLE)
  (BODY 
    (KNOWN
      Material        (KB-FETCH 'Bumper 'BumperMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISIONS
      FlangeThickness MinThickness
      REPLY           (KB-STORE
                        'Bumper 'BumperFlangeThickness FlangeThickness))))

{; -----------------------------------------------------------------}


(TASK
  (NAME BumperFlange2)
  (USED-BY BumperDP2)
  (BODY 
    BumperFlangeDiameter2
    BumperFlangeThickness))


(STEP
  (NAME BumperFlangeDiameter2)
  (ATTRIBUTE-NAME BumperFlangeDiameter)
  (USED-BY BumperFlange2)
  (REDESIGNER BumperFD2Redesigner)
  (FAILURE-SUGGESTIONS 
    (SUGGEST (DECREASE SpringOD))
    (SUGGEST (DECREASE SpringID))
    (SUGGEST (INCREASE CapInternalDiameter)))
  (BODY 
    (KNOWN
      SpringOD        (KB-FETCH 'Spring 'SpringOD)
      SpringID        (KB-FETCH 'Spring 'SpringID)
      Extra           0.01)
    (DECISIONS
      BFD             (+ SpringID
                         (HALF
                           (- SpringOD SpringID)))
      BFD             (+ BFD Extra)
      REPLY           (TEST-CONSTRAINT BFD<CapID)
      REPLY           (KB-STORE 'Bumper 'BumperFlangeDiameter BFD))))

{; -------------------------------------------------------------------}


{; ********** NEW, EMPTY DESIGN AGENTS TO BE DEFINED: ********** }

(STEP
  (NAME TRHDepth)
  (COMMENT "*** This DSPL design agent needs to be defined ***")
  (ATTRIBUTE-NAME ***)
  (USED-BY TieRodHoles)
  (BODY 
    (KNOWN ***)
    (DECISIONS ***)))

(TASK
  (NAME TubeBevel)
  (COMMENT "*** This DSPL design agent needs to be defined ***")
  (USED-BY TubeDP1)
  (BODY ***))

(TASK
  (NAME TubeInnerSurface)
  (COMMENT "*** This DSPL design agent needs to be defined ***")
  (USED-BY TubeDP1)
  (BODY ***))

(TASK
  (NAME RodThread)
  (COMMENT "*** This DSPL design agent needs to be defined ***")
  (USED-BY PistonAndRodDP1 PistonAndRodDP2)
  (BODY ***))

(TASK
  (NAME TieRods)
  (COMMENT "*** This DSPL design agent needs to be defined ***")
  (USED-BY RestDP1)
  (BODY ***))

(TASK
  (NAME SpringDiameters)
  (COMMENT "*** This DSPL design agent needs to be defined ***")
  (USED-BY SpringRDP1)
  (BODY ***))


{; ************************************************* AC-CONSTRAINTS.LSP }

(CONSTRAINT
  (NAME PistonThickness)
  (COMMENT "make it bigger")
  (USED-BY PistonThickness)
  (FAILURE-MESSAGE "Piston thickness too small")
  (FAILURE-SUGGESTIONS (SUGGEST (INCREASE PistonDiameter)))
  (BODY 
    (KNOWN
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (TEST
      (Thickness > (DOUBLE MinThickness)))))

(CONSTRAINT
  (NAME Hole<PDiameter)
  (COMMENT "Suggests a requirement")
  (USED-BY PistonRHole)
  (FAILURE-MESSAGE "Piston rod hole too large for piston diameter")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (DECREASE RodDiameter)) (SUGGEST (INCREASE PistonDiameter)) )
  (BODY 
    (KNOWN
      PMaterial       (KB-FETCH 'Piston 'PistonMaterial)
      PMinThickness   (KB-FETCH PMaterial 'MinThickness)
      PDiam           (KB-FETCH 'Piston 'PistonDiameter))
    (TEST
      (RodHole <= (PDiam - (DOUBLE PMinThickness))))))

(CONSTRAINT
  (NAME Available>Width)
  (COMMENT "must be enough room for the seal")
  (USED-BY PistonSealSeatWidth PistonSealSeatWidthSmaller)
  (FAILURE-MESSAGE "Seal width is greater than available space in piston")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (DECREASE PistonSealSeatWidth BY FAILURE-AMOUNT))
    (SUGGEST (INCREASE PistonThickness BY (+ 0 FAILURE-AMOUNT)))
    (IF (> SpringSeatDepth MinThickness)
     THEN (SUGGEST (DECREASE PistonSpringSeatDepth BY FAILURE-AMOUNT))))
  (BODY 
    (TEST
      (Width <= Available))))

(CONSTRAINT
  (NAME SSD>SafeDiam)
  (COMMENT "does it impinge on rod hole?")
  (USED-BY PistonSealSeatDiameter PistonSealSeatDiameterSmaller)
  (FAILURE-MESSAGE "Piston seal seat diameter is too small to be safe")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (INCREASE PistonSealSeatDiameter BY FAILURE-AMOUNT))
    (SUGGEST (DECREASE PistonRodHole BY FAILURE-AMOUNT)))
  (BODY 
    (TEST
      (SealSeatDiameter > SafeDiameter))))

(CONSTRAINT
  (NAME BreakawayCutDiameter)
  (COMMENT "mustn't be too close to rod seat diam")
  (USED-BY BreakawayCutDiameter)
  (FAILURE-MESSAGE "Piston breakaway cut diameter too small")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (INCREASE PistonBreakawayCutDiameter BY FAILURE-AMOUNT))
    (SUGGEST (DECREASE PistonRodHole BY FAILURE-AMOUNT)))
  (BODY 
    (KNOWN
      RodHoleDiam     (KB-FETCH 'Piston 'PistonRodHole))
    (TEST
      (BreakawayCutDiameter > (RodHoleDiam + (DOUBLE MinThickness))))))

(CONSTRAINT
  (NAME BreakawayCutDiameter2)
  (COMMENT "too close to seal seat")
  (USED-BY BreakawayCutDiameter)
  (FAILURE-MESSAGE "Piston breakaway cut diameter too large")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (DECREASE PistonBreakawayCutDiameter BY FAILURE-AMOUNT))
    (SUGGEST (INCREASE PistonSealSeatDiameter BY FAILURE-AMOUNT)))
  (BODY 
    (KNOWN
      SealSeatDiameter (KB-FETCH 'Piston 'PistonSealSeatDiameter))
    (TEST
      (BreakawayCutDiameter < SealSeatDiameter))))

(CONSTRAINT
  (NAME BreakawayCutDepth)
  (COMMENT "check both depth and diam")
  (USED-BY BreakawayCutDepth)
  (FAILURE-MESSAGE "Piston breakaway cut too close to seal seat")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (DECREASE PistonBreakawayCutDepth BY FAILURE-AMOUNT))
    (SUGGEST (DECREASE PistonBreakawayCutDiameter))
    (SUGGEST (INCREASE PistonSealSeatDiameter))
    (SUGGEST (DECREASE PistonSealSeatPosition))
    (SUGGEST (INCREASE PistonThickness)))
  (BODY 
    (KNOWN
      BCDiam          (KB-FETCH 'Piston 'PistonBreakawayCutDiameter)
      PDiam           (KB-FETCH 'Piston 'PistonDiameter)
      SSD             (KB-FETCH 'Piston 'PistonSealSeatDiameter)
      Clearance1      (THREE-DP
                        (HALF
                          (- SSD BCDiam)))
      COMMENT         "cl1 is radially"
      SealSeatWidth   (KB-FETCH 'Piston 'PistonSealSeatWidth)
      SealSeatPosit   (KB-FETCH 'Piston 'PistonSealSeatPosition)
      Clearance2      (THREE-DP
                        (- (- PistonThickness BreakawayCutDepth)
                           (+ SealSeatPosit SealSeatWidth)))
      Clearance       (THREE-DP
                        (SQRT
                          (VALUE
                            (+ (^ Clearance1 2)
                               (^ Clearance2 2))))))
    (TEST
      (Clearance >= MinThickness))))

(CONSTRAINT
  (NAME BreakawayCutDepth2)
  (USED-BY BreakawayCutDepth)
  (FAILURE-MESSAGE "Piston breakaway cut too small")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (INCREASE PistonBreakawayCutDepth BY FAILURE-AMOUNT)))
  (BODY 
    (TEST
      (BreakawayCutDepth >= (0.25 * MinThickness)))))


(CONSTRAINT
  (NAME CapID>SpringOD)
  (COMMENT "spring must fit in ok")
  (USED-BY CapInternalDiameter)
  (FAILURE-MESSAGE "Cap internal diameter too small for spring")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (INCREASE CapInternalDiameter BY FAILURE-AMOUNT))
    (SUGGEST (DECREASE SpringOD BY FAILURE-AMOUNT)))
  (BODY 
    (TEST
      (InternalDiameter > SpringOD))))

(CONSTRAINT
  (NAME RD<CapDepth)
  (COMMENT "recess cant be too big")
  (USED-BY CapTRRecessDepth)
  (FAILURE-MESSAGE "Tie rod head too large for cap depth")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (DECREASE CapTRRecessDepth BY FAILURE-AMOUNT))
    (SUGGEST (INCREASE CapDepth BY FAILURE-AMOUNT)))
  (BODY 
    (KNOWN
      CMaterial       (KB-FETCH 'Cap 'CapMaterial)
      CMinThickness   (KB-FETCH CMaterial 'MinThickness))
    (TEST
      (RecessDepth < (CapDepth - CMinThickness)))))

(CONSTRAINT
  (NAME Min<MaxRadius)
  (COMMENT "two radii calculated by different methods")
  (USED-BY CapTRRecessRadius)
  (FAILURE-MESSAGE "Cap recess radius calculation failure")
  (BODY 
    (TEST
      (MinRecessRadius < MaxRecessRadius))))

(CONSTRAINT
  (NAME BFD>SpringOD)
  (COMMENT "flange should support spring")
  (USED-BY BumperFlangeDiameter BumperFlangeDiameter2)
  (FAILURE-MESSAGE "Bumper flange is too small for spring")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (INCREASE BumperFlangeDiameter BY FAILURE-AMOUNT))
    (SUGGEST (DECREASE SpringOD BY FAILURE-AMOUNT)))
  (BODY 
    (TEST
      (FlangeDiameter >= SpringOD))))

(CONSTRAINT
  (NAME BFD<CapID)
  (USED-BY BumperFlangeDiameter2)
  (FAILURE-MESSAGE "Bumper flange is too large for cap")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (INCREASE CapInternalDiameter BY FAILURE-AMOUNT))
    (SUGGEST (DECREASE BumperFlangeDiameter BY FAILURE-AMOUNT)))
  (BODY 
    (KNOWN
      CapID           (KB-FETCH 'Cap 'CapInternalDiameter))
    (TEST
      (BFD < CapID))))

(CONSTRAINT
  (NAME AHCtoB>MinTh)
  (USED-BY CapAHLongit)
  (FAILURE-MESSAGE "Cap air hole too close to back of cap")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (CHANGE CapMaterial))
    (SUGGEST (INCREASE CapAirHoleCenterToBackDistance BY FAILURE-AMOUNT)))
  (BODY 
    (TEST
      (AHCenterToBack > MinThickness))))

(CONSTRAINT
  (NAME ACID)
  (USED-BY AirCavityID)
  (FAILURE-MESSAGE "Air cavity ID too large relative to tube ID")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (INCREASE TubeID BY FAILURE-AMOUNT))
    (SUGGEST (DECREASE HeadAirCavityID BY FAILURE-AMOUNT)))
  (BODY 
    (KNOWN
      TubeID          (KB-FETCH 'Tube 'TubeID))
    (TEST
      (AirCavityID < (TubeID - (DOUBLE MinThickness))))))

(CONSTRAINT
  (NAME MHtoFDist)
  (USED-BY HolesToFaceDistance)
  (FAILURE-MESSAGE "Mounting holes too close to face")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (DECREASE HeadMountingHoleDiameter BY FAILURE-AMOUNT)))
  (BODY 
    (KNOWN
      MHDiameter      (KB-FETCH 'Head 'HeadMountingHoleDiameter)
      MHMaxRadius     (HALF
                        (VALUE+ MHDiameter)))
    (TEST
      (MidHtoFDistance >= (MinThickness + MHMaxRadius)))))

(CONSTRAINT
  (NAME ACOD>ACID)
  (COMMENT )
  (USED-BY AirCavityOD)
  (FAILURE-MESSAGE "Head air cavity OD not > ID")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (INCREASE HeadAirCavityOD BY FAILURE-AMOUNT))
    (SUGGEST (DECREASE HeadAirCavityID BY FAILURE-AMOUNT)))
  (BODY 
    (KNOWN
      AirCavityID     (KB-FETCH 'Head 'HeadAirCavityID))
    (TEST
      (AirCavityOD > AirCavityID))))

(CONSTRAINT
  (NAME HoleSizeC1)
  (USED-BY HoleSize)
  (FAILURE-MESSAGE "Mounting holes too close together")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (INCREASE HeadCenterCenterDistance BY FAILURE-AMOUNT))
    (SUGGEST (DECREASE HeadMountingHoleDiameter BY FAILURE-AMOUNT))
    (SUGGEST (CHANGE HeadMaterial)))
  (BODY 
    (KNOWN
      Material        (KB-FETCH 'Head 'HeadMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (TEST
      (MinThickness <= (CenterCenterDistance - MountingHoleDiameter)))))

(CONSTRAINT
  (NAME HoleSizeC2)
  (USED-BY HoleSize)
  (FAILURE-MESSAGE "Mounting holes too far apart for head width")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (INCREASE HeadWidth BY FAILURE-AMOUNT))
    (SUGGEST (DECREASE HeadCenterCenterDistance BY FAILURE-AMOUNT))
    (SUGGEST (DECREASE HeadMountingHoleDiameter BY FAILURE-AMOUNT))
    (SUGGEST (CHANGE HeadMaterial)))
  (BODY 
    (KNOWN
      HeadWidth       (KB-FETCH 'Head 'HeadWidth)
      Material        (KB-FETCH 'Head 'HeadMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness)
      Distance        (+ CenterCenterDistance
                         (+ (VALUE+ MountingHoleDiameter)
                            (DOUBLE MinThickness))))
    (TEST
      (HeadWidth >= Distance))))

(CONSTRAINT
  (NAME CapWall>MinTh)
  (USED-BY CapInternalDepth CapBackFaceThickness)
  (FAILURE-MESSAGE "Cap internal depth produces thin end wall")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (DECREASE CapInternalDepth BY FAILURE-AMOUNT))
    (SUGGEST (INCREASE CapDepth BY FAILURE-AMOUNT)))
  (BODY 
    (KNOWN
      CapDepth        (KB-FETCH 'Cap 'CapDepth)
      CapWall         (- CapDepth InternalDepth)
      Material        (KB-FETCH 'Cap 'CapMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (TEST
      (CapWall > MinThickness))))

(CONSTRAINT
  (NAME AHLateral)
  (USED-BY AirHoleLateral)
  (FAILURE-MESSAGE "Air hole too large for head width")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (INCREASE HeadWidth BY FAILURE-AMOUNT))
    (SUGGEST (DECREASE HeadAirHoleDiameter BY FAILURE-AMOUNT)))
  (BODY 
    (KNOWN
      Material        (KB-FETCH 'Head 'HeadMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (TEST
      ( ( (DOUBLE MinThickness) + AirHoleDiameter) <= HeadWidth))))

(CONSTRAINT
  (NAME AHLongitRange)
  (USED-BY AirHoleLongitudinal)
  (FAILURE-MESSAGE "Not enough space for air hole in head")
  (FAILURE-SUGGESTIONS 
    (SUGGEST (DECREASE HeadAirHoleDiameter BY FAILURE-AMOUNT)))
  (BODY 
    (KNOWNS
      Dist            (FOUR-DP
                        (- AirCavityDepth AirHoleDiameter)))
    (TEST
      (Dist >= TubeSeatDepth))))


{; *****************************************************}
{;  the OK version of the failing test constraint       }

(CONSTRAINT
  (NAME CapIDFailTest)
  (COMMENT "fixed to not fail")
  (USED-BY CapInternalDepth)
  (FAILURE-MESSAGE "If this appears there is a BIG problem!!")
  (BODY 
    (TEST
      (1 = 1))))


{; ********** NEW, EMPTY DESIGN AGENTS TO BE DEFINED: ********** }

(CONSTRAINT
  (NAME Dummy)
  (COMMENT "*** This DSPL design agent needs to be defined ***")
  (USED-BY AirCylinderDP1)
  (FAILURE-MESSAGE ***)
  (BODY 
    (TEST
      (0 = 0))))


{; ******************************************** AC-FAILURE-HANDLERS.LSP }
{; before use ExecuteFailureHandler sets
    MESSAGE          <--- Msg:Message
    CONTRIBUTING-MSG <--- Msg:ContributingMsg
    EXPLANATION      <--- Msg:Explanation
}


{; ********************* USER Failure Handlers ***************************}
{;    For STEP                                                            }


(FAILURE-HANDLER
  (NAME PistonSealSeatWidthFH)
  (COMMENT "written by user and declared in the step")
  (TYPE USER-DECISION-CONSTRAINT-FH)
  (USED-BY PistonSealSeatWidth PistonSealSeatWidthSmaller)
  (USED-BY-TYPE Step)
  (BODY 
    (TABLE
      (DEPENDING-ON EXPLANATION)
      (MATCH
        (IF ("Seal width is greater than available space in piston")
         THEN (DO
                (COMPLAIN "Seal seat width redesign here !!")
                (STEP-REDESIGN-WITH-SUGGESTIONS))))
      (OTHERWISE (USE-FH SystemConstraintFH WITH CONTRIBUTING-MSG)))))

(FAILURE-HANDLER
  (NAME PistonSSDiameterFH)
  (TYPE USER-DECISION-CONSTRAINT-FH)
  (USED-BY PistonSealSeatDiameter PistonSealSeatDiameterSmaller)
  (USED-BY-TYPE Step)
  (BODY 
    (TABLE
      (DEPENDING-ON EXPLANATION)
      (MATCH
        (IF ("Piston seal seat diameter is too small to be safe")
         THEN (DO
                (Complain "Seal seat diameter redesign here !!")
                (STEP-REDESIGN-WITH-SUGGESTIONS))))
      (OTHERWISE (USE-FH SystemConstraintFH WITH CONTRIBUTING-MSG)))))

(FAILURE-HANDLER
  (NAME CapIDFH)
  (TYPE USER-DECISION-CONSTRAINT-FH)
  (USED-BY CapInternalDiameter)
  (USED-BY-TYPE Step)
  (BODY 
    (TABLE
      (DEPENDING-ON EXPLANATION)
      (MATCH
        (IF ("Cap internal diameter too small for spring")
         THEN (DO
                (COMPLAIN "Cap internal diameter redesign here !!")
                (STEP-REDESIGN-WITH-SUGGESTIONS))))
      (OTHERWISE (USE-FH SystemConstraintFH WITH CONTRIBUTING-MSG)))))


(FAILURE-HANDLER
  (NAME BumperFDFH)
  (TYPE USER-DECISION-CONSTRAINT-FH)
  (USED-BY BumperFlangeDiameter)
  (USED-BY-TYPE Step)
  (BODY 
    (TABLE
      (DEPENDING-ON EXPLANATION)
      (MATCH
        (IF ("Bumper flange is too small for spring")
         THEN (DO
                (COMPLAIN "Bumper flange diameter redesign here !!")
                (STEP-REDESIGN-WITH-SUGGESTIONS))))
      (OTHERWISE (USE-FH SystemConstraintFH WITH CONTRIBUTING-MSG)))))


(FAILURE-HANDLER
  (NAME CheckAirCavityFH)
  (COMMENT "this is an ASK-USER type")
  (TYPE USER-DECISION-CONSTRAINT-FH)
  (USED-BY CheckAirCavity)
  (USED-BY-TYPE Step)
  (BODY 
    (COMPLAIN "The user's answer caused the failure")
    (FAIL)))




{; -----------------------------------------------------------------}
{; for TASKS                                                        }

(FAILURE-HANDLER
  (NAME PistonSealFH)
  (COMMENT "written by user")
  (TYPE USER-STEP-FAILURE-FH)
  (USED-BY PistonSeal)
  (USED-BY-TYPE Task)
  (BODY 
    (TASK-REDESIGN-WITH-SUGGESTIONS)))

(FAILURE-HANDLER
  (NAME BumperFlangeFH)
  (COMMENT "written by user")
  (TYPE USER-STEP-FAILURE-FH)
  (USED-BY BumperFlange)
  (USED-BY-TYPE Task)
  (BODY 
    (TASK-REDESIGN-WITH-SUGGESTIONS)))


{; *********************************************** AC-REDESIGNERS.LSP  }

(REDESIGNER
  (NAME PistonSealRedesigner)
  (COMMENT "experimental")
  (USED-BY PistonSeal)
  (USED-BY-TYPE Task)
  (IGNORE-SUGGESTIONS (CHANGE PistonSealType))
  (REDESIGN-STRATEGY LEAST-BACKUP)
  (SECOND-STEP-FAILURE-STRATEGY SIMPLE)
  (VALUE ***))

{; -----------------------------------------------------------------------}

(REDESIGNER
  (NAME PistonSSWRedesigner)
  (COMMENT "really dependent on std seal sizes, need table")
  (USED-BY PistonSealSeatWidth PistonSealSeatWidthSmaller)
  (USED-BY-TYPE Step)
  (ADJUSTMENT 0.001)
  (VALUE (KB-FETCH 'Piston 'PistonSealSeatWidth))
  (INCREASE 
    (KNOWNS
      PistonThickness (KB-FETCH 'Piston 'PistonThickness)
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness)
      SpringSeatDepth (KB-FETCH 'Piston 'PistonSpringSeatDepth))
    (DECISION
      Available       (IF (> SpringSeatDepth MinThickness)
                       THEN (- PistonThickness
                               (+ SpringSeatDepth MinThickness))
                       ELSE (- PistonThickness
                               (DOUBLE MinThickness)))
      Width           (+ VALUE INCREASE)
      REPLY           (TEST-CONSTRAINT Available>Width)
      REPLY           (KB-STORE 'Piston 'PistonSealSeatWidth Width)))
  (DECREASE 
    (DECISION
      Width           (- VALUE DECREASE)
      REPLY           (IF (< Width 0.1)
                       THEN DECREASE-NOT-POSSIBLE
                       ELSE (KB-STORE 'Piston 'PistonSealSeatWidth Width))))
  (CHANGE CHANGE-NOT-POSSIBLE))

(REDESIGNER
  (NAME PistonSSDRedesigner)
  (USED-BY PistonSealSeatDiameter PistonSealSeatDiameterSmaller)
  (USED-BY-TYPE Step)
  (ADJUSTMENT 0.001)
  (VALUE (KB-FETCH 'Piston 'PistonSealSeatDiameter))
  (INCREASE INCREASE-NOT-POSSIBLE)
  (DECREASE 
    (KNOWNS
      PistonRodHole   (KB-FETCH 'Piston 'PistonRodHole)
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISION
      SealSeatDiameter (- VALUE DECREASE)
      SafeDiameter    (+ PistonRodHole MinThickness)
      REPLY           (TEST-CONSTRAINT SSD>SafeDiameter)
      REPLY           (KB-STORE
                        'Piston 'PistonSealSeatDiameter SealSeatDiameter)))
  (CHANGE CHANGE-NOT-POSSIBLE))


(REDESIGNER
  (NAME PistonSSPRedesigner)
  (USED-BY PistonSealSeatPosition)
  (USED-BY-TYPE Step)
  (ADJUSTMENT 0.001)
  (VALUE (KB-FETCH 'Piston 'PistonSealSeatPosition))
  (INCREASE 
    (KNOWNS
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness)
      PistonThickness (KB-FETCH 'Piston 'PistonThickness)
      SealSeatWidth   (KB-FETCH 'Piston 'PistonSealSeatWidth))
    (DECISION
      Position        (+ VALUE INCREASE)
      REPLY           (IF (> Position
                             (- PistonThickness SealSeatWidth))
                       THEN INCREASE-NOT-POSSIBLE
                       ELSE (KB-STORE
                              'Piston 'PistonSealSeatPosition Position))))
  (DECREASE 
    (KNOWNS
      Material        (KB-FETCH 'Piston 'PistonMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISION
      Position        (- VALUE DECREASE)
      REPLY           (IF (> Position
                             (DOUBLE MinThickness))
                       THEN (KB-STORE
                              'Piston 'PistonSealSeatPosition Position)
                       ELSE DECREASE-NOT-POSSIBLE)))
  (CHANGE CHANGE-NOT-POSSIBLE))


(REDESIGNER
  (NAME CapIDRedesigner)
  (USED-BY CapInternalDiameter)
  (USED-BY-TYPE Step)
  (ADJUSTMENT 0.001)
  (VALUE (KB-FETCH 'Cap 'CapInternalDiameter))
  (INCREASE 
    (KNOWNS
      SpringOD        (KB-FETCH 'Spring 'SpringOD)
      TubeID          (KB-FETCH 'Tube 'TubeID))
    (DECISION
      InternalDiameter (+ VALUE INCREASE)
      REPLY           (IF (NOT (< InternalDiameter TubeID))
                       THEN INCREASE-NOT-POSSIBLE)
      REPLY           (TEST-CONSTRAINT CapID>SpringOD)
      REPLY           (KB-STORE 'Cap 'CapInternalDiameter InternalDiameter)))
  (DECREASE 
    (KNOWNS
      SpringOD        (KB-FETCH 'Spring 'SpringOD))
    (DECISION
      InternalDiameter (- VALUE DECREASE)
      REPLY           (TEST-CONSTRAINT CapID>SpringOD)
      REPLY           (KB-STORE 'Cap 'CapInternalDiameter InternalDiameter)))
  (CHANGE CHANGE-NOT-POSSIBLE))


(REDESIGNER
  (NAME BumperFDRedesigner)
  (USED-BY BumperFlangeDiameter)
  (USED-BY-TYPE Step)
  (ADJUSTMENT 0.001)
  (VALUE (KB-FETCH 'Bumper 'BumperFlangeDiameter))
  (INCREASE 
    (KNOWNS
      Clearance       0.02
      CapID           (KB-FETCH 'Cap 'CapInternalDiameter))
    (DECISION
      BFD             (+ VALUE INCREASE)
      REPLY           (IF (<= BFD
                              (- CapID Clearance))
                       THEN (KB-STORE 'Bumper 'BumperFlangeDiameter BFD)
                       ELSE INCREASE-NOT-POSSIBLE)))
  (DECREASE 
    (KNOWNS
      SpringID        (KB-FETCH 'Spring 'SpringID)
      SpringOD        (KB-FETCH 'Spring 'SpringOD))
    (DECISION
      BFD             (- VALUE DECREASE)
      Min             (+ SpringID
                         (HALF
                           (- SpringOD SpringID)))
      REPLY           (IF (> BFD Min)
                       THEN (KB-STORE 'Bumper 'BumperFlangeDiameter BFD)
                       ELSE DECREASE-NOT-POSSIBLE)))
  (CHANGE CHANGE-NOT-POSSIBLE))


(REDESIGNER
  (NAME AirCavityIDRedesigner)
  (COMMENT )
  (USED-BY AirCavityID)
  (USED-BY-TYPE Step)
  (ADJUSTMENT 0.001)
  (VALUE (KB-FETCH 'Head 'HeadAirCavityID))
  (INCREASE 
    (KNOWNS
      TubeID          (KB-FETCH 'Tube 'TubeID)
      Material        (KB-FETCH 'Head 'HeadMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISION
      AirCavityID     (+ VALUE INCREASE)
      REPLY           (TEST-CONSTRAINTS ACID)
      REPLY           (KB-STORE 'Head 'HeadAirCavityID AirCavityID)))
  (DECREASE 
    (KNOWNS
      TubeID          (KB-FETCH 'Tube 'TubeID)
      Material        (KB-FETCH 'Head 'HeadMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness)
      BearingThickness (KB-FETCH 'Head 'HeadBearingThickness)
      RodDiameter     (KB-FETCH 'Rod 'RodDiameter))
    (DECISION
      AirCavityID     (- VALUE DECREASE)
      REPLY           (TEST-CONSTRAINTS ACID)
      MinIDRadius     (+ MinThickness
                         (+ (VALUE+
                              (HALF RodDiameter))
                            (VALUE+ BearingThickness)))
      REPLY           (IF (>= AirCavityID
                              (DOUBLE MinIDRadius))
                       THEN (KB-STORE 'Head 'HeadAirCavityID AirCavityID)
                       ELSE DECREASE-NOT-POSSIBLE)))
  (CHANGE CHANGE-NOT-POSSIBLE))


(REDESIGNER
  (NAME AirCavityODRedesigner)
  (USED-BY AirCavityOD)
  (USED-BY-TYPE Step)
  (ADJUSTMENT 0.001)
  (VALUE (KB-FETCH 'Head 'HeadAirCavityOD))
  (INCREASE 
    (KNOWNS
      TubeID          (KB-FETCH 'Tube 'TubeID)
      Material        (KB-FETCH 'Head 'HeadMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISION
      AirCavityOD     (+ VALUE INCREASE)
      REPLY           (TEST-CONSTRAINT ACOD>ACID)
      REPLY           (IF (<= AirCavityOD
                              (- TubeID
                                 (DOUBLE MinThickness)))
                       THEN (KB-STORE 'Head 'HeadAirCavityOD AirCavityOD)
                       ELSE INCREASE-NOT-POSSIBLE)))
  (DECREASE 
    (KNOWNS
      Material        (KB-FETCH 'Head 'HeadMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness)
      AirCavityID     (KB-FETCH 'Head 'HeadAirCavityID))
    (DECISION
      AirCavityOD     (- VALUE DECREASE)
      REPLY           (TEST-CONSTRAINT ACOD>ACID)
      REPLY           (IF (>= AirCavityOD
                              (+ AirCavityID
                                 (DOUBLE MinThickness)))
                       THEN (KB-STORE 'Head 'HeadAirCavityOD AirCavityOD)
                       ELSE DECREASE-NOT-POSSIBLE)))
  (CHANGE CHANGE-NOT-POSSIBLE))


(REDESIGNER
  (NAME AirCavityDepthRedesigner)
  (USED-BY AirCavityDepth)
  (USED-BY-TYPE Step)
  (VALUE (KB-FETCH 'Head 'HeadAirCavityDepth))
  (INCREASE 
    (KNOWNS
      Bearing1Length  (KB-FETCH 'Head 'HeadBearing1Length)
      Clearance       0.01)
    (DECISION
      AirCavityDepth  (+ VALUE INCREASE)
      Max             (- (VALUE- Bearing1Length)
                         Clearance)
      REPLY           (IF (< AirCavityDepth Max)
                       THEN (KB-STORE
                              'Head 'HeadAirCavityDepth AirCavityDepth)
                       ELSE INCREASE-NOT-POSSIBLE)))
  (DECREASE 
    (KNOWNS
      Material        (KB-FETCH 'Head 'HeadMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISION
      AirCavityDepth  (- VALUE DECREASE)
      REPLY           (IF (>= AirCavityDepth MinThickness)
                       THEN (KB-STORE
                              'Head 'HeadAirCavityDepth AirCavityDepth)
                       ELSE DECREASE-NOT-POSSIBLE)))
  (CHANGE CHANGE-NOT-POSSIBLE))


(REDESIGNER
  (NAME HtoFDistanceRedesigner)
  (COMMENT )
  (USED-BY HolesToFaceDistance)
  (USED-BY-TYPE Step)
  (ADJUSTMENT 0.001)
  (VALUE (KB-FETCH 'Head 'HeadMountingHolesToFaceDistance))
  (INCREASE 
    (KNOWNS
      MaxHtoFDistance (KB-FETCH 'Head 'HeadMaxHtoFDistance))
    (DECISION
      MidHtoFDistance (+ VALUE INCREASE)
      REPLY           (IF (>= MidHtoFDistance MaxHtoFDistance)
                       THEN INCREASE-NOT-POSSIBLE
                       ELSE (KB-STORE
                              'Head
                              'HeadMountingHolesToFaceDistance
                              MidHtoFDistance))))
  (DECREASE 
    (KNOWNS
      Material        (KB-FETCH 'Head 'HeadMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISION
      MidHtoFDistance (- VALUE DECREASE)
      REPLY           (TEST-CONSTRAINT MHtoFDistance)
      REPLY           (KB-STORE
                        'Head 'HeadMountingHolesToFaceDistance MidHtoFDistance)))
  (CHANGE CHANGE-NOT-POSSIBLE))


(REDESIGNER
  (NAME CapIDepthRedesigner)
  (USED-BY CapInternalDepth)
  (USED-BY-TYPE Step)
  (ADJUSTMENT 0.001)
  (VALUE (KB-FETCH 'Cap 'CapInternalDepth))
  (INCREASE 
    (KNOWNS
      Material        (KB-FETCH 'Cap 'CapMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISION
      InternalDepth   (+ VALUE INCREASE)
      REPLY           (TEST-CONSTRAINT CapWall>MinTh)
      REPLY           (KB-STORE 'Cap 'CapInternalDepth InternalDepth)))
  (DECREASE 
    (KNOWNS
      AirHoleDiameter (KB-FETCH 'Cap 'CapAirHoleDiameter)
      TubeSeatDepth   (KB-FETCH 'Cap 'CapTubeSeatDepth)
      Material        (KB-FETCH 'Cap 'CapMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISION
      InternalDepth   (- VALUE DECREASE)
      Min             (+ TubeSeatDepth
                         (+ AirHoleDiameter MinThickness))
      REPLY           (IF (< InternalDepth Min) THEN DECREASE-NOT-POSSIBLE)
      REPLY           (TEST-CONSTRAINT CapWall>MinTh)
      REPLY           (KB-STORE 'Cap 'CapInternalDepth InternalDepth)))
  (CHANGE CHANGE-NOT-POSSIBLE))


(REDESIGNER
  (NAME CapAHLongitRedesigner)
  (USED-BY CapAHLongit)
  (USED-BY-TYPE Step)
  (ADJUSTMENT 0.001)
  (VALUE (KB-FETCH 'Cap 'CapAirHoleCenterToBackDistance))
  (INCREASE 
    (KNOWNS
      CapDepth        (KB-FETCH 'Cap 'CapDepth)
      TubeSeatDepth   (KB-FETCH 'Cap 'CapTubeSeatDepth)
      AirHoleDiameter (KB-FETCH 'Cap 'CapAirHoleDiameter)
      Material        (KB-FETCH 'Cap 'CapMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISION
      AHCenterToBack  (+ VALUE INCREASE)
      AHCenterToFront (- CapDepth AHCenterToBack)
      Min             (+ TubeSeatDepth
                         (+ MinThickness
                            (HALF AirHoleDiameter)))
      REPLY           (IF (>= AHCenterToFront Min)
                       THEN (KB-STORE
                              'Cap
                              'CapAirHoleCenterToBackDistance
                              AHCenterToBack)
                       ELSE INCREASE-NOT-POSSIBLE)))
  (DECREASE 
    (KNOWNS
      Material        (KB-FETCH 'Cap 'CapMaterial)
      MinThickness    (KB-FETCH Material 'MinThickness))
    (DECISION
      AHCenterToBack  (- VALUE DECREASE)
      REPLY           (TEST-CONSTRAINT AHCtoB>MinTh)
      REPLY           (KB-STORE
                        'Cap 'CapAirHoleCenterToBackDistance AHCenterToBack)))
  (CHANGE CHANGE-NOT-POSSIBLE))


(REDESIGNER
  (NAME BumperFD2Redesigner)
  (USED-BY BumperFlangeDiameter2)
  (USED-BY-TYPE Step)
  (ADJUSTMENT 0.001)
  (VALUE (KB-FETCH 'Bumper 'BumperFlangeDiameter))
  (INCREASE 
    (KNOWNS
      CapID           (KB-FETCH 'Cap 'CapInternalDiameter)
      Clearance       0.01)
    (DECISION
      BFD             (+ VALUE INCREASE)
      REPLY           (IF (<= BFD
                              (- CapID Clearance))
                       THEN (KB-STORE 'Bumper 'BumperFlangeDiameter BFD)
                       ELSE INCREASE-NOT-POSSIBLE)))
  (DECREASE NOT-POSSIBLE)
  (CHANGE CHANGE-NOT-POSSIBLE))