Function SPECIFIC-ENTHALPY


Slots on this function:

Documentation: the enthalpy per unit of mass
Instance-Of: Function, Quantity-function
Arity: 2
Range: Everywhere-continuous-quantity

Other Related Axioms:

(Inherited-Facet-Value Slot-Documentation
                       Stream
                       Specific-Enthalpy
                       The Enthalpy Per Unit Of Mass)

(Quantity.Dimension (Specific-Enthalpy ?Self)
                    Specific-Energy-Dimension)

(Inherited-Facet-Value Slot-Cardinality Stream Specific-Enthalpy 1)

(Has-Quantity-Function Stream Specific-Enthalpy)

(Slot-Documentation Stream
                    Specific-Enthalpy
                    The Enthalpy Per Unit Of Mass)

(=> (Stream ?Self)
    (And (Value-Cardinality ?Self Stream-Elevation 1)
         (Quantity.Dimension (Stream-Elevation ?Self)
                             Length-Dimension)
         (Value-Cardinality ?Self Enthalpy-Rate 1)
         (Quantity.Dimension (Enthalpy-Rate ?Self) Power-Dimension)
         (Value-Cardinality ?Self Entropy-Rate 1)
         (Quantity.Dimension (Entropy-Rate ?Self)
                             Entropy-Rate-Dimension)
         (Value-Cardinality ?Self Ke-Rate 1)
         (Quantity.Dimension (Ke-Rate ?Self) Power-Dimension)
         (Value-Cardinality ?Self Mass-Rate 1)
         (Quantity.Dimension (Mass-Rate ?Self) Mass-Rate-Dimension)
         (Value-Cardinality ?Self Pe-Rate 1)
         (Quantity.Dimension (Pe-Rate ?Self) Power-Dimension)
         (Value-Cardinality ?Self Stream-Pressure 1)
         (Quantity.Dimension (Stream-Pressure ?Self)
                             Pressure-Dimension)
         (Value-Cardinality ?Self Specific-Enthalpy 1)
         (Quantity.Dimension (Specific-Enthalpy ?Self)
                             Specific-Energy-Dimension)
         (Value-Cardinality ?Self Specific-Entropy 1)
         (Quantity.Dimension (Specific-Entropy ?Self)
                             Specific-Entropy-Dimension)
         (Value-Cardinality ?Self Specific-Internal-Energy 1)
         (Quantity.Dimension (Specific-Internal-Energy ?Self)
                             Specific-Energy-Dimension)
         (Value-Cardinality ?Self Stream-Temperature 1)
         (Quantity.Dimension (Stream-Temperature ?Self)
                             Temperature-Dimension)
         (Value-Cardinality ?Self Velocity 1)
         (Quantity.Dimension (Velocity ?Self) Velocity-Dimension)
         (Value-Cardinality ?Self Quality 1)
         (Quantity.Dimension (Quality ?Self) Dimensionless)
         (Value-Cardinality ?Self Specific-Volume 1)
         (Quantity.Dimension (Specific-Volume ?Self)
                             Specific-Volume-Dimension)
         (Value-Cardinality ?Self Saturated-P 1)))

(=> (Specific-Enthalpy $X $Y) (Everywhere-Continuous-Quantity $Y))

(Forall (?Self ?Time)
        (=> (Active ?Time Stream-Junction ?Self)
            (And (All= ?Time
                       (Setofall ?X
                                 (And (Connected-Terminals ?Self
                                                           ?Terminal)
                                      (Mass-Rate ?Terminal ?X))))
                 (All= ?Time
                       (Setofall ?X
                                 (And (Connected-Terminals ?Self
                                                           ?Terminal)
                                      (Stream-Pressure ?Terminal ?X))))
                 (All= ?Time
                       (Setofall ?X
                                 (And (Connected-Terminals ?Self
                                                           ?Terminal)
                                      (Specific-Enthalpy ?Terminal
                                                         ?X))))
                 (All= ?Time
                       (Setofall ?X
                                 (And (Connected-Terminals ?Self
                                                           ?Terminal)
                                      (Specific-Entropy ?Terminal ?X))))
                 (All= ?Time
                       (Setofall 
                           ?X
                           (And (Connected-Terminals ?Self ?Terminal)
                                (Specific-Internal-Energy ?Terminal
                                                          ?X))))
                 (All= ?Time
                       (Setofall ?X
                                 (And (Connected-Terminals ?Self
                                                           ?Terminal)
                                      (Stream-Temperature ?Terminal
                                                          ?X))))
                 (All= ?Time
                       (Setofall ?X
                                 (And (Connected-Terminals ?Self
                                                           ?Terminal)
                                      (Quality ?Terminal ?X))))
                 (All= ?Time
                       (Setofall ?X
                                 (And (Connected-Terminals ?Self
                                                           ?Terminal)
                                      (Specific-Volume ?Terminal ?X)))))))

(Forall 
    (?Self ?Time)
    (=> (Active ?Time
                Control-Volume-Inlet-Stream-Thermodynamic-State
                ?Self)
        (Forall 
            (?X)
            (=> (Inlets (Cv-Involved ?Self) ?X)
                (= (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Specific-Enthalpy ?X) ?T)))
                   (Compute-Air-Thermodynamic-State 
                       (Lambda (?T)
                               (If (= ?T ?Time)
                                   (Value-At (Stream-Temperature ?X)
                                             ?T)))))))))

(Forall 
    (?Self ?Time)
    (=> (Active ?Time
                Control-Volume-Outlet-Stream-Thermodynamic-State
                ?Self)
        (Forall 
            (?X)
            (=> (Outlets (Cv-Involved ?Self) ?X)
                (= (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Specific-Enthalpy ?X) ?T)))
                   (Compute-Air-Thermodynamic-State 
                       (Lambda (?T)
                               (If (= ?T ?Time)
                                   (Value-At (Stream-Temperature ?X)
                                             ?T)))))))))

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Non-Saturated-Water-Stream-Enthalpy ?Self)
        (= (Lambda 
               (?T)
               (If (= ?T ?Time)
                   (Value-At 
                       (Specific-Enthalpy (2d-Stream-Involved ?Self))
                       ?T)))
           (+ (Compute-Saturated-Vapor-Enthalpy 
                  (Lambda 
                      (?T)
                      (If (= ?T ?Time)
                          (Value-At 
                              (Stream-Pressure 
                                  (2d-Stream-Involved ?Self))
                              ?T)))
                  0)
              (* (Lambda (?T)
                         (If (= ?T ?Time)
                             (Value-At 
                                 (Quality (2d-Stream-Involved ?Self))
                                 ?T)))
                 (- (Compute-Saturated-Vapor-Enthalpy 
                        (Lambda 
                            (?T)
                            (If (= ?T ?Time)
                                (Value-At 
                                    (Stream-Pressure 
                                        (2d-Stream-Involved ?Self))
                                    ?T)))
                        1)
                    (Compute-Saturated-Vapor-Enthalpy 
                        (Lambda 
                            (?T)
                            (If (= ?T ?Time)
                                (Value-At 
                                    (Stream-Pressure 
                                        (2d-Stream-Involved ?Self))
                                    ?T)))
                        0)))))))

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Saturated-Water-Stream-Enthalpy ?Self)
        (= (Lambda 
               (?T)
               (If (= ?T ?Time)
                   (Value-At 
                       (Specific-Enthalpy (2d-Stream-Involved ?Self))
                       ?T)))
           (Compute-Saturated-Vapor-Enthalpy 
               (Lambda 
                   (?T)
                   (If (= ?T ?Time)
                       (Value-At 
                           (Stream-Pressure (2d-Stream-Involved ?Self))
                           ?T)))
               (Lambda (?T)
                       (If (= ?T ?Time)
                           (Value-At (Quality (2d-Stream-Involved ?Self))
                                     ?T)))))))

(Forall 
    (?Self ?Time)
    (=> (Active ?Time 2d-Stream-Enthalpy-Rate ?Self)
        (= (Lambda (?T)
                   (If (= ?T ?Time)
                       (Value-At 
                           (Enthalpy-Rate (2d-Stream-Involved ?Self))
                           ?T)))
           (* (Lambda (?T)
                      (If (= ?T ?Time)
                          (Value-At (Mass-Rate 
                                        (2d-Stream-Involved ?Self))
                                    ?T)))
              (Lambda 
                  (?T)
                  (If (= ?T ?Time)
                      (Value-At 
                          (Specific-Enthalpy (2d-Stream-Involved ?Self))
                          ?T)))))))

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Steady-Flow-Adiabatic-Expansion ?Self)
        (And (Forall 
                 (?Cv)
                 (=> (Process-Cv ?Self ?Cv)
                     (= (Lambda (?T)
                                (If (= ?T ?Time)
                                    (Value-At 
                                        (Quality (Outlet-Stream ?Cv))
                                        ?T)))
                        (/ (- (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Specific-Entropy 
                                              (Outlet-Stream ?Cv))
                                          ?T)))
                              (Compute-Saturated-Vapor-Entropy 
                                  (Lambda 
                                      (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Stream-Pressure 
                                                  (Outlet-Stream ?Cv))
                                              ?T)))
                                  0))
                           (- (Compute-Saturated-Vapor-Entropy 
                                  (Lambda 
                                      (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Stream-Pressure 
                                                  (Outlet-Stream ?Cv))
                                              ?T)))
                                  1)
                              (Compute-Saturated-Vapor-Entropy 
                                  (Lambda 
                                      (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Stream-Pressure 
                                                  (Outlet-Stream ?Cv))
                                              ?T)))
                                  0))))))
             (Forall 
                 (?Cv)
                 (=> (Process-Cv ?Self ?Cv)
                     (= (Lambda 
                            (?T)
                            (If (= ?T ?Time)
                                (Value-At (Isentropic-Efficiency ?Self)
                                          ?T)))
                        (/ (- (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Specific-Enthalpy 
                                              (Inlet-Stream ?Cv))
                                          ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Specific-Enthalpy 
                                              (Outlet-Stream ?Cv))
                                          ?T))))
                           (- (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Specific-Enthalpy 
                                              (Inlet-Stream ?Cv))
                                          ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Ideal-Isentropic-Enthalpy ?Self)
                                          ?T))))))))
             (Forall 
                 (?Cv)
                 (=> (Process-Cv ?Self ?Cv)
                     (= (Lambda 
                            (?T)
                            (If (= ?T ?Time)
                                (Value-At 
                                    (Expansion-Isentropic-Efficiency ?Self)
                                    ?T)))
                        (/ (- (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Specific-Enthalpy 
                                              (Inlet-Stream ?Cv))
                                          ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Specific-Enthalpy 
                                              (Outlet-Stream ?Cv))
                                          ?T))))
                           (- (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Specific-Enthalpy 
                                              (Inlet-Stream ?Cv))
                                          ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Ideal-Isentropic-Enthalpy ?Self)
                                          ?T)))))))))))

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Steady-Flow-Adiabatic-Compression ?Self)
        (And (Forall 
                 (?Cv)
                 (=> (Process-Cv ?Self ?Cv)
                     (= (Lambda 
                            (?T)
                            (If (= ?T ?Time)
                                (Value-At 
                                    (Compression-Isentropic-Efficiency ?Self)
                                    ?T)))
                        (/ (- (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Ideal-Isentropic-Enthalpy ?Self)
                                          ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Specific-Enthalpy 
                                              (Inlet-Stream ?Cv))
                                          ?T))))
                           (- (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Specific-Enthalpy 
                                              (Outlet-Stream ?Cv))
                                          ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Specific-Enthalpy 
                                              (Inlet-Stream ?Cv))
                                          ?T))))))))
             (Forall 
                 (?Cv)
                 (=> (Process-Cv ?Self ?Cv)
                     (= (Lambda 
                            (?T)
                            (If (= ?T ?Time)
                                (Value-At (Isentropic-Efficiency ?Self)
                                          ?T)))
                        (/ (- (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Specific-Enthalpy 
                                              (Outlet-Stream ?Cv))
                                          ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Specific-Enthalpy 
                                              (Inlet-Stream ?Cv))
                                          ?T))))
                           (- (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Ideal-Isentropic-Enthalpy ?Self)
                                          ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Specific-Enthalpy 
                                              (Inlet-Stream ?Cv))
                                          ?T))))))))
             (Forall 
                 (?Cv)
                 (=> (Process-Cv ?Self ?Cv)
                     (= (Lambda (?T)
                                (If (= ?T ?Time)
                                    (Value-At 
                                        (Power-Input-Per-Mass ?Self)
                                        ?T)))
                        (- (Lambda 
                               (?T)
                               (If (= ?T ?Time)
                                   (Value-At 
                                       (Specific-Enthalpy 
                                           (Outlet-Stream ?Cv))
                                       ?T)))
                           (Lambda 
                               (?T)
                               (If (= ?T ?Time)
                                   (Value-At 
                                       (Specific-Enthalpy 
                                           (Inlet-Stream ?Cv))
                                       ?T))))))))))

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Power-System-Eight-One ?Self)
        (And (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (Thermal-Efficiency ?Self) ?T)))
                (/ (- (- (Lambda 
                             (?T)
                             (If (= ?T ?Time)
                                 (Value-At 
                                     (Specific-Enthalpy 
                                         (Outlet-Stream 
                                             (Blr-Cv (Blr-System ?Self))))
                                     ?T)))
                         (Lambda 
                             (?T)
                             (If (= ?T ?Time)
                                 (Value-At 
                                     (Specific-Enthalpy 
                                         (Outlet-Stream 
                                             (Tbn-Cv (Tbn-System ?Self))))
                                     ?T))))
                      (- (Lambda 
                             (?T)
                             (If (= ?T ?Time)
                                 (Value-At 
                                     (Specific-Enthalpy 
                                         (Outlet-Stream 
                                             (Pmp-Cv (Pmp-System ?Self))))
                                     ?T)))
                         (Lambda 
                             (?T)
                             (If (= ?T ?Time)
                                 (Value-At 
                                     (Specific-Enthalpy 
                                         (Outlet-Stream 
                                             (Hf-Cv (Cdnsr-System ?Self))))
                                     ?T)))))
                   (- (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Blr-Cv (Blr-System ?Self))))
                                  ?T)))
                      (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Pmp-Cv (Pmp-System ?Self))))
                                  ?T))))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (Back-Work-Ratio ?Self) ?T)))
                (/ (- (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Pmp-Cv (Pmp-System ?Self))))
                                  ?T)))
                      (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Hf-Cv (Cdnsr-System ?Self))))
                                  ?T))))
                   (- (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Blr-Cv (Blr-System ?Self))))
                                  ?T)))
                      (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Tbn-Cv (Tbn-System ?Self))))
                                  ?T))))))
             (= (Lambda 
                    (?T)
                    (If (= ?T ?Time)
                        (Value-At (Heat-Rate 
                                      (Htfr-Prcs (Blr-System ?Self)))
                                  ?T)))
                (* (Lambda 
                       (?T)
                       (If (= ?T ?Time)
                           (Value-At 
                               (Mass-Rate-In (Blr-Cv (Blr-System ?Self)))
                               ?T)))
                   (- (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Blr-Cv (Blr-System ?Self))))
                                  ?T)))
                      (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Pmp-Cv (Pmp-System ?Self))))
                                  ?T))))
                   (/ 1 3600000)))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (Cycle-Mass-Rate ?Self) ?T)))
                (* 3.6
                   (/ (Lambda (?T)
                              (If (= ?T ?Time)
                                  (Value-At (Net-Work-Output-Rate ?Self)
                                            ?T)))
                      (- (- (Lambda 
                                (?T)
                                (If (= ?T ?Time)
                                    (Value-At 
                                        (Specific-Enthalpy 
                                            (Outlet-Stream 
                                                (Blr-Cv 
                                                    (Blr-System ?Self))))
                                        ?T)))
                            (Lambda 
                                (?T)
                                (If (= ?T ?Time)
                                    (Value-At 
                                        (Specific-Enthalpy 
                                            (Outlet-Stream 
                                                (Tbn-Cv 
                                                    (Tbn-System ?Self))))
                                        ?T))))
                         (- (Lambda 
                                (?T)
                                (If (= ?T ?Time)
                                    (Value-At 
                                        (Specific-Enthalpy 
                                            (Outlet-Stream 
                                                (Pmp-Cv 
                                                    (Pmp-System ?Self))))
                                        ?T)))
                            (Lambda 
                                (?T)
                                (If (= ?T ?Time)
                                    (Value-At 
                                        (Specific-Enthalpy 
                                            (Outlet-Stream 
                                                (Hf-Cv (Cdnsr-System ?Self))))
                                        ?T))))))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (Cycle-Mass-Rate ?Self) ?T)))
                (Lambda 
                    (?T)
                    (If (= ?T ?Time)
                        (Value-At (Mass-Rate-In 
                                      (Blr-Cv (Blr-System ?Self)))
                                  ?T))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (Cycle-Mass-Rate ?Self) ?T)))
                (Lambda 
                    (?T)
                    (If (= ?T ?Time)
                        (Value-At (Mass-Rate-In 
                                      (Tbn-Cv (Tbn-System ?Self)))
                                  ?T))))
             (= (Lambda 
                    (?T)
                    (If (= ?T ?Time)
                        (Value-At 
                            (Condensor-Heat-Out-Rate 
                                (Cdnsr-System ?Self))
                            ?T)))
                (* (Lambda 
                       (?T)
                       (If (= ?T ?Time)
                           (Value-At 
                               (Cycle-Mass-Rate 
                                   (Hf-Cv (Cdnsr-System ?Self)))
                               ?T)))
                   (- (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Tbn-Cv (Tbn-System ?Self))))
                                  ?T)))
                      (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Hf-Cv (Cdnsr-System ?Self))))
                                  ?T)))))))))