module Drasil.SWHS.GenDefs (genDefs, htFluxWaterFromCoil, htFluxPCMFromWater,
  rocTempSimp, rocTempSimpDeriv, rocTempSimpRC) where

import Language.Drasil
import Utils.Drasil (weave)
import Theory.Drasil (GenDefn, gd, gdNoRefs, deModel', equationalModel')
import Language.Drasil.Chunk.Concept.NamedCombinators
import qualified Language.Drasil.Sentence.Combinators as S

import Data.Drasil.Concepts.Math (rOfChng, unit_)
import Data.Drasil.Concepts.Thermodynamics (lawConvCooling)

import Data.Drasil.Quantities.Math (uNormalVect, surface, gradient)
import Data.Drasil.Quantities.PhysicalProperties as QPP (vol, mass, density)
import Data.Drasil.Quantities.Physics as QP (time)
import Data.Drasil.Quantities.Thermodynamics as QT (heatCapSpec, temp)

import Drasil.SWHS.Assumptions (assumpCWTAT, assumpLCCCW, assumpLCCWP,
  assumpTPCAV, assumpDWPCoV, assumpSHECoV, assumpTHCCoT)
import Drasil.SWHS.Concepts (coil, gaussDiv, phaseChangeMaterial)
import Drasil.SWHS.References (koothoor2013)
import Drasil.SWHS.TMods (consThermE, nwtnCooling)
import Drasil.SWHS.Unitals (coilHTC, htFluxC, htFluxIn, htFluxOut, htFluxP,
  inSA, outSA, pcmHTC, tempC, tempPCM, tempW, thFluxVect, volHtGen)

---------------------------
--  General Definitions  --
---------------------------

--FIXME: genDefs, nwtnCoolingGD, and rocTempSimpGD were added--
--since referencing implementation for RelationConcept hasn't--
--stabilized yet (since RelationConcept isn't an instance of --
--the Referable class.                                       --
genDefs :: [GenDefn]
genDefs :: [GenDefn]
genDefs = [GenDefn
rocTempSimp, GenDefn
htFluxWaterFromCoil, GenDefn
htFluxPCMFromWater] 

rocTempSimp :: GenDefn
rocTempSimp :: GenDefn
rocTempSimp = forall u.
IsUnit u =>
ModelKind ModelExpr
-> Maybe u -> Maybe Derivation -> String -> [Sentence] -> GenDefn
gdNoRefs (forall e. RelationConcept -> ModelKind e
deModel' RelationConcept
rocTempSimpRC) (forall a. Maybe a
Nothing :: Maybe UnitDefn)
  (forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ Sentence -> [ConceptInstance] -> Derivation
rocTempSimpDeriv Sentence
rocTempDerivConsFlxSWHS
   [ConceptInstance
assumpCWTAT, ConceptInstance
assumpTPCAV, ConceptInstance
assumpDWPCoV, ConceptInstance
assumpSHECoV])
  String
"rocTempSimp" [{-Notes-}]

rocTempSimpRC :: RelationConcept
rocTempSimpRC :: RelationConcept
rocTempSimpRC = forall e.
Express e =>
String -> NP -> Sentence -> e -> RelationConcept
makeRC String
"rocTempSimpRC" (String -> NP
nounPhraseSP forall a b. (a -> b) -> a -> b
$ String
"Simplified rate " forall a. [a] -> [a] -> [a]
++
  String
"of change of temperature") Sentence
EmptyS ModelExpr
rocTempSimpRel

rocTempSimpRel :: ModelExpr
rocTempSimpRel :: ModelExpr
rocTempSimpRel = forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
QPP.mass forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
QT.heatCapSpec forall r. ExprC r => r -> r -> r
`mulRe`
  forall r c. (ModelExprC r, HasUID c, HasSymbol c) => r -> c -> r
deriv (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
QT.temp) UnitalChunk
QP.time forall r. ExprC r => r -> r -> r
$= (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
htFluxIn forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
inSA forall r. ExprC r => r -> r -> r
$-
  (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
htFluxOut forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
outSA)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
volHtGen forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
QPP.vol)

----

htFluxWaterFromCoil :: GenDefn
htFluxWaterFromCoil :: GenDefn
htFluxWaterFromCoil = forall u.
IsUnit u =>
ModelKind ModelExpr
-> Maybe u
-> Maybe Derivation
-> [DecRef]
-> String
-> [Sentence]
-> GenDefn
gd (forall e. QDefinition e -> ModelKind e
equationalModel' ModelQDef
htFluxWaterFromCoilQD) (forall u. MayHaveUnit u => u -> Maybe UnitDefn
getUnit UnitalChunk
htFluxC) forall a. Maybe a
Nothing
  [forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
koothoor2013] String
"htFluxWaterFromCoil"
  [UnitalChunk -> ConceptInstance -> ConceptChunk -> Sentence
newtonLawNote UnitalChunk
htFluxC ConceptInstance
assumpLCCCW ConceptChunk
coil, forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpTHCCoT]

htFluxWaterFromCoilQD :: ModelQDef
htFluxWaterFromCoilQD :: ModelQDef
htFluxWaterFromCoilQD = forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef UnitalChunk
htFluxC ModelExpr
htFluxWaterFromCoilExpr

htFluxWaterFromCoilExpr :: ModelExpr
htFluxWaterFromCoilExpr :: ModelExpr
htFluxWaterFromCoilExpr = forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
coilHTC forall r. ExprC r => r -> r -> r
`mulRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
tempC forall r. ExprC r => r -> r -> r
$- forall r f a.
(ExprC r, HasUID f, HasSymbol f, HasUID a, HasSymbol a) =>
f -> a -> r
apply1 ConstrConcept
tempW UnitalChunk
time)

--Can't include info in description beyond definition of variables?
----

htFluxPCMFromWater :: GenDefn
htFluxPCMFromWater :: GenDefn
htFluxPCMFromWater = forall u.
IsUnit u =>
ModelKind ModelExpr
-> Maybe u
-> Maybe Derivation
-> [DecRef]
-> String
-> [Sentence]
-> GenDefn
gd (forall e. QDefinition e -> ModelKind e
equationalModel' ModelQDef
htFluxPCMFromWaterQD) (forall u. MayHaveUnit u => u -> Maybe UnitDefn
getUnit UnitalChunk
htFluxP) forall a. Maybe a
Nothing
  [forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
koothoor2013] String
"htFluxPCMFromWater"
  [UnitalChunk -> ConceptInstance -> ConceptChunk -> Sentence
newtonLawNote UnitalChunk
htFluxP ConceptInstance
assumpLCCWP ConceptChunk
phaseChangeMaterial]

htFluxPCMFromWaterQD :: ModelQDef
htFluxPCMFromWaterQD :: ModelQDef
htFluxPCMFromWaterQD = forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef UnitalChunk
htFluxP ModelExpr
htFluxPCMFromWaterExpr

htFluxPCMFromWaterExpr :: ModelExpr
htFluxPCMFromWaterExpr :: ModelExpr
htFluxPCMFromWaterExpr = forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
pcmHTC forall r. ExprC r => r -> r -> r
`mulRe` (forall r f a.
(ExprC r, HasUID f, HasSymbol f, HasUID a, HasSymbol a) =>
f -> a -> r
apply1 ConstrConcept
tempW UnitalChunk
time forall r. ExprC r => r -> r -> r
$- forall r f a.
(ExprC r, HasUID f, HasSymbol f, HasUID a, HasSymbol a) =>
f -> a -> r
apply1 ConstrConcept
tempPCM UnitalChunk
time)

newtonLawNote :: UnitalChunk -> ConceptInstance -> ConceptChunk -> Sentence
newtonLawNote :: UnitalChunk -> ConceptInstance -> ConceptChunk -> Sentence
newtonLawNote UnitalChunk
u ConceptInstance
a ConceptChunk
c = [Sentence] -> Sentence
foldlSent [forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
u Sentence -> Sentence -> Sentence
`S.is` String -> Sentence
S String
"found by assuming that",
  forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
lawConvCooling, String -> Sentence
S String
"applies" Sentence -> Sentence -> Sentence
+:+. Sentence -> Sentence
sParen (forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
a), String -> Sentence
S String
"This law",
  Sentence -> Sentence
sParen (String -> Sentence
S String
"defined" Sentence -> Sentence -> Sentence
`S.in_` forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS TheoryModel
nwtnCooling) Sentence -> Sentence -> Sentence
`S.is` String -> Sentence
S String
"used on",
  forall n. NounPhrase n => n -> Sentence
phraseNP (UnitalChunk
surface forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`the_ofThe` ConceptChunk
c)]

--------------------------------------
--  General Definitions Derivation  --
--------------------------------------

rocTempSimpDeriv :: Sentence -> [ConceptInstance] -> Derivation
rocTempSimpDeriv :: Sentence -> [ConceptInstance] -> Derivation
rocTempSimpDeriv Sentence
s [ConceptInstance]
a = Sentence -> [Sentence] -> Derivation
mkDerivName (String -> Sentence
S String
"simplified" Sentence -> Sentence -> Sentence
+:+ forall n. NounPhrase n => n -> Sentence
phraseNP (ConceptChunk
rOfChng forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_` UnitalChunk
temp))
  (forall a. [[a]] -> [a]
weave [Sentence -> [ConceptInstance] -> [Sentence]
rocTempSimpDerivSent Sentence
s [ConceptInstance]
a, forall a b. (a -> b) -> [a] -> [b]
map ModelExpr -> Sentence
eS [ModelExpr]
rocTempSimpDerivEqns])

rocTempSimpDerivSent :: Sentence -> [ConceptInstance] -> [Sentence]
rocTempSimpDerivSent :: Sentence -> [ConceptInstance] -> [Sentence]
rocTempSimpDerivSent Sentence
s [ConceptInstance]
a = forall a b. (a -> b) -> [a] -> [b]
map [Sentence] -> Sentence
foldlSentCol [[Sentence]
rocTempDerivInteg, [Sentence]
rocTempDerivGauss,
  [Sentence]
rocTempDerivArbVol, Sentence -> [ConceptInstance] -> [Sentence]
rocTempDerivConsFlx Sentence
s [ConceptInstance]
a, [Sentence]
rocTempDerivDens]

rocTempDerivInteg :: [Sentence]
rocTempDerivInteg :: [Sentence]
rocTempDerivInteg = [String -> Sentence
S String
"Integrating", forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS TheoryModel
consThermE, String -> Sentence
S String
"over a",
  forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
vol, Sentence -> Sentence
sParen (forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
vol) Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"we have"]

rocTempDerivGauss :: [Sentence]
rocTempDerivGauss :: [Sentence]
rocTempDerivGauss = [String -> Sentence
S String
"Applying", forall n. NamedIdea n => n -> Sentence
titleize ConceptChunk
gaussDiv, String -> Sentence
S String
"to the first term over",
  (forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
surface Sentence -> Sentence -> Sentence
+:+ forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
surface Sentence -> Sentence -> Sentence
`S.the_ofThe` forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
vol) Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"with",
  forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
thFluxVect, String -> Sentence
S String
"as the", forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
thFluxVect, String -> Sentence
S String
"for the",
  forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
surface Sentence -> Sentence -> Sentence
`S.and_` forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
uNormalVect, String -> Sentence
S String
"as a", forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
unit_,
  String -> Sentence
S String
"outward", forall n. NamedIdea n => n -> Sentence
phrase DefinedQuantityDict
uNormalVect, String -> Sentence
S String
"for a", forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
surface]

rocTempDerivArbVol :: [Sentence]
rocTempDerivArbVol :: [Sentence]
rocTempDerivArbVol = [String -> Sentence
S String
"We consider an arbitrary" Sentence -> Sentence -> Sentence
+:+. forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
vol,
  forall n. NounPhrase n => n -> Sentence
atStartNP (forall t. NamedIdea t => t -> NP
the UnitalChunk
volHtGen), String -> Sentence
S String
"is assumed constant. Then", Int -> Sentence
eqN Int
1, String -> Sentence
S String
"can be written as"]

rocTempDerivConsFlx :: Sentence -> [ConceptInstance] -> [Sentence]
rocTempDerivConsFlx :: Sentence -> [ConceptInstance] -> [Sentence]
rocTempDerivConsFlx Sentence
s [ConceptInstance]
assumps = [String -> Sentence
S String
"Where", 
  SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List (forall a b. (a -> b) -> [a] -> [b]
map forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch [UnitalChunk
htFluxIn, UnitalChunk
htFluxOut, UnitalChunk
inSA, UnitalChunk
outSA]),
  String -> Sentence
S String
"are explained in" Sentence -> Sentence -> Sentence
+:+. forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
rocTempSimp, Sentence
s, String -> Sentence
S String
"Assuming", 
  SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List (forall a b. (a -> b) -> [a] -> [b]
map forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch [UnitalChunk
density, UnitalChunk
QT.heatCapSpec, UnitalChunk
QT.temp]),
  String -> Sentence
S String
"are constant over the", forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
vol Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"which is true in our case by",
  SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List (forall a b. (a -> b) -> [a] -> [b]
map forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS [ConceptInstance]
assumps) Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"we have"]

rocTempDerivConsFlxSWHS :: Sentence
rocTempDerivConsFlxSWHS :: Sentence
rocTempDerivConsFlxSWHS = [Sentence] -> Sentence
foldlSent [String -> Sentence
S String
"The integral over the", forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
surface,
  String -> Sentence
S String
"could be simplified because the thermal flux is assumed constant over",
  forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
inSA Sentence -> Sentence -> Sentence
`S.and_` forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
outSA Sentence -> Sentence -> Sentence
`S.and_` ModelExpr -> Sentence
eS (forall r. LiteralC r => Integer -> r
exactDbl Integer
0), String -> Sentence
S String
"on all other" Sentence -> Sentence -> Sentence
+:+. forall n. NamedIdea n => n -> Sentence
plural UnitalChunk
surface,
  String -> Sentence
S String
"Outward flux is considered positive"]

rocTempDerivDens :: [Sentence]
rocTempDerivDens :: [Sentence]
rocTempDerivDens = [String -> Sentence
S String
"Using the fact that", forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
density Sentence -> Sentence -> Sentence
:+: String -> Sentence
S String
"=" Sentence -> Sentence -> Sentence
:+: forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
mass Sentence -> Sentence -> Sentence
:+:
  String -> Sentence
S String
"/" Sentence -> Sentence -> Sentence
:+: forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
vol Sentence -> Sentence -> Sentence
`sC` Int -> Sentence
eqN Int
2, String -> Sentence
S String
"can be written as"]

-- TODO: Move the below expressions to a new Expressions.hs file.

rocTempDerivIntegEq, rocTempDerivGaussEq, rocTempDerivArbVolEq,
  rocTempDerivConsFlxEq, rocTempDerivDensEq :: ModelExpr

rocTempDerivIntegEq :: ModelExpr
rocTempDerivIntegEq = forall r. ExprC r => r -> r
neg (forall r. ModelExprC r => Symbol -> r -> r
intAll (forall q. HasSymbol q => q -> Symbol
eqSymb UnitalChunk
vol) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
gradient forall r. ExprC r => r -> r -> r
$. forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
thFluxVect)) forall r. ExprC r => r -> r -> r
`addRe`
  forall r. ModelExprC r => Symbol -> r -> r
intAll (forall q. HasSymbol q => q -> Symbol
eqSymb UnitalChunk
vol) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
volHtGen) forall r. ExprC r => r -> r -> r
$=
  forall r. ModelExprC r => Symbol -> r -> r
intAll (forall q. HasSymbol q => q -> Symbol
eqSymb UnitalChunk
vol) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
density
  forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
QT.heatCapSpec forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ModelExprC r, HasUID c, HasSymbol c) => r -> c -> r
pderiv (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
QT.temp) UnitalChunk
time)

rocTempDerivGaussEq :: ModelExpr
rocTempDerivGaussEq = forall r. ExprC r => r -> r
neg (forall r. ModelExprC r => Symbol -> r -> r
intAll (forall q. HasSymbol q => q -> Symbol
eqSymb UnitalChunk
surface) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
thFluxVect forall r. ExprC r => r -> r -> r
$. forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
uNormalVect)) forall r. ExprC r => r -> r -> r
`addRe`
  forall r. ModelExprC r => Symbol -> r -> r
intAll (forall q. HasSymbol q => q -> Symbol
eqSymb UnitalChunk
vol) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
volHtGen) forall r. ExprC r => r -> r -> r
$= 
  forall r. ModelExprC r => Symbol -> r -> r
intAll (forall q. HasSymbol q => q -> Symbol
eqSymb UnitalChunk
vol)
  (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
density forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
QT.heatCapSpec forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ModelExprC r, HasUID c, HasSymbol c) => r -> c -> r
pderiv (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
QT.temp) UnitalChunk
time)

rocTempDerivArbVolEq :: ModelExpr
rocTempDerivArbVolEq = (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
htFluxIn forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
inSA forall r. ExprC r => r -> r -> r
$- (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
htFluxOut forall r. ExprC r => r -> r -> r
`mulRe`
  forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
outSA)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
volHtGen forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
vol) forall r. ExprC r => r -> r -> r
$= 
  forall r. ModelExprC r => Symbol -> r -> r
intAll (forall q. HasSymbol q => q -> Symbol
eqSymb UnitalChunk
vol) (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
density forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
QT.heatCapSpec forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ModelExprC r, HasUID c, HasSymbol c) => r -> c -> r
pderiv (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
QT.temp) UnitalChunk
time)

rocTempDerivConsFlxEq :: ModelExpr
rocTempDerivConsFlxEq = forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
density forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
QT.heatCapSpec forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
vol forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ModelExprC r, HasUID c, HasSymbol c) => r -> c -> r
deriv
  (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
QT.temp) UnitalChunk
time forall r. ExprC r => r -> r -> r
$= (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
htFluxIn forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
inSA forall r. ExprC r => r -> r -> r
$- (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
htFluxOut forall r. ExprC r => r -> r -> r
`mulRe`
  forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
outSA)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
volHtGen forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
vol)

rocTempDerivDensEq :: ModelExpr
rocTempDerivDensEq = forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
mass forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
QT.heatCapSpec forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ModelExprC r, HasUID c, HasSymbol c) => r -> c -> r
deriv (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
QT.temp)
  UnitalChunk
time forall r. ExprC r => r -> r -> r
$= (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
htFluxIn forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
inSA forall r. ExprC r => r -> r -> r
$- (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
htFluxOut
  forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
outSA)) forall r. ExprC r => r -> r -> r
`addRe` (forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
volHtGen forall r. ExprC r => r -> r -> r
`mulRe` forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
vol)

rocTempSimpDerivEqns :: [ModelExpr]
rocTempSimpDerivEqns :: [ModelExpr]
rocTempSimpDerivEqns = [ModelExpr
rocTempDerivIntegEq, ModelExpr
rocTempDerivGaussEq, ModelExpr
rocTempDerivArbVolEq, ModelExpr
rocTempDerivConsFlxEq,
  ModelExpr
rocTempDerivDensEq]