;;;; -*-  Mode: LISP; Syntax: Common-Lisp; Base: 10                          -*-
;;;; ---------------------------------------------------------------------------
;;;; File name: nst-2.meld
;;;;    System: FIRE qp-source
;;;;   Version: 2.0
;;;;    Author: Jin Yan
;;;;   Created: April 23, 2003 12:23:11
;;;;   Purpose: 
;;;; ---------------------------------------------------------------------------
;;;;  Modified: Tuesday, February 17, 2004 at 15:53:41 by jinyan

;;This flat file is based on cmlnst.dom file!
;;;; File name: nst-2.meld

;;----------------------------------
;; QPQuantityFunction & QpQuantityFn
;;----------------------------------

(#$isa #$QPQuantityFunction #$Collection)
(#$genls #$QPQuantityFunction #$Function-Denotational)
;; #$Function-Denotational could take varied arities.

(#$isa #$QpQuantityFn #$UnaryFunction)
(#$arity #$QpQuantityFn 1)
(#$arg1Isa #$QpQuantityFn #$PhysicalQuantity)
(#$resultIsa #$QpQuantityFn #$QPQuantityFunction)

(#$implies (#$isa (#$QpQuantityFn ?q) #$QPQuantityFunction)
           (#$resultIsa (#$QpQuantityFn ?q) ?q))

;;--------------------------------
;;Define #$DomainTheory collection
;;--------------------------------

(#$isa #$DomainTheory #$Collection)
(#$genls #$DomainTheory #$AbstractInformationalThing)
(#$isa #$NaiveSteamDomainTheory #$DomainTheory)
;;;(#$genls #$NaiveSteamDomainTheory #$DomainTheory)

;;---------------------------------
;;Define #$inDomainTheory predicate
;;---------------------------------

(#$isa #$inDomainTheory #$BinaryPredicate)
(#$arity #$inDomainTheory 2)
(#$arg1Isa #$inDomainTheory #$DomainTheory)
(#$arg2Isa #$inDomainTheory #$CycLAssertion)

;;-----------------------------------
;; Quantity Functions
;;-----------------------------------

;;; maybe we don't even need arg1Isa or arg2Isa...?
 
(#$arity (#$QpQuantityFn #$Pressure) 1)
(#$arg1Isa (#$QpQuantityFn #$Pressure) #$Thing)
(#$arity (#$QpQuantityFn #$Temperature) 1)
(#$arg1Isa (#$QpQuantityFn #$Temperature) #$Thing)
(#$arity (#$QpQuantityFn #$Heat) 1)
(#$arg1Isa (#$QpQuantityFn #$Heat) #$Thing)
(#$arity (#$QpQuantityFn #$Volume) 1)
(#$arg1Isa (#$QpQuantityFn #$Volume) #$Thing)
(#$arity (#$QpQuantityFn #$Level) 1)
(#$arg1Isa (#$QpQuantityFn #$Level) #$Thing)
(#$arity (#$QpQuantityFn #$Height) 1)
(#$arg1Isa (#$QpQuantityFn #$Height) #$Place)
(#$arity (#$QpQuantityFn #$Mass) 1)
(#$arg1Isa (#$QpQuantityFn #$Mass) #$Thing)
(#$arity (#$QpQuantityFn #$BottomHeight) 1)
(#$arg1Isa (#$QpQuantityFn #$BottomHeight) #$Container)
(#$arity (#$QpQuantityFn #$TopHeight) 1)
(#$arg1Isa (#$QpQuantityFn #$TopHeight) #$Container)
(#$arity (#$QpQuantityFn #$MaxHeight) 1)
(#$arg1Isa (#$QpQuantityFn #$MaxHeight) #$Path-Generic) ;;Place, Container and Path-Generic have been defined!!
(#$arity (#$QpQuantityFn #$FlowRate) 1)
(#$arg1Isa (#$QpQuantityFn #$FlowRate) #$Process) ;;Cyc didn't define #$Process. 
(#$arity (#$QpQuantityFn #$HeatFlowRate) 1)
(#$arg1Isa (#$QpQuantityFn #$HeatFlowRate) #$Process)
(#$arity (#$QpQuantityFn #$LiquidFlowRate) 1)
(#$arg1Isa (#$QpQuantityFn #$LiquidFlowRate) #$Process)
(#$arity (#$QpQuantityFn #$GenerationRate) 1)
(#$arg1Isa (#$QpQuantityFn #$GenerationRate) #$Process)
(#$arity (#$QpQuantityFn #$HeatGenerationRate) 1)
(#$arg1Isa (#$QpQuantityFn #$HeatGenerationRate) #$Process)
(#$arity (#$QpQuantityFn #$Absorbtion) 1)
(#$arg1Isa (#$QpQuantityFn #$Absorbtion) #$Process)
(#$arity (#$QpQuantityFn #$Restorative) 1)
(#$arg1Isa (#$QpQuantityFn #$Restorative) #$Process)
(#$arity (#$QpQuantityFn #$TBoil) 2)
(#$arg1Isa (#$QpQuantityFn #$TBoil) #$Substance)
(#$arg2Isa (#$QpQuantityFn #$TBoil) #$Can) ;;used to be Container here.
(#$arity (#$QpQuantityFn #$AmountOf) 3)
(#$arg1Isa (#$QpQuantityFn #$AmountOf) #$Substance)
(#$arg2Isa (#$QpQuantityFn #$AmountOf) #$State)
(#$arg3Isa (#$QpQuantityFn #$AmountOf) #$Container)
(#$arity (#$QpQuantityFn #$HeatOf) 3)
(#$arg1Isa (#$QpQuantityFn #$HeatOf) #$Substance)
(#$arg2Isa (#$QpQuantityFn #$HeatOf) #$State)
(#$arg3Isa (#$QpQuantityFn #$HeatOf) #$Container)

(#$isa #$qpQuantity #$UnaryPredicate)
(#$arity #$qpQuantity 1)
(#$arg1Isa #$qpQuantity #$PhysicalQuantity)

;;;-------------------------------------------------------
;;; (#$inDomainTheory #$NaiveSteamDomainTheory ?assertion)
;;;-------------------------------------------------------
;;; to be different with QPQuantityFunction, here we use qpQuantity instead of 
;;; qpQuantityFn or qpQuantityFunction.

(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$Pressure))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$Temperature))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$Heat))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$Volume))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$Level))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$TBoil))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$Height))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$AmountOf))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$Mass))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$HeatOf))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$BottomHeight))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$TopHeight))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$MaxHeight))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$FlowRate))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$HeatFlowRate))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$LiquidFlowRate))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$GenerationRate))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$HeatGenerationRate))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$Absorbtion))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpQuantity #$Restorative))

;;;(ask-it (->data `(evaluate ?qf (TheSetOf ?q (inDomainTheory ,dt-name (qpQuantityFunction ?q))))))
;;;get the arity by retrieving facts like: (arity (QpQuantityFn Pressure) 1)

;;;------------
;;; Quantities
;;;------------

;;; #$PhysicalQuantity definitions:

(#$isa #$Heat #$Collection)
(#$genls #$Heat #$PhysicalQuantity)
(#$isa #$Level #$Collection)
(#$genls #$Level #$PhysicalQuantity)
(#$isa #$TBoil #$Collection)
(#$genls #$TBoil #$Temperature)
(#$isa #$Height #$Collection)
(#$genls #$Height #$PhysicalQuantity)
(#$isa #$BottomHeight #$Collection)
(#$genls #$BottomHeight #$Height)
(#$isa #$TopHeight #$Collection)
(#$genls #$TopHeight #$Height)
(#$isa #$MaxHeight #$Collection)
(#$genls #$MaxHeight #$Height)
(#$isa #$AmountOf #$Collection)
(#$genls #$AmountOf #$PhysicalQuantity)
(#$isa #$HeatOf #$Collection)
(#$genls #$HeatOf #$PhysicalQuantity)
(#$isa #$HeatFlowRate #$Collection)
(#$genls #$HeatFlowRate #$FlowRate)
(#$isa #$LiquidFlowRate #$Collection)
(#$genls #$LiquidFlowRate #$FlowRate)
(#$isa #$GenerationRate #$Collection)
(#$genls #$GenerationRate #$Rate)
(#$isa #$HeatGenerationRate #$Collection)
(#$genls #$HeatGenerationRate #$GenerationRate)
(#$isa #$Absorbtion #$Collection)
(#$genls #$Absorbtion #$PhysicalQuantity)
(#$isa #$Restorative #$Collection)
(#$genls #$Restorative #$PhysicalQuantity)
(#$isa #$Density #$Collection)
(#$genls #$Density #$PhysicalQuantity)
(#$isa #$SpecificHeat #$Collection)
(#$genls #$SpecificHeat #$Heat)
(#$isa #$ThermalConductivity #$Collection)
(#$genls #$ThermalConductivity #$PhysicalQuantity)

;;;-------------------------------
;;; Substance and Phase relations
;;;-------------------------------

;; predicates definition:
(#$isa #$qpEntity #$Predicate)
(#$arity #$qpEntity 1)
(#$arg1Isa #$qpEntity #$Thing) 

(#$isa #$qpEntitySubclass #$BinaryPredicate)
(#$arity #$qpEntitySubclass 2)
(#$arg1Isa #$qpEntitySubclass #$Thing)
(#$arg2Isa #$qpEntitySubclass #$Thing)

(#$isa #$qpEntityQuantity #$BinaryPredicate)
(#$arity #$qpEntityQuantity 2)
(#$arg1Isa #$qpEntityQuantity #$Thing)
(#$arg2Isa #$qpEntityQuantity #$PhysicalQuantity)

(#$isa #$qpEntityQuantityDimension #$Predicate)
(#$arity #$qpEntityQuantityDimension 3)
(#$arg1Isa #$qpEntityQuantityDimension #$Thing)
(#$arg2Isa #$qpEntityQuantityDimension #$PhysicalQuantity)
(#$arg3Isa #$qpEntityQuantityDimension #$PhysicalQuantity)

(#$isa #$qpEntityQuantityType #$Predicate)
(#$arity #$qpEntityQuantityType 3)
(#$arg1Isa #$qpEntityQuantityType #$Thing)
(#$arg2Isa #$qpEntityQuantityType #$PhysicalQuantity)
(#$arg3Isa #$qpEntityQuantityType #$QpQuantityFunction)

(#$isa #$qpEntityConsequence #$Predicate)
(#$arity #$qpEntityConsequence 2)
(#$arg1Isa #$qpEntityConsequence #$Thing)
(#$arg2Isa #$qpEntityConsequence #$CycLAssertion)

(#$isa #$qpEntityDocumentation #$Predicate)
(#$arity #$qpEntityDocumentation 2)
(#$arg1Isa #$qpEntityDocumentation #$Thing)
(#$arg2Isa #$qpEntityDocumentation #$CycLAssertion)

;; Constant definition:
(#$isa #$Substance #$Collection)
(#$genls #$Substance #$Thing)
(#$isa #$Phase #$Collection)
(#$genls #$Phase #$Thing)

;; Assertions
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpEntity #$Substance))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpEntity #$Phase))

;; Question about Dimension! what's the difference between Dimension and Type?
(#$qpEntityQuantity #$Substance #$Density)
(#$qpEntityQuantityType #$Substance #$Density (#$QpQuantityFn #$Density))
;;;(#$qpEntityQuantityDimension #$Substance #$Density #$Density)
(#$qpEntityQuantity #$Substance #$SpecificHeat)
(#$qpEntityQuantityType #$Substance #$SpecificHeat (#$QpQuantityFn #$Heat))
;;;(#$qpEntityQuantityDimension #$Substance #$SpecificHeat #$Heat)
(#$qpEntityQuantity #$Substance #$ThermalConductivity)
(#$qpEntityQuantityType #$Substance #$ThermalConductivity (#$QpQuantityFn #$ThermalConductivity))
;;;(#$qpEntityQuantityDimension #$Substance #$ThermalConductivity #$ThermalConductivity)

(#$forAll (?x)
          (#$implies (#$isa ?x #$Substance)
                     (#$and (#$isa ((#$QpQuantityFn #$Density) ?x) #$Quantity)
                            (#$isa ((#$QpQuantityFn #$Heat) ?x) #$Quantity)
                            (#$isa ((#$QpQuantityFn #$ThermalConductivity) ?x) #$Quantity))))

;; Predicates definition:
(#$isa #$qpRelation #$Predicate)
(#$arity #$qpRelation 1)
(#$arg1Isa #$qpRelation #$Predicate)

(#$isa #$qpRelationImplies #$Predicate)
(#$arity #$qpRelationImplies 2)
(#$arg1Isa #$qpRelationImplies #$Predicate)
(#$arg2Isa #$qpRelationImplies #$CycLAssertion)

(#$isa #$> #$OrderingPredicate) ;; could be replaced by greaterThan
(#$arity #$> 2)
(#$arg1Isa #$> #$ScalarInterval)
(#$arg2Isa #$> #$ScalarInterval)

(#$isa #$>= #$OrderingPredicate) ;;greaterThanOrEqualTo
(#$arity #$>= 2)
(#$arg1Isa #$>= #$ScalarInterval)
(#$arg2Isa #$>= #$ScalarInterval)

(#$isa #$<= #$OrderingPredicate) ;;smallerThanOrEqualTo
(#$arity #$<= 2)
(#$arg1Isa #$<= #$ScalarInterval)
(#$arg2Isa #$<= #$ScalarInterval)

(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpRelation #$canContainSubstance))

(#$isa #$canContainSubstance #$Predicate)
(#$arity #$canContainSubstance 3)
(#$arg1Isa #$canContainSubstance #$Can)
(#$arg2Isa #$canContainSubstance #$Substance)
(#$arg3Isa #$canContainSubstance #$Phase)

(#$isa #$Quantity #$Collection)
(#$genls #$Quantity #$ScalarInterval)
(#$genls #$PhysicalQuantity #$Quantity)

;; Assertions
(#$qpRelationImplies #$canContainSubstance 
                     (#$and (#$isa ((#$QpQuantityFn #$TBoil) ?sub ?can) #$Quantity)
                            (#$> ((#$QpQuantityFn #$TBoil) ?sub ?can) 0)))

;;;----------------------------
;;; Constants & Universal Facts
;;;----------------------------

;; Predicate Definition:
(#$isa #$qpConstant #$Predicate)
(#$arity #$qpConstant 1)
(#$arg1Isa #$qpConstant #$Thing)

(#$isa #$qpUnivFact #$UnaryPredicate)
(#$arity #$qpUnivFact 1)
(#$arg1Isa #$qpUnivFact #$CycLAssertion)

;; Constant Definition:
(#$isa #$Gas #$Collection)
(#$genls #$Gas #$Phase)
(#$isa #$Liquid #$Collection)
(#$genls #$Liquid #$Phase)

;; Assertions:
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpConstant #$Water))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpConstant #$Liquid))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpConstant #$Gas))

(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpUnivFact (#$genls #$Water #$Substance)))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpUnivFact (#$genls #$Liquid #$Phase)))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpUnivFact (#$genls #$Gas #$Phase)))

;;;---------------------------------
;;; Container and fluid definitions
;;;---------------------------------

;; Constant definition
(#$isa #$FluidPath #$Collection)
(#$genls #$FluidPath #$Path-Generic)
(#$isa #$HeatPath #$Collection)
(#$genls #$HeatPath #$Path-Generic)

(#$isa #$heatConnection #$Predicate)
(#$arity #$heatConnection 3)
(#$arg1Isa #$heatConnection #$Path-Generic)
(#$arg2Isa #$heatConnection #$Source)
(#$arg3Isa #$heatConnection #$Destination)

(#$isa #$fluidConnection #$Predicate)
(#$arity #$fluidConnection 3)
(#$arg1Isa #$fluidConnection #$Path-Generic)
(#$arg2Isa #$fluidConnection #$Source) ;; any other better concepts?
(#$arg3Isa #$fluidConnection #$Destination)

;; Assertions
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpEntity #$Container))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpEntity #$FluidPath))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpEntity #$HeatPath))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpRelation #$fluidConnection))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpRelation #$heatConnection))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpMF #$HeatConnectionToContainedStuff))

(#$forAll (?x)
          (#$implies (#$isa ?x #$Container)
                     (#$and (#$isa ((#$QpQuantityFn #$BottomHeight) ?x) #$Quantity)
                            (#$isa ((#$QpQuantityFn #$TopHeight) ?x) #$Quantity)
                            (#$> #$TopHeight #$BottomHeight))))

;;;Problem: This could be a wrong human's representations. Containers might not always have 
;;;TopHeight and BottomHeight properties.

(#$forAll (?x)
          (#$implies (#$isa ?x #$FluidPath)
                     (#$and (#$isa ((#$QpQuantityFn #$MaxHeight) ?x) #$Quantity))))

(#$qpEntityQuantity #$Container #$BottomHeight)
(#$qpEntityQuantityType #$Container #$BottomHeight (#$QpQuantityFn #$BottomHeight))
(#$qpEntityQuantity #$Container #$TopHeight)
(#$qpEntityQuantityType #$Container #$TopHeight (#$QpQuantityFn #$TopHeight))
(#$qpEntityConsequence #$Container (#$> #$TopHeight #$BottomHeight))

(#$qpEntity #$FluidPath)
(#$qpEntityQuantity #$FluidPath #$MaxHeight)
(#$qpEntityQuantityType #$FluidPath #$MaxHeight (#$QpQuantityFn #$MaxHeight))
(#$qpEntity #$HeatPath)

;;;-----------
;;;qpMF
;;;-----------

;;; qpMF predicates definitions:

(#$isa #$ModelFragment #$Collection)
(#$genls #$ModelFragment #$Individual)

(#$isa #$qpMF #$Predicate)
(#$arity #$qpMF 1)
(#$arg1Isa #$qpMF #$ModelFragment)

(#$isa #$qpMFParticipant #$BinaryPredicate)
(#$arity #$qpMFParticipant 2)
(#$arg1Isa #$qpMFParticipant #$ModelFragment)
(#$arg2Isa #$qpMFParticipant #$Individual)

(#$isa #$qpMFParticipantType #$Predicate)
(#$arity #$qpMFParticipantType 3)
(#$arg1Isa #$qpMFParticipantType #$ModelFragment)
(#$arg2Isa #$qpMFParticipantType #$Individual)
(#$arg3Isa #$qpMFParticipantType #$Thing)

(#$isa #$qpMFParticipantConstraint #$Predicate)
(#$arity #$qpMFParticipantConstraint 3)
(#$arg1Isa #$qpMFParticipantConstraint #$ModelFragment)
(#$arg2Isa #$qpMFParticipantConstraint #$Individual)
(#$arg3Isa #$qpMFParticipantConstraint #$CycLAssertion)

(#$isa #$qpMFQuantity #$BinaryPredicate)
(#$arity #$qpMFQuantity 2)
(#$arg1Isa #$qpMFQuantity #$ModelFragment)
(#$arg2Isa #$qpMFQuantity #$PhysicalQuantity)

;;;(#$isa #$qpMFQuantityArgument #$Predicate)
;;;(#$arity #$qpMFQuantityArgument 3)
;;;(#$arg1Isa #$qpMFQuantityArgument #$ModelFragment)
;;;(#$arg2Isa #$qpMFQuantityArgument #$PhysicalQuantity)
;;;(#$arg3Isa #$qpMFQuantityArgument #$Individual)

(#$isa #$qpMFQuantityArguments #$Predicate)
(#$arity #$qpMFQuantityArguments 3)
(#$arg1Isa #$qpMFQuantityArguments #$ModelFragment)
(#$arg2Isa #$qpMFQuantityArguments #$PhysicalQuantity)
(#$arg3Isa #$qpMFQuantityArguments #$List)

(#$isa #$qpMFQuantityType #$Predicate)
(#$arity #$qpMFQuantityType 3)
(#$arg1Isa #$qpMFQuantityType #$ModelFragment)
(#$arg2Isa #$qpMFQuantityType #$PhysicalQuantity)
(#$arg2Isa #$qpMFQuantityType #$QpQuantityFunction)

;;;(#$isa #$QpMfPartFn #$Function)
;;;(#$arity #$QpMfPartFn 1)
;;;(#$arg1Isa #$QpMfPartFn #$Individual)
;;;(#$resultIsa #$QpMfPartFn #$Individual)

;;;----------------------------------------------------------
;;; Jin: MFConditions and MFConsequenses are more complicated
;;;----------------------------------------------------------

(#$isa #$qpMFCondition #$BinaryPredicate)
(#$arity #$qpMFCondition 2)
(#$arg1Isa #$qpMFCondition #$ModelFragment)
(#$arg2Isa #$qpMFCondition #$CycLAssertion)

(#$isa #$qpMFConsequence #$BinaryPredicate)
(#$arity #$qpMFConsequence 2)
(#$arg1Isa #$qpMFConsequence #$ModelFragment)
(#$arg2Isa #$qpMFConsequence #$CycLAssertion)

;;;(#$comment #$ContainedStuff "The CONTAINED-STUFF model fragment 
;;; >>is<< the contained stuff, as noted by it being a subclass of physical object.")
;;;(#$isa #$qpMFDocumentation #$BinaryPredicate)
;;;(#$arity #$qpMFDocumentation 2)
;;;(#$arg1Isa #$qpMFDocumentation #$ModelFragment)
;;;(#$arg2Isa #$qpMFDocumentation #$CycLAssertion)

(#$isa #$TheCS #$Collection)
(#$genls #$TheCS #$Individual)
(#$isa #$TheHeatSource #$Collection)
(#$genls #$TheHeatSource #$Individual)
(#$isa #$TheHP #$Collection)
(#$genls #$TheHP #$Individual)
(#$isa #$TheCan #$Collection)
(#$genls #$TheCan #$Individual)
(#$isa #$TheSub #$Collection)
(#$genls #$TheSub #$Individual)
(#$isa #$ThePhase #$Collection)
(#$genls #$ThePhase #$Individual)
(#$isa #$TheCStuff #$Collection)
(#$genls #$TheCStuff #$Individual)
(#$isa #$TheSrc #$Collection)
(#$genls #$TheSrc #$Individual)
(#$isa #$TheDst #$Collection)
(#$genls #$TheDst #$Individual)
(#$isa #$ThePath #$Collection)
(#$genls #$ThePath #$Individual)
(#$isa #$TheSrcStuff #$Collection)
(#$genls #$TheSrcStuff #$Individual)
(#$isa #$TheDstStuff #$Collection)
(#$genls #$TheDstStuff #$Individual)
(#$isa #$TheCLiquid #$Collection)
(#$genls #$TheCLiquid #$Individual)
(#$isa #$TheHeatFlow #$Collection)
(#$genls #$TheHeatFlow #$Individual)
(#$isa #$TheBoiling #$Collection)
(#$genls #$TheBoiling #$Individual)
(#$isa #$TheCGas #$Collection)
(#$genls #$TheCGas #$Individual)
(#$isa #$TheGasHeatFlow #$Collection)
(#$genls #$TheGasHeatFlow #$Individual)
(#$isa #$TheSource #$Collection)
(#$genls #$TheSource #$Individual)

;;;(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpMF #$HeatConnectionToContainedStuff))
;;;(#$qpMFParticipant #$HeatConnectionToContainedStuff (#$QpMfPartFn ?TheCS))
;;;(#$qpMFParticipant #$HeatConnectionToContainedStuff (#$QpMfPartFn ?TheCan))
;;;(#$qpMFParticipant #$HeatConnectionToContainedStuff (#$QpMfPartFn ?TheHeatSource))
;;;(#$qpMFParticipant #$HeatConnectionToContainedStuff (#$QpMfPartFn ?TheHP))
;;;(#$qpMFParticipantType #$HeatConnectionToContainedStuff (#$QpMfPartFn ?TheCS) #$ContainedStuff)
;;;(#$qpMFParticipantType #$HeatConnectionToContainedStuff (#$QpMfPartFn ?TheCan) #$Container)
;;;(#$qpMFParticipantConstraint #$HeatConnectionToContainedStuff (#$QpMfPartFn ?TheCan) 
;;;                             (#$theCanOf (#$QpMfPartFn ?TheCS) (#$QpMfPartFn ?TheCan)))
;;;(#$qpMFParticipantType #$HeatConnectionToContainedStuff (#$QpMfPartFn ?TheHeatSource) #$ThermalPhysob)
;;;(#$qpMFParticipantType #$HeatConnectionToContainedStuff (#$QpMfPartFn ?TheHP) #$HeatPath)
;;;(#$qpMFParticipantConstraint #$HeatConnectionToContainedStuff (#$QpMfPartFn ?TheHP) 
;;;                             (#$heatConnection (#$QpMfPartFn ?TheHP) 
;;;                                               (#$QpMfPartFn ?TheHeatSource) 
;;;                                               (#$QpMfPartFn ?TheCan)))
;;;(#$qpMFCondition #$HeatConnectionToContainedStuff (#$active (#$QpMfPartFn ?TheCS)))
;;;(#$qpMFConsequence #$HeatConnectionToContainedStuff 
;;;                   (#$heatConnection (#$QpMfPartFn ?TheHP) (#$QpMfPartFn ?TheHeatSource) (#$QpMfPartFn ?TheCS)))

(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpMF #$HeatConnectionToContainedStuff))
(#$qpMFParticipant #$HeatConnectionToContainedStuff #$TheCS)
(#$qpMFParticipant #$HeatConnectionToContainedStuff #$TheCan)
(#$qpMFParticipant #$HeatConnectionToContainedStuff #$TheHeatSource)
(#$qpMFParticipant #$HeatConnectionToContainedStuff #$TheHP)
(#$qpMFParticipantType #$HeatConnectionToContainedStuff #$TheCS #$ContainedStuff)
(#$qpMFParticipantType #$HeatConnectionToContainedStuff #$TheCan #$Container)
(#$qpMFParticipantConstraint #$HeatConnectionToContainedStuff #$TheCan 
                             (#$theCanOf #$TheCS #$TheCan))
(#$qpMFParticipantType #$HeatConnectionToContainedStuff #$TheHeatSource #$ThermalPhysob)
(#$qpMFParticipantType #$HeatConnectionToContainedStuff #$TheHP #$HeatPath)
(#$qpMFParticipantConstraint #$HeatConnectionToContainedStuff #$TheHP
                             (#$heatConnection #$TheHP #$TheHeatSource #$TheCan))
(#$qpMFCondition #$HeatConnectionToContainedStuff (#$active #$TheCS))
(#$qpMFConsequence #$HeatConnectionToContainedStuff 
                   (#$heatConnection #$TheHP #$TheHeatSource #$TheCS))

(#$isa #$theCanOf #$Predicate)
(#$arity #$theCanOf 2)
(#$arg1Isa #$theCanOf #$Thing)
(#$arg2Isa #$theCanOf #$Thing)

(#$isa #$theSubOf #$Predicate)
(#$arity #$theSubOf 2)
(#$arg1Isa #$theSubOf #$Thing)
(#$arg2Isa #$theSubOf #$Thing)

(#$isa #$thePhaseOf #$Predicate)
(#$arity #$thePhaseOf 2)
(#$arg1Isa #$thePhaseOf #$Thing)
(#$arg2Isa #$thePhaseOf #$Thing)

(#$isa #$theDstOf #$Predicate)
(#$arity #$theDstOf 2)
(#$arg1Isa #$theDstOf #$Thing)
(#$arg2Isa #$theDstOf #$Thing)

(#$isa #$theCLiquidOf #$Predicate)
(#$arity #$theCLiquidOf 2)
(#$arg1Isa #$theCLiquidOf #$Thing)
(#$arg2Isa #$theCLiquidOf #$Thing)

(#$isa #$active #$Predicate)
(#$arity #$active 1)
(#$arg1Isa #$active #$Thing)

;;;-----------------------------------------------------
;;; Physical objects and thermal properties definitions
;;;-----------------------------------------------------

;; Predicate definitions:
(#$isa #$qprop #$BinaryPredicate)
(#$arity #$qprop 2)
(#$arg1Isa #$qprop #$PhysicalQuantity)
(#$arg2Isa #$qprop #$PhysicalQuantity)

(#$isa #$qprop- #$BinaryPredicate)
(#$arity #$qprop- 2)
(#$arg1Isa #$qprop- #$PhysicalQuantity)
(#$arg2Isa #$qprop- #$PhysicalQuantity)

(#$isa #$correspondence #$Predicate)
(#$arity #$correspondence 4)
(#$arg1Isa #$correspondence #$ScalarInterval)
(#$arg2Isa #$correspondence #$ScalarInterval)
(#$arg3Isa #$correspondence #$ScalarInterval) 
(#$arg4Isa #$correspondence #$ScalarInterval)

;; Constant definitions:
(#$isa #$Physob #$Collection)
(#$genls #$Physob #$Thing)
(#$isa #$VolumetricPhysob #$Collection)
(#$genls #$VolumetricPhysob #$Physob)
(#$isa #$ThermalPhysob #$Collection)
(#$genls #$ThermalPhysob #$Physob)
(#$isa #$FinitThermalPhysob #$Collection)
(#$genls #$FinitThermalPhysob #$ThermalPhysob)
(#$isa #$TemperatureSource #$Collection)
(#$genls #$TemperatureSource #$Thing)

(#$isa #$heatSource #$UnaryPredicate)
(#$arity #$heatSource 1)
(#$arg1Isa #$heatSource #$Physob)

;; Assertions
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpEntity #$Physob))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpEntity #$VolumetricPhysob))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpEntity #$ThermalPhysob))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpEntity #$FiniteThermalPhysob))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpEntity #$TemperatureSource))

(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpRelation #$heatSource)) 
;; Why is #$heatSource defined as a relation?

(#$qpEntitySubclass #$VolumetricPhysob #$Physob)
;;;(#$genls #$VolumetricPhysob #$Physob)
(#$qpEntityQuantity #$VolumetricPhysob #$Pressure)
(#$qpEntityQuantityType #$VolumetricPhysob #$Pressure (#$QpQuantityFn #$Pressure))
(#$qpEntityQuantity #$VolumetricPhysob #$Volume)
(#$qpEntityQuantityType #$VolumetricPhysob #$Volume (#$QpQuantityFn #$Volume))

(#$forAll (?x)
          (#$implies (#$isa ?x #$VolumetricPhysob)
                     (#$and (#$isa ((#$QpQuantityFn #$Pressure) ?x) #$Quantity)
                            (#$isa ((#$QpQuantityFn #$Volume) ?x) #$Quantity))))

(#$qpEntitySubclass #$ThermalPhysob #$Physob)
;;;(#$genls #$ThermalPhysob #$Physob)
(#$qpEntityQuantity #$ThermalPhysob #$Heat)
(#$qpEntityQuantityType #$ThermalPhysob #$Heat (#$QpQuantityFn #$Heat))
(#$qpEntityQuantity #$ThermalPhysob #$Temperature)
(#$qpEntityQuantityType #$ThermalPhysob #$Temperature (#$QpQuantityFn #$Temperature))
(#$qpEntityConsequence #$ThermalPhysob (#$> #$Heat 0))
(#$qpEntityConsequence #$ThermalPhysob (#$> #$Temperature 0))

(#$forAll (?x)
          (#$implies (#$isa ?x #$ThermalPhysob)
                     (and (#$isa ((#$QpQuantityFn #$Heat) ?x) #$Quantity)
                          (#$isa ((#$QpQuantityFn #$Temperature) ?x) #$Quantity)
                          (#$> #$Heat 0)
                          (#$> #$Temperature 0))))

(#$qpEntitySubclass #$FiniteThermalPhysob #$ThermalPhysob)
;;;(#$genls #$FiniteThermalPhysob #$ThermalPhysob)
(#$qpEntityQuantity #$FiniteThermalPhysob #$Heat)
(#$qpEntityQuantityType #$FiniteThermalPhysob #$Heat (#$QpQuantityFn #$Heat))
(#$qpEntityQuantity #$FiniteThermalPhysob #$Temperature)
(#$qpEntityQuantityType #$FiniteThermalPhysob #$Temperature (#$QpQuantityFn #$Temperature))
(#$qpEntityConsequence #$FiniteThermalPhysob (#$qprop #$Temperature #$Heat))
(#$qpEntityConsequence #$FiniteThermalPhysob (#$correspondence #$Temperature #$Heat 0 0))

(#$forAll (?x)
          (#$implies (#$isa ?x #$FiniteThermalPhysob)
                     (and (#$isa ((#$QpQuantityFn #$Heat) ?x) #$Quantity)
                          (#$isa ((#$QpQuantityFn #$Temperature) ?x) #$Quantity)
                          (#$qprop #$Temperature #$Heat)
                          (#$correspondence #$Temperature #$Heat 0 0))))

(#$qpEntitySubclass #$TemperatureSource #$ThermalPhysob)
;;;(#$genls #$TemperatureSource #$ThermalPhysob)

;;;------------------  
;;; Contained stuffs
;;;------------------

;; Predicate definitions

;; Constant definitions
(#$isa #$ContainedStuffPossibility #$Collection)
(#$genls #$ContainedStuffPossibility #$ModelFragment)
(#$isa #$ContainedStuff #$Collection)
(#$genls #$ContainedStuff #$ModelFragment)
(#$isa #$ContainedLiquidProperties #$Collection)
(#$genls #$ContainedLiquidProperties #$ModelFragment)
(#$isa #$ContainedGasProperties #$Collection)
(#$genls #$ContainedGasProperties #$ModelFragment)


;; Assertions

(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpMF #$ContainedStuffPossibility))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpMF #$ContainedStuff))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpMF #$ContainedLiquidProperties))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpMF #$ContainedGasProperties))

;;;(#$qpMF #$ContainedStuffPossibility)
(#$qpMFParticipant #$ContainedStuffPossibility #$TheCan)
(#$qpMFParticipantType #$ContainedStuffPossibility #$TheCan #$Container)
(#$qpMFParticipant #$ContainedStuffPossibility #$ThePhase)
(#$qpMFParticipantType #$ContainedStuffPossibility #$ThePhase #$Phase)
(#$qpMFParticipant #$ContainedStuffPossibility #$TheSub)
(#$qpMFParticipantType #$ContainedStuffPossibility #$TheSub #$Substance)
(#$qpMFCondition #$ContainedStuffPossibility (#$canContainSubstance #$TheCan #$TheSub #$ThePhase))

(#$qpMFQuantity #$ContainedStuffPossibility #$AmountOf)
(#$qpMFQuantityArguments #$ContainedStuffPossibility #$AmountOf (#$TheSub #$ThePhase #$TheCan))
;;;(#$qpMFQuantityArgument #$ContainedStuffPossibility #$AmountOf #$ThePhase)
;;;(#$qpMFQuantityArgument #$ContainedStuffPossibility #$AmountOf #$TheCan)
(#$qpMFConsequence #$ContainedStuffPossibility (#$>= ((#$QpQuantityFn #$AmountOf) 
                                                      #$TheSub
                                                      #$ThePhase
                                                      #$TheCan) 0))
                                                
;; MF Contained-stuff:
(#$qpMFSubclass #$ContainedStuff #$physical-object)
(#$qpMFParticipant #$ContainedStuff #$TheCan)
(#$qpMFParticipantType #$ContainedStuff #$TheCan #$Container)
(#$qpMFParticipant #$ContainedStuff #$ThePhase)
(#$qpMFParticipantType #$ContainedStuff #$ThePhase #$Phase)
(#$qpMFParticipant #$ContainedStuff #$TheSub)
(#$qpMFParticipantType #$ContainedStuff #$TheSub #$Substance)

(#$qpMFCondition #$ContainedStuff (#$> ((#$QpQuantityFn #$AmountOf) #$TheSub #$ThePhase #$TheCan) 0)) 
(#$qpMFQuantity #$ContainedStuff #$Mass)
(#$qpMFQuantityType #$ContainedStuff #$Mass (#$QpQuantityFn #$Mass))
(#$qpMFConsequence #$ContainedStuff (#$q= #$Mass ((#$QpQuantityFn #$AmountOf) #$TheSub #$ThePhase #$TheCan)))

;;;(#$qpMFConsequence #$ContainedStuff (#$q= ((#$QpQuantityFn #$Mass) #$ContainedStuff)
;;;                                          ((#$QpQuantityFn #$AmountOf) #$TheSub #$ThePhase #$TheCan)))

(#$qpMFConsequence #$ContainedStuff (#$biconditional (#$self #$VolumetricPhysob)))
(#$qpMFConsequence #$ContainedStuff (#$biconditional (#$self #$FiniteThermalPhysob)))

(#$isa #$biconditional #$Predicate)
(#$arity #$biconditional 1)
(#$arg1Isa #$biconditional #$CycLAssertion)

(#$isa #$self #$Predicate)
(#$arity #$self 1)
(#$arg1Isa #$self #$Thing)

;;ContainedLiquidProperties MF:
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpMF #$ContainedLiquidProperties))
;;;(#$qpMF #$ContainedLiquidProperties)
(#$qpMFParticipant #$ContainedLiquidProperties #$TheCStuff)
(#$qpMFParticipantType #$ContainedLiquidProperties #$TheCStuff #$ContainedStuff)
(#$qpMFParticipantConstraint #$ContainedLiquidProperties #$TheCStuff (#$thePhaseOf #$TheCStuff #$Liquid))

(#$qpMFParticipant #$ContainedLiquidProperties #$TheSub)
(#$qpMFParticipantType #$ContainedLiquidProperties #$TheSub #$Substance)
(#$qpMFParticipantConstraint #$ContainedLiquidProperties #$TheSub (#$theSubOf #$TheCStuff #$TheSub))

(#$qpMFParticipant #$ContainedLiquidProperties #$TheCan)
(#$qpMFParticipantType #$ContainedLiquidProperties #$TheCan #$Container)
(#$qpMFParticipantConstraint #$ContainedLiquidProperties #$TheCan
                             (#$theCanOf #$TheCStuff #$TheCan))
(#$qpMFQuantity #$ContainedLiquidProperties #$Level)
(#$qpMFQuantityType #$ContainedLiquidProperties #$Level (#$QpQuantityFn #$Level))
(#$qpMFQuantityArguments #$ContainedLiquidProperties #$Level (#$TheCStuff))
(#$qpMFCondition #$ContainedLiquidProperties (#$active #$TheCStuff))
(#$qpMFConsequence #$ContainedLiquidProperties (#$function #$mass<-amount-of ((#$QpQuantityFn #$Mass) #$TheCStuff)
                                                           (((#$QpQuantityFn #$AmountOf) #$TheSub #$Liquid #$TheCan)) ()))
(#$qpMFConsequence #$ContainedLiquidProperties (#$function #$level<-mass&bottom 
                                                           ((#$QpQuantityFn #$Level) #$TheCStuff)
                                                           (((#$QpQuantityFn #$Mass) #$TheCStuff)) ()))
(#$qpMFConsequence #$ContainedLiquidProperties (#$correspondence ((#$QpQuantityFn #$Level) #$TheCStuff)
                                                                 ((#$QpQuantityFn #$Mass) #$TheCStuff)
                                                                 ((#$QpQuantityFn #$BottomHeight) #$TheCan)
                                                                 0))
(#$qpMFConsequence #$ContainedLiquidProperties (#$function #$pressure<-level 
                                                           ((#$QpQuantityFn #$Pressure) #$TheCStuff)
                                                           (((#$QpQuantityFn #$Level) #$TheCStuff))
                                                           ()))
(#$qpMFConsequence #$ContainedLiquidProperties (#$<= ((#$QpQuantityFn #$Temperature) #$TheCStuff)
                                                     ((#$QpQuantityFn #$TBoil) #$TheSub #$TheCan)))

(#$isa #$function #$Predicate) ;;not very nice way!! 
(#$arity #$function 3)
(#$arg1Isa #$function #$predicate)
(#$arg2Isa #$function #$PhysicalQuantity)
(#$arg2Isa #$function #$PhysicalQuantity)

(#$isa #$mass<-amount-of #$predicate)
(#$arity #$mass<-amount-of 2)
(#$arg1Isa #$mass<-amount-of #$PhysicalQuantity)
(#$arg2Isa #$mass<-amount-of #$PhysicalQuantity)

(#$isa #$pressure<-level #$predicate)
(#$arity #$pressure<-level 2)
(#$arg1Isa #$pressure<-level #$PhysicalQuantity)
(#$arg2Isa #$pressure<-level #$PhysicalQuantity)

(#$isa #$level<-mass&bottom #$predicate)
(#$arity #$level<-mass&bottom 2)
(#$arg1Isa #$level<-mass&bottom #$PhysicalQuantity)
(#$arg2Isa #$level<-mass&bottom #$PhysicalQuantity)

;;; MF ContainedCasProperties:

(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpMF #$ContainedGasProperties))
(#$qpMFParticipant #$ContainedGasProperties #$TheCStuff)
(#$qpMFParticipantType #$ContainedGasProperties #$TheCStuff #$ContainedStuff)
(#$qpMFParticipantConstraint #$ContainedGasProperties #$TheCStuff (#$thePhaseOf #$TheCStuff #$Gas))

(#$qpMFParticipant #$ContainedGasProperties #$TheSub)
(#$qpMFParticipantType #$ContainedGasProperties #$TheSub #$Substance)
(#$qpMFParticipantConstraint #$ContainedGasProperties #$TheSub (#$theSubOf #$TheCStuff #$TheSub))

(#$qpMFParticipant #$ContainedGasProperties #$TheCan)
(#$qpMFParticipantType #$ContainedGasProperties #$TheCan #$Container)
(#$qpMFParticipantConstraint #$ContainedGasProperties #$TheCan (#$theCanOf #$TheCStuff #$TheCan))

(#$qpMFCondition #$ContainedGasProperties (#$active #$TheCStuff))
(#$qpMFConsequence #$ContainedGasProperties (#$>= ((#$QpQuantityFn #$Temperature) #$TheCStuff)
                                                  ((#$QpQuantityFn #$TBoil) #$TheSub #$TheCan)))
(#$qpMFConsequence #$ContainedGasProperties (#$qprop ((#$QpQuantityFn #$Pressure) #$TheCStuff)
                                                     ((#$QpQuantityFn #$Mass) #$TheCStuff)))
(#$qpMFConsequence #$ContainedGasProperties (#$qprop- ((#$QpQuantityFn #$Pressure) #$TheCStuff)
                                                      ((#$QpQuantityFn #$Volume) #$TheCStuff)))
(#$qpMFConsequence #$ContainedGasProperties (#$qprop ((#$QpQuantityFn #$Pressure) #$TheCStuff)
                                                     ((#$QpQuantityFn #$Heat) #$TheCStuff)))

;;;----------------                
;;; Flow processes
;;;----------------

(#$isa #$HeatFlow #$Collection)
(#$genls #$HeatFlow #$ModelFragment)
(#$isa #$LiquidFlow #$Collection)
(#$genls #$LiquidFlow #$ModelFragment)

;; Predicate definitions
(#$isa #$heatAligned #$Predicate)
(#$arity #$heatAligned 1)
(#$arg1Isa #$heatAligned #$Thing)

;; Constant definitions
(#$isa #$physical-process #$Collection)
(#$genls #$physical-process #$ProcessingEvent) ;;!!! NOT SURE

(#$isa #$physical-object #$Collection)
(#$genls #$physical-object #$ModelFragment)

;; Assertions
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpMF #$HeatFlow))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpMF #$LiquidFlow))

;;;(#$qpMF #$HeatFlow)
(#$qpMFSubclass #$HeatFlow #$physical-process)
(#$qpMFParticipant #$HeatFlow #$TheSrc)
(#$qpMFParticipant #$HeatFlow #$TheDst)
(#$qpMFParticipant #$HeatFlow #$ThePath)
(#$qpMFParticipantType #$HeatFlow #$TheSrc #$ThermalPhysob)
(#$qpMFParticipantType #$HeatFlow #$TheDst #$ThermalPhysob)
(#$qpMFParticipantType #$HeatFlow #$ThePath #$HeatPath)
(#$qpMFParticipantConstraint #$HeatFlow #$ThePath (#$heatConnection #$ThePath #$TheSrc #$TheDst))
(#$qpMFCondition #$HeatFlow (#$heatAligned #$ThePath))
(#$qpMFCondition #$HeatFlow 
                 (#$> ((#$QpQuantityFn #$Temperature) #$TheSrc) ((#$QpQuantityFn #$Temperature) #$TheDst)))
(#$qpMFQuantity #$HeatFlow #$HeatFlowRate)

(#$isa #$- #$BinaryPredicate)
(#$arity #$- 2)
(#$arg1Isa #$- #$PhysicalQuantity)
(#$arg2Isa #$- #$PhysicalQuantity)

(#$isa #$q= #$BinaryPredicate)
(#$arity #$q= 2)
(#$arg1Isa #$q= #$PhysicalQuantity)
(#$arg2Isa #$q= #$PhysicalQuantity)

(#$isa #$i- #$BinaryPredicate)
(#$arity #$i- 2)
(#$arg1Isa #$i- #$PhysicalQuantity)
(#$arg2Isa #$i- #$PhysicalQuantity)

(#$isa #$i+ #$BinaryPredicate)
(#$arity #$i+ 2)
(#$arg1Isa #$i+ #$PhysicalQuantity)
(#$arg2Isa #$i+ #$PhysicalQuantity)

(#$qpMFConsequence #$HeatFlow (#$q= #$HeatFlowRate (#$- ((#$QpQuantityFn #$Temperature) #$TheSrc)
                                                        ((#$QpQuantityFn #$Temperature) #$TheDst))))
(#$qpMFConsequence #$HeatFlow (#$i- ((#$QpQuantityFn #$Heat) #$TheSrc) #$HeatFlowRate))
(#$qpMFConsequence #$HeatFlow (#$i+ ((#$QpQuantityFn #$Heat) #$TheDst) #$HeatFlowRate))

;; Liquid-flow

(#$qpMFSubclass #$LiquidFlow #$physical-process)
(#$qpMFParticipant #$LiquidFlow #$TheSrc)
(#$qpMFParticipant #$LiquidFlow #$TheSub)
(#$qpMFParticipant #$LiquidFlow #$TheDst)
(#$qpMFParticipantType #$LiquidFlow #$TheSrc #$Container)
(#$qpMFParticipantType #$LiquidFlow #$TheSub #$Substance)
(#$qpMFParticipantType #$LiquidFlow #$TheDst #$Container)

(#$qpMFParticipant #$LiquidFlow #$ThePath)
(#$qpMFParticipantType #$LiquidFlow #$ThePath #$FluidPath)
(#$qpMFParticipantConstraint #$LiquidFlow #$ThePath (#$fluidConnection #$ThePath #$TheSrc #$TheDst))

(#$qpMFParticipant #$LiquidFlow #$TheSrcStuff)
(#$qpMFParticipantType #$LiquidFlow #$TheSrcStuff #$ContainedStuff)
(#$qpMFParticipantConstraint #$LiquidFlow #$TheSrcStuff (#$thePhaseOf #$TheSrcStuff #$Liquid))
(#$qpMFParticipantConstraint #$LiquidFlow #$TheSrcStuff (#$theCanOf #$TheSrcStuff #$TheSrc))
(#$qpMFParticipantConstraint #$LiquidFlow #$TheSrcStuff (#$theSubOf #$TheSrcStuff #$TheSub))

(#$qpMFParticipant #$LiquidFlow #$TheDstStuff)
(#$qpMFParticipantType #$LiquidFlow #$TheDstStuff #$ContainedStuff)
(#$qpMFParticipantConstraint #$LiquidFlow #$TheDstStuff (#$thePhaseOf #$TheDstStuff #$Liquid))
(#$qpMFParticipantConstraint #$LiquidFlow #$TheDstStuff (#$theCanOf #$TheDstStuff #$TheDst))
(#$qpMFParticipantConstraint #$LiquidFlow #$TheDstStuff (#$theSubOf #$TheDstStuff #$TheSub))

(#$isa #$aligned #$Predicate)
(#$arity #$aligned 1)
(#$arg1Isa #$aligned #$Thing)

(#$qpMFCondition #$LiquidFlow (#$aligned #$ThePath))
(#$qpMFCondition #$LiquidFlow (#$> ((#$QpQuantityFn #$Pressure) #$TheSrcStuff) 
                                  ((#$QpQuantityFn #$Pressure) #$TheDstStuff)))
(#$qpMFQuantity #$LiquidFlow #$LiquidFlowRate)
(#$qpMFConsequence #$LiquidFlow (#$q= #$LiquidFlowRate (#$- ((#$QpQuantityFn #$Pressure) #$TheSrcStuff)
                                                            ((#$QpQuantityFn #$Pressure) #$TheDstStuff))))
(#$qpMFConsequence #$LiquidFlow (#$i- ((#$QpQuantityFn #$AmountOf) #$TheSub #$Liquid #$TheSrc) 
                                      #$LiquidFlowRate))
(#$qpMFConsequence #$LiquidFlow (#$i+ ((#$QpQuantityFn #$AmountOf) #$TheSub #$Liquid #$TheDst) 
                                     #$LiquidFlowRate))


;;;--------------- 
;;; Phase changes
;;;---------------

;; Assertions
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpMF #$Boiling))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpMF #$LatentHeatAbsorptionBySteam))
(#$inDomainTheory #$NaiveSteamDomainTheory (#$qpMF #$HeatReplenish))

;;;(#$isa ?Boiling #$ModelFragment)

;;;(#$qpMF #$Boiling)
(#$qpMFSubclass #$Boiling #$physical-process)

(#$qpMFParticipant #$Boiling #$TheCLiquid)
(#$qpMFParticipantType #$Boiling #$TheCLiquid #$ContainedStuff)
(#$qpMFParticipantConstraint #$Boiling #$TheCLiquid (#$thePhaseOf #$TheCLiquid #$Liquid))

(#$qpMFParticipant #$Boiling #$TheSub)
(#$qpMFParticipantType #$Boiling #$TheSub #$Substance)
(#$qpMFParticipantConstraint #$Boiling #$TheSub (#$theSubOf #$TheCLiquid #$TheSub))

(#$qpMFParticipant #$Boiling #$TheCan)
(#$qpMFParticipantType #$Boiling #$TheCan #$Container)
(#$qpMFParticipantConstraint #$Boiling #$TheCan (#$theCanOf #$TheCLiquid #$TheCan))

(#$qpMFParticipant #$Boiling #$TheHeatFlow)
(#$qpMFParticipantType #$Boiling #$TheHeatFlow #$HeatFlow)
(#$qpMFParticipantConstraint #$Boiling #$TheHeatFlow (#$theDstOf #$TheHeatFlow #$TheCLiquid))

(#$qpMFCondition #$Boiling (#$>= ((#$QpQuantityFn #$Temperature) #$TheCLiquid) 
                                 ((#$QpQuantityFn #$TBoil) #$TheSub #$TheCan)))
(#$qpMFCondition #$Boiling (#$active #$TheHeatFlow))

(#$qpMFQuantity #$Boiling #$GenerationRate)
(#$qpMFQuantityType #$Boiling #$GenerationRate (#$QpQuantityFn #$GenerationRate))
(#$qpMFConsequence #$Boiling (#$> #$GenerationRate 0))
(#$qpMFConsequence #$Boiling (#$i+ ((#$QpQuantityFn #$AmountOf) #$TheSub #$Gas #$TheCan)
                                   #$GenerationRate))
(#$qpMFConsequence #$Boiling (#$i- ((#$QpQuantityFn #$AmountOf) #$TheSub #$Liquid #$TheCan)
                                   #$GenerationRate))
(#$qpMFConsequence #$Boiling (#$i- ((#$QpQuantityFn #$Heat) #$TheCLiquid)
                                   ((#$QpQuantityFn #$HeatFlowRate) #$TheHeatFlow)))

;;; MF Latent-heat-absorption-by-steam:
;;;(#$qpMF #$LatentHeatAbsorptionBySteam)
(#$qpMFParticipant #$LatentHeatAbsorptionBySteam #$TheBoiling)
(#$qpMFParticipantType #$LatentHeatAbsorptionBySteam #$TheBoiling #$Boiling)
(#$qpMFParticipant #$LatentHeatAbsorptionBySteam #$TheSub)
(#$qpMFParticipantType #$LatentHeatAbsorptionBySteam #$TheSub #$Substance)
(#$qpMFParticipantConstraint #$LatentHeatAbsorptionBySteam #$TheSub (#$theSubOf #$TheBoiling #$TheSub))

(#$qpMFParticipant #$LatentHeatAbsorptionBySteam #$TheCan)
(#$qpMFParticipantType #$LatentHeatAbsorptionBySteam #$TheCan #$Container)
(#$qpMFParticipantConstraint #$LatentHeatAbsorptionBySteam #$TheCan (#$theCanOf #$TheBoiling #$TheCan))

(#$qpMFParticipant #$LatentHeatAbsorptionBySteam #$TheCGas)
(#$qpMFParticipantType #$LatentHeatAbsorptionBySteam #$TheCGas #$ContainedStuff)
(#$qpMFParticipantConstraint #$LatentHeatAbsorptionBySteam #$TheCGas (#$thePhaseOf #$TheCGas #$Gas))

(#$qpMFParticipant #$LatentHeatAbsorptionBySteam #$TheCLiquid)
(#$qpMFParticipantType #$LatentHeatAbsorptionBySteam #$TheCLiquid #$ContainedStuff)
(#$qpMFParticipantConstraint #$LatentHeatAbsorptionBySteam #$TheCLiquid (#$theCLiquidOf #$TheBoiling #$TheCLiquid))

(#$qpMFParticipant #$LatentHeatAbsorptionBySteam #$TheGasHeatFlow)
(#$qpMFParticipantType #$LatentHeatAbsorptionBySteam #$TheGasHeatFlow #$HeatFlow)
(#$qpMFParticipantConstraint #$LatentHeatAbsorptionBySteam #$TheGasHeatFlow 
                             (#$theDstOf #$TheGasHeatFlow #$TheCGas))

(#$qpMFCondition #$LatentHeatAbsorptionBySteam (#$active #$TheBoiling))
(#$qpMFCondition #$LatentHeatAbsorptionBySteam (#$active #$TheCLiquid))
(#$qpMFCondition #$LatentHeatAbsorptionBySteam (#$active #$TheCGas))
(#$qpMFCondition #$LatentHeatAbsorptionBySteam (#$active #$TheGasHeatFlow))

(#$qpMFQuantity #$LatentHeatAbsorptionBySteam #$HeatGenerationRate)
(#$qpMFQuantityType #$LatentHeatAbsorptionBySteam #$HeatGenerationRate (#$QpQuantityFn #$HeatGenerationRate))
(#$qpMFConsequence #$LatentHeatAbsorptionBySteam 
                   (#$> #$HeatGenerationRate 0))
(#$qpMFConsequence #$LatentHeatAbsorptionBySteam 
                   (#$i- ((#$QpQuantityFn #$Heat) #$TheCGas) ((#$QpQuantityFn #$HeatFlowRate) #$TheGasHeatFlow)))

;;; HeatReplenish

(#$isa #$HeatReplenish #$Collection)
(#$genls #$HeatReplenish #$ModelFragment)

(#$qpMFParticipant #$HeatReplenish #$TheSource)
(#$qpMFParticipantType #$HeatReplenish #$TheSource #$heatSource)
(#$qpMFCondition #$HeatReplenish (#$heatSource #$TheSource))
(#$qpMFQuantity #$HeatReplenish #$Restorative)
(#$qpMFQuantityType #$HeatReplenish #$Restorative (#$QpQuantityFn #$Restorative))
(#$qpMFConsequence #$HeatReplenish (#$i+ #$Heat #$Restorative))

;;;--------------
;;;Scenario
;;;--------------

(#$isa #$TwoContainers #$Scenario-Generalized)
(#$isa #$Wf #$Thing)
(#$isa #$Wg #$Thing)
(#$isa #$G #$Thing)
(#$isa #$F #$Thing)
(#$isa #$P1 #$Thing) 
(#$isa #$scenFragment #$Predicate)
(#$arity #$scenFragment 2)
(#$arg1Isa #$scenFrgment #$Scenario-Generalized)
(#$arg2Isa #$scenFragment #$Thing)
(#$isa #$scenFragmentBinding #$Predicate)
(#$arity #$scenFragmentBinding 2)
(#$arg1Isa #$scenFragmentBinding #$Thing)
(#$arg2Isa #$scenFragmentBinding #$CycLAssertion)
(#$isa #$scenIndividual #$Predicate)
(#$arity #$scenIndividual 2)
(#$arg1Isa #$scenIndividual #$Scenario-Generalized)
(#$arg2Isa #$scenIndividual #$Thing)
(#$isa #$scenIndividualType #$Predicate)
(#$arity #$scenIndividualType 2)
(#$arg1Isa #$scenIndividualType #$Thing)
(#$arg2Isa #$scenIndividualType #$Thing)
(#$isa #$scenThroughOut #$Predicate)
(#$arity #$scenThroughOut 2)
(#$arg1Isa #$scenThroughOut #$Scenario-Generalized)
(#$arg2Isa #$scenThroughOut #$CycLAssertion)

(#$comment #$TwoContainers "Two container example")
(#$scenFragment #$TwoContainers #$Wf)
(#$scenFragmentType #$Wf #$ContainedStuff)
(#$scenFragmentBinding #$Wf (#$isa #$F #$TheCan))
(#$scenFragmentBinding #$Wf (#$genls #$Liquid #$ThePhase))
(#$scenFragmentBinding #$Wf (#$genls #$Water #$TheSub))
(#$scenFragment #$TwoContainers #$Wg)
(#$scenFragmentType #$Wg #$ContainedStuff)
(#$scenFragmentBinding #$Wg (#$isa #$G #$TheCan))
(#$scenFragmentBinding #$Wg (#$genls #$Liquid #$ThePhase))
(#$scenFragmentBinding #$Wg (#$genls #$Water #$TheSub))
(#$scenIndividual #$TwoContainers #$F)
(#$scenIndividualType #$F #$Container)
(#$scenIndividual #$TwoContainers #$G)
(#$scenIndividualType #$G #$Container)
(#$scenIndividual #$TwoContainers #$Water)
(#$scenIndividualType #$Water #$Substance)
(#$scenIndividual #$TwoContainers #$Liquid)
(#$scenIndividualType #$Liquid #$Phase)
(#$scenIndividual #$TwoContainers #$P1)
(#$scenIndividualType #$P1 #$FluidPath)
(#$scenThroughOut #$TwoContainers (#$fluidConnection #$P1 #$F #$G))
(#$scenThroughOut #$TwoContainers (#$fluidConnection #$P1 #$G #$F))
(#$scenThroughOut #$TwoContainers (#$= ((#$QpQuantityFn #$BottomHeight) #$F) ((#$QpQuantityFn #$BottomHeight) #$G)))
(#$scenThroughOut #$TwoContainers (#$:=> (#$active #$Wf) (> ((#$QpQuantityFn #$TBoil) #$Water #$F) 
                                                            ((#$QpQuantityFn #$Temperature) #$Wf))))
(#$scenThroughOut #$TwoContainers (#$:=> (#$active #$Wg) (> ((#$QpQuantityFn #$TBoil) #$Water #$G) 
                                                            ((#$QpQuantityFn #$Temperature) #$Wg))))