add csv hazardprovider

Author: sebastianrowan

hazardproviders/csv_multi_hazard.go

@@ -0,0 +1,111 @@
+package hazardproviders
+
+import (
+	"encoding/csv"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/USACE/go-consequences/geography"
+	"github.com/USACE/go-consequences/hazards"
+)
+
+type csvArrivalDepthDurationMultiHazardProvider struct {
+	f         *os.File
+	arrivals  []time.Time
+	depths    []float64
+	durations []float64
+	process   HazardFunction
+	bbox      geography.BBox
+}
+
+func InitCSV(fp string, b geography.BBox) (csvArrivalDepthDurationMultiHazardProvider, error) {
+	fmt.Println("Connecting to: " + fp)
+	file, err := os.Open(fp)
+	if err != nil {
+		panic(err)
+	}
+
+	reader := csv.NewReader(file)
+
+	rows, err := reader.ReadAll()
+	if err != nil {
+		panic(err)
+	}
+	arrivals := make([]time.Time, len(rows)-1)
+	depths := make([]float64, len(rows)-1)
+	durations := make([]float64, len(rows)-1)
+
+	for i, row := range rows[1:] {
+		year, err := strconv.Atoi(row[2])
+		if err != nil {
+			panic(err)
+		}
+		month, err := strconv.Atoi(strings.TrimSpace(row[3]))
+		if err != nil {
+			panic(err)
+		}
+		day, err := strconv.Atoi(strings.TrimSpace(row[4]))
+		if err != nil {
+			panic(err)
+		}
+		at := time.Date(year, time.Month(month), int(day), 0, 0, 0, 0, time.UTC)
+		depth, err := strconv.ParseFloat(row[5], 64)
+		if err != nil {
+			panic(err)
+		}
+		dur, err := strconv.ParseFloat(row[6], 64)
+		if err != nil {
+			panic(err)
+		}
+
+		arrivals[i] = at
+		depths[i] = depth
+		durations[i] = dur
+	}
+
+	return csvArrivalDepthDurationMultiHazardProvider{
+		f:         file,
+		arrivals:  arrivals,
+		depths:    depths,
+		durations: durations,
+		process:   ArrivalDepthAndDurationHazardFunction(),
+		bbox:      b,
+	}, nil
+
+}
+
+func (c csvArrivalDepthDurationMultiHazardProvider) Close() {
+	c.f.Close()
+}
+
+func (c csvArrivalDepthDurationMultiHazardProvider) Hazard(l geography.Location) (hazards.HazardEvent, error) {
+	var hm hazards.ArrivalDepthandDurationEventMulti
+	if c.bbox.Contains(l) {
+		for i, d := range c.depths {
+			hd := hazards.HazardData{
+				Depth:       d,
+				Velocity:    0,
+				ArrivalTime: c.arrivals[i],
+				Erosion:     0,
+				Duration:    c.durations[i],
+				WaveHeight:  0,
+				Salinity:    false,
+				Qualitative: "",
+			}
+			var h hazards.HazardEvent
+			h, err := c.process(hd, h)
+			if err != nil {
+				panic(err)
+			}
+			hm.Append(h.(hazards.ArrivalDepthandDurationEvent))
+		}
+	}
+	return &hm, nil
+}
+
+func (c csvArrivalDepthDurationMultiHazardProvider) HazardBoundary() (geography.BBox, error) {
+	return c.bbox, nil
+}

hazardproviders/csv_multi_hazard_test.go

@@ -0,0 +1,66 @@
+package hazardproviders
+
+import (
+	"testing"
+	"time"
+
+	"github.com/USACE/go-consequences/geography"
+	"github.com/USACE/go-consequences/hazards"
+)
+
+func TestInitCSV(t *testing.T) {
+	file := "/workspaces/go-consequences/data/lifecycle/test_arrival-depth-duration_hazards.csv"
+
+	expectedDepths := []float64{1.0, 1.0, 1.0, 2.0, 2.0}
+	expectedDurations := []float64{0.0, 5.0, 0.0, 0.0, 0.0}
+	et1 := time.Date(1984, time.Month(1), 1, 0, 0, 0, 0, time.UTC)
+	et2 := time.Date(1984, time.Month(1), 11, 0, 0, 0, 0, time.UTC)
+	et3 := time.Date(1984, time.Month(1), 21, 0, 0, 0, 0, time.UTC)
+	et4 := time.Date(1985, time.Month(1), 1, 0, 0, 0, 0, time.UTC)
+	et5 := time.Date(1985, time.Month(1), 11, 0, 0, 0, 0, time.UTC)
+	expectedArrivals := []time.Time{et1, et2, et3, et4, et5}
+
+	b := geography.BBox{
+		// xMin, yMin, xMax, yMax
+		Bbox: []float64{-71.1, 43, -71, 43.1},
+	}
+	ADDMHP, err := InitCSV(file, b)
+	if err != nil {
+		panic(err)
+	}
+	defer ADDMHP.Close()
+
+	loc := geography.Location{
+		X:    -71.05,
+		Y:    43.05,
+		SRID: "",
+	}
+
+	haz, err := ADDMHP.Hazard(loc)
+	h := haz.(*hazards.ArrivalDepthandDurationEventMulti)
+	if err != nil {
+		panic(err)
+	}
+
+	for {
+		edepth := expectedDepths[h.Index()]
+		edur := expectedDurations[h.Index()]
+		earr := expectedArrivals[h.Index()]
+
+		if h.Depth() != edepth {
+			t.Errorf("Event at index %d had Depth = %v. Expected: %3.2f", h.Index(), h.Depth(), edepth)
+		}
+		if h.Duration() != edur {
+			t.Errorf("Event at index %d had Duration = %v. Expected: %3.2f", h.Index(), h.Duration(), edur)
+		}
+		if h.Depth() != edepth {
+			t.Errorf("Event at index %d had ArrivalTime = %v. Expected: %v", h.Index(), h.ArrivalTime(), earr)
+		}
+
+		if h.HasNext() {
+			h.Increment()
+		} else {
+			break
+		}
+	}
+}

hazardproviders/json_multi_hazard.go

@@ -17,7 +17,7 @@ type jsonArrivalDepthDurationMultiHazardProvider struct {
 	process   HazardFunction
 }
 
-type ADDProperties struct { // will try to not use this
+type ADDProperties struct {
 	Year      float64 `json:"year"`
 	Month     float64 `json:"month"`
 	Day       float64 `json:"day"`
@@ -93,6 +93,9 @@ func (j jsonArrivalDepthDurationMultiHazardProvider) Hazard(l geography.Location
 		}
 		var h hazards.HazardEvent
 		h, err = j.process(hd, h)
+		if err != nil {
+			panic(err)
+		}
 		hm.Append(h.(hazards.ArrivalDepthandDurationEvent))
 	}
 	return &hm, nil

structures/structure.go

@@ -471,11 +471,7 @@ func computeConsequencesMulti(events []hazards.HazardEvent, s StructureDetermini
 }
 
 func computeConsequencesMultiHazard(event hazards.MultiHazardEvent, s StructureDeterministic) (consequences.Result, error) {
-	// this function needs to return a single result. Not a slice of results
-	// Make a nested Result where each column is itself a Result
 
-	// Rethinking the results format. The current version repeats the structure info for each result.
-	// The main result body can include the structure info, and we can simply store the details of the iteration results in a column as json.
 	mainHeader := []string{
 		"fd_id", "x", "y", "damage category", "occupancy type",
 		"pop2amu65", "pop2amo65", "pop2pmu65", "pop2pmo65", "cbfips",
@@ -677,5 +673,6 @@ func computeConsequencesMultiHazard(event hazards.MultiHazardEvent, s StructureD
 			break
 		}
 	}
+	// ret.Result[20] = fmt.Sprintf("%v", subResult) // saving the results as a string
 	return ret, err
 }