; -*-Lisp-*-
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Description:  MoldDesignAdvisor Customization: Functions for calculating the 
;               Screw Boss variables
; Language:     Lisp
; Package:      MOLD-UI
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(in-package :mold-ui)
(use-package '(:oli :frame2))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;         Formulas originally used for the Screw Boss calculation
;; 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defparameter *screw-boss-formula-list* 
    (list :default-formular-group :original
          :original (list :regi-name *original-group*
		          :hole-dia 'screwb-hole-diameter
		          :hole-dia-low 'screwb-hole-diameter-lower-limit
                          :hole-dia-high 'screwb-hole-diameter-upper-limit
		          :counterbore-dia 'screwb-counterbore-diameter
		          :counterbore-dia-low 'screwb-counterbore-diameter-lower-limit
		          :counterbore-dia-high 'screwb-counterbore-diameter-upper-limit
		          :counterbore-dep 'screwb-counterbore-depth
		          :counterbore-dep-low 'screwb-counterbore-depth-lower-limit
		          :counterbore-dep-high 'screwb-counterbore-depth-upper-limit
		          :thread-engage 'screwb-thread-engage
		          :thread-engage-low 'screwb-thread-engage-lower-limit
		          :thread-engage-high 'screwb-thread-engage-upper-limit
		          :hole-blend-radius 'screwb-hole-blend-radius
		          :hole-blend-radius-low 'screwb-hole-blend-radius-lower-limit
		          :hole-blend-radius-high 'screwb-hole-blend-radius-upper-limit
		          :boss-dia 'screwb-boss-diameter
		          :boss-dia-low 'screwb-boss-diameter-lower-limit
		          :boss-dia-high 'screwb-boss-diameter-upper-limit
		          :boss-height 'screwb-boss-height
		          :boss-height-low 'screwb-boss-height-lower-limit
		          :boss-height-high 'screwb-boss-height-upper-limit
		          :boss-draft-angle 'screwb-boss-draft-angle
		          :boss-draft-angle-low 'screwb-boss-draft-angle-lower-limit
		          :boss-draft-angle-high 'screwb-boss-draft-angle-upper-limit
		          :boss-blend-radius 'screwb-boss-blend-radius
		          :boss-blend-radius-low 'screwb-boss-blend-radius-lower-limit
		          :boss-blend-radius-high 'screwb-boss-blend-radius-upper-limit
		          )))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;;                      Original Formula Definition
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;; Hole Diameter ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; calculate value 
(defun screwb-hole-diameter(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia 
		                                  :calc-var :hole-dia)))
    (unless screw-dia
      (return-from screwb-hole-diameter nil))
    (setq val (* 0.8 screw-dia))
    (list :hole-dia val) 
    ))
;; calculate lower limit: 
(defun screwb-hole-diameter-lower-limit(known-args &aux val)
  (setq val -1.0)
  (list :hole-dia-low val) 
  )
;; calculate upper limit: 
(defun screwb-hole-diameter-upper-limit(known-args &aux val)
  (setq val -1.0)
  (list :hole-dia-high val) 
  )

;;;;;;;;;;;;;;;;;;;;;;;;;; Counterbore Diameter ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; calculate value 
(defun screwb-counterbore-diameter(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia  
		                                  :calc-var :counterbore-dia)))
    (unless screw-dia
      (return-from screwb-counterbore-diameter nil))
    (setq val (+ 0.2 screw-dia))
    (list :counterbore-dia val) 
    ))
;; calculate lower limit: 
(defun screwb-counterbore-diameter-lower-limit(known-args &aux val)
  (setq val -1.0)
  (list :counterbore-dia-low val) 
  )
;; calculate upper limit: 
(defun screwb-counterbore-diameter-upper-limit(known-args &aux val)
  (setq val -1.0)
  (list :counterbore-dia-high val) 
  )

;;;;;;;;;;;;;;;;;;;;;;;;;;;; Counterbore Depth ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; calculate value 
(defun screwb-counterbore-depth(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia  
		                                  :calc-var :counterbore-dep)))
    (unless screw-dia
      (return-from screwb-counterbore-depth nil))
    (setq val (* 0.4 screw-dia))
    (list :counterbore-dep val) 
    ))
;; calculate lower limit: 
(defun screwb-counterbore-depth-lower-limit(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia  
		                                  :calc-var :counterbore-dep-low)))
    (unless screw-dia
      (return-from screwb-counterbore-depth-lower-limit nil))
    (setq val (* 0.3 screw-dia))
    (list :counterbore-dep-low val) 
    ))
;; calculate upper limit: 
(defun screwb-counterbore-depth-upper-limit(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia  
		                                  :calc-var :counterbore-dep-high)))
    (unless screw-dia
      (return-from screwb-counterbore-depth-upper-limit nil))
    (setq val (* 0.5 screw-dia))
    (list :counterbore-dep-high val) 
    ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;; Minimum Thread Engagement ;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; calculate value 
(defun screwb-thread-engage(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia 
		                                  :calc-var :thread-engage)))
    (unless screw-dia
      (return-from screwb-thread-engage nil))
    (setq val (* 2.0  screw-dia))
    (list :thread-engage val) 
    ))
;; calculate lower limit: 
(defun screwb-thread-engage-lower-limit(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia  
		                                  :calc-var :thread-engage-low)))
    (unless screw-dia
      (return-from screwb-thread-engage-lower-limit nil))
    (setq val (* 1.7 screw-dia))
    (list :thread-engage-low val) 
    ))
;; calculate upper limit: 
(defun screwb-thread-engage-upper-limit(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia  
		                                  :calc-var :thread-engage-high)))
    (unless screw-dia
      (return-from screwb-thread-engage-upper-limit nil))
    (setq val (* 2.5 screw-dia))
    (list :thread-engage-high val) 
    ))

;;;;;;;;;;;;;;;;;;;;;;; Hole Blend Radius ;;;;;;;;;;;;;;;;;;;;;;
;;
;; calculate value 
(defun screwb-hole-blend-radius(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia  
		                                  :calc-var :thread-engage-high)))
    (setq val 0.5)
    (unless (or (not screw-dia) (< val (* 0.375 screw-dia)))  
      ;; when hole-blend-radius >= hole-radius (0.75d/2)
      (setq val (* 0.35 screw-dia)))
    (list :hole-blend-radius val)) 
  )
;; calculate lower limit: 
(defun screwb-hole-blend-radius-lower-limit(known-args &aux val)
  (setq val -1.0)
  (list :hole-blend-radius-low val) 
  )
;; calculate upper limit: 
(defun screwb-hole-blend-radius-upper-limit(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia  
		                                  :calc-var :thread-engage-high)))
    (if screw-dia
        (setq val (* 0.35 screw-dia))
      (setq val -1.0))
    (list :hole-blend-radius-high val) 
    ))

;;;;;;;;;;;;;;;;;;;;;;; Boss Diameter ;;;;;;;;;;;;;;;;;;;;;;
;;
;; calculate value 
(defun screwb-boss-diameter(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia 
		                                  :calc-var :boss-dia)))
    (unless screw-dia
      (return-from screwb-boss-diameter nil))
    (setq val (* 2.0 screw-dia))
    (unless (> val (+ 0.2 screw-dia))     ;; when boss-dia <= counterbore-dia
      (setq val (+ 1.0 screw-dia))) 
    (list :boss-dia val) 
    ))
;; calculate lower limit: 
(defun screwb-boss-diameter-lower-limit(known-args &aux val)
  (setq val -1.0)
  (list :boss-dia-low val) 
  )
;; calculate upper limit: 
(defun screwb-boss-diameter-upper-limit(known-args &aux val)
  (setq val -1.0)
  (list :boss-dia-high val) 
  )

;;;;;;;;;;;;;;;;;;;;;;; Boss Height ;;;;;;;;;;;;;;;;;;;;;;
;;
;; calculate value 
(defun screwb-boss-height(known-args &aux val)
  (let ((boss-dia (inq-known-variable known-args :inq-var :boss-dia 
                                                 :calc-var :boss-height)))
    (unless boss-dia
      (return-from screwb-boss-height nil))
    (setq val (* 2.5 boss-dia))
    (list :boss-height val) 
    ))
;; calculate lower limit: 
(defun screwb-boss-height-lower-limit(known-args &aux val)
  (let ((boss-dia (inq-known-variable known-args :inq-var :boss-dia 
		                                 :calc-var :boss-height-low)))
    (unless boss-dia
      (return-from screwb-boss-height-lower-limit nil))
    (setq val (* 2.5 boss-dia))
    (list :boss-height-low val) 
    ))
;; calculate upper limit: 
(defun screwb-boss-height-upper-limit(known-args &aux val)
  (let ((boss-dia (inq-known-variable known-args :inq-var :boss-dia 
		                                 :calc-var :boss-height-high)))
    (unless boss-dia
      (return-from screwb-boss-height-upper-limit nil))
    (setq val (* 3.0 boss-dia))
    (list :boss-height-high val) 
    ))

;;;;;;;;;;;;;;;;;;;;;;; Boss Draft Angle ;;;;;;;;;;;;;;;;;;;;;;
;;
;; calculate value 
(defun screwb-boss-draft-angle(known-args &aux val)
  (setq val (sd-deg-to-rad 0.5))
  (list :boss-draft-angle val) 
  )
;; calculate lower limit: 
(defun screwb-boss-draft-angle-lower-limit(known-args &aux val)
  (setq val (sd-deg-to-rad 0.5))
  (list :boss-draft-angle-low val) 
  )
;; calculate upper limit: 
(defun screwb-boss-draft-angle-upper-limit(known-args &aux val)
  (setq val (sd-deg-to-rad 10.0))
  (list :boss-draft-angle-high val) 
  )

;;;;;;;;;;;;;;;;;;;;;;; Boss Blend Radius ;;;;;;;;;;;;;;;;;;;;;;
;;
;; calculate value 
(defun screwb-boss-blend-radius(known-args &aux val)
  (let ((ref-wall-thick (inq-known-variable known-args :inq-var :ref-wall-thick 
		                                       :calc-var :boss-blend-radius)))
    (unless ref-wall-thick
      (return-from screwb-boss-blend-radius nil))
    (setq val (* 0.25 ref-wall-thick))
    (list :boss-blend-radius val) 
    ))
;; calculate lower limit: 
(defun screwb-boss-blend-radius-lower-limit(known-args &aux val)
  (let ((ref-wall-thick (inq-known-variable known-args :inq-var :ref-wall-thick 
		                                       :calc-var :boss-blend-radius-low)))
    (unless ref-wall-thick
      (return-from screwb-boss-blend-radius-lower-limit nil))
    (setq val (* 0.12 ref-wall-thick))
    (list :boss-blend-radius-low val) 
    ))
;; calculate upper limit: 
(defun screwb-boss-blend-radius-upper-limit(known-args &aux val)
  (let ((ref-wall-thick (inq-known-variable known-args :inq-var :ref-wall-thick 
		                                       :calc-var :boss-blend-radius-high)))
    (unless ref-wall-thick
      (return-from screwb-boss-blend-radius-upper-limit nil))
    (setq val (* 0.5 ref-wall-thick))
    (list :boss-blend-radius-high val) 
    ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Registration of User Defined Formula Sets for Screw Boss
;;
;; A user defined formula set for calculating the parameters of the Screw 
;; Feature will be regisetered here
;; 
;; What is needed to be done by the user?
;; ======================================
;;
;; 1. Register the new formula set by invoking register-a-function-set() and 
;;    make the following specifications (:as-default is optional):
;;      :regi-keyword    a key word for the new formula set
;;      :regi-list       name of a global list which contains defined formula 
;;                       sets for calculating the parameters of a plastic feature.
;;                       (!) For creating Screw Boss Feature the user is only 
;;                       allowed to specify it as *screw-boss-formula-list* (it
;;                       is defined above in this file, each different plastic 
;;                       feature will have itsown such gloable list)
;;      :redef-formulas  a p-list which contains the parameter key word and 
;;                       the new defined function to calculate the parameter
;;                       (the parameter keywords could be seen above when the 
;;                       *screw-boss-formula-list* is defined and the meaning of 
;;                       the parameters is shown in the feature dialog) 
;;      :as-default      boolean value type to specify if the new formula set is 
;;                       desired to be the default formula set
;;
;; 2. Define the new functions for calculating the feature parameters. The
;;    following function could be used for the definition:
;;
;;    - function inq-known-variable(known-args &key inq-var calc-var)
;;
;;      checks if a input parameter used for calculating the variable has been 
;;      defined. known-args is a p-list which is passed in originally by the  
;;      feature dialog and contains the parameters needed for the calculation,
;;      inq-var gives the keyword of the parameter being checked, and calc-var 
;;      gives the variable to be calculated. If check fails, a error message will 
;;      be shown in SolidDesigner, otherwise the function returns the parameter value
;;
;;
;; Example:
;; ========
;;
(register-a-function-set :regi-keyword :demo_rule2 
                         :regi-list *screw-boss-formula-list*
                         :redef-formulas (list :hole-dia 'rule2-screwb-hole-diameter
					       :thread-engage 'rule2-screwb-thread-engage
					       :boss-dia 'rule2-screwb-boss-diameter)
			 :as-default t
  )

(defun rule2-screwb-hole-diameter(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia 
		                                  :calc-var :hole-dia)))
    (unless screw-dia
      (return-from rule2-screwb-hole-diameter nil))
    (setq val (* 0.85 screw-dia))
    (list :hole-dia val) 
    ))

(defun rule2-screwb-thread-engage(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia 
		                                  :calc-var :thread-engage)))
    (unless screw-dia
      (return-from rule2-screwb-thread-engage nil))
    (setq val (* 2.2 screw-dia))
    (list :thread-engage val) 
    ))

(defun rule2-screwb-boss-diameter(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia 
		                                  :calc-var :boss-dia)))
    (unless screw-dia
      (return-from rule2-screwb-boss-diameter nil))
    (setq val (* 2.5  screw-dia))
    (unless (> val (+ 0.2 screw-dia))     ;; when boss-dia <= counterbore-dia
      (setq val (+ 1.0 screw-dia))) 
    (list :boss-dia val) 
    ))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(register-a-function-set :regi-keyword :demo_rule3
                         :regi-list *screw-boss-formula-list*
                         :redef-formulas (list :hole-dia 'rule3-screwb-hole-diameter
					       :thread-engage 'rule3-screwb-thread-engage
					       :boss-dia 'rule3-screwb-boss-diameter)
			 :as-default t
  )

(defun rule3-screwb-hole-diameter(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia 
		                                  :calc-var :hole-dia)))
    (unless screw-dia
      (return-from rule3-screwb-hole-diameter nil))
    (setq val (* 0.75 screw-dia))
    (list :hole-dia val) 
    ))

(defun rule3-screwb-thread-engage(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia 
		                                  :calc-var :thread-engage)))
    (unless screw-dia
      (return-from rule3-screwb-thread-engage nil))
    (setq val (* 1.7  screw-dia))
    (list :thread-engage val) 
    ))

(defun rule3-screwb-boss-diameter(known-args &aux val)
  (let ((screw-dia (inq-known-variable known-args :inq-var :screw-dia 
		                                  :calc-var :boss-dia)))
    (unless screw-dia
      (return-from rule3-screwb-boss-diameter nil))
    (setq val (* 1.85 screw-dia))
    (unless (> val (+ 0.2 screw-dia))     ;; when boss-dia <= counterbore-dia
      (setq val (+ 1.0 screw-dia))) 
    (list :boss-dia val) 
    ))

