Function ISENTROPIC-EFFICIENCY

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

Slots on this function:

Documentation:

the measure of comparison between the actual performance of a device and the performance that would be achieved under idealized circumstances for the same inlet state and the same exit pressure

Instance-Of: Function, Quantity-function

Arity: 2

Range: Everywhere-continuous-quantity

Other Related Axioms:

(Inherited-Facet-Value 
    Slot-Documentation
    Steady-Flow-Expansion-Or-Compression
    Isentropic-Efficiency
    The Measure Of Comparison Between The Actual Performance Of A Device And The Performance That Would Be Achieved Under Idealized Circumstances For The Same Inlet State And The Same Exit Pressure)

(Quantity.Dimension (Isentropic-Efficiency ?Self) Dimensionless)

(Inherited-Facet-Value Slot-Cardinality
                       Steady-Flow-Expansion-Or-Compression
                       Isentropic-Efficiency
                       1)

(Has-Quantity-Function Steady-Flow-Expansion-Or-Compression
                       Isentropic-Efficiency)

(Slot-Documentation 
    Steady-Flow-Expansion-Or-Compression
    Isentropic-Efficiency
    The Measure Of Comparison Between The Actual Performance Of A Device And The Performance That Would Be Achieved Under Idealized Circumstances For The Same Inlet State And The Same Exit Pressure)

(=> (Steady-Flow-Expansion-Or-Compression ?Self)
    (And (Value-Cardinality ?Self Isentropic-Efficiency 1)
         (Quantity.Dimension (Isentropic-Efficiency ?Self)
                             Dimensionless)
         (Value-Cardinality ?Self Ideal-Isentropic-Enthalpy 1)
         (Quantity.Dimension (Ideal-Isentropic-Enthalpy ?Self)
                             Energy-Dimension)))

(=> (Isentropic-Efficiency $X $Y)
    (Everywhere-Continuous-Quantity $Y))

(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))))))))))