Class STEADY-STATE-STEADY-FLOW-PROCESS

Slots on this class:

Documentation:
the model of a steady flow in steady state employing the first law of thermodynamics (Energy conservation) and mass conservation
Instance-Of: Class
Subclass-Of: Model-fragment, Thermal-process
Arity: 1
Has-Quantity-Function: Power-input-per-mass
Power-Input-Per-Mass:
Slot-Documentation:
the rate of power input per unit of mass passing through the cv associated with the process
Range-Of: Undergoing
Superclass-Of:
Steady-flow-adiabatic-process, Steady-flow-compression, Steady-flow-expansion-or-compression, Steady-flow-heat-transfer, Steady-flow-isobaric-process, Steady-flow-isothermal-process

Slots on instances of this class:

Power-Input-Per-Mass:
Slot-Cardinality: 1
Slot-Documentation:
the rate of power input per unit of mass passing through the cv associated with the process

Axioms:

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Steady-State-Steady-Flow-Process ?Self)
        (And (Forall (?Cv)
                     (=> (Process-Cv ?Self ?Cv)
                         (= (- (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (Heat-Rate ?Self)
                                                     ?T)))
                               (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (Work-Rate ?Self)
                                                     ?T))))
                            (+ (- (Lambda 
                                      (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Enthalpy-Rate-Out ?Cv)
                                              ?T)))
                                  (Lambda 
                                      (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Enthalpy-Rate-In ?Cv)
                                              ?T))))
                               (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (D-Pe-Rate ?Cv)
                                                     ?T)))
                               (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (D-Ke-Rate ?Cv)
                                                     ?T)))))))
             (Forall 
                 (?Cv)
                 (=> (Process-Cv ?Self ?Cv)
                     (= (Lambda 
                            (?T)
                            (If (= ?T ?Time)
                                (Value-At 
                                    (Entropy-Generation-Rate ?Self)
                                    ?T)))
                        (+ (- (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Entropy-Rate-Out ?Cv)
                                              ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Entropy-Rate-In ?Cv)
                                              ?T))))
                           (- (/ (Lambda (?T)
                                         (If (= ?T ?Time)
                                             (Value-At (Heat-Rate ?Self)
                                                       ?T)))
                                 (Lambda 
                                     (?T)
                                     (If (= ?T ?Time)
                                         (Value-At 
                                             (Heat-Transfer-Temperature ?Self)
                                             ?T)))))))))
             (Forall (?Cv)
                     (=> (Process-Cv ?Self ?Cv)
                         (= (Lambda (?T)
                                    (If (= ?T ?Time)
                                        (Value-At (Mass-Rate-In ?Cv)
                                                  ?T)))
                            (Lambda (?T)
                                    (If (= ?T ?Time)
                                        (Value-At (Mass-Rate-Out ?Cv)
                                                  ?T)))))))))

(Forall (?Self ?Time)
        (<=> (Active ?Time Steady-State-Steady-Flow-Process ?Self)
             (And (Steady-State-Steady-Flow-Process ?Self)
                  (Active ?Time Thermal-Process ?Self))))

Other Related Axioms:

(=> (Undergoing $X $Y) (Steady-State-Steady-Flow-Process $Y))

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Steady-State-Steady-Flow-Process ?Self)
        (And (Forall (?Cv)
                     (=> (Process-Cv ?Self ?Cv)
                         (= (- (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (Heat-Rate ?Self)
                                                     ?T)))
                               (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (Work-Rate ?Self)
                                                     ?T))))
                            (+ (- (Lambda 
                                      (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Enthalpy-Rate-Out ?Cv)
                                              ?T)))
                                  (Lambda 
                                      (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Enthalpy-Rate-In ?Cv)
                                              ?T))))
                               (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (D-Pe-Rate ?Cv)
                                                     ?T)))
                               (Lambda (?T)
                                       (If (= ?T ?Time)
                                           (Value-At (D-Ke-Rate ?Cv)
                                                     ?T)))))))
             (Forall 
                 (?Cv)
                 (=> (Process-Cv ?Self ?Cv)
                     (= (Lambda 
                            (?T)
                            (If (= ?T ?Time)
                                (Value-At 
                                    (Entropy-Generation-Rate ?Self)
                                    ?T)))
                        (+ (- (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Entropy-Rate-Out ?Cv)
                                              ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Entropy-Rate-In ?Cv)
                                              ?T))))
                           (- (/ (Lambda (?T)
                                         (If (= ?T ?Time)
                                             (Value-At (Heat-Rate ?Self)
                                                       ?T)))
                                 (Lambda 
                                     (?T)
                                     (If (= ?T ?Time)
                                         (Value-At 
                                             (Heat-Transfer-Temperature ?Self)
                                             ?T)))))))))
             (Forall (?Cv)
                     (=> (Process-Cv ?Self ?Cv)
                         (= (Lambda (?T)
                                    (If (= ?T ?Time)
                                        (Value-At (Mass-Rate-In ?Cv)
                                                  ?T)))
                            (Lambda (?T)
                                    (If (= ?T ?Time)
                                        (Value-At (Mass-Rate-Out ?Cv)
                                                  ?T)))))))))

(Forall (?Self ?Time)
        (<=> (Active ?Time Steady-State-Steady-Flow-Process ?Self)
             (And (Steady-State-Steady-Flow-Process ?Self)
                  (Active ?Time Thermal-Process ?Self))))

(=> (Steady-State-Steady-Flow-Process ?Self)
    (Value-Cardinality ?Self Power-Input-Per-Mass 1))

(Quantity-Function-Of Power-Input-Per-Mass
                      Steady-State-Steady-Flow-Process)

(Forall (?Self ?Time)
        (<=> (Active ?Time Steady-Flow-Adiabatic-Process ?Self)
             (And (Steady-Flow-Adiabatic-Process ?Self)
                  (Active ?Time
                          Steady-State-Steady-Flow-Process
                          ?Self))))

(Forall (?Self ?Time)
        (<=> (Active ?Time Steady-Flow-Isobaric-Process ?Self)
             (And (Steady-Flow-Isobaric-Process ?Self)
                  (Active ?Time
                          Steady-State-Steady-Flow-Process
                          ?Self))))

(Forall (?Self ?Time)
        (<=> (Active ?Time Steady-Flow-Isothermal-Process ?Self)
             (And (Steady-Flow-Isothermal-Process ?Self)
                  (Active ?Time
                          Steady-State-Steady-Flow-Process
                          ?Self))))

(Forall (?Self ?Time)
        (<=> (Active ?Time Steady-Flow-Heat-Transfer ?Self)
             (And (Steady-Flow-Heat-Transfer ?Self)
                  (Active ?Time
                          Steady-State-Steady-Flow-Process
                          ?Self))))

(Forall (?Self ?Time)
        (<=> (Active ?Time
                     Steady-Flow-Expansion-Or-Compression
                     ?Self)
             (And (Steady-Flow-Expansion-Or-Compression ?Self)
                  (Active ?Time
                          Steady-State-Steady-Flow-Process
                          ?Self))))

(Forall (?Self ?Time)
        (<=> (Active ?Time Steady-Flow-Compression ?Self)
             (And (Steady-Flow-Compression ?Self)
                  (Active ?Time
                          Steady-State-Steady-Flow-Process
                          ?Self))))