Function CYCLE-MASS-RATE

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

Slots on this function:

Documentation:

the mass flow rate of the main medium flowing through the thermal cycle

Instance-Of: Function, Quantity-function

Arity: 2

Range: Everywhere-continuous-quantity

Other Related Axioms:

(Inherited-Facet-Value 
    Slot-Documentation
    Thermal-Cycle
    Cycle-Mass-Rate
    The Mass Flow Rate Of The Main Medium Flowing Through The Thermal Cycle)

(Quantity.Dimension (Cycle-Mass-Rate ?Self) Mass-Rate-Dimension)

(Inherited-Facet-Value Slot-Cardinality
                       Thermal-Cycle
                       Cycle-Mass-Rate
                       1)

(Has-Quantity-Function Thermal-Cycle Cycle-Mass-Rate)

(Slot-Documentation 
    Thermal-Cycle
    Cycle-Mass-Rate
    The Mass Flow Rate Of The Main Medium Flowing Through The Thermal Cycle)

(=> (Thermal-Cycle ?Self)
    (And (Value-Cardinality ?Self Net-Heat-Output-Rate 1)
         (Quantity.Dimension (Net-Heat-Output-Rate ?Self)
                             Power-Dimension)
         (Value-Cardinality ?Self Net-Work-Output-Rate 1)
         (Quantity.Dimension (Net-Work-Output-Rate ?Self)
                             Power-Dimension)
         (Value-Cardinality ?Self Net-Heat-Input-Rate 1)
         (Quantity.Dimension (Net-Heat-Input-Rate ?Self)
                             Power-Dimension)
         (Value-Cardinality ?Self Thermal-Efficiency 1)
         (Quantity.Dimension (Thermal-Efficiency ?Self)
                             Dimensionless)
         (Value-Cardinality ?Self Back-Work-Ratio 1)
         (Quantity.Dimension (Back-Work-Ratio ?Self) Dimensionless)
         (Value-Cardinality ?Self Cycle-Mass-Rate 1)
         (Quantity.Dimension (Cycle-Mass-Rate ?Self)
                             Mass-Rate-Dimension)))

(=> (Cycle-Mass-Rate $X $Y) (Everywhere-Continuous-Quantity $Y))

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Power-System-Eight-One ?Self)
        (And (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (Thermal-Efficiency ?Self) ?T)))
                (/ (- (- (Lambda 
                             (?T)
                             (If (= ?T ?Time)
                                 (Value-At 
                                     (Specific-Enthalpy 
                                         (Outlet-Stream 
                                             (Blr-Cv (Blr-System ?Self))))
                                     ?T)))
                         (Lambda 
                             (?T)
                             (If (= ?T ?Time)
                                 (Value-At 
                                     (Specific-Enthalpy 
                                         (Outlet-Stream 
                                             (Tbn-Cv (Tbn-System ?Self))))
                                     ?T))))
                      (- (Lambda 
                             (?T)
                             (If (= ?T ?Time)
                                 (Value-At 
                                     (Specific-Enthalpy 
                                         (Outlet-Stream 
                                             (Pmp-Cv (Pmp-System ?Self))))
                                     ?T)))
                         (Lambda 
                             (?T)
                             (If (= ?T ?Time)
                                 (Value-At 
                                     (Specific-Enthalpy 
                                         (Outlet-Stream 
                                             (Hf-Cv (Cdnsr-System ?Self))))
                                     ?T)))))
                   (- (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Blr-Cv (Blr-System ?Self))))
                                  ?T)))
                      (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Pmp-Cv (Pmp-System ?Self))))
                                  ?T))))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (Back-Work-Ratio ?Self) ?T)))
                (/ (- (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Pmp-Cv (Pmp-System ?Self))))
                                  ?T)))
                      (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Hf-Cv (Cdnsr-System ?Self))))
                                  ?T))))
                   (- (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Blr-Cv (Blr-System ?Self))))
                                  ?T)))
                      (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Tbn-Cv (Tbn-System ?Self))))
                                  ?T))))))
             (= (Lambda 
                    (?T)
                    (If (= ?T ?Time)
                        (Value-At (Heat-Rate 
                                      (Htfr-Prcs (Blr-System ?Self)))
                                  ?T)))
                (* (Lambda 
                       (?T)
                       (If (= ?T ?Time)
                           (Value-At 
                               (Mass-Rate-In (Blr-Cv (Blr-System ?Self)))
                               ?T)))
                   (- (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Blr-Cv (Blr-System ?Self))))
                                  ?T)))
                      (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Pmp-Cv (Pmp-System ?Self))))
                                  ?T))))
                   (/ 1 3600000)))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (Cycle-Mass-Rate ?Self) ?T)))
                (* 3.6
                   (/ (Lambda (?T)
                              (If (= ?T ?Time)
                                  (Value-At (Net-Work-Output-Rate ?Self)
                                            ?T)))
                      (- (- (Lambda 
                                (?T)
                                (If (= ?T ?Time)
                                    (Value-At 
                                        (Specific-Enthalpy 
                                            (Outlet-Stream 
                                                (Blr-Cv 
                                                    (Blr-System ?Self))))
                                        ?T)))
                            (Lambda 
                                (?T)
                                (If (= ?T ?Time)
                                    (Value-At 
                                        (Specific-Enthalpy 
                                            (Outlet-Stream 
                                                (Tbn-Cv 
                                                    (Tbn-System ?Self))))
                                        ?T))))
                         (- (Lambda 
                                (?T)
                                (If (= ?T ?Time)
                                    (Value-At 
                                        (Specific-Enthalpy 
                                            (Outlet-Stream 
                                                (Pmp-Cv 
                                                    (Pmp-System ?Self))))
                                        ?T)))
                            (Lambda 
                                (?T)
                                (If (= ?T ?Time)
                                    (Value-At 
                                        (Specific-Enthalpy 
                                            (Outlet-Stream 
                                                (Hf-Cv (Cdnsr-System ?Self))))
                                        ?T))))))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (Cycle-Mass-Rate ?Self) ?T)))
                (Lambda 
                    (?T)
                    (If (= ?T ?Time)
                        (Value-At (Mass-Rate-In 
                                      (Blr-Cv (Blr-System ?Self)))
                                  ?T))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (Cycle-Mass-Rate ?Self) ?T)))
                (Lambda 
                    (?T)
                    (If (= ?T ?Time)
                        (Value-At (Mass-Rate-In 
                                      (Tbn-Cv (Tbn-System ?Self)))
                                  ?T))))
             (= (Lambda 
                    (?T)
                    (If (= ?T ?Time)
                        (Value-At 
                            (Condensor-Heat-Out-Rate 
                                (Cdnsr-System ?Self))
                            ?T)))
                (* (Lambda 
                       (?T)
                       (If (= ?T ?Time)
                           (Value-At 
                               (Cycle-Mass-Rate 
                                   (Hf-Cv (Cdnsr-System ?Self)))
                               ?T)))
                   (- (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Tbn-Cv (Tbn-System ?Self))))
                                  ?T)))
                      (Lambda 
                          (?T)
                          (If (= ?T ?Time)
                              (Value-At 
                                  (Specific-Enthalpy 
                                      (Outlet-Stream 
                                          (Hf-Cv (Cdnsr-System ?Self))))
                                  ?T)))))))))