GlassBR: Move code-oriented QDefs forced into SRS to Choices as hand-wired QDefs.

code/drasil-example/glassbr/lib/Drasil/GlassBR/Choices.hs

@@ -1,5 +1,6 @@
 module Drasil.GlassBR.Choices where
 
+import Language.Drasil (mkQuantDef, SimpleQDef, ExprC(..), LiteralC(..))
 import Language.Drasil.Code (Choices(..), defaultChoices, Comments(..),
   Verbosity(..), ConstraintBehaviour(..), ImplementationType(..), Lang(..),
   Logging(..), Modularity(..), Structure(..), ConstantStructure(..),
@@ -8,6 +9,8 @@ import Language.Drasil.Code (Choices(..), defaultChoices, Comments(..),
 import Utils.Drasil (RelativeFile, relativeFile)
 
 import Drasil.GlassBR.ModuleDefs (allMods)
+import Drasil.GlassBR.Unitals (aspectRatio, standOffDist, stressDistFac,
+  demand, eqTNTWeight, dimlessLoad, sdfTol, tolLoad, interpY, interpZ)
 
 choices :: Choices
 choices = defaultChoices {
@@ -20,8 +23,21 @@ choices = defaultChoices {
     [SampleInput "../../datafiles/glassbr/sampleInput.txt", ReadME],
   srsConstraints = makeConstraints Exception Exception,
   defaultConfigFiles = configFp,
-  extraMods = allMods
+  extraMods = allMods,
+  handWiredDefs = [strDisFacQD, demandQD, tolPreQD]
 }
 
+strDisFacQD :: SimpleQDef
+strDisFacQD = mkQuantDef stressDistFac
+  $ apply interpZ [str "SDF.txt", sy aspectRatio, sy dimlessLoad]
+
+demandQD :: SimpleQDef
+demandQD = mkQuantDef demand
+  $ apply interpY [str "TSD.txt", sy standOffDist, sy eqTNTWeight]
+
+tolPreQD :: SimpleQDef
+tolPreQD = mkQuantDef tolLoad
+  $ apply interpY [str "SDF.txt", sy aspectRatio, sy sdfTol]
+
 configFp :: [RelativeFile]
 configFp = map relativeFile ["SDF.txt", "TSD.txt"]

code/drasil-example/glassbr/lib/Drasil/GlassBR/DataDefs.hs

@@ -1,8 +1,7 @@
 module Drasil.GlassBR.DataDefs (dataDefs, aspRat, glaTyFac, glaTyFacQD, gtfRef,
-  hFromt, hFromtQD, loadDFDD, standOffDis, eqTNTWDD, calofDemand, aGrtrThanB,
+  hFromt, hFromtQD, loadDFDD, standOffDis, eqTNTWDD, aGrtrThanB,
   arRef, hRef, stdVals) where
 
-import Control.Lens ((^.))
 import Prelude hiding (log, exp, sqrt)
 
 import Drasil.Database (HasUID)
@@ -11,12 +10,10 @@ import Theory.Drasil (DataDefinition, ddE)
 import qualified Language.Drasil.Sentence.Combinators as S
 import Drasil.Sentence.Combinators (definedIn', definedIn)
 
-import Data.Drasil.Concepts.Math (parameter)
 import Data.Drasil.Concepts.PhysicalProperties (dimension)
 
 import Drasil.GlassBR.Assumptions (assumpSV, assumpLDFC)
 import Drasil.GlassBR.Concepts (annealed, fullyT, glass, heatS)
-import Drasil.GlassBR.LabelledContent (demandVsSDFig)
 import Drasil.GlassBR.References (astm2009)
 import Drasil.GlassBR.Unitals
 
@@ -25,7 +22,7 @@ import Drasil.GlassBR.Unitals
 ----------------------
 
 dataDefs :: [DataDefinition]
-dataDefs = [hFromt, loadDFDD, glaTyFac, standOffDis, aspRat, eqTNTWDD, calofDemand]
+dataDefs = [hFromt, loadDFDD, glaTyFac, standOffDis, aspRat, eqTNTWDD]
 
 {--}
 
@@ -103,17 +100,6 @@ eqTNTWQD = mkQuantDef eqTNTWeight eqTNTWEq
 eqTNTWDD :: DataDefinition
 eqTNTWDD = ddE eqTNTWQD [dRef astm2009] Nothing "eqTNTW" []
 
-{--}
-
-calofDemandEq :: Expr
-calofDemandEq = apply interpY [str "TSD.txt", sy standOffDist, sy eqTNTWeight]
-
-calofDemandQD :: SimpleQDef
-calofDemandQD = mkQuantDef demand calofDemandEq
-
-calofDemand :: DataDefinition
-calofDemand = ddE calofDemandQD [dRef astm2009] Nothing "calofDemand" [calofDemandDesc]
-
 -- Additional Notes --
 aGrtrThanB :: Sentence
 aGrtrThanB = ch plateLen `S.and_` ch plateWidth `S.are`
@@ -128,15 +114,6 @@ hsGlass = glassTypeHelper heatS
 glassTypeHelper :: CI -> Sentence
 glassTypeHelper t = short t `S.is` phrase t +:+. phrase glass
 
-calofDemandDesc :: Sentence
-calofDemandDesc =
-  foldlSent [ch demand `sC` EmptyS `S.or_` phrase demandq `sC` EmptyS `S.isThe`
-  (demandq ^. defn), S "obtained from", refS demandVsSDFig,
-  S "by interpolation using", phrase standOffDist, sParen (ch standOffDist)
-  `S.and_` ch eqTNTWeight, S "as" +:+. plural parameter, ch eqTNTWeight,
-  S "is defined in" +:+. refS eqTNTWDD, ch standOffDist `S.isThe`
-  phrase standOffDist, S "as defined in", refS standOffDis]
-
 hMin :: Sentence
 hMin = ch nomThick `S.is` S "a function that maps from the nominal thickness"
   +:+. (sParen (ch minThick) `S.toThe` phrase minThick)

code/drasil-example/glassbr/lib/Drasil/GlassBR/IMods.hs

@@ -3,28 +3,26 @@ module Drasil.GlassBR.IMods (symb, iMods, pbIsSafe, lrIsSafe, instModIntro) wher
 import Control.Lens ((^.))
 import Prelude hiding (exp)
 
-import Drasil.Database (HasUID)
 import Drasil.Sentence.Combinators (definedIn', definedIn)
 import Language.Drasil
 import qualified Language.Drasil.Development as D
-import Language.Drasil.Chunk.Concept.NamedCombinators
+import Language.Drasil.Chunk.Concept.NamedCombinators (the)
 import qualified Language.Drasil.Sentence.Combinators as S
 import Theory.Drasil (InstanceModel, imNoDeriv, qwC, qwUC, equationalModelN, output)
 
 import Data.Drasil.Citations (campidelli)
-import Data.Drasil.Concepts.Documentation (goal, user, datum)
-import Data.Drasil.SI_Units
+import Data.Drasil.Concepts.Documentation (goal, user)
+import Data.Drasil.SI_Units (kilogram, metre)
 
-import Drasil.GlassBR.DataDefs (aGrtrThanB, arRef, calofDemand, glaTyFac,
+import Drasil.GlassBR.DataDefs (aGrtrThanB, glaTyFac,
   gtfRef, hRef, loadDFDD, stdVals)
-import Drasil.GlassBR.LabelledContent (dimlessloadVsARFig)
 import Drasil.GlassBR.Goals (willBreakGS)
 import Drasil.GlassBR.References (astm2009, beasonEtAl1998)
 import Drasil.GlassBR.Unitals
 
 iMods :: [InstanceModel]
-iMods = [risk, strDisFac, nonFL, dimLL, tolPre, tolStrDisFac, probOfBreak,
-  calofCapacity, pbIsSafe, lrIsSafe]
+iMods = [risk, nonFL, dimLL, tolStrDisFac, probOfBreak, calofCapacity,
+  pbIsSafe, lrIsSafe]
 
 symb :: [UnitalChunk]
 symb = [ucuc plateLen metre, ucuc plateWidth metre, ucuc charWeight kilogram,
@@ -34,9 +32,6 @@ abInputConstraints :: [(DefinedQuantityDict, Maybe (RealInterval Expr Expr))]
 abInputConstraints = [qwC plateLen   $ UpFrom  (Exc, exactDbl 0),
                       qwC plateWidth $ Bounded (Exc, exactDbl 0) (Inc, sy plateLen)]
 
-aspectRatioConstraint :: RealInterval Expr Expr
-aspectRatioConstraint = UpFrom (Inc, exactDbl 1)
-
 probConstraint :: RealInterval Expr Expr
 probConstraint = Bounded (Inc, exactDbl 0) (Inc, exactDbl 1)
 
@@ -47,7 +42,7 @@ risk = imNoDeriv (equationalModelN (riskFun ^. term) riskQD)
   (qwUC modElas : qwUC loadDF : qwUC stressDistFac :
     map qwUC [sflawParamK, sflawParamM, minThick] ++ abInputConstraints)
     riskFun [] [dRef astm2009, dRefInfo beasonEtAl1998 $ Equation [4, 5],
-    dRefInfo campidelli $ Equation [14]] "riskFun" [aGrtrThanB, hRef, ldfRef, jRef]
+    dRefInfo campidelli $ Equation [14]] "riskFun" [aGrtrThanB, hRef, ldfRef]
 
 -- FIXME [4] !!!
 riskQD :: SimpleQDef
@@ -57,28 +52,11 @@ riskQD = mkQuantDef riskFun ((sy sflawParamK $/
 
 {--}
 
-strDisFac :: InstanceModel
-strDisFac = imNoDeriv (equationalModelN (stressDistFac ^. term) strDisFacQD)
-  (qwC aspectRatio aspectRatioConstraint : [qwUC dimlessLoad]) (dqdWr stressDistFac)
-  [Bounded (Inc, sy stressDistFacMin) (Inc, sy stressDistFacMax)]
-  [dRef astm2009] "stressDistFac"
-  [interpolating stressDistFac dimlessloadVsARFig, arRef, qHtRef]
-
-strDisFacQD :: SimpleQDef
-strDisFacQD = mkQuantDef stressDistFac strDisFacEq
-
-strDisFacEq :: Expr
--- strDisFacEq = apply (sy stressDistFac)
---   [sy dimlessLoad, sy aspectRatio]
-strDisFacEq = apply interpZ [str "SDF.txt", sy aspectRatio, sy dimlessLoad]
-
-{--}
-
 nonFL :: InstanceModel
 nonFL = imNoDeriv (equationalModelN (nonFactorL ^. term) nonFLQD)
   (qwUC tolLoad : qwUC modElas : qwUC minThick : abInputConstraints)
   (dqdWr nonFactorL) [] [dRef astm2009] "nFL"
-  [qHtTlTolRef, stdVals [modElas], hRef, aGrtrThanB]
+  [stdVals [modElas], hRef, aGrtrThanB]
 
 nonFLEq :: Expr
 nonFLEq = (sy tolLoad $* sy modElas) $* (sy minThick $^ exactDbl 4) $/
@@ -93,7 +71,7 @@ dimLL :: InstanceModel
 dimLL = imNoDeriv (equationalModelN (dimlessLoad ^. term) dimLLQD)
   (qwUC demand : qwUC modElas : qwUC minThick : qwUC gTF : abInputConstraints)
   dimlessLoad [] [dRef astm2009, dRefInfo campidelli $ Equation [7]]
-  "dimlessLoad" [qRef, aGrtrThanB, stdVals [modElas], hRef, gtfRef]
+  "dimlessLoad" [aGrtrThanB, stdVals [modElas], hRef, gtfRef]
 
 dimLLEq :: Expr
 dimLLEq = sy demand $* square (sy plateLen $* sy plateWidth)
@@ -104,21 +82,6 @@ dimLLQD = mkQuantDef dimlessLoad dimLLEq
 
 {--}
 
-tolPre :: InstanceModel
-tolPre = imNoDeriv (equationalModelN (tolLoad ^. term) tolPreQD)
-  [qwC aspectRatio aspectRatioConstraint, qwUC $ tolStrDisFac ^. output] tolLoad []
-  [dRef astm2009] "tolLoad" [interpolating tolLoad dimlessloadVsARFig, arRef,
-    jtolRef]
-
-tolPreEq :: Expr
---tolPreEq = apply (sy tolLoad) [sy sdfTol, (sy plateLen) / (sy plateWidth)]
-tolPreEq = apply interpY [str "SDF.txt", sy aspectRatio, sy sdfTol]
-
-tolPreQD :: SimpleQDef
-tolPreQD = mkQuantDef tolLoad tolPreEq
-
-{--}
-
 tolStrDisFac :: InstanceModel
 tolStrDisFac = imNoDeriv (equationalModelN (sdfTol ^. term) tolStrDisFacQD)
   ((loadDF, Nothing) : qwC pbTol probConstraint : qwUC modElas : abInputConstraints ++
@@ -169,7 +132,7 @@ lrIsSafe = imNoDeriv (equationalModelN (nounPhraseSP "Safety Req-LR") lrIsSafeQD
   [qwC lRe $ UpFrom (Exc, exactDbl 0), qwC demand $ UpFrom (Exc, exactDbl 0)]
   isSafeLR []
   [dRef astm2009] "isSafeLR"
-  [lrIsSafeDesc, capRef, qRef]
+  [lrIsSafeDesc, capRef]
 
 lrIsSafeQD :: SimpleQDef
 lrIsSafeQD = mkQuantDef isSafeLR (sy lRe $> sy demand)
@@ -191,9 +154,6 @@ lrCap = ch lRe +:+. S "is also called capacity"
 pbTolUsr :: Sentence
 pbTolUsr = ch pbTol `S.is` S "entered by the" +:+. phrase user
 
-qRef :: Sentence
-qRef = ch demand `S.isThe` (demandq ^. defn) `sC` S "as given in" +:+. refS calofDemand
-
 lrIsSafeDesc :: Sentence
 lrIsSafeDesc = iModDesc isSafeLR
   (ch isSafePb +:+ fromSource pbIsSafe `S.and_` ch isSafeLR)
@@ -202,19 +162,9 @@ pbIsSafeDesc :: Sentence
 pbIsSafeDesc = iModDesc isSafePb
   (ch isSafePb `S.and_` ch isSafeLR +:+ fromSource lrIsSafe)
 
-capRef, jRef, jtolRef, ldfRef, nonFLRef, probBRRef, qHtRef, qHtTlTolRef,
-  riskRef :: Sentence
+capRef, ldfRef, nonFLRef, probBRRef, riskRef :: Sentence
 capRef      = definedIn' calofCapacity (S "and is also called capacity")
-jRef        = definedIn  strDisFac
-jtolRef     = definedIn  tolStrDisFac
 ldfRef      = definedIn  loadDFDD
 nonFLRef    = definedIn  nonFL
 probBRRef   = definedIn  probOfBreak
-qHtRef      = definedIn  dimLL
-qHtTlTolRef = definedIn  tolPre
 riskRef     = definedIn  risk
-
--- Helper --
-interpolating :: (HasUID s, HasSymbol s, Referable f, HasShortName f) => s -> f -> Sentence
-interpolating s f = foldlSent [ch s `S.is` S "obtained by interpolating from",
-  plural datum, S "shown" `S.in_` refS f]