module Drasil.GlassBR.DataDefs (aspRat, dataDefs, dimLL, qDefns, glaTyFac,
  hFromt, loadDF, nonFL, risk, standOffDis, strDisFac, tolPre, tolStrDisFac,
  eqTNTWDD, probOfBreak, calofCapacity, calofDemand, pbTolUsr, qRef,configFp)
  where

import Control.Lens ((^.))
import Language.Drasil
import Prelude hiding (log, exp, sqrt)
import Theory.Drasil (DataDefinition, ddE)
import SysInfo.Drasil
import qualified Language.Drasil.Sentence.Combinators as S

import Data.Drasil.Concepts.Documentation (datum, user)
import Data.Drasil.Concepts.Math (parameter)
import Data.Drasil.Concepts.PhysicalProperties (dimension)

import Data.Drasil.Citations (campidelli)

import Drasil.GlassBR.Assumptions (assumpSV, assumpLDFC)
import Drasil.GlassBR.Concepts (annealed, fullyT, glass, heatS)
import Drasil.GlassBR.Figures (demandVsSDFig, dimlessloadVsARFig)
import Drasil.GlassBR.References (astm2009, beasonEtAl1998)
import Drasil.GlassBR.Unitals (actualThicknesses, aspectRatio, charWeight,
  demand, demandq, dimlessLoad, eqTNTWeight, gTF, glassType, glassTypeCon,
  glassTypeFactors, lDurFac, lRe, loadDur, loadSF, minThick, modElas, nomThick,
  nominalThicknesses, nonFactorL, pbTol, plateLen, plateWidth, probBr, riskFun,
  sdfTol, sdx, sdy, sdz, sflawParamK, sflawParamM, standOffDist, stressDistFac,
  tNT, tolLoad, interpY, interpZ)

----------------------
-- DATA DEFINITIONS --
----------------------

dataDefs :: [DataDefinition]
dataDefs :: [DataDefinition]
dataDefs = [DataDefinition
risk, DataDefinition
hFromt, DataDefinition
loadDF, DataDefinition
strDisFac, DataDefinition
nonFL, DataDefinition
glaTyFac,
  DataDefinition
dimLL, DataDefinition
tolPre, DataDefinition
tolStrDisFac, DataDefinition
standOffDis, DataDefinition
aspRat, DataDefinition
eqTNTWDD, DataDefinition
probOfBreak,
  DataDefinition
calofCapacity, DataDefinition
calofDemand]

qDefns :: [Block SimpleQDef]
qDefns :: [Block SimpleQDef]
qDefns = SimpleQDef -> [SimpleQDef] -> Block SimpleQDef
forall a. a -> [a] -> Block a
Parallel SimpleQDef
hFromtQD {-DD2-} [SimpleQDef
glaTyFacQD {-DD6-}] Block SimpleQDef -> [Block SimpleQDef] -> [Block SimpleQDef]
forall a. a -> [a] -> [a]
: --can be calculated on their own
  (SimpleQDef -> Block SimpleQDef)
-> [SimpleQDef] -> [Block SimpleQDef]
forall a b. (a -> b) -> [a] -> [b]
map (SimpleQDef -> [SimpleQDef] -> Block SimpleQDef
forall a. a -> [a] -> Block a
`Parallel` []) [SimpleQDef
dimLLQD {-DD7-}, SimpleQDef
strDisFacQD {-DD4-}, SimpleQDef
riskQD {-DD1-},
  SimpleQDef
tolStrDisFacQD {-DD9-}, SimpleQDef
tolPreQD {-DD8-}, SimpleQDef
nonFLQD {-DD5-}]

--DD1--

riskEq :: Expr
riskEq :: Expr
riskEq = (UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
sflawParamK Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$/
  (Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
mulRe (UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
plateLen) (UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
plateWidth) Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$^ (UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
sflawParamM Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$- Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 1))) Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
`mulRe`
  ((UnitalChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
modElas Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
`mulRe` Expr -> Expr
forall r. (ExprC r, LiteralC r) => r -> r
square (UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
minThick)) Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$^ UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
sflawParamM) Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
`mulRe` QuantityDict -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy QuantityDict
lDurFac Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
`mulRe` Expr -> Expr
forall r. ExprC r => r -> r
exp (ConstrainedChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrainedChunk
stressDistFac)

-- FIXME [4] !!!
riskQD :: SimpleQDef
riskQD :: SimpleQDef
riskQD = QuantityDict -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef QuantityDict
riskFun Expr
riskEq

risk :: DataDefinition
risk :: DataDefinition
risk = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
riskQD
  [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
astm2009, Citation -> RefInfo -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> RefInfo -> DecRef
dRefInfo Citation
beasonEtAl1998 (RefInfo -> DecRef) -> RefInfo -> DecRef
forall a b. (a -> b) -> a -> b
$ [Int] -> RefInfo
Equation [4, 5],
  Citation -> RefInfo -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> RefInfo -> DecRef
dRefInfo Citation
campidelli (RefInfo -> DecRef) -> RefInfo -> DecRef
forall a b. (a -> b) -> a -> b
$ [Int] -> RefInfo
Equation [14]]
  Maybe Derivation
forall a. Maybe a
Nothing "riskFun" [Sentence
aGrtrThanB, Sentence
hRef, Sentence
ldfRef, Sentence
jRef]

--DD2--

hFromtEq :: Relation
hFromtEq :: Expr
hFromtEq = Integer -> Integer -> Expr
forall r. (ExprC r, LiteralC r) => Integer -> Integer -> r
frac 1 1000 Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
`mulRe` [(Expr, Expr)] -> Expr
forall r. ExprC r => [(r, r)] -> r
incompleteCase ((Double -> Double -> (Expr, Expr))
-> [Double] -> [Double] -> [(Expr, Expr)]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Double -> Double -> (Expr, Expr)
hFromtHelper
  [Double]
actualThicknesses [Double]
nominalThicknesses)

hFromtHelper :: Double -> Double -> (Expr, Relation)
hFromtHelper :: Double -> Double -> (Expr, Expr)
hFromtHelper result :: Double
result condition :: Double
condition = (Double -> Expr
forall r. LiteralC r => Double -> r
dbl Double
result, ConstrainedChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrainedChunk
nomThick Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$= Double -> Expr
forall r. LiteralC r => Double -> r
dbl Double
condition)

hFromtQD :: SimpleQDef
hFromtQD :: SimpleQDef
hFromtQD = UnitaryChunk -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef UnitaryChunk
minThick Expr
hFromtEq

hFromt :: DataDefinition
hFromt :: DataDefinition
hFromt = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
hFromtQD [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
astm2009] Maybe Derivation
forall a. Maybe a
Nothing "minThick" [Sentence
hMin]

--DD3-- (#749)

loadDFEq :: Expr
loadDFEq :: Expr
loadDFEq = (UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
loadDur Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$/ Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 60) Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$^ (UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
sflawParamM Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$/ Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 16)

loadDFQD :: SimpleQDef
loadDFQD :: SimpleQDef
loadDFQD = QuantityDict -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef QuantityDict
lDurFac Expr
loadDFEq

loadDF :: DataDefinition
loadDF :: DataDefinition
loadDF = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
loadDFQD [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
astm2009] Maybe Derivation
forall a. Maybe a
Nothing "loadDurFactor"
  [[UnitaryChunk] -> Sentence
forall s. (HasSymbol s, HasUID s) => [s] -> Sentence
stdVals [UnitaryChunk
loadDur, UnitaryChunk
sflawParamM], Sentence
ldfConst]

--DD4--

strDisFacEq :: Expr
-- strDisFacEq = apply (sy stressDistFac)
--   [sy dimlessLoad, sy aspectRatio]
strDisFacEq :: Expr
strDisFacEq = QuantityDict -> [Expr] -> Expr
forall r f. (ExprC r, HasUID f, HasSymbol f) => f -> [r] -> r
apply QuantityDict
interpZ [String -> Expr
forall r. LiteralC r => String -> r
str "SDF.txt", UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
aspectRatio, QuantityDict -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy QuantityDict
dimlessLoad]

strDisFacQD :: SimpleQDef
strDisFacQD :: SimpleQDef
strDisFacQD = ConstrainedChunk -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef ConstrainedChunk
stressDistFac Expr
strDisFacEq

strDisFac :: DataDefinition
strDisFac :: DataDefinition
strDisFac = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
strDisFacQD [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
astm2009] Maybe Derivation
forall a. Maybe a
Nothing "stressDistFac"
  [ConstrainedChunk -> LabelledContent -> Sentence
forall s f.
(HasUID s, HasSymbol s, Referable f, HasShortName f) =>
s -> f -> Sentence
interpolating ConstrainedChunk
stressDistFac LabelledContent
dimlessloadVsARFig, Sentence
arRef, Sentence
qHtRef]

--DD5--

nonFLEq :: Expr
nonFLEq :: Expr
nonFLEq = Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
mulRe (Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
mulRe (QuantityDict -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy QuantityDict
tolLoad) (UnitalChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
modElas)) (UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
minThick Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$^ Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 4) Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$/
  Expr -> Expr
forall r. (ExprC r, LiteralC r) => r -> r
square (Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
mulRe (UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
plateLen) (UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
plateWidth))

nonFLQD :: SimpleQDef
nonFLQD :: SimpleQDef
nonFLQD = UnitalChunk -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef UnitalChunk
nonFactorL Expr
nonFLEq

nonFL :: DataDefinition
nonFL :: DataDefinition
nonFL = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
nonFLQD [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
astm2009] Maybe Derivation
forall a. Maybe a
Nothing "nFL"
  [Sentence
qHtTlTolRef, [UnitalChunk] -> Sentence
forall s. (HasSymbol s, HasUID s) => [s] -> Sentence
stdVals [UnitalChunk
modElas], Sentence
hRef, Sentence
aGrtrThanB]

--DD6--

glaTyFacEq :: Expr
glaTyFacEq :: Expr
glaTyFacEq = [(Expr, Expr)] -> Expr
forall r. ExprC r => [(r, r)] -> r
incompleteCase ((Integer -> String -> (Expr, Expr))
-> [Integer] -> [String] -> [(Expr, Expr)]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Integer -> String -> (Expr, Expr)
glaTyFacHelper [Integer]
glassTypeFactors ([String] -> [(Expr, Expr)]) -> [String] -> [(Expr, Expr)]
forall a b. (a -> b) -> a -> b
$ ((Integer, CI) -> String) -> [(Integer, CI)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (CI -> String
getAccStr (CI -> String) -> ((Integer, CI) -> CI) -> (Integer, CI) -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Integer, CI) -> CI
forall a b. (a, b) -> b
snd) [(Integer, CI)]
glassType)

glaTyFacHelper :: Integer -> String -> (Expr, Relation)
glaTyFacHelper :: Integer -> String -> (Expr, Expr)
glaTyFacHelper result :: Integer
result condition :: String
condition = (Integer -> Expr
forall r. LiteralC r => Integer -> r
int Integer
result, ConstrConcept -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstrConcept
glassTypeCon Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$= String -> Expr
forall r. LiteralC r => String -> r
str String
condition)

glaTyFacQD :: SimpleQDef
glaTyFacQD :: SimpleQDef
glaTyFacQD = DefinedQuantityDict -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef DefinedQuantityDict
gTF Expr
glaTyFacEq

glaTyFac :: DataDefinition
glaTyFac :: DataDefinition
glaTyFac = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
glaTyFacQD [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
astm2009] Maybe Derivation
forall a. Maybe a
Nothing "gTF"
  [Sentence
anGlass, Sentence
ftGlass, Sentence
hsGlass]

--DD7--

dimLLEq :: Expr
dimLLEq :: Expr
dimLLEq = Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
mulRe (UnitalChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
demand) (Expr -> Expr
forall r. (ExprC r, LiteralC r) => r -> r
square (Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
mulRe (UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
plateLen) (UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
plateWidth)))
  Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$/ Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
mulRe (Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
mulRe (UnitalChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
modElas) (UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
minThick Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$^ Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 4)) (DefinedQuantityDict -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
gTF)

dimLLQD :: SimpleQDef
dimLLQD :: SimpleQDef
dimLLQD = QuantityDict -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef QuantityDict
dimlessLoad Expr
dimLLEq

dimLL :: DataDefinition
dimLL :: DataDefinition
dimLL = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
dimLLQD [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
astm2009, Citation -> RefInfo -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> RefInfo -> DecRef
dRefInfo Citation
campidelli (RefInfo -> DecRef) -> RefInfo -> DecRef
forall a b. (a -> b) -> a -> b
$ [Int] -> RefInfo
Equation [7]] Maybe Derivation
forall a. Maybe a
Nothing "dimlessLoad"
  [Sentence
qRef, Sentence
aGrtrThanB, [UnitalChunk] -> Sentence
forall s. (HasSymbol s, HasUID s) => [s] -> Sentence
stdVals [UnitalChunk
modElas], Sentence
hRef, Sentence
gtfRef]

--DD8--

tolPreEq :: Expr
--tolPreEq = apply (sy tolLoad) [sy sdfTol, (sy plateLen) / (sy plateWidth)]
tolPreEq :: Expr
tolPreEq = QuantityDict -> [Expr] -> Expr
forall r f. (ExprC r, HasUID f, HasSymbol f) => f -> [r] -> r
apply QuantityDict
interpY [String -> Expr
forall r. LiteralC r => String -> r
str "SDF.txt", UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
aspectRatio, QuantityDict -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy QuantityDict
sdfTol]

tolPreQD :: SimpleQDef
tolPreQD :: SimpleQDef
tolPreQD = QuantityDict -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef QuantityDict
tolLoad Expr
tolPreEq

tolPre :: DataDefinition
tolPre :: DataDefinition
tolPre = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
tolPreQD [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
astm2009] Maybe Derivation
forall a. Maybe a
Nothing "tolLoad"
  [QuantityDict -> LabelledContent -> Sentence
forall s f.
(HasUID s, HasSymbol s, Referable f, HasShortName f) =>
s -> f -> Sentence
interpolating QuantityDict
tolLoad LabelledContent
dimlessloadVsARFig, Sentence
arRef, Sentence
jtolRef]

--DD9--

tolStrDisFacEq :: Expr
tolStrDisFacEq :: Expr
tolStrDisFacEq = Expr -> Expr
forall r. ExprC r => r -> r
ln (Expr -> Expr
forall r. ExprC r => r -> r
ln (Expr -> Expr
forall r. (ExprC r, LiteralC r) => r -> r
recip_ (Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 1 Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$- UncertainChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertainChunk
pbTol))
  Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
`mulRe` ((UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
plateLen Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
`mulRe` UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
plateWidth) Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$^ (UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
sflawParamM Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$- Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 1) Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$/
    (UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
sflawParamK Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
`mulRe` ((UnitalChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
modElas Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
`mulRe`
    Expr -> Expr
forall r. (ExprC r, LiteralC r) => r -> r
square (UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
minThick)) Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$^ UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
sflawParamM) Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
`mulRe` QuantityDict -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy QuantityDict
lDurFac)))

tolStrDisFacQD :: SimpleQDef
tolStrDisFacQD :: SimpleQDef
tolStrDisFacQD = QuantityDict -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef QuantityDict
sdfTol Expr
tolStrDisFacEq

tolStrDisFac :: DataDefinition
tolStrDisFac :: DataDefinition
tolStrDisFac = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
tolStrDisFacQD [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
astm2009] Maybe Derivation
forall a. Maybe a
Nothing "sdfTol"
  [Sentence
pbTolUsr, Sentence
aGrtrThanB, [UnitaryChunk] -> Sentence
forall s. (HasSymbol s, HasUID s) => [s] -> Sentence
stdVals [UnitaryChunk
sflawParamM, UnitaryChunk
sflawParamK, UnitalChunk -> UnitaryChunk
forall u. (Unitary u, MayHaveUnit u) => u -> UnitaryChunk
mkUnitary UnitalChunk
modElas],
   Sentence
hRef, Sentence
ldfRef]

--DD10--

standOffDisEq :: Expr
standOffDisEq :: Expr
standOffDisEq = Expr -> Expr
forall r. ExprC r => r -> r
sqrt (Expr -> Expr
forall r. (ExprC r, LiteralC r) => r -> r
square (UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
sdx) Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
`addRe` Expr -> Expr
forall r. (ExprC r, LiteralC r) => r -> r
square (UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
sdy) Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
`addRe` Expr -> Expr
forall r. (ExprC r, LiteralC r) => r -> r
square (UnitaryChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitaryChunk
sdz))

standOffDisQD :: SimpleQDef
standOffDisQD :: SimpleQDef
standOffDisQD = UncertQ -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef UncertQ
standOffDist Expr
standOffDisEq

standOffDis :: DataDefinition
standOffDis :: DataDefinition
standOffDis = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
standOffDisQD [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
astm2009] Maybe Derivation
forall a. Maybe a
Nothing "standOffDist" []

--DD11--

aspRatEq :: Expr
aspRatEq :: Expr
aspRatEq = UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
plateLen Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$/ UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
plateWidth

aspRatQD :: SimpleQDef
aspRatQD :: SimpleQDef
aspRatQD = UncertQ -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef UncertQ
aspectRatio Expr
aspRatEq

aspRat :: DataDefinition
aspRat :: DataDefinition
aspRat = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
aspRatQD [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
astm2009] Maybe Derivation
forall a. Maybe a
Nothing "aspectRatio" [Sentence
aGrtrThanB]

--DD12--
eqTNTWEq :: Expr
eqTNTWEq :: Expr
eqTNTWEq = Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
mulRe (UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
charWeight) (UncertainChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertainChunk
tNT)

eqTNTWQD :: SimpleQDef
eqTNTWQD :: SimpleQDef
eqTNTWQD = UnitalChunk -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef UnitalChunk
eqTNTWeight Expr
eqTNTWEq

eqTNTWDD :: DataDefinition
eqTNTWDD :: DataDefinition
eqTNTWDD = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
eqTNTWQD [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
astm2009] Maybe Derivation
forall a. Maybe a
Nothing "eqTNTW" []

--DD13--
probOfBreakEq :: Expr
probOfBreakEq :: Expr
probOfBreakEq = Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 1 Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
$- Expr -> Expr
forall r. ExprC r => r -> r
exp (Expr -> Expr
forall r. ExprC r => r -> r
neg (DataDefinition -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DataDefinition
risk))

probOfBreakQD :: SimpleQDef
probOfBreakQD :: SimpleQDef
probOfBreakQD = ConstrainedChunk -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef ConstrainedChunk
probBr Expr
probOfBreakEq

probOfBreak :: DataDefinition
probOfBreak :: DataDefinition
probOfBreak = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
probOfBreakQD ((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
astm2009, Citation
beasonEtAl1998]) Maybe Derivation
forall a. Maybe a
Nothing "probOfBreak" [Sentence
riskRef]

--DD14--
calofCapacityEq :: Expr
calofCapacityEq :: Expr
calofCapacityEq = DataDefinition -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DataDefinition
nonFL Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
`mulRe` DataDefinition -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DataDefinition
glaTyFac Expr -> Expr -> Expr
forall r. ExprC r => r -> r -> r
`mulRe` DefinedQuantityDict -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy DefinedQuantityDict
loadSF

calofCapacityQD :: SimpleQDef
calofCapacityQD :: SimpleQDef
calofCapacityQD = UnitalChunk -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef UnitalChunk
lRe Expr
calofCapacityEq

calofCapacity :: DataDefinition
calofCapacity :: DataDefinition
calofCapacity = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
calofCapacityQD [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
astm2009] Maybe Derivation
forall a. Maybe a
Nothing "calofCapacity"
  [Sentence
lrCap, Sentence
nonFLRef, Sentence
gtfRef]

--DD15--
calofDemandEq :: Expr
calofDemandEq :: Expr
calofDemandEq = QuantityDict -> [Expr] -> Expr
forall r f. (ExprC r, HasUID f, HasSymbol f) => f -> [r] -> r
apply QuantityDict
interpY [String -> Expr
forall r. LiteralC r => String -> r
str "TSD.txt", UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
standOffDist, UnitalChunk -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UnitalChunk
eqTNTWeight]

calofDemandQD :: SimpleQDef
calofDemandQD :: SimpleQDef
calofDemandQD = UnitalChunk -> Expr -> SimpleQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef UnitalChunk
demand Expr
calofDemandEq

calofDemand :: DataDefinition
calofDemand :: DataDefinition
calofDemand = SimpleQDef
-> [DecRef]
-> Maybe Derivation
-> String
-> [Sentence]
-> DataDefinition
ddE SimpleQDef
calofDemandQD [Citation -> DecRef
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> DecRef
dRef Citation
astm2009] Maybe Derivation
forall a. Maybe a
Nothing "calofDemand" [Sentence
calofDemandDesc]


--Additional Notes--
calofDemandDesc :: Sentence
calofDemandDesc :: Sentence
calofDemandDesc =
  [Sentence] -> Sentence
foldlSent [UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
demand Sentence -> Sentence -> Sentence
`sC` Sentence
EmptyS Sentence -> Sentence -> Sentence
`S.or_` ConceptChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase ConceptChunk
demandq Sentence -> Sentence -> Sentence
`sC` Sentence
EmptyS Sentence -> Sentence -> Sentence
`S.isThe`
  (ConceptChunk
demandq ConceptChunk -> Getting Sentence ConceptChunk Sentence -> Sentence
forall s a. s -> Getting a s a -> a
^. Getting Sentence ConceptChunk Sentence
forall c. Definition c => Lens' c Sentence
defn), String -> Sentence
S "obtained from", LabelledContent -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS LabelledContent
demandVsSDFig,
  String -> Sentence
S "by interpolation using", UncertQ -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase UncertQ
standOffDist, Sentence -> Sentence
sParen (UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
standOffDist)
  Sentence -> Sentence -> Sentence
`S.and_` UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
eqTNTWeight, String -> Sentence
S "as" Sentence -> Sentence -> Sentence
+:+. ConceptChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
plural ConceptChunk
parameter, UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
eqTNTWeight,
  String -> Sentence
S "is defined in" Sentence -> Sentence -> Sentence
+:+. DataDefinition -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS DataDefinition
eqTNTWDD, UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
standOffDist Sentence -> Sentence -> Sentence
`S.isThe`
  UncertQ -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase UncertQ
standOffDist, String -> Sentence
S "as defined in", DataDefinition -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS DataDefinition
standOffDis]

aGrtrThanB :: Sentence
aGrtrThanB :: Sentence
aGrtrThanB = UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
plateLen Sentence -> Sentence -> Sentence
`S.and_` UncertQ -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertQ
plateWidth Sentence -> Sentence -> Sentence
`S.are` (ConceptChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
plural ConceptChunk
dimension Sentence -> Sentence -> Sentence
`S.the_ofThe` String -> Sentence
S "plate") Sentence -> Sentence -> Sentence
`sC`
  String -> Sentence
S "where" Sentence -> Sentence -> Sentence
+:+. Sentence -> Sentence
sParen (ModelExpr -> Sentence
eS ModelExpr
rel)
  where
    rel :: ModelExpr
    rel :: ModelExpr
rel = UncertQ -> ModelExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
plateLen ModelExpr -> ModelExpr -> ModelExpr
forall r. ExprC r => r -> r -> r
$>= UncertQ -> ModelExpr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
plateWidth

anGlass :: Sentence
anGlass :: Sentence
anGlass = CI -> Sentence
getAcc CI
annealed Sentence -> Sentence -> Sentence
`S.is` CI -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase CI
annealed Sentence -> Sentence -> Sentence
+:+. NamedChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase NamedChunk
glass

ftGlass :: Sentence
ftGlass :: Sentence
ftGlass = CI -> Sentence
getAcc CI
fullyT Sentence -> Sentence -> Sentence
`S.is` CI -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase CI
fullyT Sentence -> Sentence -> Sentence
+:+. NamedChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase NamedChunk
glass

hMin :: Sentence
hMin :: Sentence
hMin = ConstrainedChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch ConstrainedChunk
nomThick Sentence -> Sentence -> Sentence
`S.is` String -> Sentence
S "a function that maps from the nominal thickness"
  Sentence -> Sentence -> Sentence
+:+. (Sentence -> Sentence
sParen (UnitaryChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitaryChunk
minThick) Sentence -> Sentence -> Sentence
`S.toThe` UnitaryChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase UnitaryChunk
minThick)

hsGlass :: Sentence
hsGlass :: Sentence
hsGlass = CI -> Sentence
getAcc CI
heatS Sentence -> Sentence -> Sentence
`S.is` CI -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase CI
heatS Sentence -> Sentence -> Sentence
+:+. NamedChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase NamedChunk
glass

ldfConst :: Sentence
ldfConst :: Sentence
ldfConst = QuantityDict -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch QuantityDict
lDurFac Sentence -> Sentence -> Sentence
`S.is` String -> Sentence
S "assumed to be constant" Sentence -> Sentence -> Sentence
+:+. ConceptInstance -> Sentence
forall r. (Referable r, HasShortName r) => r -> Sentence
fromSource ConceptInstance
assumpLDFC

lrCap :: Sentence
lrCap :: Sentence
lrCap = UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
lRe Sentence -> Sentence -> Sentence
+:+. String -> Sentence
S "is also called capacity"

pbTolUsr :: Sentence
pbTolUsr :: Sentence
pbTolUsr = UncertainChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UncertainChunk
pbTol Sentence -> Sentence -> Sentence
`S.is` String -> Sentence
S "entered by the" Sentence -> Sentence -> Sentence
+:+. NamedChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase NamedChunk
user

qRef :: Sentence
qRef :: Sentence
qRef = UnitalChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch UnitalChunk
demand Sentence -> Sentence -> Sentence
`S.isThe` (ConceptChunk
demandq ConceptChunk -> Getting Sentence ConceptChunk Sentence -> Sentence
forall s a. s -> Getting a s a -> a
^. Getting Sentence ConceptChunk Sentence
forall c. Definition c => Lens' c Sentence
defn) Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S "as given in" Sentence -> Sentence -> Sentence
+:+. DataDefinition -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS DataDefinition
calofDemand

arRef, gtfRef, hRef, jRef, jtolRef, ldfRef, nonFLRef, qHtRef, qHtTlTolRef, riskRef :: Sentence
arRef :: Sentence
arRef       = DataDefinition -> Sentence
forall r.
(Referable r, HasShortName r, HasSymbol r) =>
r -> Sentence
definedIn  DataDefinition
aspRat
gtfRef :: Sentence
gtfRef      = DataDefinition -> Sentence
forall r.
(Referable r, HasShortName r, HasSymbol r) =>
r -> Sentence
definedIn  DataDefinition
glaTyFac
hRef :: Sentence
hRef        = DataDefinition -> Sentence -> Sentence
forall r.
(Referable r, HasShortName r, HasSymbol r) =>
r -> Sentence -> Sentence
definedIn' DataDefinition
hFromt (String -> Sentence
S "and is based on the nominal thicknesses")
jRef :: Sentence
jRef        = DataDefinition -> Sentence
forall r.
(Referable r, HasShortName r, HasSymbol r) =>
r -> Sentence
definedIn  DataDefinition
strDisFac
jtolRef :: Sentence
jtolRef     = DataDefinition -> Sentence
forall r.
(Referable r, HasShortName r, HasSymbol r) =>
r -> Sentence
definedIn  DataDefinition
tolStrDisFac
ldfRef :: Sentence
ldfRef      = DataDefinition -> Sentence
forall r.
(Referable r, HasShortName r, HasSymbol r) =>
r -> Sentence
definedIn  DataDefinition
loadDF
nonFLRef :: Sentence
nonFLRef    = DataDefinition -> Sentence
forall r.
(Referable r, HasShortName r, HasSymbol r) =>
r -> Sentence
definedIn  DataDefinition
nonFL
qHtRef :: Sentence
qHtRef      = DataDefinition -> Sentence
forall r.
(Referable r, HasShortName r, HasSymbol r) =>
r -> Sentence
definedIn  DataDefinition
dimLL
qHtTlTolRef :: Sentence
qHtTlTolRef = DataDefinition -> Sentence
forall r.
(Referable r, HasShortName r, HasSymbol r) =>
r -> Sentence
definedIn  DataDefinition
tolPre
riskRef :: Sentence
riskRef     = DataDefinition -> Sentence
forall r.
(Referable r, HasShortName r, HasSymbol r) =>
r -> Sentence
definedIn  DataDefinition
risk

-- List of Configuration Files necessary for DataDefs.hs
configFp :: [String]
configFp :: [String]
configFp = ["SDF.txt", "TSD.txt"]

--- Helpers
interpolating :: (HasUID s, HasSymbol s, Referable f, HasShortName f) => s -> f -> Sentence
interpolating :: s -> f -> Sentence
interpolating s :: s
s f :: f
f = [Sentence] -> Sentence
foldlSent [s -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch s
s Sentence -> Sentence -> Sentence
`S.is` String -> Sentence
S "obtained by interpolating from",
  NamedChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
plural NamedChunk
datum, String -> Sentence
S "shown" Sentence -> Sentence -> Sentence
`S.in_` f -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS f
f]

stdVals :: (HasSymbol s, HasUID s) => [s] -> Sentence
stdVals :: [s] -> Sentence
stdVals s :: [s]
s = SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List ((s -> Sentence) -> [s] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map s -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch [s]
s) Sentence -> Sentence -> Sentence
+:+ Sentence
sent Sentence -> Sentence -> Sentence
+:+. ConceptInstance -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS ConceptInstance
assumpSV
  where sent :: Sentence
sent = case [s]
s of [ ]   -> String -> Sentence
forall a. HasCallStack => String -> a
error "stdVals needs quantities"
                         [_]   -> String -> Sentence
S "comes from"
                         (_:_) -> String -> Sentence
S "come from"