module Drasil.GlassBR.Unitals where --whole file is used

import Language.Drasil
import Language.Drasil.Display (Symbol(..))
import Language.Drasil.ShortHands
import Language.Drasil.Chunk.Concept.NamedCombinators

import Prelude hiding (log)

import Data.Drasil.Concepts.Math (xComp, yComp, zComp)
import Data.Drasil.Constraints (gtZeroConstr, probConstr)
import Data.Drasil.Quantities.Physics (subMax, subMin, subX, subY, subZ)
import Data.Drasil.SI_Units (kilogram, metre, millimetre, pascal, second)

import Drasil.GlassBR.Concepts (aR, annealed, fullyT, glaPlane, glassTypeFac, 
  heatS, iGlass, lGlass, lResistance, lShareFac, loadDurFactor, nFL, responseTy, 
  stdOffDist)
import Drasil.GlassBR.References (astm2009, astm2012, astm2016)
import Drasil.GlassBR.Units (sFlawPU)

--FIXME: Many of the current terms can be separated into terms and defns?

{--}

symbolsWithDefns :: [UnitalChunk]
symbolsWithDefns :: [UnitalChunk]
symbolsWithDefns = [UnitalChunk
modElas]

modElas :: UnitalChunk
modElas :: UnitalChunk
modElas = String -> NP -> String -> Symbol -> UnitDefn -> UnitalChunk
forall u.
IsUnit u =>
String -> NP -> String -> Symbol -> u -> UnitalChunk
uc' "modElas" (String -> NP
nounPhraseSP "modulus of elasticity of glass")
  "the ratio of tensile stress to tensile strain of glass" Symbol
cE UnitDefn
pascal

{--}

constrained :: [ConstrainedChunk]
constrained :: [ConstrainedChunk]
constrained = (UncertainChunk -> ConstrainedChunk)
-> [UncertainChunk] -> [ConstrainedChunk]
forall a b. (a -> b) -> [a] -> [b]
map UncertainChunk -> ConstrainedChunk
forall c.
(Quantity c, Constrained c, HasReasVal c, MayHaveUnit c) =>
c -> ConstrainedChunk
cnstrw [UncertainChunk]
inputDataConstraints [ConstrainedChunk] -> [ConstrainedChunk] -> [ConstrainedChunk]
forall a. [a] -> [a] -> [a]
++ 
  [ConstrainedChunk -> ConstrainedChunk
forall c.
(Quantity c, Constrained c, HasReasVal c, MayHaveUnit c) =>
c -> ConstrainedChunk
cnstrw ConstrainedChunk
probBr, ConstrainedChunk -> ConstrainedChunk
forall c.
(Quantity c, Constrained c, HasReasVal c, MayHaveUnit c) =>
c -> ConstrainedChunk
cnstrw ConstrainedChunk
probFail, ConstrainedChunk -> ConstrainedChunk
forall c.
(Quantity c, Constrained c, HasReasVal c, MayHaveUnit c) =>
c -> ConstrainedChunk
cnstrw ConstrainedChunk
stressDistFac] 

plateLen, plateWidth, aspectRatio, charWeight, standOffDist :: UncertQ
pbTol, tNT :: UncertainChunk
nomThick :: ConstrainedChunk
glassTypeCon :: ConstrConcept

{--}

inputs :: [QuantityDict]
inputs :: [QuantityDict]
inputs = (UncertQ -> QuantityDict) -> [UncertQ] -> [QuantityDict]
forall a b. (a -> b) -> [a] -> [b]
map UncertQ -> QuantityDict
forall q. (Quantity q, MayHaveUnit q) => q -> QuantityDict
qw [UncertQ]
inputsWUnitsUncrtn [QuantityDict] -> [QuantityDict] -> [QuantityDict]
forall a. [a] -> [a] -> [a]
++ (UncertainChunk -> QuantityDict)
-> [UncertainChunk] -> [QuantityDict]
forall a b. (a -> b) -> [a] -> [b]
map UncertainChunk -> QuantityDict
forall q. (Quantity q, MayHaveUnit q) => q -> QuantityDict
qw [UncertainChunk]
inputsWUncrtn [QuantityDict] -> [QuantityDict] -> [QuantityDict]
forall a. [a] -> [a] -> [a]
++ 
  (ConstrainedChunk -> QuantityDict)
-> [ConstrainedChunk] -> [QuantityDict]
forall a b. (a -> b) -> [a] -> [b]
map ConstrainedChunk -> QuantityDict
forall q. (Quantity q, MayHaveUnit q) => q -> QuantityDict
qw [ConstrainedChunk]
inputsNoUncrtn [QuantityDict] -> [QuantityDict] -> [QuantityDict]
forall a. [a] -> [a] -> [a]
++ (UnitaryChunk -> QuantityDict) -> [UnitaryChunk] -> [QuantityDict]
forall a b. (a -> b) -> [a] -> [b]
map UnitaryChunk -> QuantityDict
forall q. (Quantity q, MayHaveUnit q) => q -> QuantityDict
qw [UnitaryChunk]
sdVector

--inputs with units and uncertainties
inputsWUnitsUncrtn :: [UncertQ]
inputsWUnitsUncrtn :: [UncertQ]
inputsWUnitsUncrtn = [UncertQ
plateLen, UncertQ
plateWidth, UncertQ
charWeight]

--derived inputs with units and uncertainties
derivedInsWUnitsUncrtn :: [UncertQ]
derivedInsWUnitsUncrtn :: [UncertQ]
derivedInsWUnitsUncrtn = [UncertQ
standOffDist]

--inputs with uncertainties and no units
inputsWUncrtn :: [UncertainChunk]
inputsWUncrtn :: [UncertainChunk]
inputsWUncrtn = [UncertainChunk
pbTol, UncertainChunk
tNT]

--derived inputs with uncertainties and no units
derivedInsWUncrtn :: [UncertQ]
derivedInsWUncrtn :: [UncertQ]
derivedInsWUncrtn = [UncertQ
aspectRatio]

--inputs with no uncertainties
inputsNoUncrtn :: [ConstrainedChunk]
inputsNoUncrtn :: [ConstrainedChunk]
inputsNoUncrtn = [ConstrConcept -> ConstrainedChunk
forall c.
(Quantity c, Constrained c, HasReasVal c, MayHaveUnit c) =>
c -> ConstrainedChunk
cnstrw ConstrConcept
glassTypeCon, ConstrainedChunk
nomThick]

inputDataConstraints :: [UncertainChunk]
inputDataConstraints :: [UncertainChunk]
inputDataConstraints = (UncertQ -> UncertainChunk) -> [UncertQ] -> [UncertainChunk]
forall a b. (a -> b) -> [a] -> [b]
map UncertQ -> UncertainChunk
forall c.
(HasUncertainty c, Quantity c, Constrained c, HasReasVal c,
 MayHaveUnit c) =>
c -> UncertainChunk
uncrtnw [UncertQ]
inputsWUnitsUncrtn [UncertainChunk] -> [UncertainChunk] -> [UncertainChunk]
forall a. [a] -> [a] -> [a]
++ 
  (UncertainChunk -> UncertainChunk)
-> [UncertainChunk] -> [UncertainChunk]
forall a b. (a -> b) -> [a] -> [b]
map UncertainChunk -> UncertainChunk
forall c.
(HasUncertainty c, Quantity c, Constrained c, HasReasVal c,
 MayHaveUnit c) =>
c -> UncertainChunk
uncrtnw [UncertainChunk]
inputsWUncrtn [UncertainChunk] -> [UncertainChunk] -> [UncertainChunk]
forall a. [a] -> [a] -> [a]
++ (UncertQ -> UncertainChunk) -> [UncertQ] -> [UncertainChunk]
forall a b. (a -> b) -> [a] -> [b]
map UncertQ -> UncertainChunk
forall c.
(HasUncertainty c, Quantity c, Constrained c, HasReasVal c,
 MayHaveUnit c) =>
c -> UncertainChunk
uncrtnw [UncertQ]
derivedInsWUnitsUncrtn [UncertainChunk] -> [UncertainChunk] -> [UncertainChunk]
forall a. [a] -> [a] -> [a]
++ 
  (UncertQ -> UncertainChunk) -> [UncertQ] -> [UncertainChunk]
forall a b. (a -> b) -> [a] -> [b]
map UncertQ -> UncertainChunk
forall c.
(HasUncertainty c, Quantity c, Constrained c, HasReasVal c,
 MayHaveUnit c) =>
c -> UncertainChunk
uncrtnw [UncertQ]
derivedInsWUncrtn

plateLen :: UncertQ
plateLen = String
-> NP
-> Symbol
-> UnitDefn
-> Space
-> [ConstraintE]
-> Expr
-> Uncertainty
-> UncertQ
forall u.
IsUnit u =>
String
-> NP
-> Symbol
-> u
-> Space
-> [ConstraintE]
-> Expr
-> Uncertainty
-> UncertQ
uqcND "plateLen" (String -> NP
nounPhraseSP "plate length (long dimension)")
  Symbol
lA UnitDefn
metre Space
Real 
  [ ConstraintE
gtZeroConstr,
    RealInterval Expr Expr -> ConstraintE
physc (RealInterval Expr Expr -> ConstraintE)
-> RealInterval Expr Expr -> ConstraintE
forall a b. (a -> b) -> a -> b
$ (Inclusive, Expr) -> RealInterval Expr Expr
forall b a. (Inclusive, b) -> RealInterval a b
UpFrom (Inclusive
Inc, UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
plateWidth),
    RealInterval Expr Expr -> ConstraintE
sfwrc (RealInterval Expr Expr -> ConstraintE)
-> RealInterval Expr Expr -> ConstraintE
forall a b. (a -> b) -> a -> b
$ (Inclusive, Expr) -> (Inclusive, Expr) -> RealInterval Expr Expr
forall a b. (Inclusive, a) -> (Inclusive, b) -> RealInterval a b
Bounded (Inclusive
Inc , ConstQDef -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstQDef
dimMin) (Inclusive
Inc , ConstQDef -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstQDef
dimMax)] (Double -> Expr
forall r. LiteralC r => Double -> r
dbl 1.5) Uncertainty
defaultUncrt

plateWidth :: UncertQ
plateWidth = String
-> NP
-> Symbol
-> UnitDefn
-> Space
-> [ConstraintE]
-> Expr
-> Uncertainty
-> UncertQ
forall u.
IsUnit u =>
String
-> NP
-> Symbol
-> u
-> Space
-> [ConstraintE]
-> Expr
-> Uncertainty
-> UncertQ
uqcND "plateWidth" (String -> NP
nounPhraseSP "plate width (short dimension)")
  Symbol
lB UnitDefn
metre Space
Real
  [ RealInterval Expr Expr -> ConstraintE
physc (RealInterval Expr Expr -> ConstraintE)
-> RealInterval Expr Expr -> ConstraintE
forall a b. (a -> b) -> a -> b
$ (Inclusive, Expr) -> (Inclusive, Expr) -> RealInterval Expr Expr
forall a b. (Inclusive, a) -> (Inclusive, b) -> RealInterval a b
Bounded (Inclusive
Exc, Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 0) (Inclusive
Inc, UncertQ -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy UncertQ
plateLen),
    RealInterval Expr Expr -> ConstraintE
sfwrc (RealInterval Expr Expr -> ConstraintE)
-> RealInterval Expr Expr -> ConstraintE
forall a b. (a -> b) -> a -> b
$ (Inclusive, Expr) -> (Inclusive, Expr) -> RealInterval Expr Expr
forall a b. (Inclusive, a) -> (Inclusive, b) -> RealInterval a b
Bounded (Inclusive
Inc, ConstQDef -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstQDef
dimMin) (Inclusive
Inc, ConstQDef -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstQDef
dimMax)] (Double -> Expr
forall r. LiteralC r => Double -> r
dbl 1.2) Uncertainty
defaultUncrt

aspectRatio :: UncertQ
aspectRatio = ConstrConcept -> Uncertainty -> UncertQ
forall c.
(Quantity c, Constrained c, Concept c, HasReasVal c,
 MayHaveUnit c) =>
c -> Uncertainty -> UncertQ
uq (DefinedQuantityDict -> [ConstraintE] -> Expr -> ConstrConcept
forall c.
(Concept c, MayHaveUnit c, Quantity c) =>
c -> [ConstraintE] -> Expr -> ConstrConcept
constrained' (ConceptChunk -> Symbol -> Space -> DefinedQuantityDict
dqdNoUnit ConceptChunk
aspectRatioCon (String -> Symbol
variable "AR") Space
Real)
  [ RealInterval Expr Expr -> ConstraintE
physc (RealInterval Expr Expr -> ConstraintE)
-> RealInterval Expr Expr -> ConstraintE
forall a b. (a -> b) -> a -> b
$ (Inclusive, Expr) -> RealInterval Expr Expr
forall b a. (Inclusive, b) -> RealInterval a b
UpFrom (Inclusive
Inc, Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 1), 
    RealInterval Expr Expr -> ConstraintE
sfwrc (RealInterval Expr Expr -> ConstraintE)
-> RealInterval Expr Expr -> ConstraintE
forall a b. (a -> b) -> a -> b
$ (Inclusive, Expr) -> RealInterval Expr Expr
forall a b. (Inclusive, a) -> RealInterval a b
UpTo (Inclusive
Inc, ConstQDef -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstQDef
arMax)] (Double -> Expr
forall r. LiteralC r => Double -> r
dbl 1.5)) Uncertainty
defaultUncrt

pbTol :: UncertainChunk
pbTol = String
-> NP
-> Symbol
-> Space
-> [ConstraintE]
-> Expr
-> Uncertainty
-> UncertainChunk
uvc "pbTol" (String -> NP
nounPhraseSP "tolerable probability of breakage") 
  (Symbol -> Symbol -> Symbol
sub Symbol
cP ([Symbol] -> Symbol
Concat [Symbol
lBreak, Symbol
lTol])) Space
Real
  [ConstraintE
probConstr] (Double -> Expr
forall r. LiteralC r => Double -> r
dbl 0.008) (Double -> Maybe Int -> Uncertainty
uncty 0.001 Maybe Int
forall a. Maybe a
Nothing)

charWeight :: UncertQ
charWeight = String
-> NP
-> Symbol
-> UnitDefn
-> Space
-> [ConstraintE]
-> Expr
-> Uncertainty
-> UncertQ
forall u.
IsUnit u =>
String
-> NP
-> Symbol
-> u
-> Space
-> [ConstraintE]
-> Expr
-> Uncertainty
-> UncertQ
uqcND "charWeight" (String -> NP
nounPhraseSP "charge weight") 
  Symbol
lW UnitDefn
kilogram Space
Real
  [ ConstraintE
gtZeroConstr,
    RealInterval Expr Expr -> ConstraintE
sfwrc (RealInterval Expr Expr -> ConstraintE)
-> RealInterval Expr Expr -> ConstraintE
forall a b. (a -> b) -> a -> b
$ (Inclusive, Expr) -> (Inclusive, Expr) -> RealInterval Expr Expr
forall a b. (Inclusive, a) -> (Inclusive, b) -> RealInterval a b
Bounded (Inclusive
Inc, ConstQDef -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstQDef
cWeightMin) (Inclusive
Inc, ConstQDef -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstQDef
cWeightMax)]
    (Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 42) Uncertainty
defaultUncrt

tNT :: UncertainChunk
tNT = String
-> NP
-> Symbol
-> Space
-> [ConstraintE]
-> Expr
-> Uncertainty
-> UncertainChunk
uvc "tNT" (String -> NP
nounPhraseSP "TNT equivalent factor")
  (String -> Symbol
variable "TNT") Space
Real
  [ ConstraintE
gtZeroConstr ] (Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 1) Uncertainty
defaultUncrt

standOffDist :: UncertQ
standOffDist = ConstrConcept -> Uncertainty -> UncertQ
forall c.
(Quantity c, Constrained c, Concept c, HasReasVal c,
 MayHaveUnit c) =>
c -> Uncertainty -> UncertQ
uq (UnitalChunk -> [ConstraintE] -> Expr -> ConstrConcept
forall c.
(Concept c, MayHaveUnit c, Quantity c) =>
c -> [ConstraintE] -> Expr -> ConstrConcept
constrained' (ConceptChunk -> Symbol -> Space -> UnitDefn -> UnitalChunk
forall c u.
(Concept c, IsUnit u) =>
c -> Symbol -> Space -> u -> UnitalChunk
ucs' ConceptChunk
sD (String -> Symbol
variable "SD") Space
Real UnitDefn
metre)
  [ ConstraintE
gtZeroConstr,
    RealInterval Expr Expr -> ConstraintE
sfwrc (RealInterval Expr Expr -> ConstraintE)
-> RealInterval Expr Expr -> ConstraintE
forall a b. (a -> b) -> a -> b
$ (Inclusive, Expr) -> (Inclusive, Expr) -> RealInterval Expr Expr
forall a b. (Inclusive, a) -> (Inclusive, b) -> RealInterval a b
Bounded (Inclusive
Inc, ConstQDef -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstQDef
sdMin) (Inclusive
Inc, ConstQDef -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstQDef
sdMax)] (Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 45)) Uncertainty
defaultUncrt

nomThick :: ConstrainedChunk
nomThick = String
-> NP
-> Symbol
-> UnitDefn
-> Space
-> [ConstraintE]
-> Expr
-> ConstrainedChunk
forall u.
IsUnit u =>
String
-> NP
-> Symbol
-> u
-> Space
-> [ConstraintE]
-> Expr
-> ConstrainedChunk
cuc "nomThick" 
  (Sentence -> NP
nounPhraseSent (Sentence -> NP) -> Sentence -> NP
forall a b. (a -> b) -> a -> b
$ String -> Sentence
S "nominal thickness" Sentence -> Sentence -> Sentence
+:+ ConstrainedChunk -> [Double] -> Sentence
forall a. Quantity a => a -> [Double] -> Sentence
displayDblConstrntsAsSet 
    ConstrainedChunk
nomThick [Double]
nominalThicknesses)
  Symbol
lT UnitDefn
millimetre {-Discrete nominalThicknesses, but not implemented-} Space
Rational 
  [{- TODO: add back constraint: enumc nominalThicknesses -}] (Expr -> ConstrainedChunk) -> Expr -> ConstrainedChunk
forall a b. (a -> b) -> a -> b
$ Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 8

glassTypeCon :: ConstrConcept
glassTypeCon  = DefinedQuantityDict -> [ConstraintE] -> ConstrConcept
forall c.
(Concept c, MayHaveUnit c, Quantity c) =>
c -> [ConstraintE] -> ConstrConcept
constrainedNRV' (ConceptChunk -> Symbol -> Space -> DefinedQuantityDict
dqdNoUnit ConceptChunk
glassTy Symbol
lG Space
String) 
  [{- TODO: add back constraint: EnumeratedStr Software $ map (getAccStr . snd) glassType -}]

{--}

outputs :: [QuantityDict]
outputs :: [QuantityDict]
outputs = (QuantityDict -> QuantityDict) -> [QuantityDict] -> [QuantityDict]
forall a b. (a -> b) -> [a] -> [b]
map QuantityDict -> QuantityDict
forall q. (Quantity q, MayHaveUnit q) => q -> QuantityDict
qw [QuantityDict
isSafePb, QuantityDict
isSafeLR] [QuantityDict] -> [QuantityDict] -> [QuantityDict]
forall a. [a] -> [a] -> [a]
++ (ConstrainedChunk -> QuantityDict)
-> [ConstrainedChunk] -> [QuantityDict]
forall a b. (a -> b) -> [a] -> [b]
map ConstrainedChunk -> QuantityDict
forall q. (Quantity q, MayHaveUnit q) => q -> QuantityDict
qw [ConstrainedChunk
probBr] [QuantityDict] -> [QuantityDict] -> [QuantityDict]
forall a. [a] -> [a] -> [a]
++ (ConstrainedChunk -> QuantityDict)
-> [ConstrainedChunk] -> [QuantityDict]
forall a b. (a -> b) -> [a] -> [b]
map ConstrainedChunk -> QuantityDict
forall q. (Quantity q, MayHaveUnit q) => q -> QuantityDict
qw [ConstrainedChunk
stressDistFac]

tmSymbols :: [QuantityDict]
tmSymbols :: [QuantityDict]
tmSymbols = (ConstrainedChunk -> QuantityDict)
-> [ConstrainedChunk] -> [QuantityDict]
forall a b. (a -> b) -> [a] -> [b]
map ConstrainedChunk -> QuantityDict
forall q. (Quantity q, MayHaveUnit q) => q -> QuantityDict
qw [ConstrainedChunk
probFail, ConstrainedChunk
pbTolfail] [QuantityDict] -> [QuantityDict] -> [QuantityDict]
forall a. [a] -> [a] -> [a]
++ (QuantityDict -> QuantityDict) -> [QuantityDict] -> [QuantityDict]
forall a b. (a -> b) -> [a] -> [b]
map QuantityDict -> QuantityDict
forall q. (Quantity q, MayHaveUnit q) => q -> QuantityDict
qw [QuantityDict
isSafeProb, QuantityDict
isSafeLoad]

probBr, probFail, pbTolfail, stressDistFac :: ConstrainedChunk
probBr :: ConstrainedChunk
probBr = String
-> NP
-> Symbol
-> Space
-> [ConstraintE]
-> Maybe Expr
-> ConstrainedChunk
cvc "probBr" (String -> NP
nounPhraseSP "probability of breakage")
  (Symbol -> Symbol -> Symbol
sub Symbol
cP Symbol
lBreak) Space
Rational
  [ConstraintE
probConstr] (Expr -> Maybe Expr
forall a. a -> Maybe a
Just (Expr -> Maybe Expr) -> Expr -> Maybe Expr
forall a b. (a -> b) -> a -> b
$ Double -> Expr
forall r. LiteralC r => Double -> r
dbl 0.4)

stressDistFac :: ConstrainedChunk
stressDistFac = String
-> NP
-> Symbol
-> Space
-> [ConstraintE]
-> Maybe Expr
-> ConstrainedChunk
cvc "stressDistFac" (String -> NP
nounPhraseSP "stress distribution factor (Function)") 
  Symbol
cJ Space
Real [RealInterval Expr Expr -> ConstraintE
physc (RealInterval Expr Expr -> ConstraintE)
-> RealInterval Expr Expr -> ConstraintE
forall a b. (a -> b) -> a -> b
$ (Inclusive, Expr) -> (Inclusive, Expr) -> RealInterval Expr Expr
forall a b. (Inclusive, a) -> (Inclusive, b) -> RealInterval a b
Bounded (Inclusive
Inc, ConstQDef -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstQDef
stressDistFacMin) (Inclusive
Inc, ConstQDef -> Expr
forall r c. (ExprC r, HasUID c, HasSymbol c) => c -> r
sy ConstQDef
stressDistFacMax)] (Expr -> Maybe Expr
forall a. a -> Maybe a
Just (Expr -> Maybe Expr) -> Expr -> Maybe Expr
forall a b. (a -> b) -> a -> b
$ Integer -> Expr
forall r. LiteralC r => Integer -> r
exactDbl 15)

probFail :: ConstrainedChunk
probFail = String
-> NP
-> Symbol
-> Space
-> [ConstraintE]
-> Maybe Expr
-> ConstrainedChunk
cvc "probFail" (String -> NP
nounPhraseSP "probability of failure")
  (Symbol -> Symbol -> Symbol
sub Symbol
cP Symbol
lFail) Space
Rational
  [ConstraintE
probConstr] (Expr -> Maybe Expr
forall a. a -> Maybe a
Just (Expr -> Maybe Expr) -> Expr -> Maybe Expr
forall a b. (a -> b) -> a -> b
$ Double -> Expr
forall r. LiteralC r => Double -> r
dbl 0.4)

pbTolfail :: ConstrainedChunk
pbTolfail = String
-> NP
-> Symbol
-> Space
-> [ConstraintE]
-> Maybe Expr
-> ConstrainedChunk
cvc "pbTolfail" (String -> NP
nounPhraseSP "tolerable probability of failure") 
  (Symbol -> Symbol -> Symbol
sub Symbol
cP ([Symbol] -> Symbol
Concat [Symbol
lFail, Symbol
lTol])) Space
Real
  [ConstraintE
probConstr] (Expr -> Maybe Expr
forall a. a -> Maybe a
Just (Expr -> Maybe Expr) -> Expr -> Maybe Expr
forall a b. (a -> b) -> a -> b
$ Double -> Expr
forall r. LiteralC r => Double -> r
dbl 0.008) 
  

  --FIXME: no typical value!

{--}

specParamVals :: [ConstQDef]
specParamVals :: [ConstQDef]
specParamVals = [ConstQDef
dimMax, ConstQDef
dimMin, ConstQDef
arMax, ConstQDef
cWeightMax, ConstQDef
cWeightMin,
  ConstQDef
sdMax, ConstQDef
sdMin, ConstQDef
stressDistFacMin, ConstQDef
stressDistFacMax]

dimMax, dimMin, arMax, cWeightMax, cWeightMin, sdMax, stressDistFacMin, stressDistFacMax,
  sdMin :: ConstQDef

dimMax :: ConstQDef
dimMax     = UnitaryChunk -> Literal -> ConstQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef (String -> NP -> Symbol -> UnitDefn -> Space -> UnitaryChunk
forall u.
IsUnit u =>
String -> NP -> Symbol -> u -> Space -> UnitaryChunk
unitary "dimMax"
  (String -> NP
nounPhraseSP "maximum value for one of the dimensions of the glass plate") 
  (Symbol -> Symbol
subMax Symbol
lD) UnitDefn
metre Space
Real) (Integer -> Literal
forall r. LiteralC r => Integer -> r
exactDbl 5)

dimMin :: ConstQDef
dimMin     = UnitaryChunk -> Literal -> ConstQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef (String -> NP -> Symbol -> UnitDefn -> Space -> UnitaryChunk
forall u.
IsUnit u =>
String -> NP -> Symbol -> u -> Space -> UnitaryChunk
unitary "dimMin"
  (String -> NP
nounPhraseSP "minimum value for one of the dimensions of the glass plate") 
  (Symbol -> Symbol
subMin Symbol
lD) UnitDefn
metre Space
Real) (Double -> Literal
forall r. LiteralC r => Double -> r
dbl 0.1)

arMax :: ConstQDef
arMax     = QuantityDict -> Literal -> ConstQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef (String -> NP -> Symbol -> Space -> QuantityDict
vc "arMax"
  (String -> NP
nounPhraseSP "maximum aspect ratio")
  (Symbol -> Symbol
subMax (String -> Symbol
variable "AR")) Space
Rational) (Integer -> Literal
forall r. LiteralC r => Integer -> r
exactDbl 5)

cWeightMax :: ConstQDef
cWeightMax = UnitaryChunk -> Literal -> ConstQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef (String -> NP -> Symbol -> UnitDefn -> Space -> UnitaryChunk
forall u.
IsUnit u =>
String -> NP -> Symbol -> u -> Space -> UnitaryChunk
unitary "cWeightMax" 
  (String -> NP
nounPhraseSP "maximum permissible input charge weight")
  (Symbol -> Symbol
subMax (UncertQ -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb UncertQ
charWeight)) UnitDefn
kilogram Space
Rational) (Integer -> Literal
forall r. LiteralC r => Integer -> r
exactDbl 910)

cWeightMin :: ConstQDef
cWeightMin = UnitaryChunk -> Literal -> ConstQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef (String -> NP -> Symbol -> UnitDefn -> Space -> UnitaryChunk
forall u.
IsUnit u =>
String -> NP -> Symbol -> u -> Space -> UnitaryChunk
unitary "cWeightMin"
  (String -> NP
nounPhraseSP "minimum permissible input charge weight")
  (Symbol -> Symbol
subMin (UncertQ -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb UncertQ
charWeight)) UnitDefn
kilogram Space
Rational) (Double -> Literal
forall r. LiteralC r => Double -> r
dbl 4.5)

sdMax :: ConstQDef
sdMax     = UnitaryChunk -> Literal -> ConstQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef (String -> NP -> Symbol -> UnitDefn -> Space -> UnitaryChunk
forall u.
IsUnit u =>
String -> NP -> Symbol -> u -> Space -> UnitaryChunk
unitary "sdMax"
  (String -> NP
nounPhraseSP "maximum stand off distance permissible for input")
  (Symbol -> Symbol
subMax (UncertQ -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb UncertQ
standOffDist)) UnitDefn
metre Space
Real) (Integer -> Literal
forall r. LiteralC r => Integer -> r
exactDbl 130)

sdMin :: ConstQDef
sdMin     = UnitaryChunk -> Literal -> ConstQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef (String -> NP -> Symbol -> UnitDefn -> Space -> UnitaryChunk
forall u.
IsUnit u =>
String -> NP -> Symbol -> u -> Space -> UnitaryChunk
unitary "sdMin"
  (String -> NP
nounPhraseSP "minimum stand off distance permissible for input") 
  (Symbol -> Symbol
subMin (UncertQ -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb UncertQ
standOffDist)) UnitDefn
metre Space
Real) (Integer -> Literal
forall r. LiteralC r => Integer -> r
exactDbl 6)

stressDistFacMin :: ConstQDef
stressDistFacMin = QuantityDict -> Literal -> ConstQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef (String -> NP -> Symbol -> Space -> QuantityDict
vc "stressDistFacMin" (String -> NP
nounPhraseSP "minimum value for the stress distribution factor") 
  (Symbol -> Symbol
subMin (ConstrainedChunk -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb ConstrainedChunk
stressDistFac)) Space
Real) (Integer -> Literal
forall r. LiteralC r => Integer -> r
exactDbl 1)

stressDistFacMax :: ConstQDef
stressDistFacMax = QuantityDict -> Literal -> ConstQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef (String -> NP -> Symbol -> Space -> QuantityDict
vc "stressDistFacMax" (String -> NP
nounPhraseSP "maximum value for the stress distribution factor") 
  (Symbol -> Symbol
subMax (ConstrainedChunk -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb ConstrainedChunk
stressDistFac)) Space
Real) (Integer -> Literal
forall r. LiteralC r => Integer -> r
exactDbl 32)
{--}

symbols :: [UnitaryChunk]
symbols :: [UnitaryChunk]
symbols = [UnitaryChunk
minThick, UnitaryChunk
sflawParamK, UnitaryChunk
sflawParamM, UnitaryChunk
loadDur] [UnitaryChunk] -> [UnitaryChunk] -> [UnitaryChunk]
forall a. [a] -> [a] -> [a]
++ 
  (UnitalChunk -> UnitaryChunk) -> [UnitalChunk] -> [UnitaryChunk]
forall a b. (a -> b) -> [a] -> [b]
map UnitalChunk -> UnitaryChunk
forall u. (Unitary u, MayHaveUnit u) => u -> UnitaryChunk
mkUnitary [UnitalChunk
demand, UnitalChunk
tmDemand, UnitalChunk
lRe, UnitalChunk
tmLRe, UnitalChunk
nonFactorL, UnitalChunk
eqTNTWeight]

minThick, sflawParamK, sflawParamM, sdx, sdy, sdz, loadDur :: UnitaryChunk

demand, tmDemand, lRe, tmLRe, nonFactorL, eqTNTWeight :: UnitalChunk

demand :: UnitalChunk
demand      = ConceptChunk -> Symbol -> Space -> UnitDefn -> UnitalChunk
forall c u.
(Concept c, IsUnit u) =>
c -> Symbol -> Space -> u -> UnitalChunk
ucs' ConceptChunk
demandq Symbol
lQ Space
Rational UnitDefn
pascal --correct Space used?

tmDemand :: UnitalChunk
tmDemand    = ConceptChunk -> Symbol -> Space -> UnitDefn -> UnitalChunk
forall c u.
(Concept c, IsUnit u) =>
c -> Symbol -> Space -> u -> UnitalChunk
ucs' ConceptChunk
load (String -> Symbol
variable "Load") Space
Rational UnitDefn
pascal --correct Space used?
  
lRe :: UnitalChunk
lRe         = ConceptChunk -> Symbol -> Space -> UnitDefn -> UnitalChunk
forall c u.
(Concept c, IsUnit u) =>
c -> Symbol -> Space -> u -> UnitalChunk
ucs' ConceptChunk
loadResis (String -> Symbol
variable "LR") Space
Rational UnitDefn
pascal --correct Space used?

tmLRe :: UnitalChunk
tmLRe       = ConceptChunk -> Symbol -> Space -> UnitDefn -> UnitalChunk
forall c u.
(Concept c, IsUnit u) =>
c -> Symbol -> Space -> u -> UnitalChunk
ucs' ConceptChunk
capacity (String -> Symbol
variable "capacity") Space
Rational UnitDefn
pascal --correct Space used?

nonFactorL :: UnitalChunk
nonFactorL  = ConceptChunk -> Symbol -> Space -> UnitDefn -> UnitalChunk
forall c u.
(Concept c, IsUnit u) =>
c -> Symbol -> Space -> u -> UnitalChunk
ucs' ConceptChunk
nonFactoredL (String -> Symbol
variable "NFL") Space
Rational UnitDefn
pascal --correct Space used?

eqTNTWeight :: UnitalChunk
eqTNTWeight = ConceptChunk -> Symbol -> Space -> UnitDefn -> UnitalChunk
forall c u.
(Concept c, IsUnit u) =>
c -> Symbol -> Space -> u -> UnitalChunk
ucs' ConceptChunk
eqTNTChar (Symbol -> Symbol -> Symbol
sub (UncertQ -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb UncertQ
charWeight) (UncertainChunk -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb UncertainChunk
tNT)) Space
Real 
  UnitDefn
kilogram

loadDur :: UnitaryChunk
loadDur     = String -> NP -> Symbol -> UnitDefn -> Space -> UnitaryChunk
forall u.
IsUnit u =>
String -> NP -> Symbol -> u -> Space -> UnitaryChunk
unitary "loadDur"    (String -> NP
nounPhraseSP "duration of load")
  (Symbol -> Symbol -> Symbol
sub Symbol
lT Symbol
lDur) UnitDefn
second Space
Real

minThick :: UnitaryChunk
minThick    = String -> NP -> Symbol -> UnitDefn -> Space -> UnitaryChunk
forall u.
IsUnit u =>
String -> NP -> Symbol -> u -> Space -> UnitaryChunk
unitary "minThick"   (String -> NP
nounPhraseSP "minimum thickness")
  Symbol
lH UnitDefn
metre Space
Rational

sdx :: UnitaryChunk
sdx         = String -> NP -> Symbol -> UnitDefn -> Space -> UnitaryChunk
forall u.
IsUnit u =>
String -> NP -> Symbol -> u -> Space -> UnitaryChunk
unitary "sdx" (Sentence -> NP
nounPhraseSent (Sentence -> NP) -> Sentence -> NP
forall a b. (a -> b) -> a -> b
$ UncertQ -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase UncertQ
standOffDist Sentence -> Sentence -> Sentence
+:+ Sentence -> Sentence
sParen (ConceptChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase ConceptChunk
xComp))
  (Symbol -> Symbol
subX (UncertQ -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb UncertQ
standOffDist)) UnitDefn
metre Space
Real

sdy :: UnitaryChunk
sdy         = String -> NP -> Symbol -> UnitDefn -> Space -> UnitaryChunk
forall u.
IsUnit u =>
String -> NP -> Symbol -> u -> Space -> UnitaryChunk
unitary "sdy" (Sentence -> NP
nounPhraseSent (Sentence -> NP) -> Sentence -> NP
forall a b. (a -> b) -> a -> b
$ UncertQ -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase UncertQ
standOffDist Sentence -> Sentence -> Sentence
+:+ Sentence -> Sentence
sParen (ConceptChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase ConceptChunk
yComp))
  (Symbol -> Symbol
subY (UncertQ -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb UncertQ
standOffDist)) UnitDefn
metre Space
Real

sdz :: UnitaryChunk
sdz         = String -> NP -> Symbol -> UnitDefn -> Space -> UnitaryChunk
forall u.
IsUnit u =>
String -> NP -> Symbol -> u -> Space -> UnitaryChunk
unitary "sdz" (Sentence -> NP
nounPhraseSent (Sentence -> NP) -> Sentence -> NP
forall a b. (a -> b) -> a -> b
$ UncertQ -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase UncertQ
standOffDist Sentence -> Sentence -> Sentence
+:+ Sentence -> Sentence
sParen (ConceptChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase ConceptChunk
zComp))
  (Symbol -> Symbol
subZ (UncertQ -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb UncertQ
standOffDist)) UnitDefn
metre Space
Real

sflawParamK :: UnitaryChunk
sflawParamK = String -> NP -> Symbol -> UnitDefn -> Space -> UnitaryChunk
forall u.
IsUnit u =>
String -> NP -> Symbol -> u -> Space -> UnitaryChunk
unitary "sflawParamK" (String -> NP
nounPhraseSP "surface flaw parameter") --parameterize?
  Symbol
lK UnitDefn
sFlawPU Space
Real

sflawParamM :: UnitaryChunk
sflawParamM = String -> NP -> Symbol -> UnitDefn -> Space -> UnitaryChunk
forall u.
IsUnit u =>
String -> NP -> Symbol -> u -> Space -> UnitaryChunk
unitary "sflawParamM" (String -> NP
nounPhraseSP "surface flaw parameter") --parameterize?
  Symbol
lM UnitDefn
sFlawPU Space
Real

{-Quantities-}

unitless :: [QuantityDict]
unitless :: [QuantityDict]
unitless = [QuantityDict
riskFun, QuantityDict
isSafePb, QuantityDict
isSafeProb, QuantityDict
isSafeLR, QuantityDict
isSafeLoad,  
  QuantityDict
sdfTol, QuantityDict
dimlessLoad, QuantityDict
tolLoad, QuantityDict
lDurFac] [QuantityDict] -> [QuantityDict] -> [QuantityDict]
forall a. [a] -> [a] -> [a]
++ (DefinedQuantityDict -> QuantityDict)
-> [DefinedQuantityDict] -> [QuantityDict]
forall a b. (a -> b) -> [a] -> [b]
map DefinedQuantityDict -> QuantityDict
forall q. (Quantity q, MayHaveUnit q) => q -> QuantityDict
qw [DefinedQuantityDict
gTF, DefinedQuantityDict
loadSF]

interps :: [QuantityDict]
interps :: [QuantityDict]
interps = [QuantityDict
interpY, QuantityDict
interpZ]  

riskFun, isSafePb, isSafeProb, isSafeLR, isSafeLoad, sdfTol,
  dimlessLoad, tolLoad, lDurFac, interpY, interpZ :: QuantityDict

gTF, loadSF :: DefinedQuantityDict

dimlessLoad :: QuantityDict
dimlessLoad = String -> NP -> Symbol -> Space -> QuantityDict
vc "dimlessLoad" (String -> NP
nounPhraseSP "dimensionless load") (Symbol -> Symbol
hat Symbol
lQ) Space
Real

gTF :: DefinedQuantityDict
gTF           = ConceptChunk -> Symbol -> Space -> DefinedQuantityDict
dqdNoUnit ConceptChunk
glTyFac (String -> Symbol
variable "GTF") Space
Real

isSafePb :: QuantityDict
isSafePb   = String -> NP -> Symbol -> Space -> QuantityDict
vc "isSafePb"   (String -> NP
nounPhraseSP "probability of glass breakage safety requirement")
  (String -> Symbol
variable "isSafePb")   Space
Boolean
isSafeProb :: QuantityDict
isSafeProb = String -> NP -> Symbol -> Space -> QuantityDict
vc "isSafeProb" (String -> NP
nounPhraseSP "probability of failure safety requirement")
  (String -> Symbol
variable "isSafeProb") Space
Boolean
isSafeLR :: QuantityDict
isSafeLR   = String -> NP -> Symbol -> Space -> QuantityDict
vc "isSafeLR"   (String -> NP
nounPhraseSP "3 second load equivalent resistance safety requirement")
  (String -> Symbol
variable "isSafeLR")   Space
Boolean
isSafeLoad :: QuantityDict
isSafeLoad = String -> NP -> Symbol -> Space -> QuantityDict
vc "isSafeLoad" (String -> NP
nounPhraseSP "load resistance safety requirement")
  (String -> Symbol
variable "isSafeLoad") Space
Boolean

interpY :: QuantityDict
interpY = String -> NP -> Symbol -> Space -> QuantityDict
vc "interpY" (String -> NP
nounPhraseSP "interpY") (String -> Symbol
variable "interpY") Space
Real
interpZ :: QuantityDict
interpZ = String -> NP -> Symbol -> Space -> QuantityDict
vc "interpZ" (String -> NP
nounPhraseSP "interpZ") (String -> Symbol
variable "interpZ") Space
Real


lDurFac :: QuantityDict
lDurFac       = CI -> Symbol -> Space -> QuantityDict
forall c. Idea c => c -> Symbol -> Space -> QuantityDict
vc'' CI
loadDurFactor (String -> Symbol
variable "LDF") Space
Real
loadSF :: DefinedQuantityDict
loadSF        = ConceptChunk -> Symbol -> Space -> DefinedQuantityDict
dqdNoUnit ConceptChunk
loadShareFac (String -> Symbol
variable "LSF") Space
Real

riskFun :: QuantityDict
riskFun = String -> NP -> Symbol -> Space -> QuantityDict
vc "riskFun" (String -> NP
nounPhraseSP "risk of failure") Symbol
cB Space
Real

sdfTol :: QuantityDict
sdfTol = String -> NP -> Symbol -> Space -> QuantityDict
vc "sdfTol" (String -> NP
nounPhraseSP "stress distribution factor (Function) based on Pbtol") 
  (Symbol -> Symbol -> Symbol
sub (ConstrainedChunk -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb ConstrainedChunk
stressDistFac) Symbol
lTol) Space
Real

tolLoad :: QuantityDict
tolLoad = String -> NP -> Symbol -> Space -> QuantityDict
vc "tolLoad" (String -> NP
nounPhraseSP "tolerable load")
  (Symbol -> Symbol -> Symbol
sub (QuantityDict -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb QuantityDict
dimlessLoad) Symbol
lTol) Space
Real



lBreak, lDur, lFail, lTol :: Symbol
lBreak :: Symbol
lBreak = String -> Symbol
label "b"
lDur :: Symbol
lDur   = String -> Symbol
label "d"
lFail :: Symbol
lFail  = String -> Symbol
label "f"
lTol :: Symbol
lTol   = String -> Symbol
label "tol"

terms :: [ConceptChunk]
terms :: [ConceptChunk]
terms = [ConceptChunk
aspectRatioCon, ConceptChunk
glBreakage, ConceptChunk
lite, ConceptChunk
glassTy, ConceptChunk
annealedGl, ConceptChunk
fTemperedGl, ConceptChunk
hStrengthGl,
  ConceptChunk
glTyFac, ConceptChunk
lateral, ConceptChunk
load, ConceptChunk
specDeLoad, ConceptChunk
loadResis, ConceptChunk
longDurLoad, ConceptChunk
nonFactoredL,
  ConceptChunk
glassWL, ConceptChunk
shortDurLoad, ConceptChunk
loadShareFac, ConceptChunk
probBreak, ConceptChunk
specA, ConceptChunk
blastResisGla, ConceptChunk
eqTNTChar,
  ConceptChunk
sD, ConceptChunk
blast, ConceptChunk
blastTy, ConceptChunk
glassGeo, ConceptChunk
capacity, ConceptChunk
demandq, ConceptChunk
safeMessage, ConceptChunk
notSafe, ConceptChunk
bomb,
  ConceptChunk
explosion]

aspectRatioCon, glBreakage, lite, glassTy, annealedGl, fTemperedGl, hStrengthGl,
  glTyFac, lateral, load, specDeLoad, loadResis, longDurLoad, nonFactoredL,
  glassWL, shortDurLoad, loadShareFac, probBreak, specA, blastResisGla, eqTNTChar,
  sD, blast, blastTy, glassGeo, capacity, demandq, safeMessage, notSafe, bomb,
  explosion :: ConceptChunk

annealedGl :: ConceptChunk
annealedGl    = CI -> Sentence -> ConceptChunk
forall c. Idea c => c -> Sentence -> ConceptChunk
cc' CI
annealed
  (String -> Sentence
S "a flat, monolithic, glass lite which has uniform thickness where" Sentence -> Sentence -> Sentence
+:+
  String -> Sentence
S "the residual surface stresses are almost zero, as defined in"Sentence -> Sentence -> Sentence
+:+ Citation -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS Citation
astm2016)
aspectRatioCon :: ConceptChunk
aspectRatioCon   = CI -> String -> ConceptChunk
forall c. Idea c => c -> String -> ConceptChunk
cc CI
aR
  ("the ratio of the long dimension of the glass to the short dimension of " String -> String -> String
forall a. [a] -> [a] -> [a]
++
    "the glass. For glass supported on four sides, the aspect ratio is " String -> String -> String
forall a. [a] -> [a] -> [a]
++
    "always equal to or greater than 1.0. For glass supported on three " String -> String -> String
forall a. [a] -> [a] -> [a]
++
    "sides, the ratio of the length of one of the supported edges " String -> String -> String
forall a. [a] -> [a] -> [a]
++
    "perpendicular to the free edge, to the length of the free edge, is " String -> String -> String
forall a. [a] -> [a] -> [a]
++
    "equal to or greater than 0.5")
blast :: ConceptChunk
blast         = String -> NP -> String -> ConceptChunk
dcc "blast"       (String -> NP
nounPhraseSP "blast")
  "any kind of man-made explosion"
blastResisGla :: ConceptChunk
blastResisGla = String -> NP -> String -> ConceptChunk
dcc "blastResisGla"    (String -> NP
nounPhraseSP "blast resistant glazing")
  "glazing that provides protection against air blast pressure generated by explosions"
blastTy :: ConceptChunk
blastTy       = String -> NP -> String -> ConceptChunk
dcc "blastTy"     (String -> NP
nounPhraseSP "blast type")
  ("the blast type input includes parameters like weight of charge, TNT " String -> String -> String
forall a. [a] -> [a] -> [a]
++
    "equivalent factor, and stand off distance from the point of explosion")
bomb :: ConceptChunk
bomb          = String -> NP -> String -> ConceptChunk
dcc "bomb"        (String -> NP
nounPhraseSP "bomb") ("a container filled " String -> String -> String
forall a. [a] -> [a] -> [a]
++
  "with a destructive substance designed to exlode on impact or via detonation")
capacity :: ConceptChunk
capacity      = String -> NP -> String -> ConceptChunk
dcc "capacity"    (String -> NP
nounPhraseSP "capacity or load resistance")
  "load resistance calculated"
demandq :: ConceptChunk
demandq       = String -> NP -> String -> ConceptChunk
dcc "demandq"     (String -> NP
nounPhraseSP "applied load (demand)") 
  "3 second duration equivalent pressure"
eqTNTChar :: ConceptChunk
eqTNTChar     = String -> NP -> String -> ConceptChunk
dcc "eqTNTChar"   (String -> NP
nounPhraseSP "equivalent TNT charge mass")
  "mass of TNT placed on the ground in a hemisphere that represents the design explosive threat"
explosion :: ConceptChunk
explosion     = String -> NP -> String -> ConceptChunk
dcc "explosion"   (String -> NP
nounPhraseSP "explosion") 
  "a destructive shattering of something"
fTemperedGl :: ConceptChunk
fTemperedGl   = CI -> Sentence -> ConceptChunk
forall c. Idea c => c -> Sentence -> ConceptChunk
cc' CI
fullyT
  ([Sentence] -> Sentence
foldlSent_ [String -> Sentence
S "a flat, monolithic, glass lite of uniform thickness that has",
  String -> Sentence
S "been subjected to a special heat treatment process where the residual",
  String -> Sentence
S "surface compression is not less than 69 MPa (10 000 psi) or the edge",
  String -> Sentence
S "compression not less than 67 MPa (9700 psi), as defined in", Citation -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS Citation
astm2012])
glassGeo :: ConceptChunk
glassGeo      = String -> NP -> Sentence -> ConceptChunk
dccWDS "glassGeo"    (String -> NP
nounPhraseSP "glass geometry")
  (String -> Sentence
S "the glass geometry based inputs include the dimensions of the" Sentence -> Sentence -> Sentence
+:+ 
    SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List [NamedChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase NamedChunk
glaPlane, ConceptChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase ConceptChunk
glassTy, NamedChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
phrase NamedChunk
responseTy])
glassTy :: ConceptChunk
glassTy       = String -> NP -> String -> ConceptChunk
dcc "glassTy"     (String -> NP
cn' "glass type") "type of glass"
glassWL :: ConceptChunk
glassWL       = String -> NP -> String -> ConceptChunk
dcc "glassWL"     (String -> NP
nounPhraseSP "glass weight load")
  "the dead load component of the glass weight"
glBreakage :: ConceptChunk
glBreakage    = String -> NP -> String -> ConceptChunk
dcc "glBreakage"  (String -> NP
nounPhraseSP "glass breakage")
  "the fracture or breakage of any lite or ply in monolithic, laminated, or insulating glass"
glTyFac :: ConceptChunk
glTyFac       = CI -> Sentence -> ConceptChunk
forall c. Idea c => c -> Sentence -> ConceptChunk
cc' CI
glassTypeFac
  ([Sentence] -> Sentence
foldlSent_ [String -> Sentence
S "a multiplying factor for adjusting the", CI -> Sentence
getAcc CI
lResistance, 
  String -> Sentence
S "of different glass type, that is,", SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
Options [Sentence]
glassTypeAbbrs
  Sentence -> Sentence -> Sentence
`sC` String -> Sentence
S "in monolithic glass" Sentence -> Sentence -> Sentence
`sC` CI -> Sentence
getAcc CI
lGlass, Sentence -> Sentence
sParen (CI -> Sentence
forall n. NamedIdea n => n -> Sentence
titleize CI
lGlass) Sentence -> Sentence -> Sentence
`sC`
   String -> Sentence
S "or", CI -> Sentence
getAcc CI
iGlass, Sentence -> Sentence
sParen (CI -> Sentence
forall n. NamedIdea n => n -> Sentence
titleize CI
iGlass), String -> Sentence
S "constructions"])
hStrengthGl :: ConceptChunk
hStrengthGl   = CI -> Sentence -> ConceptChunk
forall c. Idea c => c -> Sentence -> ConceptChunk
cc' CI
heatS
  ([Sentence] -> Sentence
foldlSent_ [String -> Sentence
S "a flat, monolithic, glass lite of uniform thickness that has",
  String -> Sentence
S "been subjected to a special heat treatment process where the residual",
  String -> Sentence
S "surface compression is not less than 24 MPa (3500psi) or greater than",
  String -> Sentence
S "52 MPa (7500 psi), as defined in", Citation -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS Citation
astm2012])
lateral :: ConceptChunk
lateral       = String -> NP -> String -> ConceptChunk
dcc "lateral"     (String -> NP
nounPhraseSP "lateral") 
  "perpendicular to the glass surface"
lite :: ConceptChunk
lite          = String -> NP -> String -> ConceptChunk
dcc "lite"        (String -> NP
cn' "lite")
  "pieces of glass that are cut, prepared, and used to create the window or door"
load :: ConceptChunk
load          = String -> NP -> String -> ConceptChunk
dcc "load"        (String -> NP
nounPhraseSP "applied load (demand) or pressure") 
  "a uniformly distributed lateral pressure"
loadResis :: ConceptChunk
loadResis     = CI -> Sentence -> ConceptChunk
forall c. Idea c => c -> Sentence -> ConceptChunk
cc' CI
lResistance
  ([Sentence] -> Sentence
foldlSent_ [String -> Sentence
S "the uniform lateral load that a glass construction can sustain",
  String -> Sentence
S "based upon a given probability of breakage and load duration as defined in",
  Citation -> RefInfo -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> RefInfo -> Sentence
complexRef Citation
astm2009 (RefInfo -> Sentence) -> RefInfo -> Sentence
forall a b. (a -> b) -> a -> b
$ [Int] -> RefInfo
Page [1, 53]])
loadShareFac :: ConceptChunk
loadShareFac  = CI -> Sentence -> ConceptChunk
forall c. Idea c => c -> Sentence -> ConceptChunk
cc' CI
lShareFac
  ([Sentence] -> Sentence
foldlSent_ [String -> Sentence
S "a multiplying factor derived from the load sharing between the",
  String -> Sentence
S "double glazing, of equal or different thicknesses and types (including the",
  String -> Sentence
S "layered behaviour of", CI -> Sentence
getAcc CI
lGlass, String -> Sentence
S "under long duration",
  String -> Sentence
S "loads), in a sealed", CI -> Sentence
getAcc CI
iGlass, String -> Sentence
S "unit"])
longDurLoad :: ConceptChunk
longDurLoad   = String -> NP -> String -> ConceptChunk
dcc "longDurLoad"        (String -> NP
nounPhraseSP "long duration load")
  "any load lasting approximately 30 days"
nonFactoredL :: ConceptChunk
nonFactoredL  = CI -> Sentence -> ConceptChunk
forall c. Idea c => c -> Sentence -> ConceptChunk
cc' CI
nFL
  ([Sentence] -> Sentence
foldlSent_ [String -> Sentence
S "three second duration uniform load associated with a", 
  String -> Sentence
S "probability of breakage less than or equal to 8", ConceptChunk -> Sentence
forall n. (HasUID n, NamedIdea n) => n -> Sentence
plural ConceptChunk
lite,
  String -> Sentence
S "per 1000 for monolithic", CI -> Sentence
getAcc CI
annealed, String -> Sentence
S "glass"])
notSafe :: ConceptChunk
notSafe       = String -> NP -> String -> ConceptChunk
dcc "notSafe"     (String -> NP
nounPhraseSP "not safe")
  "For the given input parameters, the glass is NOT considered safe."
probBreak :: ConceptChunk
probBreak     = ConstrainedChunk -> Sentence -> ConceptChunk
forall c. Idea c => c -> Sentence -> ConceptChunk
cc' ConstrainedChunk
probBr
  ([Sentence] -> Sentence
foldlSent_ [String -> Sentence
S "the fraction of glass lites or plies that would break at the",
  String -> Sentence
S "first occurrence of a specified load and duration, typically expressed",
  String -> Sentence
S "in lites per 1000", Sentence -> Sentence
sParen (Sentence -> Sentence) -> Sentence -> Sentence
forall a b. (a -> b) -> a -> b
$ Citation -> Sentence
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Sentence
refS Citation
astm2016])
safeMessage :: ConceptChunk
safeMessage   = String -> NP -> String -> ConceptChunk
dcc "safeMessage" (String -> NP
nounPhraseSP "safe")
  "For the given input parameters, the glass is considered safe."
sD :: ConceptChunk
sD            = CI -> Sentence -> ConceptChunk
forall c. Idea c => c -> Sentence -> ConceptChunk
cc' CI
stdOffDist
  (String -> Sentence
S "the distance from the glazing surface to the centroid of a hemispherical" Sentence -> Sentence -> Sentence
+:+
   String -> Sentence
S "high explosive charge. It is represented by the coordinates" Sentence -> Sentence -> Sentence
+:+ Sentence -> Sentence
sParen Sentence
sdVectorSent)
shortDurLoad :: ConceptChunk
shortDurLoad  = String -> NP -> String -> ConceptChunk
dcc "shortDurLoad"       (String -> NP
nounPhraseSP "short duration load")
  "any load lasting 3 seconds or less"
specA :: ConceptChunk
specA         = String -> NP -> String -> ConceptChunk
dcc "specA"       (String -> NP
nounPhraseSP "specifying authority")
  ("the design professional responsible for interpreting applicable " String -> String -> String
forall a. [a] -> [a] -> [a]
++
    "regulations of authorities having jurisdiction and considering " String -> String -> String
forall a. [a] -> [a] -> [a]
++
    "appropriate site specific factors to determine the appropriate " String -> String -> String
forall a. [a] -> [a] -> [a]
++
    "values used to calculate the specified design load, and furnishing" String -> String -> String
forall a. [a] -> [a] -> [a]
++
    " other information required to perform this practice")
specDeLoad :: ConceptChunk
specDeLoad    = String -> NP -> String -> ConceptChunk
dcc "specDeLoad"  (String -> NP
nounPhraseSP "specified design load")
  ("the magnitude in Pa (psf), type (for example, wind or snow) and " String -> String -> String
forall a. [a] -> [a] -> [a]
++
    "duration of the load given by the specifying authority")

{--}

--Constants--

constants :: [ConstQDef]
constants :: [ConstQDef]
constants = [ConstQDef
constantM, ConstQDef
constantK, ConstQDef
constantModElas, ConstQDef
constantLoadDur, ConstQDef
constantLoadSF]
                [ConstQDef] -> [ConstQDef] -> [ConstQDef]
forall a. [a] -> [a] -> [a]
++ [ConstQDef]
specParamVals 

constantM, constantK, constantModElas, constantLoadDur, constantLoadSF :: ConstQDef
constantK :: ConstQDef
constantK       = UnitaryChunk -> Literal -> ConstQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef UnitaryChunk
sflawParamK (Literal -> ConstQDef) -> Literal -> ConstQDef
forall a b. (a -> b) -> a -> b
$ Double -> Literal
forall r. LiteralC r => Double -> r
dbl 2.86e-53
constantM :: ConstQDef
constantM       = UnitaryChunk -> Literal -> ConstQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef UnitaryChunk
sflawParamM (Literal -> ConstQDef) -> Literal -> ConstQDef
forall a b. (a -> b) -> a -> b
$ Integer -> Literal
forall r. LiteralC r => Integer -> r
exactDbl 7
constantModElas :: ConstQDef
constantModElas = UnitalChunk -> Literal -> ConstQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef UnitalChunk
modElas     (Literal -> ConstQDef) -> Literal -> ConstQDef
forall a b. (a -> b) -> a -> b
$ Double -> Literal
forall r. LiteralC r => Double -> r
dbl 7.17e10
constantLoadDur :: ConstQDef
constantLoadDur = UnitaryChunk -> Literal -> ConstQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef UnitaryChunk
loadDur     (Literal -> ConstQDef) -> Literal -> ConstQDef
forall a b. (a -> b) -> a -> b
$ Integer -> Literal
forall r. LiteralC r => Integer -> r
exactDbl 3
constantLoadSF :: ConstQDef
constantLoadSF  = DefinedQuantityDict -> Literal -> ConstQDef
forall c e. (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
mkQuantDef DefinedQuantityDict
loadSF      (Literal -> ConstQDef) -> Literal -> ConstQDef
forall a b. (a -> b) -> a -> b
$ Integer -> Literal
forall r. LiteralC r => Integer -> r
exactDbl 1

--Equations--

sdVectorSent :: Sentence
sdVectorSent :: Sentence
sdVectorSent = [Sentence] -> Sentence
foldlsC ((UnitaryChunk -> Sentence) -> [UnitaryChunk] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map UnitaryChunk -> Sentence
forall c. (HasUID c, HasSymbol c) => c -> Sentence
ch [UnitaryChunk]
sdVector)

sdVector :: [UnitaryChunk]
sdVector :: [UnitaryChunk]
sdVector = [UnitaryChunk
sdx, UnitaryChunk
sdy, UnitaryChunk
sdz]

--
--Pulled to be used in "Terms And Definitions" Section--
termsWithDefsOnly, termsWithAccDefn, loadTypes, glassTypes :: [ConceptChunk]

glassTypes :: [ConceptChunk]
glassTypes = [ConceptChunk
annealedGl, ConceptChunk
fTemperedGl, ConceptChunk
hStrengthGl]
termsWithDefsOnly :: [ConceptChunk]
termsWithDefsOnly = [ConceptChunk
glBreakage, ConceptChunk
lateral, ConceptChunk
lite, ConceptChunk
specA, ConceptChunk
blastResisGla, ConceptChunk
eqTNTChar]
termsWithAccDefn :: [ConceptChunk]
termsWithAccDefn  = [ConceptChunk
sD, ConceptChunk
loadShareFac, ConceptChunk
glTyFac, ConceptChunk
aspectRatioCon]
loadTypes :: [ConceptChunk]
loadTypes = [ConceptChunk
loadResis, ConceptChunk
nonFactoredL, ConceptChunk
glassWL, ConceptChunk
shortDurLoad, ConceptChunk
specDeLoad, ConceptChunk
longDurLoad] 

--Defined for DataDefs.hs and this file only--
actualThicknesses :: [Double]
actualThicknesses :: [Double]
actualThicknesses = ((Double, Double) -> Double) -> [(Double, Double)] -> [Double]
forall a b. (a -> b) -> [a] -> [b]
map (Double, Double) -> Double
forall a b. (a, b) -> b
snd [(Double, Double)]
glassThickness

nominalThicknesses :: [Double]
nominalThicknesses :: [Double]
nominalThicknesses = ((Double, Double) -> Double) -> [(Double, Double)] -> [Double]
forall a b. (a -> b) -> [a] -> [b]
map (Double, Double) -> Double
forall a b. (a, b) -> a
fst [(Double, Double)]
glassThickness 

glassTypeFactors :: [Integer]
glassTypeFactors :: [Integer]
glassTypeFactors = ((Integer, CI) -> Integer) -> [(Integer, CI)] -> [Integer]
forall a b. (a -> b) -> [a] -> [b]
map (Integer, CI) -> Integer
forall a b. (a, b) -> a
fst [(Integer, CI)]
glassType

glassTypeAbbrs :: [Sentence]
glassTypeAbbrs :: [Sentence]
glassTypeAbbrs = ((Integer, CI) -> Sentence) -> [(Integer, CI)] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map (CI -> Sentence
getAcc (CI -> Sentence)
-> ((Integer, CI) -> CI) -> (Integer, CI) -> Sentence
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Integer, CI) -> CI
forall a b. (a, b) -> b
snd) [(Integer, CI)]
glassType

type GlassType = [(Integer, CI)]         --[(Factor, Term)]
type GlassThickness = [(Double, Double)] --[(Nominal, Actual)]

glassType :: GlassType
glassType :: [(Integer, CI)]
glassType = [(1, CI
annealed), (4, CI
fullyT), (2, CI
heatS)]

glassThickness :: GlassThickness
glassThickness :: [(Double, Double)]
glassThickness =   
  [(2.5, 2.16),
  (2.7, 2.59),
  (3.0, 2.92),
  (4.0, 3.78),
  (5.0, 4.57),
  (6.0, 5.56),
  (8.0, 7.42),
  (10.0, 9.02),
  (12.0, 11.91),
  (16.0, 15.09),
  (19.0, 18.26),
  (22.0, 21.44)]

--Below are present in this file temporarily--
lateralLoad :: NamedChunk
lateralLoad :: NamedChunk
lateralLoad  = ConceptChunk -> ConceptChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC ConceptChunk
lateral ConceptChunk
load