Function INLET-STREAM


Slots on this function:

Documentation: the inlet stream
Instance-Of: Function
Arity: 2
Range: 2d-stream

Other Related Axioms:

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Internally-Reversible-Adiabatic-Process ?Self)
        (= (Lambda 
               (?T)
               (If (= ?T ?Time)
                   (Value-At 
                       (Specific-Entropy 
                           (Outlet-Stream (1-1-Cv-Involved ?Self)))
                       ?T)))
           (Lambda 
               (?T)
               (If (= ?T ?Time)
                   (Value-At 
                       (Specific-Entropy 
                           (Inlet-Stream (1-1-Cv-Involved ?Self)))
                       ?T))))))

(Inherited-Facet-Value Slot-Documentation
                       1-Input-Control-Volume
                       Inlet-Stream
                       The Inlet Stream)

(Inherited-Facet-Value Slot-Value-Type
                       1-Input-Control-Volume
                       Inlet-Stream
                       2d-Stream)

(Inherited-Facet-Value Slot-Cardinality
                       1-Input-Control-Volume
                       Inlet-Stream
                       1)

(Has-Attribute-Function 1-Input-Control-Volume Inlet-Stream)

(Slot-Documentation 1-Input-Control-Volume
                    Inlet-Stream
                    The Inlet Stream)

(=> (1-Input-Control-Volume ?Self)
    (And (Value-Cardinality ?Self Inlet-Stream 1)
         (Value-Type ?Self Inlet-Stream 2d-Stream)
         (Value-Cardinality ?Self Inlet-Stream 1)))

(=> (Inlet-Stream $X $Y) (2d-Stream $Y))

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Steady-Flow-Isobaric-Process ?Self)
        (Forall 
            (?Cv)
            (=> (Process-Cv ?Self ?Cv)
                (= (Lambda 
                       (?T)
                       (If (= ?T ?Time)
                           (Value-At (Stream-Pressure (Inlet-Stream ?Cv))
                                     ?T)))
                   (Lambda 
                       (?T)
                       (If (= ?T ?Time)
                           (Value-At (Stream-Pressure 
                                         (Outlet-Stream ?Cv))
                                     ?T))))))))

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Steady-Flow-Isothermal-Process ?Self)
        (Forall 
            (?Cv)
            (=> (Process-Cv ?Self ?Cv)
                (= (Lambda 
                       (?T)
                       (If (= ?T ?Time)
                           (Value-At 
                               (Stream-Temperature (Inlet-Stream ?Cv))
                               ?T)))
                   (Lambda 
                       (?T)
                       (If (= ?T ?Time)
                           (Value-At 
                               (Stream-Temperature (Outlet-Stream ?Cv))
                               ?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)))))))))))

(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 Pump-Power-Input-Per-Mass-Approximation ?Self)
        (= (Lambda 
               (?T)
               (If (= ?T ?Time)
                   (Value-At 
                       (Power-Input-Per-Mass (Process-Involved ?Self))
                       ?T)))
           (* (Lambda 
                  (?T)
                  (If (= ?T ?Time)
                      (Value-At 
                          (Specific-Volume 
                              (Inlet-Stream (1-1-Cv-Involved ?Self)))
                          ?T)))
              (/ (- (Lambda 
                        (?T)
                        (If (= ?T ?Time)
                            (Value-At 
                                (Stream-Pressure 
                                    (Outlet-Stream 
                                        (1-1-Cv-Involved ?Self)))
                                ?T)))
                    (Lambda 
                        (?T)
                        (If (= ?T ?Time)
                            (Value-At 
                                (Stream-Pressure 
                                    (Inlet-Stream 
                                        (1-1-Cv-Involved ?Self)))
                                ?T))))
                 1000)))))

(Substance-In (Inlet-Stream (Pmp-Cv ?Self)) (Water-In-Pmp ?Self))

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

(Substance-In (Inlet-Stream (Cf-Cv ?Self)) (Water-In-Cnd ?Self))

(Substance-In (Inlet-Stream (Hf-Cv ?Self)) (Water-In-Cnd ?Self))

(=> (Condensor-System ?Self)
    (And (Value-Cardinality ?Self Cnd-Cv 1)
         (Value-Type ?Self Cnd-Cv Control-Volume)
         (Value-Cardinality ?Self Cnd-Cv 1)
         (Value-Cardinality ?Self Adbtc-Hxg-Prcs 1)
         (Value-Type ?Self
                     Adbtc-Hxg-Prcs
                     Steady-Flow-Adiabatic-Heat-Exchange)
         (Value-Cardinality ?Self Adbtc-Hxg-Prcs 1)
         (Value-Cardinality ?Self Cf-Cv 1)
         (Value-Type ?Self Cf-Cv 1-1-Control-Volume)
         (Value-Cardinality ?Self Cf-Cv 1)
         (Value-Cardinality ?Self Hf-Cv 1)
         (Value-Type ?Self Hf-Cv 1-1-Control-Volume)
         (Value-Cardinality ?Self Hf-Cv 1)
         (Value-Cardinality ?Self Water-In-Cnd 1)
         (Value-Type ?Self Water-In-Cnd Water)
         (Value-Cardinality ?Self Water-In-Cnd 1)
         (Value-Cardinality ?Self Condensor-Heat-Out-Rate 1)
         (Quantity.Dimension (Condensor-Heat-Out-Rate ?Self)
                             Power-Dimension)
         (Cv-Component (Cnd-Cv ?Self) (Cnd ?Self))
         (Component-Cv (Cnd ?Self) (Cnd-Cv ?Self))
         (Process-Cv (Adbtc-Hxg-Prcs ?Self) (Cnd-Cv ?Self))
         (Cv-Component (Cf-Cv ?Self) (Cold-Flow (Cnd ?Self)))
         (Component-Cv (Cold-Flow (Cnd ?Self)) (Cf-Cv ?Self))
         (Cv-Component (Hf-Cv ?Self) (Hot-Flow (Cnd ?Self)))
         (Component-Cv (Hot-Flow (Cnd ?Self)) (Hf-Cv ?Self))
         (Substance-In (Cnd-Cv ?Self) (Water-In-Cnd ?Self))
         (Substance-In (Hf-Cv ?Self) (Water-In-Cnd ?Self))
         (Substance-In (Inlet-Stream (Hf-Cv ?Self))
                       (Water-In-Cnd ?Self))
         (Substance-In (Outlet-Stream (Hf-Cv ?Self))
                       (Water-In-Cnd ?Self))
         (Substance-In (Cf-Cv ?Self) (Water-In-Cnd ?Self))
         (Substance-In (Inlet-Stream (Cf-Cv ?Self))
                       (Water-In-Cnd ?Self))
         (Substance-In (Outlet-Stream (Cf-Cv ?Self))
                       (Water-In-Cnd ?Self))))

(Substance-In (Inlet-Stream (Tbn-Cv ?Self)) (Water-In-Tbn ?Self))

(=> (Turbine-System ?Self)
    (And (Value-Cardinality ?Self Tbn 1)
         (Value-Type ?Self Tbn Simple-Turbine)
         (Value-Cardinality ?Self Tbn 1)
         (Value-Cardinality ?Self Tbn-Cv 1)
         (Value-Type ?Self Tbn-Cv 1-1-Control-Volume)
         (Value-Cardinality ?Self Tbn-Cv 1)
         (Value-Cardinality ?Self Expsn-Prcs 1)
         (Value-Type ?Self
                     Expsn-Prcs
                     Steady-Flow-Adiabatic-Expansion)
         (Value-Cardinality ?Self Expsn-Prcs 1)
         (Value-Cardinality ?Self Water-In-Tbn 1)
         (Value-Type ?Self Water-In-Tbn Water)
         (Value-Cardinality ?Self Water-In-Tbn 1)
         (Cv-Component (Tbn-Cv ?Self) (Tbn ?Self))
         (Component-Cv (Tbn ?Self) (Tbn-Cv ?Self))
         (Process-Cv (Expsn-Prcs ?Self) (Tbn-Cv ?Self))
         (Substance-In (Tbn-Cv ?Self) (Water-In-Tbn ?Self))
         (Substance-In (Inlet-Stream (Tbn-Cv ?Self))
                       (Water-In-Tbn ?Self))
         (Substance-In (Outlet-Stream (Tbn-Cv ?Self))
                       (Water-In-Tbn ?Self))))

(Substance-In (Inlet-Stream (Blr-Cv ?Self)) (Water-In-Blr ?Self))

(=> (Boiler-System ?Self)
    (And (Value-Cardinality ?Self Blr 1)
         (Value-Type ?Self Blr Boiler)
         (Value-Cardinality ?Self Blr 1)
         (Value-Cardinality ?Self Blr-Cv 1)
         (Value-Type ?Self Blr-Cv 1-1-Control-Volume)
         (Value-Cardinality ?Self Blr-Cv 1)
         (Value-Cardinality ?Self Htfr-Prcs 1)
         (Value-Type ?Self Htfr-Prcs Steady-Flow-Heat-Transfer)
         (Value-Cardinality ?Self Htfr-Prcs 1)
         (Value-Cardinality ?Self Water-In-Blr 1)
         (Value-Type ?Self Water-In-Blr Water)
         (Value-Cardinality ?Self Water-In-Blr 1)
         (Cv-Component (Blr-Cv ?Self) (Blr ?Self))
         (Component-Cv (Blr ?Self) (Blr-Cv ?Self))
         (Process-Cv (Htfr-Prcs ?Self) (Blr-Cv ?Self))
         (Substance-In (Blr-Cv ?Self) (Water-In-Blr ?Self))
         (Substance-In (Inlet-Stream (Blr-Cv ?Self))
                       (Water-In-Blr ?Self))
         (Substance-In (Outlet-Stream (Blr-Cv ?Self))
                       (Water-In-Blr ?Self))))

(Connected-Terminals (Pmp-Blr-Junction ?Self)
                     (Inlet-Stream (Blr-Cv (Blr-System ?Self))))

(Connected-Terminals (Cnd-Pmp-Junction ?Self)
                     (Inlet-Stream (Pmp-Cv (Pmp-System ?Self))))

(Connected-Terminals (Tbn-Cnd-Junction ?Self)
                     (Inlet-Stream (Hf-Cv (Cdnsr-System ?Self))))

(Connected-Terminals (Blr-Tbn-Junction ?Self)
                     (Inlet-Stream (Tbn-Cv (Tbn-System ?Self))))

(=> (Power-System-Eight-One ?Self)
    (And (Value-Cardinality ?Self Blr-System 1)
         (Value-Type ?Self Blr-System Boiler-System)
         (Value-Cardinality ?Self Blr-System 1)
         (Value-Cardinality ?Self Tbn-System 1)
         (Value-Type ?Self Tbn-System Turbine-System)
         (Value-Cardinality ?Self Tbn-System 1)
         (Value-Cardinality ?Self Cdnsr-System 1)
         (Value-Type ?Self Cdnsr-System Condensor-System)
         (Value-Cardinality ?Self Cdnsr-System 1)
         (Value-Cardinality ?Self Pmp-System 1)
         (Value-Type ?Self Pmp-System Pump-System)
         (Value-Cardinality ?Self Pmp-System 1)
         (Value-Cardinality ?Self Cnd-Pmp-Junction 1)
         (Value-Type ?Self Cnd-Pmp-Junction Stream-Junction)
         (Value-Cardinality ?Self Cnd-Pmp-Junction 1)
         (Value-Cardinality ?Self Blr-Tbn-Junction 1)
         (Value-Type ?Self Blr-Tbn-Junction Stream-Junction)
         (Value-Cardinality ?Self Blr-Tbn-Junction 1)
         (Value-Cardinality ?Self Tbn-Cnd-Junction 1)
         (Value-Type ?Self Tbn-Cnd-Junction Stream-Junction)
         (Value-Cardinality ?Self Tbn-Cnd-Junction 1)
         (Value-Cardinality ?Self Pmp-Blr-Junction 1)
         (Value-Type ?Self Pmp-Blr-Junction Stream-Junction)
         (Value-Cardinality ?Self Pmp-Blr-Junction 1)
         (Value-Cardinality ?Self Working-Fluid-In-Cycle 1)
         (Value-Type ?Self Working-Fluid-In-Cycle Water)
         (Value-Cardinality ?Self Working-Fluid-In-Cycle 1)
         (Connected-Terminals (Blr-Tbn-Junction ?Self)
                              (Outlet-Stream (Blr-Cv (Blr-System ?Self))))
         (Connected-Terminals (Blr-Tbn-Junction ?Self)
                              (Inlet-Stream (Tbn-Cv (Tbn-System ?Self))))
         (Connected-Terminals (Tbn-Cnd-Junction ?Self)
                              (Outlet-Stream (Tbn-Cv (Tbn-System ?Self))))
         (Connected-Terminals (Tbn-Cnd-Junction ?Self)
                              (Inlet-Stream (Hf-Cv (Cdnsr-System ?Self))))
         (Connected-Terminals (Cnd-Pmp-Junction ?Self)
                              (Outlet-Stream (Hf-Cv (Cdnsr-System ?Self))))
         (Connected-Terminals (Cnd-Pmp-Junction ?Self)
                              (Inlet-Stream (Pmp-Cv (Pmp-System ?Self))))
         (Connected-Terminals (Pmp-Blr-Junction ?Self)
                              (Outlet-Stream (Pmp-Cv (Pmp-System ?Self))))
         (Connected-Terminals (Pmp-Blr-Junction ?Self)
                              (Inlet-Stream (Blr-Cv (Blr-System ?Self))))))

(Connected-Terminals (Cp-Junction ?Self)
                     (Inlet-Stream (Pmp-Cv (Pmp-Sys ?Self))))

(Connected-Terminals (Tbn2-Cnd-Junction ?Self)
                     (Inlet-Stream (Cndsr-Cv (Cnd-Sys ?Self))))

(Connected-Terminals (Sgen-Tbn2-Junction ?Self)
                     (Inlet-Stream (Tbn-Cv (Tbn-Sys2 ?Self))))

(Connected-Terminals (Sgen-Tbn1-Junction ?Self)
                     (Inlet-Stream (Tbn-Cv (Tbn-Sys1 ?Self))))

(=> (Power-System-With-Reheat ?Self)
    (And (Value-Cardinality ?Self Sgen-Sys 1)
         (Value-Type ?Self
                     Sgen-Sys
                     Steam-Generator-With-Reheat-System)
         (Value-Cardinality ?Self Sgen-Sys 1)
         (Value-Cardinality ?Self Tbn-Sys1 1)
         (Value-Type ?Self Tbn-Sys1 Turbine-System)
         (Value-Cardinality ?Self Tbn-Sys1 1)
         (Value-Cardinality ?Self Tbn-Sys2 1)
         (Value-Type ?Self Tbn-Sys2 Turbine-System)
         (Value-Cardinality ?Self Tbn-Sys2 1)
         (Value-Cardinality ?Self Cnd-Sys 1)
         (Value-Type ?Self
                     Cnd-Sys
                     Condensor-With-Heat-Transfer-System)
         (Value-Cardinality ?Self Cnd-Sys 1)
         (Value-Cardinality ?Self Pmp-Sys 1)
         (Value-Type ?Self Pmp-Sys Pump-System)
         (Value-Cardinality ?Self Pmp-Sys 1)
         (Value-Cardinality ?Self Sgen-Tbn1-Junction 1)
         (Value-Type ?Self Sgen-Tbn1-Junction Stream-Junction)
         (Value-Cardinality ?Self Sgen-Tbn1-Junction 1)
         (Value-Cardinality ?Self Tbn1-Sgen-Junction 1)
         (Value-Type ?Self Tbn1-Sgen-Junction Stream-Junction)
         (Value-Cardinality ?Self Tbn1-Sgen-Junction 1)
         (Value-Cardinality ?Self Sgen-Tbn2-Junction 1)
         (Value-Type ?Self Sgen-Tbn2-Junction Stream-Junction)
         (Value-Cardinality ?Self Sgen-Tbn2-Junction 1)
         (Value-Cardinality ?Self Tbn2-Cnd-Junction 1)
         (Value-Type ?Self Tbn2-Cnd-Junction Stream-Junction)
         (Value-Cardinality ?Self Tbn2-Cnd-Junction 1)
         (Value-Cardinality ?Self Cp-Junction 1)
         (Value-Type ?Self Cp-Junction Stream-Junction)
         (Value-Cardinality ?Self Cp-Junction 1)
         (Value-Cardinality ?Self Pmp-Sgen-Junction 1)
         (Value-Type ?Self Pmp-Sgen-Junction Stream-Junction)
         (Value-Cardinality ?Self Pmp-Sgen-Junction 1)
         (Connected-Terminals (Sgen-Tbn1-Junction ?Self)
                              (Outlet-Stream1 (Sgen-Cv (Sgen-Sys ?Self))))
         (Connected-Terminals (Sgen-Tbn1-Junction ?Self)
                              (Inlet-Stream (Tbn-Cv (Tbn-Sys1 ?Self))))
         (Connected-Terminals (Tbn1-Sgen-Junction ?Self)
                              (Outlet-Stream (Tbn-Cv (Tbn-Sys1 ?Self))))
         (Connected-Terminals (Tbn1-Sgen-Junction ?Self)
                              (Inlet-Stream2 (Sgen-Cv (Sgen-Sys ?Self))))
         (Connected-Terminals (Sgen-Tbn2-Junction ?Self)
                              (Outlet-Stream2 (Sgen-Cv (Sgen-Sys ?Self))))
         (Connected-Terminals (Sgen-Tbn2-Junction ?Self)
                              (Inlet-Stream (Tbn-Cv (Tbn-Sys2 ?Self))))
         (Connected-Terminals (Tbn2-Cnd-Junction ?Self)
                              (Outlet-Stream (Tbn-Cv (Tbn-Sys2 ?Self))))
         (Connected-Terminals (Tbn2-Cnd-Junction ?Self)
                              (Inlet-Stream (Cndsr-Cv (Cnd-Sys ?Self))))
         (Connected-Terminals (Cp-Junction ?Self)
                              (Outlet-Stream (Cndsr-Cv (Cnd-Sys ?Self))))
         (Connected-Terminals (Cp-Junction ?Self)
                              (Inlet-Stream (Pmp-Cv (Pmp-Sys ?Self))))
         (Connected-Terminals (Pmp-Sgen-Junction ?Self)
                              (Outlet-Stream (Pmp-Cv (Pmp-Sys ?Self))))
         (Connected-Terminals (Pmp-Sgen-Junction ?Self)
                              (Inlet-Stream1 (Sgen-Cv (Sgen-Sys ?Self))))))

(Connected-Terminals (Chtr-Trp-Junction ?Self)
                     (Inlet-Stream (Nzl-Cv (Trp-System ?Self))))

(Connected-Terminals (Ohtr-Pmp2-Junction ?Self)
                     (Inlet-Stream (Pmp-Cv (Pmp-System2 ?Self))))

(Connected-Terminals (Cnd-Pmp1-Junction ?Self)
                     (Inlet-Stream (Pmp-Cv (Pmp-System1 ?Self))))

(Connected-Terminals (Xtbn2-Cnd-Junction ?Self)
                     (Inlet-Stream (Cndsr-Cv (Cnd-System ?Self))))

(Connected-Terminals (Sgen-Xtbn2-Junction ?Self)
                     (Inlet-Stream (Xtbn-Cv (Xtbn-System2 ?Self))))

(Connected-Terminals (Sgen-Xtbn1-Junction ?Self)
                     (Inlet-Stream (Xtbn-Cv (Xtbn-System1 ?Self))))

(=> (Power-System-With-Extraction-Turbines ?Self)
    (And (Value-Cardinality ?Self Sgen-System 1)
         (Value-Type ?Self
                     Sgen-System
                     Steam-Generator-With-Reheat-System)
         (Value-Cardinality ?Self Sgen-System 1)
         (Value-Cardinality ?Self Xtbn-System1 1)
         (Value-Type ?Self Xtbn-System1 Extraction-Turbine-System)
         (Value-Cardinality ?Self Xtbn-System1 1)
         (Value-Cardinality ?Self Xtbn-System2 1)
         (Value-Type ?Self Xtbn-System2 Extraction-Turbine-System)
         (Value-Cardinality ?Self Xtbn-System2 1)
         (Value-Cardinality ?Self Cnd-System 1)
         (Value-Type ?Self
                     Cnd-System
                     Condensor-With-Heat-Transfer-System)
         (Value-Cardinality ?Self Cnd-System 1)
         (Value-Cardinality ?Self Pmp-System1 1)
         (Value-Type ?Self Pmp-System1 Pump-System)
         (Value-Cardinality ?Self Pmp-System1 1)
         (Value-Cardinality ?Self Ohtr-System 1)
         (Value-Type ?Self
                     Ohtr-System
                     3-1-Open-Feedwater-Heater-System)
         (Value-Cardinality ?Self Ohtr-System 1)
         (Value-Cardinality ?Self Pmp-System2 1)
         (Value-Type ?Self Pmp-System2 Pump-System)
         (Value-Cardinality ?Self Pmp-System2 1)
         (Value-Cardinality ?Self Chtr-System 1)
         (Value-Type ?Self
                     Chtr-System
                     2-2-Closed-Feedwater-Heater-System)
         (Value-Cardinality ?Self Chtr-System 1)
         (Value-Cardinality ?Self Trp-System 1)
         (Value-Type ?Self Trp-System Nozzle-System)
         (Value-Cardinality ?Self Trp-System 1)
         (Value-Cardinality ?Self Sgen-Xtbn1-Junction 1)
         (Value-Type ?Self Sgen-Xtbn1-Junction Stream-Junction)
         (Value-Cardinality ?Self Sgen-Xtbn1-Junction 1)
         (Value-Cardinality ?Self Xtbn1-Chtr-Junction 1)
         (Value-Type ?Self Xtbn1-Chtr-Junction Stream-Junction)
         (Value-Cardinality ?Self Xtbn1-Chtr-Junction 1)
         (Value-Cardinality ?Self Xtbn1-Sgen-Junction 1)
         (Value-Type ?Self Xtbn1-Sgen-Junction Stream-Junction)
         (Value-Cardinality ?Self Xtbn1-Sgen-Junction 1)
         (Value-Cardinality ?Self Sgen-Xtbn2-Junction 1)
         (Value-Type ?Self Sgen-Xtbn2-Junction Stream-Junction)
         (Value-Cardinality ?Self Sgen-Xtbn2-Junction 1)
         (Value-Cardinality ?Self Xtbn2-Ohtr-Junction 1)
         (Value-Type ?Self Xtbn2-Ohtr-Junction Stream-Junction)
         (Value-Cardinality ?Self Xtbn2-Ohtr-Junction 1)
         (Value-Cardinality ?Self Xtbn2-Cnd-Junction 1)
         (Value-Type ?Self Xtbn2-Cnd-Junction Stream-Junction)
         (Value-Cardinality ?Self Xtbn2-Cnd-Junction 1)
         (Value-Cardinality ?Self Cnd-Pmp1-Junction 1)
         (Value-Type ?Self Cnd-Pmp1-Junction Stream-Junction)
         (Value-Cardinality ?Self Cnd-Pmp1-Junction 1)
         (Value-Cardinality ?Self Pmp1-Ohtr-Junction 1)
         (Value-Type ?Self Pmp1-Ohtr-Junction Stream-Junction)
         (Value-Cardinality ?Self Pmp1-Ohtr-Junction 1)
         (Value-Cardinality ?Self Ohtr-Pmp2-Junction 1)
         (Value-Type ?Self Ohtr-Pmp2-Junction Stream-Junction)
         (Value-Cardinality ?Self Ohtr-Pmp2-Junction 1)
         (Value-Cardinality ?Self Pmp2-Chtr-Junction 1)
         (Value-Type ?Self Pmp2-Chtr-Junction Stream-Junction)
         (Value-Cardinality ?Self Pmp2-Chtr-Junction 1)
         (Value-Cardinality ?Self Chtr-Sgen-Junction 1)
         (Value-Type ?Self Chtr-Sgen-Junction Stream-Junction)
         (Value-Cardinality ?Self Chtr-Sgen-Junction 1)
         (Value-Cardinality ?Self Chtr-Trp-Junction 1)
         (Value-Type ?Self Chtr-Trp-Junction Stream-Junction)
         (Value-Cardinality ?Self Chtr-Trp-Junction 1)
         (Value-Cardinality ?Self Trp-Ohtr-Junction 1)
         (Value-Type ?Self Trp-Ohtr-Junction Stream-Junction)
         (Value-Cardinality ?Self Trp-Ohtr-Junction 1)
         (Connected-Terminals (Sgen-Xtbn1-Junction ?Self)
                              (Outlet-Stream1 
                                  (Sgen-Cv (Sgen-System ?Self))))
         (Connected-Terminals (Sgen-Xtbn1-Junction ?Self)
                              (Inlet-Stream (Xtbn-Cv 
                                                (Xtbn-System1 ?Self))))
         (Connected-Terminals 
             (Xtbn1-Chtr-Junction ?Self)
             (Outlet-Stream2 (Xtbn-Cv (Xtbn-System1 ?Self))))
         (Connected-Terminals (Xtbn1-Chtr-Junction ?Self)
                              (Inlet-Stream2 (Chtr-Cv 
                                                 (Chtr-System ?Self))))
         (Connected-Terminals 
             (Xtbn1-Sgen-Junction ?Self)
             (Outlet-Stream1 (Xtbn-Cv (Xtbn-System1 ?Self))))
         (Connected-Terminals (Xtbn1-Sgen-Junction ?Self)
                              (Inlet-Stream2 (Sgen-Cv 
                                                 (Sgen-System ?Self))))
         (Connected-Terminals (Sgen-Xtbn2-Junction ?Self)
                              (Outlet-Stream2 
                                  (Sgen-Cv (Sgen-System ?Self))))
         (Connected-Terminals (Sgen-Xtbn2-Junction ?Self)
                              (Inlet-Stream (Xtbn-Cv 
                                                (Xtbn-System2 ?Self))))
         (Connected-Terminals 
             (Xtbn2-Ohtr-Junction ?Self)
             (Outlet-Stream2 (Xtbn-Cv (Xtbn-System2 ?Self))))
         (Connected-Terminals 
             (Xtbn2-Ohtr-Junction ?Self)
             (Inlet-Stream2 (Fwt-Htr-Cv (Ohtr-System ?Self))))
         (Connected-Terminals 
             (Xtbn2-Cnd-Junction ?Self)
             (Outlet-Stream1 (Xtbn-Cv (Xtbn-System2 ?Self))))
         (Connected-Terminals (Xtbn2-Cnd-Junction ?Self)
                              (Inlet-Stream (Cndsr-Cv (Cnd-System ?Self))))
         (Connected-Terminals (Cnd-Pmp1-Junction ?Self)
                              (Outlet-Stream (Cndsr-Cv 
                                                 (Cnd-System ?Self))))
         (Connected-Terminals (Cnd-Pmp1-Junction ?Self)
                              (Inlet-Stream (Pmp-Cv (Pmp-System1 ?Self))))
         (Connected-Terminals (Pmp1-Ohtr-Junction ?Self)
                              (Outlet-Stream (Pmp-Cv (Pmp-System1 ?Self))))
         (Connected-Terminals 
             (Pmp1-Ohtr-Junction ?Self)
             (Inlet-Stream1 (Fwt-Htr-Cv (Ohtr-System ?Self))))
         (Connected-Terminals 
             (Ohtr-Pmp2-Junction ?Self)
             (Outlet-Stream (Fwt-Htr-Cv (Ohtr-System ?Self))))
         (Connected-Terminals (Ohtr-Pmp2-Junction ?Self)
                              (Inlet-Stream (Pmp-Cv (Pmp-System2 ?Self))))
         (Connected-Terminals (Pmp2-Chtr-Junction ?Self)
                              (Outlet-Stream (Pmp-Cv (Pmp-System2 ?Self))))
         (Connected-Terminals (Pmp2-Chtr-Junction ?Self)
                              (Inlet-Stream1 (Chtr-Cv 
                                                 (Chtr-System ?Self))))
         (Connected-Terminals (Chtr-Sgen-Junction ?Self)
                              (Outlet-Stream1 
                                  (Chtr-Cv (Chtr-System ?Self))))
         (Connected-Terminals (Chtr-Sgen-Junction ?Self)
                              (Inlet-Stream1 (Sgen-Cv 
                                                 (Sgen-System ?Self))))
         (Connected-Terminals (Chtr-Trp-Junction ?Self)
                              (Outlet-Stream2 
                                  (Chtr-Cv (Chtr-System ?Self))))
         (Connected-Terminals (Chtr-Trp-Junction ?Self)
                              (Inlet-Stream (Nzl-Cv (Trp-System ?Self))))
         (Connected-Terminals (Trp-Ohtr-Junction ?Self)
                              (Outlet-Stream (Nzl-Cv (Trp-System ?Self))))
         (Connected-Terminals 
             (Trp-Ohtr-Junction ?Self)
             (Inlet-Stream3 (Fwt-Htr-Cv (Ohtr-System ?Self))))))