{-# LANGUAGE PostfixOperators #-}
module Drasil.SSP.IMods where

import Prelude hiding (tan, product, sin, cos)

import Language.Drasil
import Theory.Drasil
import Utils.Drasil (weave)
import Language.Drasil.Chunk.Concept.NamedCombinators
import qualified Language.Drasil.Sentence.Combinators as S
import Drasil.DocLang.SRS (propCorSol)

-- Needed for derivations
import Data.Drasil.Concepts.Documentation (analysis, assumption, constraint,
  definition, first, goal, method_, physical, problem, solution, value)
import Data.Drasil.Concepts.Math (angle, equation, leftSide)
import Data.Drasil.Concepts.PhysicalProperties (mass)
import Data.Drasil.Concepts.Physics (force)

import Drasil.SSP.Assumptions (assumpSSC, assumpINSFL,
  assumpES, assumpSF, assumpSL)
import Drasil.SSP.BasicExprs (eqlExpr, eqlExprN, eqlExprSepG, eqlExprNSepG,
  eqlExprNoKQ, eqlExprNNoKQ, sliceExpr, momExpr, momExprNoKQ)
import Drasil.SSP.DataDefs (convertFunc1, convertFunc2,
  intersliceWtrF, lengthB, angleA, angleB, slcHeight, ratioVariation)
import Drasil.SSP.GenDefs (normShrRGD, momentEqlGD, normForcEqGD, mobShearWOGD,
  resShearWOGD, bsShrFEqGD, mobShrGD, srfWtrFGD)
import Drasil.SSP.Goals (goals, identifyCritAndFSGS)
import Drasil.SSP.Defs (crtSlpSrf, factorOfSafety, morPrice, slice,
  slpSrf, ssa)
import Drasil.SSP.References (chen2005, li2010, karchewski2012)
import Drasil.SSP.TMods (equilibrium, mcShrStrgth)
import Drasil.SSP.Unitals (baseAngle, baseHydroForce, baseLngth, baseWthX,
  critCoords,
  effCohesion, constF, dryWeight, earthqkLoadFctr, fricAngle, fs, fsMin,
  index, indx1, indxn, intNormForce, intShrForce, inxi, inxiM1, midpntHght,
  minFunction, mobShrC, mobShrI, nrmForceSum, nrmShearNum, normToShear,
  nrmFSubWat, numbSlices, satWeight, scalFunc, shearFNoIntsl, nrmShearDen,
  shearRNoIntsl, shrResC, slipDist, slipHght, slopeDist, slopeHght, sum1toN,
  surfAngle, surfHydroForce, surfLoad, totNrmForce, varblV, watrForce,
  waterDist, waterHght, waterWeight, watForceSum, xi, xMaxExtSlip, xMaxEtrSlip,
  xMinExtSlip, xMinEtrSlip, yi, yMaxSlip, yMinSlip)

---------------------
-- Instance Models --
---------------------

iMods :: [InstanceModel]
iMods :: [InstanceModel]
iMods = [InstanceModel
fctSfty, InstanceModel
nrmShrFor, InstanceModel
nrmShrForNum, InstanceModel
nrmShrForDen, InstanceModel
intsliceFs, InstanceModel
crtSlpId]

--

fctSfty :: InstanceModel
fctSfty :: InstanceModel
fctSfty = ModelKind Relation
-> Inputs
-> Output
-> OutputConstraints
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> InstanceModel
im (QDefinition Relation -> ModelKind Relation
forall e. QDefinition e -> ModelKind e
equationalModel' QDefinition Relation
fctSftyQD)
 [UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeDist, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeHght, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterHght, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
effCohesion, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
fricAngle,
  UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
dryWeight, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
satWeight, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterWeight, UnitalChunk -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipDist, UnitalChunk -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipHght, DefinedQuantityDict -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC DefinedQuantityDict
constF]
  (ConstrConcept -> Output
forall q. (Quantity q, MayHaveUnit q) => q -> Output
qw ConstrConcept
fs) [] ((Citation -> DecRef) -> [Citation] -> [DecRef]
forall a b. (a -> b) -> [a] -> [b]
map Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef [Citation
chen2005, Citation
karchewski2012])
  (Derivation -> Maybe Derivation
forall a. a -> Maybe a
Just Derivation
fctSftyDeriv) String
"fctSfty" [Sentence
fctSftyDesc]

fctSftyQD :: SimpleQDef
fctSftyQD :: QDefinition Relation
fctSftyQD = ConstrConcept -> NP -> Relation -> QDefinition Relation
forall c e.
(Quantity c, MayHaveUnit c) =>
c -> NP -> e -> QDefinition e
mkQuantDef' ConstrConcept
fs NP
factorOfSafety Relation
PExpr
fctSftyExpr

fctSftyExpr :: PExpr
fctSftyExpr :: PExpr
fctSftyExpr = UnitalChunk -> r
forall {c}. (HasUID c, HasSymbol c) => c -> r
sumOp UnitalChunk
shearRNoIntsl r -> r -> r
forall r. ExprC r => r -> r -> r
$/ UnitalChunk -> r
forall {c}. (HasUID c, HasSymbol c) => c -> r
sumOp UnitalChunk
shearFNoIntsl
  where prodOp :: r
prodOp = Symbol -> r -> r -> r -> r
forall r. ExprC r => Symbol -> r -> r -> r -> r
defprod (DefinedQuantityDict -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb DefinedQuantityDict
varblV) (DefinedQuantityDict -> r
forall {c}. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index) (DefinedQuantityDict -> r
forall {c}. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1)
          (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall {c}. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall {c}. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
varblV))
        sumOp :: c -> r
sumOp c
sym = Symbol -> r -> r -> r -> r
forall r. ExprC r => Symbol -> r -> r -> r -> r
defsum (DefinedQuantityDict -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb DefinedQuantityDict
index) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) (DefinedQuantityDict -> r
forall {c}. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1)
          (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (c -> r
forall {c}. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy c
sym) (DefinedQuantityDict -> r
forall {c}. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r
prodOp) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ r -> r -> r
forall r. ExprC r => r -> r -> r
idx (c -> r
forall {c}. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy c
sym) (DefinedQuantityDict -> r
forall {c}. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices)

fctSftyDesc :: Sentence
fctSftyDesc :: Sentence
fctSftyDesc = SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List [UnitalChunk
shearRNoIntsl UnitalChunk -> GenDefn -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` GenDefn
resShearWOGD,
  DefinedQuantityDict
mobShrC DefinedQuantityDict -> DataDefinition -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
convertFunc2,
  UnitalChunk
shearFNoIntsl UnitalChunk -> GenDefn -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` GenDefn
mobShearWOGD]

fctSftyDeriv :: Derivation
fctSftyDeriv :: Derivation
fctSftyDeriv = [Sentence] -> Derivation
mkDerivNoHeader ([[Sentence]] -> [Sentence]
forall a. [[a]] -> [a]
weave [[Sentence]
fctSftyDerivSentences1, (ModelExpr -> Sentence) -> [ModelExpr] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map ModelExpr -> Sentence
eS [ModelExpr]
forall r. (ExprC r, LiteralC r) => [r]
fctSftyDerivEqns1] [Sentence] -> [Sentence] -> [Sentence]
forall a. [a] -> [a] -> [a]
++
  (ModelExpr -> Sentence) -> [ModelExpr] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map ModelExpr -> Sentence
eS [ModelExpr
PExpr
fctSftyDerivEqn10b, ModelExpr
PExpr
fctSftyDerivEqn10c] [Sentence] -> [Sentence] -> [Sentence]
forall a. [a] -> [a] -> [a]
++ [Sentence
fctSftyDerivEllipsis] [Sentence] -> [Sentence] -> [Sentence]
forall a. [a] -> [a] -> [a]
++
  (ModelExpr -> Sentence) -> [ModelExpr] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map ModelExpr -> Sentence
eS [ModelExpr
PExpr
fctSftyDerivEqn10d, ModelExpr
PExpr
fctSftyDerivEqn10e, ModelExpr
PExpr
fctSftyDerivEqn10f] [Sentence] -> [Sentence] -> [Sentence]
forall a. [a] -> [a] -> [a]
++
  [[Sentence]] -> [Sentence]
forall a. [[a]] -> [a]
weave [[Sentence]
fctSftyDerivSentences2, (ModelExpr -> Sentence) -> [ModelExpr] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map ModelExpr -> Sentence
eS [ModelExpr]
forall r. (ExprC r, LiteralC r) => [r]
fctSftyDerivEqns2] [Sentence] -> [Sentence] -> [Sentence]
forall a. [a] -> [a] -> [a]
++
  [Sentence]
fctSftyDerivSentence20)

fctSftyDerivSentences1 :: [Sentence]
fctSftyDerivSentences1 :: [Sentence]
fctSftyDerivSentences1 = ([Sentence] -> Sentence) -> [[Sentence]] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map [Sentence] -> Sentence
foldlSentCol [[Sentence]
fctSftyDerivSentence1,
  [Sentence]
fctSftyDerivSentence2, [Sentence]
fctSftyDerivSentence3, [Sentence]
fctSftyDerivSentence4,
  [Sentence]
fctSftyDerivSentence5, [Sentence]
fctSftyDerivSentence6, [Sentence]
fctSftyDerivSentence7,
  [Sentence]
fctSftyDerivSentence8, [Sentence]
fctSftyDerivSentence9, [Sentence]
fctSftyDerivSentence10]

fctSftyDerivSentences2 :: [Sentence]
fctSftyDerivSentences2 :: [Sentence]
fctSftyDerivSentences2 = ([Sentence] -> Sentence) -> [[Sentence]] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map [Sentence] -> Sentence
foldlSentCol [[Sentence]
fctSftyDerivSentence11,
  [Sentence]
fctSftyDerivSentence12, [Sentence]
fctSftyDerivSentence13, [Sentence]
fctSftyDerivSentence14,
  [Sentence]
fctSftyDerivSentence15, [Sentence]
fctSftyDerivSentence16, [Sentence]
fctSftyDerivSentence17,
  [Sentence]
fctSftyDerivSentence18, [Sentence]
fctSftyDerivSentence19]

fctSftyDerivEqns1 :: (ExprC r, LiteralC r) => [r]
fctSftyDerivEqns1 :: forall r. (ExprC r, LiteralC r) => [r]
fctSftyDerivEqns1 = [r
PExpr
fctSftyDerivEqn1, r
PExpr
fctSftyDerivEqn2, r
PExpr
fctSftyDerivEqn3,
  r
PExpr
fctSftyDerivEqn4, r
PExpr
fctSftyDerivEqn5, r
PExpr
fctSftyDerivEqn6, r
PExpr
fctSftyDerivEqn7,
  r
PExpr
fctSftyDerivEqn8, r
PExpr
fctSftyDerivEqn9, r
PExpr
fctSftyDerivEqn10a]

fctSftyDerivEqns2 :: (ExprC r, LiteralC r) => [r]
fctSftyDerivEqns2 :: forall r. (ExprC r, LiteralC r) => [r]
fctSftyDerivEqns2 = [r
PExpr
fctSftyDerivEqn11, r
PExpr
fctSftyDerivEqn12, r
PExpr
fctSftyDerivEqn13,
  r
PExpr
fctSftyDerivEqn14, r
PExpr
fctSftyDerivEqn15, r
PExpr
fctSftyDerivEqn16, r
PExpr
fctSftyDerivEqn17,
  r
PExpr
fctSftyDerivEqn18, ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$= r
PExpr
fctSftyExpr]

fctSftyDerivSentence1 :: [Sentence]
fctSftyDerivSentence1 :: [Sentence]
fctSftyDerivSentence1 = [NP -> Sentence
forall n. NounPhrase n => n -> Sentence
atStartNP (UnitalChunk -> NP
forall t. NamedIdea t => t -> NP
the UnitalChunk
mobShrI), GenDefn -> Sentence
forall r. (Referable r, HasShortName r) => r -> Sentence
definedIn'' GenDefn
bsShrFEqGD, 
  String -> Sentence
S String
"can be substituted into the definition" Sentence -> Sentence -> Sentence
`S.of_` UnitalChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
mobShrI, 
  String -> Sentence
S String
"based on the", ConstrConcept -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase ConstrConcept
fs Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"from",
  GenDefn -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
mobShrGD, String -> Sentence
S String
"yielding", Int -> Sentence
eqN Int
1, String -> Sentence
S String
"below"]

fctSftyDerivSentence2 :: [Sentence]
fctSftyDerivSentence2 :: [Sentence]
fctSftyDerivSentence2 = [String -> Sentence
S String
"An expression for the", UnitalChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
nrmFSubWat Sentence -> Sentence -> Sentence
`sC`
  UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
nrmFSubWat Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"can be derived by substituting the",
  UnitalChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
totNrmForce, String -> Sentence
S String
"equilibrium from", GenDefn -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
normForcEqGD,
  String -> Sentence
S String
"into the definition" Sentence -> Sentence -> Sentence
`S.for` UnitalChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
nrmFSubWat, String -> Sentence
S String
"from" Sentence -> Sentence -> Sentence
+:+. GenDefn -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
resShearWOGD, String -> Sentence
S String
"This results in", Int -> Sentence
eqN Int
2]

fctSftyDerivSentence3 :: [Sentence]
fctSftyDerivSentence3 :: [Sentence]
fctSftyDerivSentence3 = [String -> Sentence
S String
"Substituting", Int -> Sentence
eqN Int
2, String -> Sentence
S String
"into", Int -> Sentence
eqN Int
1, String -> Sentence
S String
"gives"]

fctSftyDerivSentence4 :: [Sentence]
fctSftyDerivSentence4 :: [Sentence]
fctSftyDerivSentence4 = [String -> Sentence
S String
"Since the", UnitalChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
intShrForce,
  UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
intShrForce Sentence -> Sentence -> Sentence
`S.and_` UnitalChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
intNormForce, UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
intNormForce,
  String -> Sentence
S String
"are unknown" Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"they are separated from the other terms as follows"]

fctSftyDerivSentence5 :: [Sentence]
fctSftyDerivSentence5 :: [Sentence]
fctSftyDerivSentence5 = [String -> Sentence
S String
"Applying assumptions", ConceptInstance -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpSF Sentence -> Sentence -> Sentence
`S.and_`
  ConceptInstance -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpSL Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"which state that the",
  NP -> Sentence
forall n. NounPhrase n => n -> Sentence
phraseNP (DefinedQuantityDict
earthqkLoadFctr DefinedQuantityDict -> UnitalChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`andThe` UnitalChunk
surfLoad) Sentence -> Sentence -> Sentence
`sC`
  String -> Sentence
S String
"respectively" Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"are zero" Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"allows" Sentence -> Sentence -> Sentence
`S.for` String -> Sentence
S String
"further simplification as shown below"]

fctSftyDerivSentence6 :: [Sentence]
fctSftyDerivSentence6 :: [Sentence]
fctSftyDerivSentence6 = [String -> Sentence
S String
"The definitions of", GenDefn -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
resShearWOGD
  Sentence -> Sentence -> Sentence
`S.and_` GenDefn -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
mobShearWOGD, String -> Sentence
S String
"are present in this equation" Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"and",
  String -> Sentence
S String
"thus can be replaced by", ModelExpr -> Sentence
eS (UnitalChunk -> ModelExpr
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearRNoIntsl) Sentence -> Sentence -> Sentence
`S.and_`
  ModelExpr -> Sentence
eS (UnitalChunk -> ModelExpr
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearFNoIntsl) Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"respectively"]

fctSftyDerivSentence7 :: [Sentence]
fctSftyDerivSentence7 :: [Sentence]
fctSftyDerivSentence7 = [NP -> Sentence
forall n. NounPhrase n => n -> Sentence
atStartNP (UnitalChunk -> NP
forall t. NamedIdea t => t -> NP
the UnitalChunk
intShrForce), UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
intShrForce,
  String -> Sentence
S String
"can be expressed in terms" Sentence -> Sentence -> Sentence
`S.ofThe` UnitalChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase UnitalChunk
intNormForce,
  UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
intNormForce, String -> Sentence
S String
"using", ConceptInstance -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpINSFL Sentence -> Sentence -> Sentence
`S.and_`
  GenDefn -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
normShrRGD Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"resulting in"]

fctSftyDerivSentence8 :: [Sentence]
fctSftyDerivSentence8 :: [Sentence]
fctSftyDerivSentence8 = [String -> Sentence
S String
"Rearranging yields the following"]

fctSftyDerivSentence9 :: [Sentence]
fctSftyDerivSentence9 :: [Sentence]
fctSftyDerivSentence9 = [String -> Sentence
S String
"The definitions for" Sentence -> Sentence -> Sentence
+:+ DefinedQuantityDict -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
shrResC Sentence -> Sentence -> Sentence
`S.and_`
  DefinedQuantityDict -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
mobShrC Sentence -> Sentence -> Sentence
+:+ String -> Sentence
S String
"from" Sentence -> Sentence -> Sentence
+:+ DataDefinition -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS DataDefinition
convertFunc1 Sentence -> Sentence -> Sentence
`S.and_`
  DataDefinition -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS DataDefinition
convertFunc2 Sentence -> Sentence -> Sentence
+:+ String -> Sentence
S String
"simplify the above to", Int -> Sentence
eqN Int
3]

fctSftyDerivSentence10 :: [Sentence]
fctSftyDerivSentence10 :: [Sentence]
fctSftyDerivSentence10 = [String -> Sentence
S String
"Versions of", Int -> Sentence
eqN Int
3, String -> Sentence
S String
"instantiated for slices",
  String -> Sentence
S String
"1 to", DefinedQuantityDict -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
numbSlices, String -> Sentence
S String
"are shown below"]

fctSftyDerivEllipsis :: Sentence
fctSftyDerivEllipsis :: Sentence
fctSftyDerivEllipsis = String -> Sentence
S String
"..."

fctSftyDerivSentence11 :: [Sentence]
fctSftyDerivSentence11 :: [Sentence]
fctSftyDerivSentence11 = [String -> Sentence
S String
"Applying", ConceptInstance -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpES Sentence -> Sentence -> Sentence
`sC`
  String -> Sentence
S String
"which says that", ModelExpr -> Sentence
eS (ModelExpr -> ModelExpr -> ModelExpr
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> ModelExpr
forall c. (HasUID c, HasSymbol c) => c -> ModelExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (Integer -> ModelExpr
forall r. LiteralC r => Integer -> r
int Integer
0)) Sentence -> Sentence -> Sentence
`S.and_`
  ModelExpr -> Sentence
eS (UnitalChunk -> ModelExpr
forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
intNormForce), String -> Sentence
S String
"are zero" Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"results in the following special cases:",Int -> Sentence
eqN Int
8, String -> Sentence
S String
"for the first slice"]

fctSftyDerivSentence12 :: [Sentence]
fctSftyDerivSentence12 :: [Sentence]
fctSftyDerivSentence12 = [String -> Sentence
S String
"and", Int -> Sentence
eqN Int
9, String -> Sentence
S String
"for the", DefinedQuantityDict -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
numbSlices Sentence -> Sentence -> Sentence
:+:
  String -> Sentence
S String
"th slice"]

fctSftyDerivSentence13 :: [Sentence]
fctSftyDerivSentence13 :: [Sentence]
fctSftyDerivSentence13 = [String -> Sentence
S String
"Substituting", Int -> Sentence
eqN Int
8, String -> Sentence
S String
"into", Int -> Sentence
eqN Int
4, String -> Sentence
S String
"yields", Int -> Sentence
eqN Int
10]

fctSftyDerivSentence14 :: [Sentence]
fctSftyDerivSentence14 :: [Sentence]
fctSftyDerivSentence14 = [String -> Sentence
S String
"which can be substituted into", Int -> Sentence
eqN Int
5, String -> Sentence
S String
"to get", Int -> Sentence
eqN Int
11]

fctSftyDerivSentence15 :: [Sentence]
fctSftyDerivSentence15 :: [Sentence]
fctSftyDerivSentence15 = [String -> Sentence
S String
"and so on until", Int -> Sentence
eqN Int
12, String -> Sentence
S String
"is obtained from", Int -> Sentence
eqN Int
7]

fctSftyDerivSentence16 :: [Sentence]
fctSftyDerivSentence16 :: [Sentence]
fctSftyDerivSentence16 = [Int -> Sentence
eqN Int
9, String -> Sentence
S String
"can then be substituted into the",
  CI -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase CI
leftSide Sentence -> Sentence -> Sentence
`S.of_` Int -> Sentence
eqN Int
12 Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"resulting in"]

fctSftyDerivSentence17 :: [Sentence]
fctSftyDerivSentence17 :: [Sentence]
fctSftyDerivSentence17 = [String -> Sentence
S String
"This can be rearranged by multiplying both sides",
  String -> Sentence
S String
"by", ModelExpr -> Sentence
eS (ModelExpr -> ModelExpr -> ModelExpr
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> ModelExpr
forall c. (HasUID c, HasSymbol c) => c -> ModelExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> ModelExpr
forall c. (HasUID c, HasSymbol c) => c -> ModelExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices ModelExpr -> ModelExpr -> ModelExpr
forall r. ExprC r => r -> r -> r
$- Integer -> ModelExpr
forall r. LiteralC r => Integer -> r
int Integer
1)) Sentence -> Sentence -> Sentence
`S.and_`
  String -> Sentence
S String
"then distributing the multiplication of each", DefinedQuantityDict -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
mobShrC,
  String -> Sentence
S String
"over addition to obtain"]

fctSftyDerivSentence18 :: [Sentence]
fctSftyDerivSentence18 :: [Sentence]
fctSftyDerivSentence18 = [String -> Sentence
S String
"The multiplication" Sentence -> Sentence -> Sentence
`S.ofThe` DefinedQuantityDict -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
mobShrC,
  String -> Sentence
S String
"terms can be further distributed over the subtractions, resulting in the",
  String -> Sentence
S String
"equation having terms that each either contain an", UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
shearRNoIntsl,
  String -> Sentence
S String
"or a" Sentence -> Sentence -> Sentence
+:+. UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
shearFNoIntsl, String -> Sentence
S String
"The equation can then be rearranged so",
  String -> Sentence
S String
"terms containing an", UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
shearRNoIntsl, String -> Sentence
S String
"are on one side" Sentence -> Sentence -> Sentence
`S.ofThe` String -> Sentence
S String
"equality" Sentence -> Sentence -> Sentence
`sC` 
  String -> Sentence
S String
"and terms containing a", UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
shearFNoIntsl Sentence -> Sentence -> Sentence
+:+.
  String -> Sentence
S String
"are on the other", String -> Sentence
S String
"The multiplication by the", ConstrConcept -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase ConstrConcept
fs,
  String -> Sentence
S String
"is common to all" Sentence -> Sentence -> Sentence
`S.ofThe` UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
shearFNoIntsl, String -> Sentence
S String
"terms" Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"and thus can be",
  String -> Sentence
S String
"factored out" Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"resulting in"]

fctSftyDerivSentence19 :: [Sentence]
fctSftyDerivSentence19 :: [Sentence]
fctSftyDerivSentence19 = [String -> Sentence
S String
"Isolating the", ConstrConcept -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase ConstrConcept
fs, String -> Sentence
S String
"on the left-hand",
  String -> Sentence
S String
"side and using compact notation" Sentence -> Sentence -> Sentence
`S.for` String -> Sentence
S String
"the products and sums yields",
  Int -> Sentence
eqN Int
13 Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"which can also be seen in", InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
fctSfty]

fctSftyDerivSentence20 :: [Sentence]
fctSftyDerivSentence20 :: [Sentence]
fctSftyDerivSentence20 = [ConstrConcept -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch ConstrConcept
fs Sentence -> Sentence -> Sentence
+:+ String -> Sentence
S String
"depends on the unknowns" Sentence -> Sentence -> Sentence
+:+
  DefinedQuantityDict -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
normToShear Sentence -> Sentence -> Sentence
+:+ Sentence -> Sentence
sParen (InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
nrmShrFor) Sentence -> Sentence -> Sentence
`S.and_` UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
intNormForce Sentence -> Sentence -> Sentence
+:+.
  Sentence -> Sentence
sParen (InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
intsliceFs)]

fctSftyDerivEqn1 :: PExpr
fctSftyDerivEqn1 :: PExpr
fctSftyDerivEqn1 = --FIXME: pull the right side of this from GD4
  (r -> r) -> (r -> r) -> (r -> r -> r) -> r
forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExpr r -> r
forall r. ExprC r => r -> r
sin r -> r
forall r. ExprC r => r -> r
cos (\r
x r
y -> r
x r -> r -> r
forall r. ExprC r => r -> r -> r
$- UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce r -> r -> r
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce r -> r -> r
forall r. ExprC r => r -> r -> r
$+ r
y)
  r -> r -> r
forall r. ExprC r => r -> r -> r
$= (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
nrmFSubWat r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
tan (UncertQ -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (UncertQ -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
effCohesion r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseLngth)) r -> r -> r
forall r. ExprC r => r -> r -> r
$/ ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs

fctSftyDerivEqn2 :: PExpr
fctSftyDerivEqn2 :: PExpr
fctSftyDerivEqn2 = UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
nrmFSubWat r -> r -> r
forall r. ExprC r => r -> r -> r
$= (r -> r) -> (r -> r) -> (r -> r -> r) -> r
forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExprN r -> r
forall r. ExprC r => r -> r
cos r -> r
forall r. ExprC r => r -> r
sin (\r
x r
y -> r
x r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce r -> r -> r
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce r -> r -> r
forall r. ExprC r => r -> r -> r
$+ r
y) r -> r -> r
forall r. ExprC r => r -> r -> r
$- UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseHydroForce

fctSftyDerivEqn3 :: PExpr
fctSftyDerivEqn3 :: PExpr
fctSftyDerivEqn3 = (r -> r) -> (r -> r) -> (r -> r -> r) -> r
forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExpr r -> r
forall r. ExprC r => r -> r
sin r -> r
forall r. ExprC r => r -> r
cos (\r
x r
y -> r
x r -> r -> r
forall r. ExprC r => r -> r -> r
$- UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce r -> r -> r
forall r. ExprC r => r -> r -> r
$+ r
y) r -> r -> r
forall r. ExprC r => r -> r -> r
$= (((r -> r) -> (r -> r) -> (r -> r -> r) -> r
forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExprN r -> r
forall r. ExprC r => r -> r
cos r -> r
forall r. ExprC r => r -> r
sin (\r
x r
y -> r
x r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce r -> r -> r
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce r -> r -> r
forall r. ExprC r => r -> r -> r
$+ r
y) r -> r -> r
forall r. ExprC r => r -> r -> r
$- UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseHydroForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r
forall r. ExprC r => r -> r
tan (UncertQ -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (UncertQ -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
effCohesion r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseLngth)) r -> r -> r
forall r. ExprC r => r -> r -> r
$/ ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs

fctSftyDerivEqn4 :: PExpr
fctSftyDerivEqn4 :: PExpr
fctSftyDerivEqn4 = (r -> r) -> (r -> r) -> (r -> r -> r) -> r
forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExprSepG r -> r
forall r. ExprC r => r -> r
sin r -> r
forall r. ExprC r => r -> r
cos r -> r -> r
forall r. ExprC r => r -> r -> r
($+) r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  ((r -> r
forall r. ExprC r => r -> r
neg (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
sin (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) r -> r -> r
forall r. ExprC r => r -> r -> r
$=
  (((r -> r) -> (r -> r) -> (r -> r -> r) -> r
forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExprNSepG r -> r
forall r. ExprC r => r -> r
cos r -> r
forall r. ExprC r => r -> r
sin r -> r -> r
forall r. ExprC r => r -> r -> r
($+) r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  (((r -> r
forall r. ExprC r => r -> r
neg (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
cos (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseHydroForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r
forall r. ExprC r => r -> r
tan (UncertQ -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (UncertQ -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
effCohesion r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseLngth)) r -> r -> r
forall r. ExprC r => r -> r -> r
$/ ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs

fctSftyDerivEqn5 :: PExpr
fctSftyDerivEqn5 :: PExpr
fctSftyDerivEqn5 = (r -> r) -> (r -> r) -> (r -> r -> r) -> r
forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExprNoKQ r -> r
forall r. ExprC r => r -> r
sin r -> r
forall r. ExprC r => r -> r
cos r -> r -> r
forall r. ExprC r => r -> r -> r
($+) r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  ((r -> r
forall r. ExprC r => r -> r
neg (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
sin (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) r -> r -> r
forall r. ExprC r => r -> r -> r
$=
  (((r -> r) -> (r -> r) -> (r -> r -> r) -> r
forall r.
(ExprC r, LiteralC r) =>
(r -> r) -> (r -> r) -> (r -> r -> r) -> r
eqlExprNNoKQ r -> r
forall r. ExprC r => r -> r
cos r -> r
forall r. ExprC r => r -> r
sin r -> r -> r
forall r. ExprC r => r -> r -> r
($+) r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  ((r -> r
forall r. ExprC r => r -> r
neg (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
cos (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseHydroForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r
forall r. ExprC r => r -> r
tan (UncertQ -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (UncertQ -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
effCohesion r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseLngth)) r -> r -> r
forall r. ExprC r => r -> r -> r
$/ ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs

fctSftyDerivEqn6 :: PExpr
fctSftyDerivEqn6 :: PExpr
fctSftyDerivEqn6 = (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearFNoIntsl r -> r -> r
forall r. ExprC r => r -> r -> r
$+ ((r -> r
forall r. ExprC r => r -> r
neg (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
sin (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) r -> r -> r
forall r. ExprC r => r -> r -> r
$- ((r -> r
forall r. ExprC r => r -> r
neg (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
cos (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle))) r -> r -> r
forall r. ExprC r => r -> r -> r
$= (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearRNoIntsl r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  (((r -> r
forall r. ExprC r => r -> r
neg (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intShrForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intShrForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
cos (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle) r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  ((r -> r
forall r. ExprC r => r -> r
neg (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
sin (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle))) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r
forall r. ExprC r => r -> r
tan (UncertQ -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle))) r -> r -> r
forall r. ExprC r => r -> r -> r
$/ ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs

fctSftyDerivEqn7 :: PExpr
fctSftyDerivEqn7 :: PExpr
fctSftyDerivEqn7 = (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearFNoIntsl r -> r -> r
forall r. ExprC r => r -> r -> r
$+ ((r -> r
forall r. ExprC r => r -> r
neg (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear) r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce)) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r
forall r. ExprC r => r -> r
sin (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) r -> r -> r
forall r. ExprC r => r -> r -> r
$- ((r -> r
forall r. ExprC r => r -> r
neg (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
cos (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)))
  r -> r -> r
forall r. ExprC r => r -> r -> r
$= (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearRNoIntsl r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (((r -> r
forall r. ExprC r => r -> r
neg (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce)) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
cos (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ ((r -> r
forall r. ExprC r => r -> r
neg (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce)
  r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
sin (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle))) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
tan (UncertQ -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle))) r -> r -> r
forall r. ExprC r => r -> r -> r
$/ ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs

fctSftyDerivEqn8 :: PExpr
fctSftyDerivEqn8 :: PExpr
fctSftyDerivEqn8 = (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$* ((DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r
forall r. ExprC r => r -> r
cos (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle) r -> r -> r
forall r. ExprC r => r -> r -> r
$- r -> r
forall r. ExprC r => r -> r
sin (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
tan (UncertQ -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  ((DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
sin (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle) r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  r -> r
forall r. ExprC r => r -> r
cos (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) r -> r -> r
forall r. ExprC r => r -> r -> r
$* ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs))) r -> r -> r
forall r. ExprC r => r -> r -> r
$= (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  ((DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
cos (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  r -> r
forall r. ExprC r => r -> r
sin (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
tan (UncertQ -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
fricAngle) r -> r -> r
forall r. ExprC r => r -> r -> r
$- ((DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
sin (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ r -> r
forall r. ExprC r => r -> r
cos (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearFNoIntsl) r -> r -> r
forall r. ExprC r => r -> r -> r
$- UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearRNoIntsl)

fctSftyDerivEqn9 :: PExpr
fctSftyDerivEqn9 :: PExpr
fctSftyDerivEqn9 = (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
shrResC) r -> r -> r
forall r. ExprC r => r -> r -> r
$= (DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
mobShrC r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
shrResC r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearFNoIntsl) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearRNoIntsl)

fctSftyDerivEqn10a :: PExpr
fctSftyDerivEqn10a :: PExpr
fctSftyDerivEqn10a = Integer -> r
forall r. (ExprC r, LiteralC r) => Integer -> r
sliceExpr Integer
1

fctSftyDerivEqn10b :: PExpr
fctSftyDerivEqn10b :: PExpr
fctSftyDerivEqn10b = Integer -> r
forall r. (ExprC r, LiteralC r) => Integer -> r
sliceExpr Integer
2

fctSftyDerivEqn10c :: PExpr
fctSftyDerivEqn10c :: PExpr
fctSftyDerivEqn10c = Integer -> r
forall r. (ExprC r, LiteralC r) => Integer -> r
sliceExpr Integer
3

fctSftyDerivEqn10d :: PExpr
fctSftyDerivEqn10d :: PExpr
fctSftyDerivEqn10d = r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$= (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
3) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
3) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
3) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2)) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2))

fctSftyDerivEqn10e :: PExpr
fctSftyDerivEqn10e :: PExpr
fctSftyDerivEqn10e = r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$= (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1)) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1))

fctSftyDerivEqn10f :: PExpr
fctSftyDerivEqn10f :: PExpr
fctSftyDerivEqn10f = r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices) r -> r -> r
forall r. ExprC r => r -> r -> r
$= (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices)) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices))

fctSftyDerivEqn11 :: PExpr
fctSftyDerivEqn11 :: PExpr
fctSftyDerivEqn11 = (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 DefinedQuantityDict
shrResC) r -> r -> r
forall r. ExprC r => r -> r -> r
$=
  (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
shearFNoIntsl r -> r -> r
forall r. ExprC r => r -> r -> r
$- UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
shearRNoIntsl)

fctSftyDerivEqn12 :: PExpr
fctSftyDerivEqn12 :: PExpr
fctSftyDerivEqn12 = r -> r
forall r. ExprC r => r -> r
neg ((ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearFNoIntsl r -> r -> r
forall r. ExprC r => r -> r -> r
$- UnitalChunk -> r
forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearRNoIntsl) r -> r -> r
forall r. ExprC r => r -> r -> r
$/
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1)) r -> r -> r
forall r. ExprC r => r -> r -> r
$=
  (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1))

fctSftyDerivEqn13 :: PExpr
fctSftyDerivEqn13 :: PExpr
fctSftyDerivEqn13 = r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$=
  (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2)) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2))

fctSftyDerivEqn14 :: PExpr
fctSftyDerivEqn14 :: PExpr
fctSftyDerivEqn14 = r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
3) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
3) r -> r -> r
forall r. ExprC r => r -> r -> r
$=
  (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2)) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
3)) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
3))

-- Need to ($+) ellipses where appropriate
fctSftyDerivEqn15 :: PExpr
fctSftyDerivEqn15 :: PExpr
fctSftyDerivEqn15 = r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
shrResC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$= (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
3) r -> r -> r
forall r. ExprC r => r -> r -> r
$* (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$- r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2)) r -> r -> r
forall r. ExprC r => r -> r -> r
$- r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2)) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1)) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1))

-- Ellipses needed here too
fctSftyDerivEqn16 :: PExpr
fctSftyDerivEqn16 :: PExpr
fctSftyDerivEqn16 = r -> r
forall r. ExprC r => r -> r
neg ((ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearFNoIntsl r -> r -> r
forall r. ExprC r => r -> r -> r
$- UnitalChunk -> r
forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearRNoIntsl) r -> r -> r
forall r. ExprC r => r -> r -> r
$/
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1)) r -> r -> r
forall r. ExprC r => r -> r -> r
$= (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
3) r -> r -> r
forall r. ExprC r => r -> r -> r
$* (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$- r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2)) r -> r -> r
forall r. ExprC r => r -> r -> r
$- r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2)) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1)) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1))

-- Ellipses needed here too
fctSftyDerivEqn17 :: PExpr
fctSftyDerivEqn17 :: PExpr
fctSftyDerivEqn17 = r -> r
forall r. ExprC r => r -> r
neg (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearFNoIntsl r -> r -> r
forall r. ExprC r => r -> r -> r
$- UnitalChunk -> r
forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearRNoIntsl) r -> r -> r
forall r. ExprC r => r -> r -> r
$=
  (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
shearFNoIntsl r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
shearRNoIntsl) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$- r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2))) r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$-
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1))))

-- Ellipses needed here too
fctSftyDerivEqn18 :: PExpr
fctSftyDerivEqn18 :: PExpr
fctSftyDerivEqn18 = ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearFNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> r
forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearFNoIntsl) r -> r -> r
forall r. ExprC r => r -> r -> r
$=
  (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
2)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (r -> r -> r
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
mobShrC) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  r -> r -> r
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
shearRNoIntsl) (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices r -> r -> r
forall r. ExprC r => r -> r -> r
$- Integer -> r
forall r. LiteralC r => Integer -> r
int Integer
1)) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> r
forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
shearRNoIntsl)

------------------------------------------------------------------------

nrmShrFor :: InstanceModel
nrmShrFor :: InstanceModel
nrmShrFor = ModelKind Relation
-> Inputs
-> Output
-> OutputConstraints
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> InstanceModel
im ModelKind Relation
nrmShrForMK [UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeDist, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeHght, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterHght,
  UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterWeight, UnitalChunk -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipDist, UnitalChunk -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipHght, DefinedQuantityDict -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC DefinedQuantityDict
constF]
  (DefinedQuantityDict -> Output
forall q. (Quantity q, MayHaveUnit q) => q -> Output
qw DefinedQuantityDict
normToShear) [] ((Citation -> DecRef) -> [Citation] -> [DecRef]
forall a b. (a -> b) -> [a] -> [b]
map Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef [Citation
chen2005, Citation
karchewski2012])
  (Derivation -> Maybe Derivation
forall a. a -> Maybe a
Just Derivation
nrmShrDeriv) String
"nrmShrFor" [Sentence
nrmShrFDesc]

nrmShrForMK :: ModelKind Expr
nrmShrForMK :: ModelKind Relation
nrmShrForMK = String -> NP -> QDefinition Relation -> ModelKind Relation
forall e. String -> NP -> QDefinition e -> ModelKind e
equationalModel String
"nrmShrForIM"
  (String -> NP
nounPhraseSP String
"normal and shear force proportionality constant") QDefinition Relation
nrmShrForQD

nrmShrForQD :: SimpleQDef
nrmShrForQD :: QDefinition Relation
nrmShrForQD = DefinedQuantityDict -> Relation -> QDefinition Relation
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef DefinedQuantityDict
normToShear Relation
PExpr
nrmShrFExpr

nrmShrFExpr :: PExpr
nrmShrFExpr :: PExpr
nrmShrFExpr = r -> r
forall r. (ExprC r, LiteralC r) => r -> r
sum1toN (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
nrmShearNum) r -> r -> r
forall r. ExprC r => r -> r -> r
$/ r -> r
forall r. (ExprC r, LiteralC r) => r -> r
sum1toN (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
nrmShearDen)

nrmShrFDesc :: Sentence
nrmShrFDesc :: Sentence
nrmShrFDesc = UnitalChunk
nrmShearNum UnitalChunk -> InstanceModel -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''`
  InstanceModel
nrmShrForNum Sentence -> Sentence -> Sentence
`S.and_` (UnitalChunk
nrmShearDen UnitalChunk -> InstanceModel -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''`
  InstanceModel
nrmShrForDen !.)

nrmShrDeriv :: Derivation
nrmShrDeriv :: Derivation
nrmShrDeriv = [Sentence] -> Derivation
mkDerivNoHeader ([[Sentence]] -> [Sentence]
forall a. [[a]] -> [a]
weave [[Sentence]
nrmShrDerivationSentences, (ModelExpr -> Sentence) -> [ModelExpr] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map ModelExpr -> Sentence
eS [ModelExpr]
forall r. (ExprC r, LiteralC r) => [r]
nrmShrDerivEqns] [Sentence] -> [Sentence] -> [Sentence]
forall a. [a] -> [a] -> [a]
++
  [Sentence]
nrmShrDerivSentence5)

nrmShrDerivSentence1 :: [Sentence]
nrmShrDerivSentence1 :: [Sentence]
nrmShrDerivSentence1 = [String -> Sentence
S String
"From the", GenDefn -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase GenDefn
momentEqlGD Sentence -> Sentence -> Sentence
`S.of_`
  GenDefn -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
momentEqlGD, String -> Sentence
S String
"with the primary", CI -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase CI
assumption Sentence -> Sentence -> Sentence
`S.for`
  String -> Sentence
S String
"the Morgenstern-Price method" Sentence -> Sentence -> Sentence
`S.of_` ConceptInstance -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpINSFL Sentence -> Sentence -> Sentence
`S.and_`
  String -> Sentence
S String
"associated", IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
definition, GenDefn -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
normShrRGD Sentence -> Sentence -> Sentence
`sC` Int -> Sentence
eqN Int
14,
  String -> Sentence
S String
"can be derived"]

nrmShrDerivSentence2 :: [Sentence]
nrmShrDerivSentence2 :: [Sentence]
nrmShrDerivSentence2 = [String -> Sentence
S String
"Rearranging the", ConceptChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
equation, String -> Sentence
S String
"in terms of",
  DefinedQuantityDict -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
normToShear, String -> Sentence
S String
"leads to", Int -> Sentence
eqN Int
15]

nrmShrDerivSentence3 :: [Sentence]
nrmShrDerivSentence3 :: [Sentence]
nrmShrDerivSentence3 = [String -> Sentence
S String
"This", ConceptChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
equation, String -> Sentence
S String
"can be simplified by",
  String -> Sentence
S String
"applying", CI -> Sentence
forall n. NamedIdea n => n -> Sentence
plural CI
assumption, ConceptInstance -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpSF Sentence -> Sentence -> Sentence
`S.and_`
  ConceptInstance -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpSL Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"which state that the seismic" Sentence -> Sentence -> Sentence
`S.and_`
  UnitalChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
plural UnitalChunk
surfLoad Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"respectively" Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"are zero"]

nrmShrDerivSentence4 :: [Sentence]
nrmShrDerivSentence4 :: [Sentence]
nrmShrDerivSentence4 = [String -> Sentence
S String
"Taking the summation of all", IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
plural IdeaDict
slice Sentence -> Sentence -> Sentence
`sC`
  String -> Sentence
S String
"and applying", ConceptInstance -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpES, String -> Sentence
S String
"to set",
  ModelExpr -> Sentence
eS (ModelExpr -> ModelExpr -> ModelExpr
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> ModelExpr
forall c. (HasUID c, HasSymbol c) => c -> ModelExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (Integer -> ModelExpr
forall r. LiteralC r => Integer -> r
int Integer
0)) Sentence -> Sentence -> Sentence
`sC` ModelExpr -> Sentence
eS (UnitalChunk -> ModelExpr
forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
intNormForce) Sentence -> Sentence -> Sentence
`sC`
  ModelExpr -> Sentence
eS (ModelExpr -> ModelExpr -> ModelExpr
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> ModelExpr
forall c. (HasUID c, HasSymbol c) => c -> ModelExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
watrForce) (Integer -> ModelExpr
forall r. LiteralC r => Integer -> r
int Integer
0)) Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"and", ModelExpr -> Sentence
eS (UnitalChunk -> ModelExpr
forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
watrForce),
  String -> Sentence
S String
"equal to zero" Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"a general", ConceptChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
equation, String -> Sentence
S String
"for the",
  DefinedQuantityDict -> Sentence
forall a. Quantity a => a -> Sentence
getTandS DefinedQuantityDict
normToShear, String -> Sentence
S String
"is developed in", Int -> Sentence
eqN Int
16 Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"which combines", InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
nrmShrFor Sentence -> Sentence -> Sentence
`sC` InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
nrmShrForNum Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"and",
  InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
nrmShrForDen]

nrmShrDerivSentence5 :: [Sentence]
nrmShrDerivSentence5 :: [Sentence]
nrmShrDerivSentence5 = [Int -> Sentence
eqN Int
16 Sentence -> Sentence -> Sentence
`S.for` DefinedQuantityDict -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
normToShear Sentence -> Sentence -> Sentence
+:+
  String -> Sentence
S String
"is a function of the unknown" Sentence -> Sentence -> Sentence
+:+ UnitalChunk -> Sentence
forall a. Quantity a => a -> Sentence
getTandS UnitalChunk
intNormForce Sentence -> Sentence -> Sentence
+:+
  Sentence -> Sentence
sParen (InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
intsliceFs) Sentence -> Sentence -> Sentence
+:+ String -> Sentence
S String
"which itself depends on the unknown" Sentence -> Sentence -> Sentence
+:+
  ConstrConcept -> Sentence
forall a. Quantity a => a -> Sentence
getTandS ConstrConcept
fs Sentence -> Sentence -> Sentence
+:+. Sentence -> Sentence
sParen (InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
fctSfty)]

nrmShrDerivationSentences :: [Sentence]
nrmShrDerivationSentences :: [Sentence]
nrmShrDerivationSentences = ([Sentence] -> Sentence) -> [[Sentence]] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map [Sentence] -> Sentence
foldlSentCol [[Sentence]
nrmShrDerivSentence1,
  [Sentence]
nrmShrDerivSentence2, [Sentence]
nrmShrDerivSentence3, [Sentence]
nrmShrDerivSentence4]

nrmShrDerivEqns :: (ExprC r, LiteralC r) => [r]
nrmShrDerivEqns :: forall r. (ExprC r, LiteralC r) => [r]
nrmShrDerivEqns = [r
PExpr
nrmShrDerivEqn1, r
PExpr
nrmShrDerivEqn2, r
PExpr
nrmShrDerivEqn3,
  r
PExpr
nrmShrDerivEqn4]

nrmShrDerivEqn1, nrmShrDerivEqn2, nrmShrDerivEqn3, nrmShrDerivEqn4 :: PExpr
nrmShrDerivEqn1 :: PExpr
nrmShrDerivEqn1 = Integer -> r
forall r. LiteralC r => Integer -> r
exactDbl Integer
0 r -> r -> r
forall r. ExprC r => r -> r -> r
$=
  (r -> r -> r) -> r
forall r. (ExprC r, LiteralC r) => (r -> r -> r) -> r
momExpr (\ r
x r
y -> r
x r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. (ExprC r, LiteralC r) => r -> r
half (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseWthX) r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc r -> r -> r
forall r. ExprC r => r -> r -> r
$+ (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$* 
  DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc))) r -> r -> r
forall r. ExprC r => r -> r -> r
$+ r
y)

nrmShrDerivEqn2 :: PExpr
nrmShrDerivEqn2 = DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear r -> r -> r
forall r. ExprC r => r -> r -> r
$= (r -> r -> r) -> r
forall r. (ExprC r, LiteralC r) => (r -> r -> r) -> r
momExpr r -> r -> r
forall r. ExprC r => r -> r -> r
($+)
  r -> r -> r
forall r. ExprC r => r -> r -> r
$/ r -> r
forall r. ExprC r => r -> r
neg (r -> r
forall r. (ExprC r, LiteralC r) => r -> r
half (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseWthX) r -> r -> r
forall r. ExprC r => r -> r -> r
$* (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc)))

nrmShrDerivEqn3 :: PExpr
nrmShrDerivEqn3 = DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear r -> r -> r
forall r. ExprC r => r -> r -> r
$= (r -> r -> r) -> r
forall r. (ExprC r, LiteralC r) => (r -> r -> r) -> r
momExprNoKQ r -> r -> r
forall r. ExprC r => r -> r -> r
($+)
  r -> r -> r
forall r. ExprC r => r -> r -> r
$/ r -> r
forall r. ExprC r => r -> r
neg (r -> r
forall r. (ExprC r, LiteralC r) => r -> r
half (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseWthX) r -> r -> r
forall r. ExprC r => r -> r -> r
$* (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc)))

nrmShrDerivEqn4 :: PExpr
nrmShrDerivEqn4 = DefinedQuantityDict -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
normToShear r -> r -> r
forall r. ExprC r => r -> r -> r
$= r -> r
forall r. (ExprC r, LiteralC r) => r -> r
sum1toN
  (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseWthX r -> r -> r
forall r. ExprC r => r -> r -> r
$* (UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
nrmForceSum r -> r -> r
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
watForceSum) r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
tan (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle) r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
midpntHght r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
neg (Integer -> r
forall r. LiteralC r => Integer -> r
exactDbl Integer
2 r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
surfHydroForce r -> r -> r
forall r. ExprC r => r -> r -> r
$* r -> r
forall r. ExprC r => r -> r
sin (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
surfAngle))))
  r -> r -> r
forall r. ExprC r => r -> r -> r
$/ r -> r
forall r. (ExprC r, LiteralC r) => r -> r
sum1toN
  (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseWthX r -> r -> r
forall r. ExprC r => r -> r -> r
$* (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  (UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc)))

---------------------------------------------------------------------

nrmShrForNum :: InstanceModel
nrmShrForNum :: InstanceModel
nrmShrForNum = ModelKind Relation
-> Inputs
-> Output
-> OutputConstraints
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> InstanceModel
im (RelationConcept -> ModelKind Relation
forall e. RelationConcept -> ModelKind e
othModel' RelationConcept
nrmShrForNumRC) [UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeDist, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeHght, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterHght,
  UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterWeight, UnitalChunk -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipDist, UnitalChunk -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipHght]
  (UnitalChunk -> Output
forall q. (Quantity q, MayHaveUnit q) => q -> Output
qw UnitalChunk
nrmShearNum) [] ((Citation -> DecRef) -> [Citation] -> [DecRef]
forall a b. (a -> b) -> [a] -> [b]
map Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef [Citation
chen2005, Citation
karchewski2012])
  (Derivation -> Maybe Derivation
forall a. a -> Maybe a
Just Derivation
nrmShrFNumDeriv) String
"nrmShrForNum" [Sentence
nrmShrFNumDesc]

nrmShrForNumRC :: RelationConcept
nrmShrForNumRC :: RelationConcept
nrmShrForNumRC = String -> NP -> Sentence -> Relation -> RelationConcept
forall e.
Express e =>
String -> NP -> Sentence -> e -> RelationConcept
makeRC String
"nrmShrForNumRC" (String -> NP
nounPhraseSP String
"normal and shear force proportionality constant numerator")
  Sentence
nrmShrFNumDesc Relation
nrmShrFNumRel

nrmShrFNumRel :: Relation
nrmShrFNumRel :: Relation
nrmShrFNumRel = UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
nrmShearNum Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$= [(Relation, Relation)] -> Relation
forall r. ExprC r => [(r, r)] -> r
incompleteCase [(Relation, Relation)
case1,(Relation, Relation)
case2,(Relation, Relation)
case3]
  where case1 :: (Relation, Relation)
case1 = (UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
baseWthX Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* (UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
intNormForce Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
watrForce) Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* 
          Relation -> Relation
forall r. ExprC r => r -> r
tan (UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
baseAngle), DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$= Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
1)
        case2 :: (Relation, Relation)
case2 = ((UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseWthX Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* 
          (UnitalChunk -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
nrmForceSum Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$+ UnitalChunk -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
watForceSum)
           Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* Relation -> Relation
forall r. ExprC r => r -> r
tan (UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseAngle)) Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$+ (UnitalChunk -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
midpntHght Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* (Relation -> Relation
forall r. ExprC r => r -> r
neg
          (Integer -> Relation
forall r. LiteralC r => Integer -> r
exactDbl Integer
2) Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
surfHydroForce Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* Relation -> Relation
forall r. ExprC r => r -> r
sin (UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
surfAngle))),
          Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
2 Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$<= DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$<= (DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$- Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
1))
        case3 :: (Relation, Relation)
case3 = (UnitalChunk -> Relation
forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
baseWthX Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* (Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce)
          (DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$- Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
1) Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$+ Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
watrForce)
          (DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$- Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
1)) Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* Relation -> Relation
forall r. ExprC r => r -> r
tan (Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
baseAngle)
          (DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$- Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
1)), DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$= DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices)

nrmShrFNumDeriv :: Derivation
nrmShrFNumDeriv :: Derivation
nrmShrFNumDeriv = [Sentence] -> Derivation
mkDerivNoHeader [[Sentence] -> Sentence
foldlSent [String -> Sentence
S String
"See", InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
nrmShrFor,
  String -> Sentence
S String
"for the derivation" Sentence -> Sentence -> Sentence
`S.of_` UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
nrmShearNum]]

nrmShrFNumDesc :: Sentence
nrmShrFNumDesc :: Sentence
nrmShrFNumDesc = (SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List [UnitalChunk
baseWthX UnitalChunk -> DataDefinition -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
lengthB,
  UnitalChunk
watrForce UnitalChunk -> DataDefinition -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
intersliceWtrF,
  UnitalChunk
baseAngle UnitalChunk -> DataDefinition -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
angleA,
  UnitalChunk
midpntHght UnitalChunk -> DataDefinition -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
slcHeight,
  UnitalChunk
surfHydroForce UnitalChunk -> GenDefn -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` GenDefn
srfWtrFGD,
  UnitalChunk
surfAngle UnitalChunk -> DataDefinition -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
angleB] !.)

---------------------------------------------------------------------------

nrmShrForDen :: InstanceModel
nrmShrForDen :: InstanceModel
nrmShrForDen = ModelKind Relation
-> Inputs
-> Output
-> OutputConstraints
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> InstanceModel
im (RelationConcept -> ModelKind Relation
forall e. RelationConcept -> ModelKind e
othModel' RelationConcept
nrmShrForDenRC) [UnitalChunk -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipDist, DefinedQuantityDict -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC DefinedQuantityDict
constF]
  (UnitalChunk -> Output
forall q. (Quantity q, MayHaveUnit q) => q -> Output
qw UnitalChunk
nrmShearDen) [] ((Citation -> DecRef) -> [Citation] -> [DecRef]
forall a b. (a -> b) -> [a] -> [b]
map Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef [Citation
chen2005, Citation
karchewski2012])
  (Derivation -> Maybe Derivation
forall a. a -> Maybe a
Just Derivation
nrmShrFDenDeriv) String
"nrmShrForDen" [Sentence
nrmShrFDenDesc]

nrmShrForDenRC :: RelationConcept
nrmShrForDenRC :: RelationConcept
nrmShrForDenRC = String -> NP -> Sentence -> Relation -> RelationConcept
forall e.
Express e =>
String -> NP -> Sentence -> e -> RelationConcept
makeRC String
"nrmShrForDenRC" (String -> NP
nounPhraseSP String
"normal and shear force proportionality constant denominator")
  Sentence
nrmShrFDenDesc Relation
nrmShrFDenRel

nrmShrFDenRel :: Relation
nrmShrFDenRel :: Relation
nrmShrFDenRel = UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
nrmShearDen Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$= [(Relation, Relation)] -> Relation
forall r. ExprC r => [(r, r)] -> r
incompleteCase [
  (UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
baseWthX Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* DefinedQuantityDict -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 DefinedQuantityDict
scalFunc Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
intNormForce, DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$= Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
1),
  (UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
baseWthX Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* (DefinedQuantityDict -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
scalFunc Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$+
    (DefinedQuantityDict -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
scalFunc Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce)),
    Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
2 Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$<= DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$<= (DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$- Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
1)),
  (UnitalChunk -> Relation
forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
baseWthX Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$- Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
1) Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* 
    Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
idx (DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
scalFunc) (DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$- Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
1), DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$= DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices)
  ]

nrmShrFDenDeriv :: Derivation
nrmShrFDenDeriv :: Derivation
nrmShrFDenDeriv = [Sentence] -> Derivation
mkDerivNoHeader [[Sentence] -> Sentence
foldlSent [String -> Sentence
S String
"See", InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
nrmShrFor,
  String -> Sentence
S String
"for the derivation" Sentence -> Sentence -> Sentence
`S.of_` UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
nrmShearDen]]

nrmShrFDenDesc :: Sentence
nrmShrFDenDesc :: Sentence
nrmShrFDenDesc = UnitalChunk
baseWthX UnitalChunk -> DataDefinition -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''`
  DataDefinition
lengthB Sentence -> Sentence -> Sentence
`S.and_` (DefinedQuantityDict
scalFunc DefinedQuantityDict -> DataDefinition -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''`
  DataDefinition
ratioVariation !.)

--------------------------------------------------------------------------

intsliceFs :: InstanceModel
intsliceFs :: InstanceModel
intsliceFs = ModelKind Relation
-> Inputs
-> Output
-> OutputConstraints
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> InstanceModel
im (RelationConcept -> ModelKind Relation
forall e. RelationConcept -> ModelKind e
othModel' RelationConcept
intsliceFsRC) [UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeDist, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeHght, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterHght
  , UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
effCohesion, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
fricAngle, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
dryWeight, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
satWeight, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterWeight
  , UnitalChunk -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipDist, UnitalChunk -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UnitalChunk
slipHght, DefinedQuantityDict -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC DefinedQuantityDict
constF]
  (UnitalChunk -> Output
forall q. (Quantity q, MayHaveUnit q) => q -> Output
qw UnitalChunk
intNormForce) [] [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
chen2005] (Derivation -> Maybe Derivation
forall a. a -> Maybe a
Just Derivation
intrSlcDeriv) String
"intsliceFs" [Sentence
sliceFsDesc]

intsliceFsRC :: RelationConcept
intsliceFsRC :: RelationConcept
intsliceFsRC = String -> NP -> Sentence -> Relation -> RelationConcept
forall e.
Express e =>
String -> NP -> Sentence -> e -> RelationConcept
makeRC String
"intsliceFsRC" (String -> NP
nounPhraseSP String
"interslice normal forces")
  Sentence
sliceFsDesc Relation
sliceFsRel -- inslideFxL

sliceFsRel :: Relation
sliceFsRel :: Relation
sliceFsRel = UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$= [(Relation, Relation)] -> Relation
forall r. ExprC r => [(r, r)] -> r
incompleteCase [
  ((ConstrConcept -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
shearFNoIntsl Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$- UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 UnitalChunk
shearRNoIntsl) Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$/ DefinedQuantityDict -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
indx1 DefinedQuantityDict
shrResC,
    DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$= Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
1),
  ((DefinedQuantityDict -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
mobShrC Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$+
    (ConstrConcept -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearFNoIntsl Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$- UnitalChunk -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearRNoIntsl)) Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$/ DefinedQuantityDict -> Relation
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
shrResC,
    Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
2 Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$<= DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$<= (DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$- Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
1)),
  (Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
0, DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$= Integer -> Relation
forall r. LiteralC r => Integer -> r
int Integer
0 Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$|| DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$= DefinedQuantityDict -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices)]
  -- FIXME: Use index i as part of condition

sliceFsDesc :: Sentence
sliceFsDesc :: Sentence
sliceFsDesc = (SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List [UnitalChunk
shearFNoIntsl UnitalChunk -> GenDefn -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` GenDefn
mobShearWOGD,
  UnitalChunk
shearRNoIntsl UnitalChunk -> GenDefn -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` GenDefn
resShearWOGD,
  DefinedQuantityDict
shrResC DefinedQuantityDict -> DataDefinition -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
convertFunc1,
  DefinedQuantityDict
mobShrC DefinedQuantityDict -> DataDefinition -> Sentence
forall q r.
(HasSymbol q, HasUID q, Referable r, HasShortName r) =>
q -> r -> Sentence
`definedIn'''` DataDefinition
convertFunc2] !.)

intrSlcDeriv :: Derivation
intrSlcDeriv :: Derivation
intrSlcDeriv = [Sentence] -> Derivation
mkDerivNoHeader ([[Sentence]] -> [Sentence]
forall a. [[a]] -> [a]
weave [[Sentence]
intrSlcDerivationSentences, (ModelExpr -> Sentence) -> [ModelExpr] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map ModelExpr -> Sentence
eS [ModelExpr]
forall r. (ExprC r, LiteralC r) => [r]
intrSlcDerivEqns] [Sentence] -> [Sentence] -> [Sentence]
forall a. [a] -> [a] -> [a]
++ [Sentence]
intrSlcDerivSentence3)

intrSlcDerivSentence1 :: [Sentence]
intrSlcDerivSentence1 :: [Sentence]
intrSlcDerivSentence1 = [String -> Sentence
S String
"This derivation" Sentence -> Sentence -> Sentence
`S.is` String -> Sentence
S String
"identical to the derivation for",
  InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
fctSfty, String -> Sentence
S String
"up until", Int -> Sentence
eqN Int
3, String -> Sentence
S String
"shown again below"]

intrSlcDerivSentence2 :: [Sentence]
intrSlcDerivSentence2 :: [Sentence]
intrSlcDerivSentence2 = [String -> Sentence
S String
"A simple rearrangement of", Int -> Sentence
eqN Int
3, String -> Sentence
S String
"leads to",
  Int -> Sentence
eqN Int
17 Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"also seen in", InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
intsliceFs]

intrSlcDerivSentence3 :: [Sentence]
intrSlcDerivSentence3 :: [Sentence]
intrSlcDerivSentence3 = [String -> Sentence
S String
"The cases shown in" Sentence -> Sentence -> Sentence
+:+ InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
intsliceFs Sentence -> Sentence -> Sentence
+:+
  String -> Sentence
S String
"for when" Sentence -> Sentence -> Sentence
+:+ ModelExpr -> Sentence
eS (DefinedQuantityDict -> ModelExpr
forall c. (HasUID c, HasSymbol c) => c -> ModelExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index ModelExpr -> ModelExpr -> ModelExpr
forall r. ExprC r => r -> r -> r
$= Integer -> ModelExpr
forall r. LiteralC r => Integer -> r
int Integer
0) Sentence -> Sentence -> Sentence
`sC` ModelExpr -> Sentence
eS (DefinedQuantityDict -> ModelExpr
forall c. (HasUID c, HasSymbol c) => c -> ModelExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index ModelExpr -> ModelExpr -> ModelExpr
forall r. ExprC r => r -> r -> r
$= Integer -> ModelExpr
forall r. LiteralC r => Integer -> r
int Integer
1) Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"or" Sentence -> Sentence -> Sentence
+:+
  ModelExpr -> Sentence
eS (DefinedQuantityDict -> ModelExpr
forall c. (HasUID c, HasSymbol c) => c -> ModelExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
index ModelExpr -> ModelExpr -> ModelExpr
forall r. ExprC r => r -> r -> r
$= DefinedQuantityDict -> ModelExpr
forall c. (HasUID c, HasSymbol c) => c -> ModelExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
numbSlices) Sentence -> Sentence -> Sentence
+:+ String -> Sentence
S String
"are derived by applying" Sentence -> Sentence -> Sentence
+:+
  ConceptInstance -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpES Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"which says that" Sentence -> Sentence -> Sentence
+:+
  ModelExpr -> Sentence
eS (ModelExpr -> ModelExpr -> ModelExpr
forall r. ExprC r => r -> r -> r
idx (UnitalChunk -> ModelExpr
forall c. (HasUID c, HasSymbol c) => c -> ModelExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
intNormForce) (Integer -> ModelExpr
forall r. LiteralC r => Integer -> r
int Integer
0)) Sentence -> Sentence -> Sentence
`S.and_` ModelExpr -> Sentence
eS (UnitalChunk -> ModelExpr
forall r a. (ExprC r, Quantity a) => a -> r
indxn UnitalChunk
intNormForce) Sentence -> Sentence -> Sentence
+:+
  String -> Sentence
S String
"are zero" Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"to" Sentence -> Sentence -> Sentence
+:+. Int -> Sentence
eqN Int
17 Sentence -> Sentence -> Sentence
+:+ UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
intNormForce Sentence -> Sentence -> Sentence
+:+
  String -> Sentence
S String
"depends on the unknowns" Sentence -> Sentence -> Sentence
+:+ ConstrConcept -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch ConstrConcept
fs Sentence -> Sentence -> Sentence
+:+ Sentence -> Sentence
sParen (InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
fctSfty) Sentence -> Sentence -> Sentence
`S.and_`
  DefinedQuantityDict -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch DefinedQuantityDict
normToShear Sentence -> Sentence -> Sentence
+:+. Sentence -> Sentence
sParen (InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
nrmShrFor)]

intrSlcDerivationSentences :: [Sentence]
intrSlcDerivationSentences :: [Sentence]
intrSlcDerivationSentences = ([Sentence] -> Sentence) -> [[Sentence]] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map [Sentence] -> Sentence
foldlSentCol [[Sentence]
intrSlcDerivSentence1,
  [Sentence]
intrSlcDerivSentence2]

intrSlcDerivEqns :: (ExprC r, LiteralC r) => [r]
intrSlcDerivEqns :: forall r. (ExprC r, LiteralC r) => [r]
intrSlcDerivEqns = [r
PExpr
fctSftyDerivEqn9, r
PExpr
intrSlcDerivEqn]

intrSlcDerivEqn :: PExpr
intrSlcDerivEqn :: PExpr
intrSlcDerivEqn = UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$=
  (DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 DefinedQuantityDict
mobShrC r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxiM1 UnitalChunk
intNormForce r -> r -> r
forall r. ExprC r => r -> r -> r
$+
  (ConstrConcept -> r
forall c. (HasUID c, HasSymbol c) => c -> r
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
fs r -> r -> r
forall r. ExprC r => r -> r -> r
$* UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearFNoIntsl) r -> r -> r
forall r. ExprC r => r -> r -> r
$- UnitalChunk -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi UnitalChunk
shearRNoIntsl) r -> r -> r
forall r. ExprC r => r -> r -> r
$/ DefinedQuantityDict -> r
forall r e. (ExprC r, LiteralC r, Quantity e) => e -> r
inxi DefinedQuantityDict
shrResC

--------------------------------------------------------------------------
crtSlpId :: InstanceModel
crtSlpId :: InstanceModel
crtSlpId = ModelKind Relation
-> Inputs
-> Output
-> OutputConstraints
-> [DecRef]
-> String
-> [Sentence]
-> InstanceModel
imNoDeriv (RelationConcept -> ModelKind Relation
forall e. RelationConcept -> ModelKind e
othModel' RelationConcept
crtSlpIdRC) [UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeDist, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
slopeHght, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterDist,
  UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterHght, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
effCohesion, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
fricAngle, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
dryWeight, UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
satWeight,
  UncertQ -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC UncertQ
waterWeight, DefinedQuantityDict -> Input
forall q. (Quantity q, MayHaveUnit q) => q -> Input
qwUC DefinedQuantityDict
constF] (DefinedQuantityDict -> Output
forall q. (Quantity q, MayHaveUnit q) => q -> Output
qw DefinedQuantityDict
fsMin) [] [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
li2010] String
"crtSlpId"
  [Sentence
crtSlpIdDesc]

crtSlpIdRC :: RelationConcept
crtSlpIdRC :: RelationConcept
crtSlpIdRC = String -> NP -> Sentence -> Relation -> RelationConcept
forall e.
Express e =>
String -> NP -> Sentence -> e -> RelationConcept
makeRC String
"crtSlpIdIM" 
  (String -> NP
nounPhraseSP String
"critical slip surface identification")
  Sentence
crtSlpIdDesc
  Relation
crtSlpIdRel

-- placeholder expression hack that's better than the horrible hack
crtSlpIdRel :: Relation
crtSlpIdRel :: Relation
crtSlpIdRel = UncertQ -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
slopeDist Relation -> Relation -> Relation
forall r. ExprC r => r -> r -> r
$= UncertQ -> Relation
forall c. (HasUID c, HasSymbol c) => c -> Relation
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
slopeHght

  {- equationalModel "crtSlpIdIM"
  (nounPhraseSP "critical slip surface identification") crtSlpIdQD -}

{-
crtSlpIdQD :: SimpleQDef
crtSlpIdQD = mkQuantDef fsMin crtSlpIdExpr

-- FIXME: horrible hack. This is short an argument... that was never defined!
-- FIXME: critCoords should also be an output
crtSlpIdExpr :: Expr
crtSlpIdExpr = apply minFunction [sy slopeDist,
  sy slopeHght, sy waterDist, sy waterHght, sy effCohesion, sy fricAngle,
  sy dryWeight, sy satWeight, sy waterWeight]
-}

-- FIXME: The constraints described here should be replaced with formal constraints on the input variables once that is possible
crtSlpIdDesc :: Sentence
crtSlpIdDesc :: Sentence
crtSlpIdDesc = [Sentence] -> Sentence
foldlSent [NP -> Sentence
forall n. NounPhrase n => n -> Sentence
atStartNP (DefinedQuantityDict -> NP
forall t. NamedIdea t => t -> NP
the DefinedQuantityDict
minFunction), String -> Sentence
S String
"must enforce the",
  NP -> Sentence
forall n. NounPhrase n => n -> Sentence
pluralNP (IdeaDict
constraint IdeaDict -> ConceptChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`onThePS` ConceptChunk
crtSlpSrf), String -> Sentence
S String
"expressed in" Sentence -> Sentence -> Sentence
+:+.
  (ConceptInstance -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpSSC Sentence -> Sentence -> Sentence
`S.and_` Section -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ([Contents] -> [Section] -> Section
propCorSol [] [])),
  String -> Sentence
S String
"The sizes" Sentence -> Sentence -> Sentence
`S.of_` UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
waterDist Sentence -> Sentence -> Sentence
`S.and_` UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
waterHght Sentence -> Sentence -> Sentence
+:+.
  String -> Sentence
S String
"must be equal and not 1", String -> Sentence
S String
"The", String -> Sentence
S String
"sizes of", UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeDist Sentence -> Sentence -> Sentence
`S.and_`
  UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeHght Sentence -> Sentence -> Sentence
+:+. (String -> Sentence
S String
"must be equal" Sentence -> Sentence -> Sentence
`S.and_` String -> Sentence
S String
"at least 2"),
  NP -> Sentence
forall n. NounPhrase n => n -> Sentence
atStartNP (IdeaDict -> NP
forall t. NamedIdea t => t -> NP
the IdeaDict
first) Sentence -> Sentence -> Sentence
`S.and_` String -> Sentence
S String
"last", UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
waterDist,
  IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
plural IdeaDict
value, String -> Sentence
S String
"must be equal" Sentence -> Sentence -> Sentence
`S.toThe` IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
first Sentence -> Sentence -> Sentence
`S.and_` String -> Sentence
S String
"last",
  UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeDist Sentence -> Sentence -> Sentence
+:+. IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
plural IdeaDict
value, UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
waterDist Sentence -> Sentence -> Sentence
`S.and_` UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeDist,
  IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
plural IdeaDict
value Sentence -> Sentence -> Sentence
+:+. String -> Sentence
S String
"must be monotonically increasing", UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
xMaxExtSlip Sentence -> Sentence -> Sentence
`sC`
  UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
xMaxEtrSlip Sentence -> Sentence -> Sentence
`sC` UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
xMinExtSlip Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"and", UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
xMinEtrSlip, String -> Sentence
S String
"must be",
  String -> Sentence
S String
"between or equal" Sentence -> Sentence -> Sentence
`S.toThe` String -> Sentence
S String
"minimum and maximum", UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeDist Sentence -> Sentence -> Sentence
+:+.
  IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
plural IdeaDict
value, UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
yMaxSlip, String -> Sentence
S String
"cannot be below the minimum", UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeHght Sentence -> Sentence -> Sentence
+:+.
  IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
value, UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
yMinSlip, String -> Sentence
S String
"cannot be above the maximum", UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeHght Sentence -> Sentence -> Sentence
+:+.
  IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
value, String -> Sentence
S String
"All", UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
xi, IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
plural IdeaDict
value Sentence -> Sentence -> Sentence
`S.of_` UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
critCoords, String -> Sentence
S String
"must be",
  String -> Sentence
S String
"between" Sentence -> Sentence -> Sentence
+:+. (UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
xMinEtrSlip Sentence -> Sentence -> Sentence
`S.and_` UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
xMaxExtSlip), String -> Sentence
S String
"All", UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
yi,
  IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
plural IdeaDict
value Sentence -> Sentence -> Sentence
`S.of_` UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
critCoords, String -> Sentence
S String
"must not be below" Sentence -> Sentence -> Sentence
+:+. UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
yMinSlip,
  String -> Sentence
S String
"For any given vertex in", UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
critCoords, String -> Sentence
S String
"the", UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
yi, IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
value,
  String -> Sentence
S String
"must not exceed the", UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeHght, IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
value, String -> Sentence
S String
"corresponding to the",
  String -> Sentence
S String
"same", UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
xi Sentence -> Sentence -> Sentence
+:+. IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
value, NP -> Sentence
forall n. NounPhrase n => n -> Sentence
atStartNP (IdeaDict -> NP
forall t. NamedIdea t => t -> NP
the IdeaDict
first) Sentence -> Sentence -> Sentence
`S.and_` String -> Sentence
S String
"last",
  String -> Sentence
S String
"vertices in", UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
critCoords, String -> Sentence
S String
"must each be equal to one" Sentence -> Sentence -> Sentence
`S.ofThe` String -> Sentence
S String
"vertices",
  String -> Sentence
S String
"formed by" Sentence -> Sentence -> Sentence
+:+. (UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeDist Sentence -> Sentence -> Sentence
`S.and_` UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
slopeHght), String -> Sentence
S String
"The slope between",
  String -> Sentence
S String
"consecutive vertices must be always increasing as", UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
xi Sentence -> Sentence -> Sentence
+:+.
  String -> Sentence
S String
"increases", String -> Sentence
S String
"The internal", ConceptChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
angle, String -> Sentence
S String
"between consecutive",
  String -> Sentence
S String
"vertices in", UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
critCoords Sentence -> Sentence -> Sentence
+:+ String -> Sentence
S String
"must not be below 110 degrees"]

-----------
-- Intro --
-----------

instModIntro :: [Sentence]
instModIntro :: [Sentence]
instModIntro = [Sentence
instModIntro1, Sentence
instModIntro2]

instModIntro1, instModIntro2 :: Sentence

instModIntro1 :: Sentence
instModIntro1 = [Sentence] -> Sentence
foldlSent [NP -> Sentence
forall n. NounPhrase n => n -> Sentence
atStartNP' (IdeaDict -> NP
forall t. NamedIdea t => t -> NP
the IdeaDict
goal), SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List
  ((ConceptInstance -> Sentence) -> [ConceptInstance] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map ConceptInstance -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS [ConceptInstance]
goals) Sentence -> Sentence -> Sentence
`S.are` String -> Sentence
S String
"met by the simultaneous" Sentence -> Sentence -> Sentence
+:+. (IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
solution Sentence -> Sentence -> Sentence
`S.of_`
  SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List ((InstanceModel -> Sentence) -> [InstanceModel] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS [InstanceModel
fctSfty, InstanceModel
nrmShrFor, InstanceModel
intsliceFs])), NP -> Sentence
forall n. NounPhrase n => n -> Sentence
atStartNP (IdeaDict -> NP
forall t. NamedIdea t => t -> NP
the IdeaDict
goal),
  ConceptInstance -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
identifyCritAndFSGS Sentence -> Sentence -> Sentence
`S.is` String -> Sentence
S String
"also contributed to by",
  InstanceModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS InstanceModel
crtSlpId]

instModIntro2 :: Sentence
instModIntro2 = [Sentence] -> Sentence
foldlSent [NP -> Sentence
forall n. NounPhrase n => n -> Sentence
titleizeNP (IdeaDict -> NP
forall t. NamedIdea t => t -> NP
the IdeaDict
morPrice),
  IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
method_, String -> Sentence
S String
"is a vertical", IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
slice Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S String
"limit equilibrium",
  IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
ssa Sentence -> Sentence -> Sentence
+:+. IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
method_, IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
atStart IdeaDict
analysis, String -> Sentence
S String
"is performed by",
  String -> Sentence
S String
"breaking the assumed", ConceptChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
slpSrf,
  String -> Sentence
S String
"into a series of vertical", IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
plural IdeaDict
slice, String -> Sentence
S String
"of" Sentence -> Sentence -> Sentence
+:+. ConceptChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
mass,
  String -> Sentence
S String
"Static equilibrium analysis is performed, using two", ConceptChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
force,
  ConceptChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
plural ConceptChunk
equation Sentence -> Sentence -> Sentence
`S.and_` String -> Sentence
S String
"one moment", ConceptChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
equation, String -> Sentence
S String
"as in" Sentence -> Sentence -> Sentence
+:+. TheoryModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS TheoryModel
equilibrium,
  NP -> Sentence
forall n. NounPhrase n => n -> Sentence
atStartNP (IdeaDict -> NP
forall t. NamedIdea t => t -> NP
the IdeaDict
problem), String -> Sentence
S String
"is statically indeterminate with only these 3",
  ConceptChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
plural ConceptChunk
equation, String -> Sentence
S String
"and one constitutive", ConceptChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase ConceptChunk
equation,
  Sentence -> Sentence
sParen (Sentence -> Sentence) -> Sentence -> Sentence
forall a b. (a -> b) -> a -> b
$ String -> Sentence
S String
"the Mohr Coulomb shear strength of" Sentence -> Sentence -> Sentence
+:+
  TheoryModel -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS TheoryModel
mcShrStrgth, String -> Sentence
S String
"so the", CI -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase CI
assumption,
  GenDefn -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
normShrRGD Sentence -> Sentence -> Sentence
`S.and_` String -> Sentence
S String
"corresponding equation",
  GenDefn -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
normShrRGD Sentence -> Sentence -> Sentence
+:+. String -> Sentence
S String
"are used",
  NP -> Sentence
forall n. NounPhrase n => n -> Sentence
atStartNP (ConceptChunk -> NP
forall t. NamedIdea t => t -> NP
the ConceptChunk
force), String -> Sentence
S String
"equilibrium", ConceptChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
plural ConceptChunk
equation, String -> Sentence
S String
"can be modified",
  String -> Sentence
S String
"to be expressed only in terms of known", IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
physical, IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
plural IdeaDict
value Sentence -> Sentence -> Sentence
`sC`
  String -> Sentence
S String
"as done in", GenDefn -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
resShearWOGD Sentence -> Sentence -> Sentence
`S.and_` GenDefn -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS GenDefn
mobShearWOGD]