diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,165 @@
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc.
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+ This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+ 0. Additional Definitions.
+
+ As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+ "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+ An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+ A "Combined Work" is a work produced by combining or linking an
+Application with the Library. The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+ The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+ The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+ 1. Exception to Section 3 of the GNU GPL.
+
+ You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+ 2. Conveying Modified Versions.
+
+ If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+ a) under this License, provided that you make a good faith effort to
+ ensure that, in the event an Application does not supply the
+ function or data, the facility still operates, and performs
+ whatever part of its purpose remains meaningful, or
+
+ b) under the GNU GPL, with none of the additional permissions of
+ this License applicable to that copy.
+
+ 3. Object Code Incorporating Material from Library Header Files.
+
+ The object code form of an Application may incorporate material from
+a header file that is part of the Library. You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+ a) Give prominent notice with each copy of the object code that the
+ Library is used in it and that the Library and its use are
+ covered by this License.
+
+ b) Accompany the object code with a copy of the GNU GPL and this license
+ document.
+
+ 4. Combined Works.
+
+ You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+ a) Give prominent notice with each copy of the Combined Work that
+ the Library is used in it and that the Library and its use are
+ covered by this License.
+
+ b) Accompany the Combined Work with a copy of the GNU GPL and this license
+ document.
+
+ c) For a Combined Work that displays copyright notices during
+ execution, include the copyright notice for the Library among
+ these notices, as well as a reference directing the user to the
+ copies of the GNU GPL and this license document.
+
+ d) Do one of the following:
+
+ 0) Convey the Minimal Corresponding Source under the terms of this
+ License, and the Corresponding Application Code in a form
+ suitable for, and under terms that permit, the user to
+ recombine or relink the Application with a modified version of
+ the Linked Version to produce a modified Combined Work, in the
+ manner specified by section 6 of the GNU GPL for conveying
+ Corresponding Source.
+
+ 1) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (a) uses at run time
+ a copy of the Library already present on the user's computer
+ system, and (b) will operate properly with a modified version
+ of the Library that is interface-compatible with the Linked
+ Version.
+
+ e) Provide Installation Information, but only if you would otherwise
+ be required to provide such information under section 6 of the
+ GNU GPL, and only to the extent that such information is
+ necessary to install and execute a modified version of the
+ Combined Work produced by recombining or relinking the
+ Application with a modified version of the Linked Version. (If
+ you use option 4d0, the Installation Information must accompany
+ the Minimal Corresponding Source and Corresponding Application
+ Code. If you use option 4d1, you must provide the Installation
+ Information in the manner specified by section 6 of the GNU GPL
+ for conveying Corresponding Source.)
+
+ 5. Combined Libraries.
+
+ You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+ a) Accompany the combined library with a copy of the same work based
+ on the Library, uncombined with any other library facilities,
+ conveyed under the terms of this License.
+
+ b) Give prominent notice with the combined library that part of it
+ is a work based on the Library, and explaining where to find the
+ accompanying uncombined form of the same work.
+
+ 6. Revised Versions of the GNU Lesser General Public License.
+
+ The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+ If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
diff --git a/SWMMoutGetMB.cabal b/SWMMoutGetMB.cabal
new file mode 100644
--- /dev/null
+++ b/SWMMoutGetMB.cabal
@@ -0,0 +1,69 @@
+-- Initial SWMMoutGetMB.cabal generated by cabal init. For further
+-- documentation, see http://haskell.org/cabal/users-guide/
+
+-- The name of the package.
+name: SWMMoutGetMB
+
+-- The package version. See the Haskell package versioning policy (PVP)
+-- for standards guiding when and how versions should be incremented.
+-- http://www.haskell.org/haskellwiki/Package_versioning_policy
+-- PVP summary: +-+------- breaking API changes
+-- | | +----- non-breaking API additions
+-- | | | +--- code changes with no API change
+version: 0.1.0.0
+
+-- A short (one-line) description of the package.
+synopsis: A parser for SWMM 5 binary .OUT files
+
+-- A longer description of the package.
+description: The United States Environmental Protection Agency (EPA) Storm Water
+ Management Model (SWMM) is a dynamic hydrology-hydraulic water
+ quality simulation model for single event or long-term (continuous)
+ simulation of runoff quantity and quality from primarily urban areas.
+
+ SWMM 5, which is currently the newest version of SWMM, produces a
+ binary .OUT file as its output. SWMMoutGetMB is a SWMM binary
+ reader using the Get monad in Haskell to retrieve contents of this
+ binary file and save it into a SWMMObject, which can then be
+ used in Haskell programs.
+
+-- URL for the project homepage or repository.
+homepage: https://github.com/siddhanathan/SWMMoutGetMB
+
+-- The license under which the package is released.
+license: LGPL-3
+
+-- The file containing the license text.
+license-file: LICENSE
+
+-- The package author(s).
+author: Siddhanathan Shanmugam
+
+-- An email address to which users can send suggestions, bug reports, and
+-- patches.
+maintainer: siddhanathan@gmail.com
+
+-- A copyright notice.
+-- copyright: (C) 2014 Siddhanathan Shanmugam
+
+category: Water, Hydrology, Environment
+
+build-type: Simple
+
+-- Constraint on the version of Cabal needed to build this package.
+cabal-version: >=1.8
+
+
+library
+ -- Modules exported by the library.
+ exposed-modules: Water.SWMM
+
+ -- Modules included in this library but not exported.
+ -- other-modules: Examples
+
+ -- Other library packages from which modules are imported.
+ build-depends: base ==4.6.*, binary ==0.7.*, bytestring ==0.10.*, data-binary-ieee754 ==0.4.*, split ==0.2.*
+
+ -- Directories containing source files.
+ hs-source-dirs: src
+
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,2 @@
+import Distribution.Simple
+main = defaultMain
diff --git a/src/Water/SWMM.hs b/src/Water/SWMM.hs
new file mode 100644
--- /dev/null
+++ b/src/Water/SWMM.hs
@@ -0,0 +1,255 @@
+-- |
+-- Module : Water.SWMM
+-- Copyright : (C) 2014 Siddhanathan Shanmugam
+-- License : LGPL (see LICENSE)
+-- Maintainer : siddhanathan@gmail.com
+-- Portability : very
+--
+-- Parser for SWMM 5 Binary .OUT files
+--
+
+{-# OPTIONS_GHC -fno-warn-warnings-deprecations #-}
+
+module Water.SWMM ( SWMMObject(..)
+ , Header(..)
+ , Ids(..)
+ , Properties(..)
+ , ObjectProperties(..)
+ , Variables(..)
+ , ReportingVariables(..)
+ , ReportingInterval(..)
+ , ValuesForOneDateTime(..)
+ , ComputedResult
+ , ClosingRecord(..)
+ , parseSWMMBinary
+ ) where
+
+import Data.Binary.Get (getWord32le, runGetState, Get(..), getLazyByteString)
+import Data.Word (Word32(..))
+import Data.ByteString.Internal (ByteString)
+import Control.Applicative ((<$>), (<*>))
+import Data.Binary.IEEE754 (getFloat32le, getFloat64le)
+import qualified Data.ByteString.Lazy as BL (ByteString, pack, unpack)
+import Data.List.Split (splitEvery)
+
+data SWMMObject = SWMMObject { header :: Header
+ , ids :: Ids
+ , properties :: ObjectProperties
+ , variables :: ReportingVariables
+ , intervals :: ReportingInterval
+ , result :: ComputedResult
+ , closingRecord :: ClosingRecord
+ } deriving (Show)
+
+data Header = Header { headerIdNumber :: Integer
+ , versionNumber :: Integer
+ , codeNumber :: Integer
+ , numberOfSubcatchments :: Integer
+ , numberOfNodes :: Integer
+ , numberOfLinks :: Integer
+ , numberOfPollutants :: Integer
+ } deriving (Show)
+
+data Ids = Ids { subcatchmentIds :: [BL.ByteString]
+ , nodeIds :: [BL.ByteString]
+ , linkIds :: [BL.ByteString]
+ , pollutantIds :: [BL.ByteString]
+ , concentrationIds :: [Integer]
+ } deriving (Show)
+
+data ObjectProperties = ObjectProperties { subcatchmentProperties :: Properties
+ , nodeProperties :: Properties
+ , linkProperties :: Properties
+ } deriving (Show)
+
+data ReportingVariables = ReportingVariables { subcatchmentVariables :: Variables
+ , nodeVariables :: Variables
+ , linkVariables :: Variables
+ , systemVariables :: Variables
+ } deriving (Show)
+
+
+data ReportingInterval = ReportingInterval { startDateTime :: Double
+ , timeIntervals :: Integer
+ } deriving (Show)
+
+type ComputedResult = [ValuesForOneDateTime]
+
+data ClosingRecord = ClosingRecord { idBytePosition :: Integer
+ , propertiesBytePosition :: Integer
+ , resultBytePosition :: Integer
+ , numberOfPeriods :: Integer
+ , errorCode :: Integer
+ , closingIdNumber :: Integer
+ } deriving (Show)
+
+data Properties = Properties { numberOfProperties :: Integer
+ , codeNumberProperties :: [Integer]
+ , valueProperties :: [Float]
+ } deriving (Show)
+
+data Variables = Variables { numberOfVariables :: Integer
+ , codeNumberVariables :: [Integer]
+ } deriving (Show)
+
+data ValuesForOneDateTime = ValuesForOneDateTime { dateTimeValue :: Double
+ , subcatchmentValue :: [[Float]]
+ , nodeValue :: [[Float]]
+ , linkValue :: [[Float]]
+ , systemValue :: [Float]
+ } deriving (Show)
+
+closingRecordSize :: Int
+closingRecordSize = 6 * 4
+
+getHeader :: Get Header
+getHeader = Header <$> a
+ <*> a
+ <*> a
+ <*> a
+ <*> a
+ <*> a
+ <*> a
+ where a = getIntegerWord32le
+
+parseSWMMBinary :: BL.ByteString -> SWMMObject
+parseSWMMBinary input = do
+ let closingByteString = getClosingByteString input
+ (closingRecord, _, _) = runGetState getClosingRecords closingByteString 1
+ (header, rest1, _) = runGetState getHeader input 1
+ (ids, rest2) = getIds rest1 header
+ (objectProperties, rest3) = getObjectProperties header rest2
+ (reportingVariables, rest4) = getReportingVariables rest3
+ (reportingIntervals, rest5, _) = runGetState getReportingIntervals rest4 1
+ (result, rest6) = getComputedResults (numberOfPeriods closingRecord)
+ reportingVariables header rest5
+ SWMMObject header
+ ids
+ objectProperties
+ reportingVariables
+ reportingIntervals
+ result
+ closingRecord
+
+getIntegerWord32le :: Get Integer
+getIntegerWord32le = fromIntegral <$> getWord32le
+
+getWords :: Integer -> BL.ByteString -> ([Integer], BL.ByteString)
+getWords n input
+ | n == 0 = ([], input)
+ | otherwise = appendW w (getWords (n-1) rest)
+ where (w, rest, _) = runGetState getIntegerWord32le input 1
+
+appendW :: a -> ([a], BL.ByteString) -> ([a], BL.ByteString)
+appendW w (x, y) = (w:x, y)
+
+getDecimals :: Integer -> BL.ByteString -> ([Float], BL.ByteString)
+getDecimals n input
+ | n == 0 = ([], input)
+ | otherwise = appendW w (getDecimals (n-1) rest)
+ where (w, rest, _) = runGetState getFloat32le input 1
+
+getByteStrings :: Integer -> BL.ByteString -> ([BL.ByteString], BL.ByteString)
+getByteStrings n input
+ | n == 0 = ([], input)
+ | otherwise = appendW w (getByteStrings (n-1) rest)
+ where (c, r, _) = runGetState getWord32le input 1
+ (w, rest, _) = runGetState ((getLazyByteString . fromIntegral) c) r 1
+
+getClosingByteString :: BL.ByteString -> BL.ByteString
+getClosingByteString = BL.pack . reverse . take closingRecordSize . reverse . BL.unpack
+
+getIds :: BL.ByteString -> Header -> (Ids, BL.ByteString)
+getIds rest1 header = do
+ let (subcatchments, rest2) = getByteStrings (numberOfSubcatchments header) rest1
+ (nodes, rest3) = getByteStrings (numberOfNodes header) rest2
+ (links, rest4) = getByteStrings (numberOfLinks header) rest3
+ (pollutants, rest5) = getByteStrings (numberOfPollutants header) rest4
+ (pollutantConcentrationUnits, rest6) = getWords (numberOfPollutants header) rest5
+ (Ids subcatchments nodes links pollutants pollutantConcentrationUnits, rest6)
+
+getObjectProperties :: Header -> BL.ByteString -> (ObjectProperties, BL.ByteString)
+getObjectProperties header rest1 = do
+ let (numberOfSubcatchmentProperties, rest2, _) = runGetState getIntegerWord32le rest1 1
+ (codeNumberSubcatchmentProperties, rest3) = getWords numberOfSubcatchmentProperties rest2
+ (valueSubcatchmentProperties, rest4) = getDecimals n rest3
+ where n = numberOfSubcatchmentProperties
+ * numberOfSubcatchments header
+ (numberOfNodeProperties, rest5, _) = runGetState getIntegerWord32le rest4 1
+ (codeNumberNodeProperties, rest6) = getWords numberOfNodeProperties rest5
+ (valueNodeProperties, rest7) = getDecimals (numberOfNodeProperties
+ * numberOfNodes header) rest6
+ (numberOfLinkProperties, rest8, _) = runGetState getIntegerWord32le rest7 1
+ (codeNumberLinkProperties, rest9) = getWords numberOfLinkProperties rest8
+ (valueLinkProperties, rest10) = getDecimals (numberOfLinkProperties
+ * numberOfLinks header) rest9
+ subcatchment = Properties numberOfSubcatchmentProperties
+ codeNumberSubcatchmentProperties
+ valueSubcatchmentProperties
+ node = Properties numberOfNodeProperties
+ codeNumberNodeProperties
+ valueNodeProperties
+ link = Properties numberOfLinkProperties
+ codeNumberLinkProperties
+ valueLinkProperties
+ object = ObjectProperties subcatchment node link
+ (object, rest10)
+
+getReportingVariables :: BL.ByteString -> (ReportingVariables, BL.ByteString)
+getReportingVariables rest1 = do
+ let (numberOfSubcatchmentVariables, rest2, _) = runGetState getIntegerWord32le rest1 1
+ (codeNumberSubcatchmentVariables, rest3) = getWords numberOfSubcatchmentVariables rest2
+ (numberOfNodeVariables, rest4, _) = runGetState getIntegerWord32le rest3 1
+ (codeNumberNodeVariables, rest5) = getWords numberOfNodeVariables rest4
+ (numberOfLinkVariables, rest6, _) = runGetState getIntegerWord32le rest5 1
+ (codeNumberLinkVariables, rest7) = getWords numberOfLinkVariables rest6
+ (numberOfSystemVariables, rest8, _) = runGetState getIntegerWord32le rest7 1
+ (codeNumberSystemVariables, rest9) = getWords numberOfSystemVariables rest8
+ subcatchment = Variables numberOfSubcatchmentVariables codeNumberSubcatchmentVariables
+ node = Variables numberOfNodeVariables codeNumberNodeVariables
+ link = Variables numberOfLinkVariables codeNumberLinkVariables
+ system = Variables numberOfSystemVariables codeNumberSystemVariables
+ reportingVariables = ReportingVariables subcatchment node link system
+ (reportingVariables, rest9)
+
+getReportingIntervals :: Get ReportingInterval
+getReportingIntervals = ReportingInterval <$> getFloat64le
+ <*> getIntegerWord32le
+
+splitEveryRemainder :: Num b => Integer -> ([b], BL.ByteString) -> ([[b]], BL.ByteString)
+splitEveryRemainder n (l, r) = (splitEvery ns l, r)
+ where ns = fromInteger n
+
+getComputedResults :: Integer -> ReportingVariables -> Header -> BL.ByteString
+ -> ([ValuesForOneDateTime], BL.ByteString)
+getComputedResults n reportingVariables header rest1
+ | n == 0 = ([], rest1)
+ | otherwise = do
+ let (dateTimeValue, rest2, _) = runGetState getFloat64le rest1 1
+ (subcatchmentValue, rest3) = splitEveryRemainder nv $ getDecimals n rest2
+ where n = numberOfSubcatchments header * nv
+ nv = (numberOfVariables . subcatchmentVariables) reportingVariables
+ (nodeValue, rest4) = splitEveryRemainder nv $ getDecimals n rest3
+ where n = numberOfNodes header * nv
+ nv = (numberOfVariables . nodeVariables) reportingVariables
+ (linkValue, rest5) = splitEveryRemainder nv $ getDecimals n rest4
+ where n = numberOfLinks header * nv
+ nv = (numberOfVariables . linkVariables) reportingVariables
+ (systemValue, rest6) = getDecimals n rest5
+ where n = (numberOfVariables . systemVariables) reportingVariables
+ valueConstructor = ValuesForOneDateTime dateTimeValue
+ subcatchmentValue
+ nodeValue
+ linkValue
+ systemValue
+ appendW valueConstructor (getComputedResults (n-1) reportingVariables header rest6)
+
+getClosingRecords :: Get ClosingRecord
+getClosingRecords = ClosingRecord <$> a
+ <*> a
+ <*> a
+ <*> a
+ <*> a
+ <*> a
+ where a = getIntegerWord32le
+