Merge 3468eef into dfd6e5e

Project.toml

@@ -1,7 +1,7 @@
 name = "ResourceAdequacy"
 uuid = "f1bff6d7-bd5f-4f25-88ac-02781f2d51b7"
 authors = ["Gord Stephen <gord.stephen@nrel.gov>"]
-version = "0.4.3"
+version = "0.5.0"
 
 [deps]
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"

src/ResourceAdequacy.jl

@@ -29,9 +29,6 @@ export
     LOLP, LOLE, EUE, ExpectedInterfaceFlow, ExpectedInterfaceUtilization,
     val, stderror,
 
-    # Distribution extraction specifications
-    Backcast, REPRA,
-
     # Simulation specifications
     NonSequentialCopperplate, SequentialCopperplate,
     NonSequentialNetworkFlow, SequentialNetworkFlow,
@@ -49,7 +46,6 @@ include("simulations/sequentialutils.jl")
 
 # Spec instances
 spec_instances = [
-    ("extraction", ["backcast", "repra"]),
     ("simulation", ["nonsequentialcopperplate", "sequentialcopperplate",
                     "nonsequentialnetworkflow", "sequentialnetworkflow"]),
     ("result", ["minimal", "temporal", "spatial", "spatiotemporal", "network"])

src/abstractspecs/abstractspecs.jl

@@ -1,19 +1,3 @@
-# Extraction
-
-"""
-An abstract parent type for specifying specific methods for extracting VG/load
-probability distributions from time series inputs. When defining a new type
-`S where {S <: ExtractionSpec}`, you must define methods for the following functions
-/ constructors:
-
- - SystemStateDistribution (for nonsequential simulations)
- - #TODO: Something for sequential simulations
-
-Check the documentation for each function for required type signatures.
-"""
-abstract type ExtractionSpec end
-
-
 # Simulation
 
 abstract type SimulationSequentiality end
@@ -70,9 +54,7 @@ You must also define the following allied types and their associated methods:
 
 """
 abstract type ResultAccumulator{
-    V <: Real, # Type of accumulated values
     S <: SystemModel, # Type of simulated system
-    ES <: ExtractionSpec, # Extraction method used in simulation
     SS <: SimulationSpec # Simulation being used
 } end
 
@@ -98,12 +80,9 @@ abstract type Result{
     N, # Number of timesteps simulated
     L, # Length of each simulation timestep
     T <: Period, # Units of each simulation timestep
-    V <: Real, # Numeric type of value data
-    ES <: ExtractionSpec, # Prob. distr. extraction method for input time series
     SS <: SimulationSpec # Type of simulation that produced the result
 } end
 
 # Load abstract methods
-include("extraction.jl")
 include("simulation.jl")
 include("result.jl")

src/abstractspecs/result.jl

@@ -33,13 +33,12 @@ end
 
 """
 
-    accumulator(::ExtractionSpec, ::SimulationSpec, ::ResultSpec,
-                ::SystemModel, seed::UInt)::ResultAccumulator
+    accumulator(::SimulationSpec, ::ResultSpec, ::SystemModel,
+                seed::UInt)::ResultAccumulator
 
 Returns a `ResultAccumulator` corresponding to the provided `ResultSpec`.
 """
-accumulator(::ExtractionSpec, ::SimulationSpec, ::S,
-            ::SystemModel{N,L,T,P,E,V}, seed::UInt
+accumulator(::SimulationSpec, ::S, ::SystemModel{N,L,T,P,E}, seed::UInt
 ) where {N,L,T,P,E,V,S<:ResultSpec} = 
     error("An `accumulator` method has not been defined for ResultSpec $T")
 
@@ -84,7 +83,7 @@ update!(::R, ::SystemOutputStateSummary, t::Int) where {R <: ResultAccumulator}
 
 """
 
-    finalize(::ExtractionSpec, ::SimulationSpec, ::ResultAccumulator)::Result
+    finalize(::SimulationSpec, ::ResultAccumulator)::Result
 
 Returns a `Result` corresponding to the provided `ResultAccumulator`.
 """

src/abstractspecs/simulation.jl

@@ -12,13 +12,12 @@ iscopperplate(::S) where {S <: SimulationSpec} =
 
 """
 
-    assess!(::ResultAccumulator, ::ExtractionSpec,
-            ::SimulationSpec, ::SystemModel)
+    assess!(::ResultAccumulator, ::SimulationSpec, ::SystemModel)
 
-Run a full simulation of `SystemModel` according to `ExtractionSpec` and
+Run a full simulation of `SystemModel` according to
 `SimulationSpec`, storing the results in `ResultAccumulator`.
 """
-assess!(::ResultAccumulator, ::ExtractionSpec, ::S, ::SystemModel
+assess!(::ResultAccumulator, ::S, ::SystemModel
 ) where {S <: SimulationSpec} =
     error("assess! not yet defined for SimulationSpec $S")
 
@@ -34,37 +33,34 @@ assess!(::ResultAccumulator, ::S, ::SystemInputStateDistribution, t::Int
 ) where {S <: SimulationSpec} =
     error("assess! not yet defined for SimulationSpec $S")
 
-function assess(extractionspec::ExtractionSpec,
-                simulationspec::SimulationSpec{NonSequential},
+function assess(simulationspec::SimulationSpec{NonSequential},
                 resultspec::ResultSpec,
-                system::SystemModel,
-                seed::UInt=rand(UInt))
+                system::SystemModel{N},
+                seed::UInt=rand(UInt)) where {N}
 
-    acc = accumulator(extractionspec, simulationspec, resultspec, system, seed)
+    acc = accumulator(simulationspec, resultspec, system, seed)
 
     #TODO: If storage devices exist, warn that they may be ignored or
     #      treated as firm capacity - need to decide how exactly that
     #      should work first though...
 
-    statedistrs = extract(extractionspec, system, iscopperplate(simulationspec))
-    Threads.@threads for (t, statedistr) in collect(enumerate(statedistrs))
-        assess!(acc, simulationspec, statedistr, t)
+    Threads.@threads for t in 1:N 
+        assess!(acc, simulationspec, system, t)
     end
 
     return finalize(acc)
 
 end
 
-function assess(extractionspec::ExtractionSpec,
-                simulationspec::SimulationSpec{Sequential},
+function assess(simulationspec::SimulationSpec{Sequential},
                 resultspec::ResultSpec,
                 system::SystemModel,
                 seed::UInt=rand(UInt))
 
-    acc = accumulator(extractionspec, simulationspec, resultspec, system, seed)
+    acc = accumulator(simulationspec, resultspec, system, seed)
 
     Threads.@threads for i in 1:simulationspec.nsamples
-        assess!(acc, extractionspec, simulationspec, system, i)
+        assess!(acc, simulationspec, system, i)
     end
 
     return finalize(acc)