Class NON-STEADY-STATE-FLOW-PROCESS

• Defined in theory: Thermal-system
• Source code: thermal-system.ol

Slots on this class:

Documentation:

the general (i.e. non-steady state) flow process model employing the first law of thermodynamics (Energy conservation) and mass conservation.

Instance-Of: Class

Subclass-Of: Model-fragment, Thermal-process

Arity: 1

Axioms:

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Non-Steady-State-Flow-Process ?Self)
        (And (Forall (?Cv)
                     (=> (Process-Cv ?Self ?Cv)
                         (= (- (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (Heat-Rate ?Self)
                                                     ?T)))
                               (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (Work-Rate ?Self)
                                                     ?T))))
                            (+ (- (Lambda 
                                      (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Enthalpy-Rate-Out ?Cv)
                                              ?T)))
                                  (Lambda 
                                      (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Enthalpy-Rate-In ?Cv)
                                              ?T))))
                               (- (Lambda (?T)
                                          (If (= ?T ?Time)
                                              (Value-At 
                                                  (Pe-Rate-Out ?Cv)
                                                  ?T)))
                                  (Lambda (?T)
                                          (If (= ?T ?Time)
                                              (Value-At (Pe-Rate-In ?Cv)
                                                        ?T))))
                               (- (Lambda (?T)
                                          (If (= ?T ?Time)
                                              (Value-At 
                                                  (Ke-Rate-Out ?Cv)
                                                  ?T)))
                                  (Lambda (?T)
                                          (If (= ?T ?Time)
                                              (Value-At (Ke-Rate-In ?Cv)
                                                        ?T))))
                               (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (Energy-Rate ?Cv)
                                                     ?T)))))))
             (Forall 
                 (?Cv)
                 (=> (Process-Cv ?Self ?Cv)
                     (= (Lambda (?T)
                                (If (= ?T ?Time)
                                    (Value-At (Energy-Rate ?Cv) ?T)))
                        (+ (Lambda 
                               (?T)
                               (If (= ?T ?Time)
                                   (Value-At (Internal-Energy-Rate ?Cv)
                                             ?T)))
                           (Lambda (?T)
                                   (If (= ?T ?Time)
                                       (Value-At (Ke-Rate ?Cv) ?T)))
                           (Lambda (?T)
                                   (If (= ?T ?Time)
                                       (Value-At (Pe-Rate ?Cv) ?T)))))))
             (Forall 
                 (?Cv)
                 (=> (Process-Cv ?Self ?Cv)
                     (= (Lambda 
                            (?T)
                            (If (= ?T ?Time)
                                (Value-At 
                                    (Entropy-Generation-Rate ?Self)
                                    ?T)))
                        (+ (- (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Entropy-Rate-Out ?Cv)
                                              ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Entropy-Rate-In ?Cv)
                                              ?T))))
                           (- (/ (Lambda (?T)
                                         (If (= ?T ?Time)
                                             (Value-At (Heat-Rate ?Self)
                                                       ?T)))
                                 (Lambda 
                                     (?T)
                                     (If (= ?T ?Time)
                                         (Value-At 
                                             (Heat-Transfer-Temperature ?Self)
                                             ?T)))))
                           (Lambda (?T)
                                   (If (= ?T ?Time)
                                       (Value-At (Entropy-Rate ?Cv)
                                                 ?T)))))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (Irreversibility-Rate ?Self)
                                      ?T)))
                (* (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Entropy-Generation-Rate ?Self)
                                         ?T)))
                   (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At 
                                   (State-Temperature *Dead-State*)
                                   ?T)))))
             (Forall (?Cv)
                     (=> (Process-Cv ?Self ?Cv)
                         (= (Lambda (?T)
                                    (If (= ?T ?Time)
                                        (Value-At (Mass-Rate ?Cv) ?T)))
                            (- (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (Mass-Rate-In ?Cv)
                                                     ?T)))
                               (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (Mass-Rate-Out ?Cv)
                                                     ?T))))))))))

(Forall (?Self ?Time)
        (<=> (Active ?Time Non-Steady-State-Flow-Process ?Self)
             (And (Non-Steady-State-Flow-Process ?Self)
                  (Active ?Time Thermal-Process ?Self))))

Other Related Axioms:

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Non-Steady-State-Flow-Process ?Self)
        (And (Forall (?Cv)
                     (=> (Process-Cv ?Self ?Cv)
                         (= (- (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (Heat-Rate ?Self)
                                                     ?T)))
                               (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (Work-Rate ?Self)
                                                     ?T))))
                            (+ (- (Lambda 
                                      (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Enthalpy-Rate-Out ?Cv)
                                              ?T)))
                                  (Lambda 
                                      (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Enthalpy-Rate-In ?Cv)
                                              ?T))))
                               (- (Lambda (?T)
                                          (If (= ?T ?Time)
                                              (Value-At 
                                                  (Pe-Rate-Out ?Cv)
                                                  ?T)))
                                  (Lambda (?T)
                                          (If (= ?T ?Time)
                                              (Value-At (Pe-Rate-In ?Cv)
                                                        ?T))))
                               (- (Lambda (?T)
                                          (If (= ?T ?Time)
                                              (Value-At 
                                                  (Ke-Rate-Out ?Cv)
                                                  ?T)))
                                  (Lambda (?T)
                                          (If (= ?T ?Time)
                                              (Value-At (Ke-Rate-In ?Cv)
                                                        ?T))))
                               (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (Energy-Rate ?Cv)
                                                     ?T)))))))
             (Forall 
                 (?Cv)
                 (=> (Process-Cv ?Self ?Cv)
                     (= (Lambda (?T)
                                (If (= ?T ?Time)
                                    (Value-At (Energy-Rate ?Cv) ?T)))
                        (+ (Lambda 
                               (?T)
                               (If (= ?T ?Time)
                                   (Value-At (Internal-Energy-Rate ?Cv)
                                             ?T)))
                           (Lambda (?T)
                                   (If (= ?T ?Time)
                                       (Value-At (Ke-Rate ?Cv) ?T)))
                           (Lambda (?T)
                                   (If (= ?T ?Time)
                                       (Value-At (Pe-Rate ?Cv) ?T)))))))
             (Forall 
                 (?Cv)
                 (=> (Process-Cv ?Self ?Cv)
                     (= (Lambda 
                            (?T)
                            (If (= ?T ?Time)
                                (Value-At 
                                    (Entropy-Generation-Rate ?Self)
                                    ?T)))
                        (+ (- (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Entropy-Rate-Out ?Cv)
                                              ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Entropy-Rate-In ?Cv)
                                              ?T))))
                           (- (/ (Lambda (?T)
                                         (If (= ?T ?Time)
                                             (Value-At (Heat-Rate ?Self)
                                                       ?T)))
                                 (Lambda 
                                     (?T)
                                     (If (= ?T ?Time)
                                         (Value-At 
                                             (Heat-Transfer-Temperature ?Self)
                                             ?T)))))
                           (Lambda (?T)
                                   (If (= ?T ?Time)
                                       (Value-At (Entropy-Rate ?Cv)
                                                 ?T)))))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (Irreversibility-Rate ?Self)
                                      ?T)))
                (* (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Entropy-Generation-Rate ?Self)
                                         ?T)))
                   (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At 
                                   (State-Temperature *Dead-State*)
                                   ?T)))))
             (Forall (?Cv)
                     (=> (Process-Cv ?Self ?Cv)
                         (= (Lambda (?T)
                                    (If (= ?T ?Time)
                                        (Value-At (Mass-Rate ?Cv) ?T)))
                            (- (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (Mass-Rate-In ?Cv)
                                                     ?T)))
                               (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (Mass-Rate-Out ?Cv)
                                                     ?T))))))))))

(Forall (?Self ?Time)
        (<=> (Active ?Time Non-Steady-State-Flow-Process ?Self)
             (And (Non-Steady-State-Flow-Process ?Self)
                  (Active ?Time Thermal-Process ?Self))))