Function COMPUTE-SATURATED-VAPOR-ENTROPY

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

Slots on this function:

Documentation:

Computes the specific entropy of saturated vapor from the quality (0 or 1) and the pressure.

Eg: (compute-saturated-vapor-entropy (stream-pressure (stream-involved ?self))
(quality (stream-involved ?self)))

We don't know how to compute this yet. It will be a call to an outside routine or a table lookup.

Instance-Of: Function

Arity: 3

Other Related Axioms:

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Saturated-Water-Stream-Entropy ?Self)
        (= (Lambda 
               (?T)
               (If (= ?T ?Time)
                   (Value-At (Specific-Entropy 
                                 (2d-Stream-Involved ?Self))
                             ?T)))
           (Compute-Saturated-Vapor-Entropy 
               (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 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)))))))))))