Class CONTROL-VOLUME

Slots on this class:

Documentation:
a region of space through which mass may flow
Instance-Of: Class
Subclass-Of: Entity, Substance-container
Arity: 1
Cv-Elevation:
Slot-Documentation:
the elevation of the control volume with respect to some reference position
Cv-Energy:
Slot-Documentation:
the total energy of the fluid in the control volume
Cv-Enthalpy:
Slot-Documentation:
the enthalpy of the fluid in the control volume
Cv-Entropy:
Slot-Documentation:
the entropy of the fluid in the control volume
Cv-Internal-Energy:
Slot-Documentation:
the internal energy of the fluid in the control volume
Cv-Ke:
Slot-Documentation:
the kinetic energy of the fluid in the control volume
Cv-Mass:
Slot-Documentation:
the mass of the fluid in the control volume
Cv-Pe:
Slot-Documentation:
the potential energy of the fluid in the control volume
Cv-Volume:
Slot-Documentation:
the volume of the fluid in the control volume
D-Entropy-Rate:
Slot-Documentation:
entropy differential across the control volume
D-Ke-Rate:
Slot-Documentation:
the kinetic energy differential of the fluid across the control volume
D-Pe-Rate:
Slot-Documentation:
the potential energy differential of the fluid across the control volume
Domain-Of:
Cv-component, Inlets, Outlets, Undergoing
Energy-Rate:
Slot-Documentation:
the rate of change of the total energy of the fluid in the control volume
Enthalpy-Rate-In:
Slot-Documentation:
the enthalpy flow rate into the control volume
Enthalpy-Rate-Out:
Slot-Documentation:
the enthalpy flow rate out of the control volume
Entropy-Rate-In:
Slot-Documentation:
the entropy flow rate into the control volume
Entropy-Rate-Out:
Slot-Documentation:
the entropy flow rate out of the control volume
Even-Ke:
Slot-Documentation:
the predicate indicating that the change in ke-rate is negligible
Even-Pe:
Slot-Documentation:
the predicate indicating that the change in pe-rate is negligible
Has-Quantity-Function:
Cv-elevation, Cv-energy, Cv-enthalpy, Cv-entropy, Cv-internal-energy, Cv-ke, Cv-mass, Cv-pe, Cv-volume, D-entropy-rate, D-ke-rate, D-pe-rate, Energy-rate, Enthalpy-rate-in, Enthalpy-rate-out, Entropy-rate-in, Entropy-rate-out, Even-ke, Even-pe, Internal-energy-rate, Ke-rate-in, Ke-rate-out, Mass-rate-in, Mass-rate-out, Pe-rate-in, Pe-rate-out
Internal-Energy-Rate:
Slot-Documentation:
the rate of change in the internal energy o fthe fluid in the control volume
Ke-Rate-In:
Slot-Documentation:
the kinetic energy flow rate into the control volume
Ke-Rate-Out:
Slot-Documentation:
the kinetic energy flow rate out of the control volume
Mass-Rate-In:
Slot-Documentation:
the mass flow rate into the control volume
Mass-Rate-Out:
Slot-Documentation:
the mass flow rate out of the control volume
Pe-Rate-In:
Slot-Documentation:
the potential energy flow rate into the control volume
Pe-Rate-Out:
Slot-Documentation:
the potential energy flow rate out of the control volume
Range-Of:
Cnd-cv, Component-cv, Cv-involved, Process-cv
Superclass-Of:
1-input-control-volume, 1-output-control-volume, 2-input-control-volume, 2-output-control-volume

Slots on instances of this class:

Cv-Elevation:
Slot-Cardinality: 1
Slot-Documentation:
the elevation of the control volume with respect to some reference position
Cv-Energy:
Slot-Cardinality: 1
Slot-Documentation:
the total energy of the fluid in the control volume
Cv-Enthalpy:
Slot-Cardinality: 1
Slot-Documentation:
the enthalpy of the fluid in the control volume
Cv-Entropy:
Slot-Cardinality: 1
Slot-Documentation:
the entropy of the fluid in the control volume
Cv-Internal-Energy:
Slot-Cardinality: 1
Slot-Documentation:
the internal energy of the fluid in the control volume
Cv-Ke:
Slot-Cardinality: 1
Slot-Documentation:
the kinetic energy of the fluid in the control volume
Cv-Mass:
Slot-Cardinality: 1
Slot-Documentation:
the mass of the fluid in the control volume
Cv-Pe:
Slot-Cardinality: 1
Slot-Documentation:
the potential energy of the fluid in the control volume
Cv-Volume:
Slot-Cardinality: 1
Slot-Documentation:
the volume of the fluid in the control volume
D-Entropy-Rate:
Slot-Cardinality: 1
Slot-Documentation:
entropy differential across the control volume
D-Ke-Rate:
Slot-Cardinality: 1
Slot-Documentation:
the kinetic energy differential of the fluid across the control volume
D-Pe-Rate:
Slot-Cardinality: 1
Slot-Documentation:
the potential energy differential of the fluid across the control volume
Energy-Rate:
Slot-Cardinality: 1
Slot-Documentation:
the rate of change of the total energy of the fluid in the control volume
Enthalpy-Rate-In:
Slot-Cardinality: 1
Slot-Documentation:
the enthalpy flow rate into the control volume
Enthalpy-Rate-Out:
Slot-Cardinality: 1
Slot-Documentation:
the enthalpy flow rate out of the control volume
Entropy-Rate-In:
Slot-Cardinality: 1
Slot-Documentation:
the entropy flow rate into the control volume
Entropy-Rate-Out:
Slot-Cardinality: 1
Slot-Documentation:
the entropy flow rate out of the control volume
Even-Ke:
Slot-Cardinality: 1
Slot-Documentation:
the predicate indicating that the change in ke-rate is negligible
Even-Pe:
Slot-Cardinality: 1
Slot-Documentation:
the predicate indicating that the change in pe-rate is negligible
Internal-Energy-Rate:
Slot-Cardinality: 1
Slot-Documentation:
the rate of change in the internal energy o fthe fluid in the control volume
Ke-Rate-In:
Slot-Cardinality: 1
Slot-Documentation:
the kinetic energy flow rate into the control volume
Ke-Rate-Out:
Slot-Cardinality: 1
Slot-Documentation:
the kinetic energy flow rate out of the control volume
Mass-Rate-In:
Slot-Cardinality: 1
Slot-Documentation:
the mass flow rate into the control volume
Mass-Rate-Out:
Slot-Cardinality: 1
Slot-Documentation:
the mass flow rate out of the control volume
Pe-Rate-In:
Slot-Cardinality: 1
Slot-Documentation:
the potential energy flow rate into the control volume
Pe-Rate-Out:
Slot-Cardinality: 1
Slot-Documentation:
the potential energy flow rate out of the control volume

Axioms:

(Quantity.Dimension (D-Ke-Rate ?Self) Power-Dimension)

(Quantity.Dimension (D-Pe-Rate ?Self) Power-Dimension)

(Quantity.Dimension (Cv-Volume ?Self) Volume-Dimension)

(Quantity.Dimension (Cv-Mass ?Self) Mass-Dimension)

(Quantity.Dimension (Internal-Energy-Rate ?Self)
                    Energy-Rate-Dimension)

(Quantity.Dimension (Energy-Rate ?Self) Energy-Rate-Dimension)

(Quantity.Dimension (Cv-Energy ?Self) Energy-Dimension)

(Quantity.Dimension (Cv-Internal-Energy ?Self) Energy-Dimension)

(Quantity.Dimension (Cv-Entropy ?Self) Entropy-Dimension)

(Quantity.Dimension (Cv-Enthalpy ?Self) Energy-Dimension)

(Quantity.Dimension (Cv-Ke ?Self) Energy-Dimension)

(Quantity.Dimension (Cv-Pe ?Self) Energy-Dimension)

(Quantity.Dimension (Cv-Elevation ?Self) Length-Dimension)

(Quantity.Dimension (Pe-Rate-Out ?Self) Power-Dimension)

(Quantity.Dimension (Pe-Rate-In ?Self) Power-Dimension)

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

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

(Quantity.Dimension (Ke-Rate-Out ?Self) Power-Dimension)

(Quantity.Dimension (Ke-Rate-In ?Self) Power-Dimension)

(Quantity.Dimension (D-Entropy-Rate ?Self) Entropy-Rate-Dimension)

(Quantity.Dimension (Entropy-Rate-Out ?Self) Entropy-Rate-Dimension)

(Quantity.Dimension (Entropy-Rate-In ?Self) Entropy-Rate-Dimension)

(Quantity.Dimension (Enthalpy-Rate-Out ?Self) Power-Dimension)

(Quantity.Dimension (Enthalpy-Rate-In ?Self) Power-Dimension)

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Control-Volume ?Self)
        (And (Forall 
                 (?X)
                 (=> (Inlets ?Self ?X)
                     (And (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Pe-Rate ?X) ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Pe-Rate-In ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Ke-Rate ?X) ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Ke-Rate-In ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Enthalpy-Rate ?X)
                                                    ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At (Enthalpy-Rate-In ?Self)
                                                ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Mass-Rate ?X)
                                                    ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Mass-Rate-In ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Entropy-Rate ?X)
                                                    ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At (Entropy-Rate-In ?Self)
                                                ?T)))))))
             (Forall 
                 (?X)
                 (=> (Outlets ?Self ?X)
                     (And (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Pe-Rate ?X) ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Pe-Rate-Out ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Ke-Rate ?X) ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Ke-Rate-Out ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Enthalpy-Rate ?X)
                                                    ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Enthalpy-Rate-Out ?Self)
                                          ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Mass-Rate ?X)
                                                    ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Mass-Rate-Out ?Self)
                                              ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Entropy-Rate ?X)
                                                    ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At (Entropy-Rate-Out ?Self)
                                                ?T)))))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (D-Entropy-Rate ?Self) ?T)))
                (- (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Entropy-Rate-In ?Self) ?T)))
                   (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Entropy-Rate-Out ?Self) ?T)))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (D-Pe-Rate ?Self) ?T)))
                (- (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Pe-Rate-Out ?Self) ?T)))
                   (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Pe-Rate-In ?Self) ?T)))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (D-Ke-Rate ?Self) ?T)))
                (- (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Ke-Rate-Out ?Self) ?T)))
                   (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Ke-Rate-In ?Self) ?T))))))))

(Forall (?Self ?Time)
        (<=> (Active ?Time Control-Volume ?Self)
             (And (Control-Volume ?Self)
                  (Active ?Time Substance-Container ?Self))))

Other Related Axioms:

(=> (Component-Cv $X $Y) (Control-Volume $Y))

(Forall 
    (?Self ?Time)
    (=> (Active ?Time Control-Volume ?Self)
        (And (Forall 
                 (?X)
                 (=> (Inlets ?Self ?X)
                     (And (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Pe-Rate ?X) ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Pe-Rate-In ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Ke-Rate ?X) ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Ke-Rate-In ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Enthalpy-Rate ?X)
                                                    ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At (Enthalpy-Rate-In ?Self)
                                                ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Mass-Rate ?X)
                                                    ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Mass-Rate-In ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Entropy-Rate ?X)
                                                    ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At (Entropy-Rate-In ?Self)
                                                ?T)))))))
             (Forall 
                 (?X)
                 (=> (Outlets ?Self ?X)
                     (And (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Pe-Rate ?X) ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Pe-Rate-Out ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Ke-Rate ?X) ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Ke-Rate-Out ?Self)
                                                    ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Enthalpy-Rate ?X)
                                                    ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At 
                                          (Enthalpy-Rate-Out ?Self)
                                          ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Mass-Rate ?X)
                                                    ?T)))
                              (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At 
                                              (Mass-Rate-Out ?Self)
                                              ?T))))
                          (C+ (Lambda (?T)
                                      (If (= ?T ?Time)
                                          (Value-At (Entropy-Rate ?X)
                                                    ?T)))
                              (Lambda 
                                  (?T)
                                  (If (= ?T ?Time)
                                      (Value-At (Entropy-Rate-Out ?Self)
                                                ?T)))))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (D-Entropy-Rate ?Self) ?T)))
                (- (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Entropy-Rate-In ?Self) ?T)))
                   (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Entropy-Rate-Out ?Self) ?T)))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (D-Pe-Rate ?Self) ?T)))
                (- (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Pe-Rate-Out ?Self) ?T)))
                   (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Pe-Rate-In ?Self) ?T)))))
             (= (Lambda (?T)
                        (If (= ?T ?Time)
                            (Value-At (D-Ke-Rate ?Self) ?T)))
                (- (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Ke-Rate-Out ?Self) ?T)))
                   (Lambda (?T)
                           (If (= ?T ?Time)
                               (Value-At (Ke-Rate-In ?Self) ?T))))))))

(Forall (?Self ?Time)
        (<=> (Active ?Time Control-Volume ?Self)
             (And (Control-Volume ?Self)
                  (Active ?Time Substance-Container ?Self))))

(Quantity-Function-Of Enthalpy-Rate-In Control-Volume)

(Quantity-Function-Of Enthalpy-Rate-Out Control-Volume)

(Quantity-Function-Of Entropy-Rate-In Control-Volume)

(Quantity-Function-Of Entropy-Rate-Out Control-Volume)

(Quantity-Function-Of D-Entropy-Rate Control-Volume)

(Quantity-Function-Of Ke-Rate-In Control-Volume)

(Quantity-Function-Of Ke-Rate-Out Control-Volume)

(Quantity-Function-Of Mass-Rate-In Control-Volume)

(Quantity-Function-Of Mass-Rate-Out Control-Volume)

(Quantity-Function-Of Pe-Rate-In Control-Volume)

(Quantity-Function-Of Pe-Rate-Out Control-Volume)

(Quantity-Function-Of Cv-Elevation Control-Volume)

(Quantity-Function-Of Cv-Pe Control-Volume)

(Quantity-Function-Of Cv-Ke Control-Volume)

(Quantity-Function-Of Cv-Enthalpy Control-Volume)

(Quantity-Function-Of Cv-Entropy Control-Volume)

(Quantity-Function-Of Cv-Internal-Energy Control-Volume)

(Quantity-Function-Of Cv-Energy Control-Volume)

(Quantity-Function-Of Energy-Rate Control-Volume)

(Quantity-Function-Of Internal-Energy-Rate Control-Volume)

(Quantity-Function-Of Cv-Mass Control-Volume)

(Quantity-Function-Of Cv-Volume Control-Volume)

(Quantity-Function-Of D-Pe-Rate Control-Volume)

(Quantity-Function-Of D-Ke-Rate Control-Volume)

(Quantity-Function-Of Even-Pe Control-Volume)

(Quantity-Function-Of Even-Ke Control-Volume)

(=> (Inlets $X $Y) (Control-Volume $X))

(=> (Outlets $X $Y) (Control-Volume $X))

(=> (Undergoing $X $Y) (Control-Volume $X))

(=> (Cv-Component $X $Y) (Control-Volume $X))

(Inherited-Facet-Value Slot-Value-Type
                       Control-Volume-Op-Mode
                       Cv-Involved
                       Control-Volume)

(Forall (?Cv-Involved)
        (<=> (Control-Volume ?Cv-Involved)
             (Exists (?Self)
                     (And (Control-Volume-Op-Mode ?Self)
                          (= (Cv-Involved ?Self) ?Cv-Involved)))))

(=> (Control-Volume-Op-Mode ?Self)
    (And (Value-Cardinality ?Self Cv-Involved 1)
         (Value-Type ?Self Cv-Involved Control-Volume)
         (Value-Cardinality ?Self Cv-Involved 1)))

(=> (Cv-Involved $X $Y) (Control-Volume $Y))

(Forall (?Self ?Time)
        (<=> (Active ?Time 1-Input-Control-Volume ?Self)
             (And (1-Input-Control-Volume ?Self)
                  (Active ?Time Control-Volume ?Self))))

(Forall (?Self ?Time)
        (<=> (Active ?Time 1-Output-Control-Volume ?Self)
             (And (1-Output-Control-Volume ?Self)
                  (Active ?Time Control-Volume ?Self))))

(Forall (?Self ?Time)
        (<=> (Active ?Time 2-Input-Control-Volume ?Self)
             (And (2-Input-Control-Volume ?Self)
                  (Active ?Time Control-Volume ?Self))))

(Forall (?Self ?Time)
        (<=> (Active ?Time 2-Output-Control-Volume ?Self)
             (And (2-Output-Control-Volume ?Self)
                  (Active ?Time Control-Volume ?Self))))

(=> (Process-Cv $X $Y) (Control-Volume $Y))

(Inherited-Facet-Value Slot-Value-Type
                       Condensor-System
                       Cnd-Cv
                       Control-Volume)

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

(=> (Cnd-Cv $X $Y) (Control-Volume $Y))