Function D-KE-RATE


Slots on this function:

Documentation:
the kinetic energy differential of the fluid across the control volume
Instance-Of: Function, Quantity-function
Arity: 2
Range: Everywhere-continuous-quantity

Other Related Axioms:

(Inherited-Facet-Value 
    Slot-Documentation
    Control-Volume
    D-Ke-Rate
    The Kinetic Energy Differential Of The Fluid Across The Control Volume)

(Quantity.Dimension (D-Ke-Rate ?Self) Power-Dimension)

(Inherited-Facet-Value Slot-Cardinality Control-Volume D-Ke-Rate 1)

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Control-Volume ?Self)
        (And (Forall 
                 (?X)
                 (=> (Inlets ?Self ?X)
                     (And (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Pe-Rate ?X) ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Pe-Rate-In ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Ke-Rate ?X) ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Ke-Rate-In ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Enthalpy-Rate ?X)
                                                    ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At (Enthalpy-Rate-In ?Self)
                                                ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Mass-Rate ?X)
                                                    ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Mass-Rate-In ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Entropy-Rate ?X)
                                                    ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At (Entropy-Rate-In ?Self)
                                                ?T)))))))
             (Forall 
                 (?X)
                 (=> (Outlets ?Self ?X)
                     (And (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Pe-Rate ?X) ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Pe-Rate-Out ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Ke-Rate ?X) ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Ke-Rate-Out ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Enthalpy-Rate ?X)
                                                    ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Enthalpy-Rate-Out ?Self)
                                          ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Mass-Rate ?X)
                                                    ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Mass-Rate-Out ?Self)
                                              ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Entropy-Rate ?X)
                                                    ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At (Entropy-Rate-Out ?Self)
                                                ?T)))))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (D-Entropy-Rate ?Self) ?T)))
                (- (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Entropy-Rate-In ?Self) ?T)))
                   (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Entropy-Rate-Out ?Self) ?T)))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (D-Pe-Rate ?Self) ?T)))
                (- (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Pe-Rate-Out ?Self) ?T)))
                   (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Pe-Rate-In ?Self) ?T)))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (D-Ke-Rate ?Self) ?T)))
                (- (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Ke-Rate-Out ?Self) ?T)))
                   (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Ke-Rate-In ?Self) ?T))))))))

(Has-Quantity-Function Control-Volume D-Ke-Rate)

(Slot-Documentation 
    Control-Volume
    D-Ke-Rate
    The Kinetic Energy Differential Of The Fluid Across The Control Volume)

(=> (Control-Volume ?Self)
    (And (Value-Cardinality ?Self Enthalpy-Rate-In 1)
         (Quantity.Dimension (Enthalpy-Rate-In ?Self)
                             Power-Dimension)
         (Value-Cardinality ?Self Enthalpy-Rate-Out 1)
         (Quantity.Dimension (Enthalpy-Rate-Out ?Self)
                             Power-Dimension)
         (Value-Cardinality ?Self Entropy-Rate-In 1)
         (Quantity.Dimension (Entropy-Rate-In ?Self)
                             Entropy-Rate-Dimension)
         (Value-Cardinality ?Self Entropy-Rate-Out 1)
         (Quantity.Dimension (Entropy-Rate-Out ?Self)
                             Entropy-Rate-Dimension)
         (Value-Cardinality ?Self D-Entropy-Rate 1)
         (Quantity.Dimension (D-Entropy-Rate ?Self)
                             Entropy-Rate-Dimension)
         (Value-Cardinality ?Self Ke-Rate-In 1)
         (Quantity.Dimension (Ke-Rate-In ?Self) Power-Dimension)
         (Value-Cardinality ?Self Ke-Rate-Out 1)
         (Quantity.Dimension (Ke-Rate-Out ?Self) Power-Dimension)
         (Value-Cardinality ?Self Mass-Rate-In 1)
         (Quantity.Dimension (Mass-Rate-In ?Self)
                             Mass-Rate-Dimension)
         (Value-Cardinality ?Self Mass-Rate-Out 1)
         (Quantity.Dimension (Mass-Rate-Out ?Self)
                             Mass-Rate-Dimension)
         (Value-Cardinality ?Self Pe-Rate-In 1)
         (Quantity.Dimension (Pe-Rate-In ?Self) Power-Dimension)
         (Value-Cardinality ?Self Pe-Rate-Out 1)
         (Quantity.Dimension (Pe-Rate-Out ?Self) Power-Dimension)
         (Value-Cardinality ?Self Cv-Elevation 1)
         (Quantity.Dimension (Cv-Elevation ?Self) Length-Dimension)
         (Value-Cardinality ?Self Cv-Pe 1)
         (Quantity.Dimension (Cv-Pe ?Self) Energy-Dimension)
         (Value-Cardinality ?Self Cv-Ke 1)
         (Quantity.Dimension (Cv-Ke ?Self) Energy-Dimension)
         (Value-Cardinality ?Self Cv-Enthalpy 1)
         (Quantity.Dimension (Cv-Enthalpy ?Self) Energy-Dimension)
         (Value-Cardinality ?Self Cv-Entropy 1)
         (Quantity.Dimension (Cv-Entropy ?Self) Entropy-Dimension)
         (Value-Cardinality ?Self Cv-Internal-Energy 1)
         (Quantity.Dimension (Cv-Internal-Energy ?Self)
                             Energy-Dimension)
         (Value-Cardinality ?Self Cv-Energy 1)
         (Quantity.Dimension (Cv-Energy ?Self) Energy-Dimension)
         (Value-Cardinality ?Self Energy-Rate 1)
         (Quantity.Dimension (Energy-Rate ?Self)
                             Energy-Rate-Dimension)
         (Value-Cardinality ?Self Internal-Energy-Rate 1)
         (Quantity.Dimension (Internal-Energy-Rate ?Self)
                             Energy-Rate-Dimension)
         (Value-Cardinality ?Self Cv-Mass 1)
         (Quantity.Dimension (Cv-Mass ?Self) Mass-Dimension)
         (Value-Cardinality ?Self Cv-Volume 1)
         (Quantity.Dimension (Cv-Volume ?Self) Volume-Dimension)
         (Value-Cardinality ?Self D-Pe-Rate 1)
         (Quantity.Dimension (D-Pe-Rate ?Self) Power-Dimension)
         (Value-Cardinality ?Self D-Ke-Rate 1)
         (Quantity.Dimension (D-Ke-Rate ?Self) Power-Dimension)
         (Value-Cardinality ?Self Even-Pe 1)
         (Value-Cardinality ?Self Even-Ke 1)))

(=> (D-Ke-Rate $X $Y) (Everywhere-Continuous-Quantity $Y))

(Forall (?Self ?Time)
        (=> (Active ?Time Control-Volume-Negligible-Ke-Change ?Self)
            (= (Lambda (?T)
                       (If (= ?T ?Time)
                           (Value-At (D-Ke-Rate (Cv-Involved ?Self))
                                     ?T)))
               0)))

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Steady-State-Steady-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 (D-Pe-Rate ?Cv)
                                                     ?T)))
                               (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (D-Ke-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)))))))))
             (Forall (?Cv)
                     (=> (Process-Cv ?Self ?Cv)
                         (= (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 Steady-Flow-Adiabatic-Heat-Exchange ?Self)
            (And (= (Lambda (?T)
                            (If (= ?T ?Time)
                                (Value-At (Work-Rate ?Self) ?T)))
                    0)
                 (Forall (?Cv)
                         (=> (Process-Cv ?Self ?Cv)
                             (= (Lambda (?T)
                                        (If (= ?T ?Time)
                                            (Value-At (D-Ke-Rate ?Cv)
                                                      ?T)))
                                0)))
                 (Forall (?Cv)
                         (=> (Process-Cv ?Self ?Cv)
                             (= (Lambda (?T)
                                        (If (= ?T ?Time)
                                            (Value-At (D-Pe-Rate ?Cv)
                                                      ?T)))
                                0))))))

(Forall (?Self ?Time)
        (=> (Active ?Time Steady-Flow-Heat-Transfer ?Self)
            (And (= (Lambda (?T)
                            (If (= ?T ?Time)
                                (Value-At (Work-Rate ?Self) ?T)))
                    0)
                 (Forall (?Cv)
                         (=> (Process-Cv ?Self ?Cv)
                             (= (Lambda (?T)
                                        (If (= ?T ?Time)
                                            (Value-At (D-Ke-Rate ?Cv)
                                                      ?T)))
                                0)))
                 (Forall (?Cv)
                         (=> (Process-Cv ?Self ?Cv)
                             (= (Lambda (?T)
                                        (If (= ?T ?Time)
                                            (Value-At (D-Pe-Rate ?Cv)
                                                      ?T)))
                                0))))))