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

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

Arity: 1

Has-Quantity-Function: Compression-isentropic-efficiency

---

Slots on instances of this class:

Compression-Isentropic-Efficiency:

Slot-Cardinality: 1

Slot-Documentation:

the isentropic efficiency of the compression process

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

(=> (Steady-Flow-Adiabatic-Compression ?Self)
    (Quantity.Dimension (Compression-Isentropic-Efficiency ?Self)
                        Dimensionless))