goroutines

Author: mpcsb

pkg/sumdb/sum.golang.org/latest

@@ -1,5 +1,5 @@
 go.sum database tree
-1464884
-SlduoaOAa2h+kG0FhoGf0liamIkYA9sCe/Ly5E32rvo=
+1499078
+NhGB7d0P5DpXsHvi4rFrUSac2bzweWcc+7XLZWeZwJ4=
 
-— sum.golang.org Az3grhuKBElG+JPcIyDHChadtxED2FTwUypIHwuJeqhkLunXbcM7WkEjb8Q+/KAOowGs6fKdXrD3pTKECovq2nlALAg=
+— sum.golang.org Az3grpqNeOVgU90vaqupg0E14F+6CMGdA5QVkgXSST3OUK0WBxzNOJvgSrxN5pDS/MvatyD9M+KacSOw/hOaWL5B1Ac=

src/cmd/forest/main.go

@@ -1,18 +1,30 @@
 package main
 
 import (
+	"log"
 	"simulation/forest"
 	"simulation/shared"
+	"time"
 )
 
 func main() {
-	p1 := shared.Coord{Lat: 38.908577, Lon: -9.400535, Alt: 0.0} //38.914104, -9.400535
-	p2 := shared.Coord{Lat: 38.914104, Lon: -9.384442, Alt: 0.0} //38.908577, -9.384442
+	p1 := shared.Coord{Lat: 38.848577, Lon: -9.410535, Alt: 0.0} //38.944104, -9.400535
+	p2 := shared.Coord{Lat: 38.924104, Lon: -9.354442, Alt: 0.0} //38.908577, -9.364442
 
-	f := forest.ForestGeneration(p1, p2, 100)
+	f := forest.ForestGeneration(p1, p2, 100, 1.0)
+	t0 := time.Now()
+	f.GetNeighbours(1.3)
+	t1 := time.Since(t0)
+	log.Printf("serial took %s", t1)
+
+	t2 := time.Now()
+	f.DistributedNeighbour(1.3)
 
 	for i := 0; i < 36; i++ {
 		f.RecordFrame()
 	}
+
 	f.Plot_forest()
+	t3 := time.Since(t2)
+	log.Printf("parallel took %s", t3)
 }

src/cmd/run/main.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"fmt"
+	"simulation/forest"
+	"simulation/shared"
+)
+
+func main() {
+	p1 := shared.Coord{Lat: 38.793613, Lon: -9.453429, Alt: 0.0}
+	p2 := shared.Coord{Lat: 38.813257, Lon: -9.434138, Alt: 0.0}
+
+	// t := terrain.GenerateTerrain(p1, p2, 500)
+	// terrain.CallPythonScripts(p1, p2, 0, "structures")
+
+	samples := 10000
+	dist := 1.0
+	f := forest.ForestGeneration(p1, p2, samples, dist)
+	if false {
+		fmt.Println(f)
+	}
+
+}

src/cmd/testing/main.go

@@ -1,7 +1,6 @@
 package forest
 
 import (
-	"fmt"
 	"math"
 
 	"math/rand"
@@ -42,7 +41,7 @@ func (p TreeCoord) Distance(c vptree.Comparable) float64 {
 	return math.Sqrt(math.Pow(Dxy, 2) + math.Pow(Dz, 2))
 }
 
-func ForestGeneration(p1, p2 shared.Coord, samples int) (f Forest) {
+func ForestGeneration(p1, p2 shared.Coord, samples int, dist float64) (f Forest) {
 	rand.Seed(1999)
 	t := terrain.GenerateTerrain(p1, p2, samples) // terrain should not be controlled by samples, but instead by SRTM resolution
 
@@ -94,29 +93,12 @@ func ForestGeneration(p1, p2 shared.Coord, samples int) (f Forest) {
 	}
 
 	f.DetermineSample(10000)
-	f.GetNeighbours(3.0)
+
 	f.RecordFrame()
 
 	return f
 }
 
-func (f *Forest) GetNeighbours(d float64) {
-	// handle vp, err :=....
-	VP, _ := vptree.New(f.Tree_Coords, 0, nil)
-	fmt.Println("VP found")
-
-	for i, q := range f.Tree_Coords {
-		var keep vptree.Keeper
-		keep = vptree.NewDistKeeper(d)
-		VP.NearestSet(keep, q)
-
-		for _, neighbour_tree := range keep.(*vptree.DistKeeper).Heap {
-			tree := neighbour_tree.Comparable.(TreeCoord)
-			f.Tree_lst[i].Neighbours = append(f.Tree_lst[i].Neighbours, tree.ID)
-		}
-	}
-}
-
 func (f *Forest) DetermineSample(size int) {
 	selected := make(map[int]bool, size)
 

src/simulation/forest/forest.go

@@ -0,0 +1,64 @@
+package forest
+
+import (
+	"fmt"
+	"sync"
+
+	"gonum.org/v1/gonum/spatial/vptree"
+)
+
+const workerNum = 4
+
+// GetNeighbours finds trees closer than a distance d
+func (f *Forest) GetNeighbours(d float64) {
+	// handle vp, err :=....
+	VP, _ := vptree.New(f.Tree_Coords, 0, nil)
+	fmt.Println("VP found")
+
+	for i, q := range f.Tree_Coords {
+		var keep vptree.Keeper
+		keep = vptree.NewDistKeeper(d)
+		VP.NearestSet(keep, q)
+
+		for _, neighbourTree := range keep.(*vptree.DistKeeper).Heap {
+			tree := neighbourTree.Comparable.(TreeCoord)
+			f.Tree_lst[i].Neighbours = append(f.Tree_lst[i].Neighbours, tree.ID)
+		}
+	}
+	fmt.Println("Neighbours found")
+}
+
+// DistributedNeighbour finds adjacent trees over const workerNum of cores
+func (f *Forest) DistributedNeighbour(d float64) {
+	// VP, _ := vptree.New(f.Tree_Coords, 0, nil)
+	fmt.Println("VP found")
+
+	wg := sync.WaitGroup{}
+	for i := 0; i < workerNum; i++ {
+		wg.Add(1)
+		go f.run(i, 3.0, &wg)
+	}
+
+}
+
+func (f *Forest) run(worker int, d float64, wg *sync.WaitGroup) {
+	VP, _ := vptree.New(f.Tree_Coords, 0, nil)
+
+	for i, q := range f.Tree_Coords {
+		if i%workerNum != worker {
+			continue
+		}
+
+		var keep vptree.Keeper
+		keep = vptree.NewDistKeeper(d)
+		VP.NearestSet(keep, q)
+
+		for _, neighbourTree := range keep.(*vptree.DistKeeper).Heap {
+			tree := neighbourTree.Comparable.(TreeCoord)
+			f.Tree_lst[i].Neighbours = append(f.Tree_lst[i].Neighbours, tree.ID)
+		}
+	}
+	// let the wait group know we finished
+	wg.Done()
+
+}

src/simulation/forest/neighbours.go

@@ -1,11 +1,11 @@
 package fuel
 
-type shrub_static struct {
-	height       float32
-	surface_area float32
+type shrubStatic struct {
+	height      float32
+	surfaceArea float32
 }
 
-type shrub_dynamic struct {
+type shrubDynamic struct {
 	moisture float32
 	state    string
 }

src/simulation/fuel/shrub.go

@@ -23,29 +23,32 @@ type Tree_dynamic struct {
 	Flame    fire.Flame
 }
 
+// Tree_data holds static and dynamic information about each tree
 type Tree_data struct {
 	ID      int
 	species string
 	Coords  s.Coord
 	Static  Tree_static
 	Dynamic Tree_dynamic
 
-	North_facing string
-	Neighbours   []int
+	Aspect     string
+	Neighbours []int
 }
 
-func CreateTree(id int, p s.Coord, species string, tree_db map[string][5]float64) Tree_data {
+// CreateTree generates a tree based on tree_db details
+func CreateTree(id int, p s.Coord, species string, treeDB map[string][5]float64) Tree_data {
 	t := Tree_data{ID: id}
 	t.species = species
 	t.Coords = s.Coord{Lat: p.Lat, Lon: p.Lon, Alt: p.Alt}
 
-	t.initStatic(tree_db)
+	t.initStatic(treeDB)
 	t.initBiomass()
+	t.Dynamic.State = "tree"
 	return t
 }
 
-func (t *Tree_data) initStatic(tree_db map[string][5]float64) {
-	dims := tree_db[t.species]
+func (t *Tree_data) initStatic(treeDB map[string][5]float64) {
+	dims := treeDB[t.species]
 
 	t.Static.Height = dims[0]
 	t.Static.DiameterBreastHeight = dims[1]
@@ -63,14 +66,14 @@ func (t *Tree_data) initBiomass() {
 	t.Dynamic.Trunk = t.Static.Height * math.Pi * math.Pow(t.Static.DiameterBreastHeight, 2) / 4.0
 	t.Dynamic.Canopy = (0.5 * t.Static.Height) * (math.Pi * math.Pow(t.Static.CrownRadius, 2) / 4.0) * t.Static.SparsenessFactor
 
-	t.Dynamic.State = "tree"
 }
 
+// UpdateMoisture controls the water content depending on the temperature of the surrounding temperature
 func (t *Tree_data) UpdateMoisture(temperature float64) {
-	temperature_diff := temperature - 25.0 // 25ºC. This would be an equilibirum point where no water transfers occur
+	temperatureDiff := temperature - 25.0 // 25ºC. This would be an equilibirum point where no water transfers occur
 	diff := 0.0
-	if temperature_diff > 0 {
-		diff = 0.01 * temperature_diff
+	if temperatureDiff > 0 {
+		diff = 0.01 * temperatureDiff
 	} else {
 		diff = 0
 	}

src/simulation/fuel/tree.go

@@ -0,0 +1,16 @@
+package interactions
+
+// // TreeImport fuel.Tree_data
+// type TreeImport fuel.Tree_data
+
+// UpdateMoisture controls the water content depending on the temperature of the surrounding temperature
+func (t *TreeImport) UpdateMoisture(temperature float64) {
+	temperatureDiff := temperature - 25.0 // 25ºC. This would be an equilibirum point where no water transfers occur
+	diff := 0.0
+	if temperatureDiff > 0 {
+		diff = 0.01 * temperatureDiff
+	} else {
+		diff = 0
+	}
+	t.Dynamic.Moisture = t.Dynamic.Moisture - (diff / t.Static.BarkThickness)
+}