Class STEADY-FLOW-ADIABATIC-COMPRESSION

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

Slots on this class:

Documentation:

the class of steady flow compression processes taking place without interacting thermally with the external world

Instance-Of: Class

Subclass-Of: Model-fragment, Steady-flow-adiabatic-process, Steady-flow-compression

Arity: 1

Compression-Isentropic-Efficiency:

Slot-Documentation:

the isentropic efficiency of the compression process

Has-Quantity-Function: Compression-isentropic-efficiency

Range-Of: Adbtc-cmpsn-prcs

---

Slots on instances of this class:

Compression-Isentropic-Efficiency:

Slot-Cardinality: 1

Slot-Documentation:

the isentropic efficiency of the compression process

Axioms:

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

(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 Steady-Flow-Adiabatic-Compression ?Self)
             (And (Steady-Flow-Adiabatic-Compression ?Self)
                  (Active ?Time Steady-Flow-Compression ?Self)
                  (Active ?Time Steady-Flow-Adiabatic-Process ?Self))))

Other Related Axioms:

(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 Steady-Flow-Adiabatic-Compression ?Self)
             (And (Steady-Flow-Adiabatic-Compression ?Self)
                  (Active ?Time Steady-Flow-Compression ?Self)
                  (Active ?Time Steady-Flow-Adiabatic-Process ?Self))))

(Quantity-Function-Of Compression-Isentropic-Efficiency
                      Steady-Flow-Adiabatic-Compression)

(Inherited-Facet-Value Slot-Value-Type
                       Pump-System
                       Adbtc-Cmpsn-Prcs
                       Steady-Flow-Adiabatic-Compression)

(=> (Pump-System ?Self)
    (And (Value-Cardinality ?Self Pmp 1)
         (Value-Type ?Self Pmp Pump)
         (Value-Cardinality ?Self Pmp 1)
         (Value-Cardinality ?Self Pmp-Cv 1)
         (Value-Type ?Self Pmp-Cv 1-1-Control-Volume)
         (Value-Cardinality ?Self Pmp-Cv 1)
         (Value-Cardinality ?Self Adbtc-Cmpsn-Prcs 1)
         (Value-Type ?Self
                     Adbtc-Cmpsn-Prcs
                     Steady-Flow-Adiabatic-Compression)
         (Value-Cardinality ?Self Adbtc-Cmpsn-Prcs 1)
         (Value-Cardinality ?Self Water-In-Pmp 1)
         (Value-Type ?Self Water-In-Pmp Water)
         (Value-Cardinality ?Self Water-In-Pmp 1)
         (Cv-Component (Pmp-Cv ?Self) (Pmp ?Self))
         (Component-Cv (Pmp ?Self) (Pmp-Cv ?Self))
         (Process-Cv (Adbtc-Cmpsn-Prcs ?Self) (Pmp-Cv ?Self))
         (Substance-In (Pmp-Cv ?Self) (Water-In-Pmp ?Self))
         (Substance-In (Inlet-Stream (Pmp-Cv ?Self))
                       (Water-In-Pmp ?Self))
         (Substance-In (Outlet-Stream (Pmp-Cv ?Self))
                       (Water-In-Pmp ?Self))))

(=> (Adbtc-Cmpsn-Prcs $X $Y) (Steady-Flow-Adiabatic-Compression $Y))