1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
package main
import (
"fmt"
"gopkg.in/cheggaaa/pb.v1"
"math"
"math/rand"
"os"
)
const (
sigma = 200.0
f_0 = 0.1
G = 4.302e-3
R_s = 1e4
)
type star struct {
x float64
y float64
z float64
}
func rho(x, y, z float64) float64 {
var r float64 = math.Sqrt((x * x) + (y * y) + (z * z))
var a float64 = (1) / (math.Sqrt(2*math.Pi) * sigma)
var b float64 = math.Exp(-(phi(r) / float64(sigma*sigma)))
//aphi := phi(r)
//asigma := float64(sigma * sigma)
//fmt.Println(aphi, asigma, math.Exp( - (aphi / asigma)))
return a * b
}
func phi(x float64) float64 {
if x == 0 {
return (-4 * math.Pi * f_0 * G * (R_s * R_s))
} else {
var a float64 = -(4 * math.Pi * G * f_0 * (R_s * R_s * R_s) / x)
var b float64 = math.Log(1.0 + (x / R_s))
return (a * b)
}
}
func genStar(f *os.File) (bool, star) {
var length float64 = 1.5e7
var rangeMin float64 = -length
var rangeMax float64 = length
var randMin float64 = rho(0, 0, 0)
var randMax float64 = rho(length, length, length)
//(max - min) * rand.Float64()) + min
var x float64 = ((rangeMax - rangeMin) * rand.Float64()) + rangeMin
var y float64 = ((rangeMax - rangeMin) * rand.Float64()) + rangeMin
var z float64 = ((rangeMax - rangeMin) * rand.Float64()) + rangeMin
var randVal float64 = (randMax-randMin)*rand.Float64() + randMin
var rhoVal float64 = rho(x, y, z)
//fmt.Printf("x: %-20f y: %-20f z: %-20f randVal: %-20f rhoVal: %-20f\n", x, y, z, randVal, rhoVal)
if randVal < rhoVal {
var starString string = fmt.Sprintf("%f, %f, %f\n", x, y, z)
_, err := f.WriteString(starString)
if err != nil {
panic(err)
}
f.Sync()
//fmt.Printf("x: %-20f y: %-20f z: %-20f randVal: %-20f rhoVal: %-20f\n", x, y, z, randVal, rhoVal)
newStar := star{
x: x,
y: y,
z: z,
}
// return that a star was generated
return true, newStar
}
// return that no star was generated
return false, star{
x: 0,
y: 0,
z: 0,
}
}
func generateGoMethods(starCount int, f *os.File, channel chan star) {
var generatedStars int = 0
// for the amount of stars
for generatedStars < starCount {
// try to generate a new star
result, star := genStar(f)
if result == true {
generatedStars += 1
channel <- star
}
}
}
func main() {
// define some arguments
var stars int = 1e6
var threads int = 1
var threadStarCount int = stars / threads
// create a channel with a buffer of 10
channel := make(chan star, 10)
// create a file that stores the data
hostname, _ := os.Hostname()
pid := os.Getpid()
f, err := os.Create(fmt.Sprintf("%s_%d.csv", hostname, pid))
if err != nil {
panic(err)
}
// use 8 threads
// each thread should generate stars / 8 stars
for i := 0; i < threads; i++ {
fmt.Printf("Creating a happy worker! He/She is trying to generate %d stars!", threadStarCount)
// generate a go-method creating threadStarCound stars
go generateGoMethods(threadStarCount, f, channel)
fmt.Printf(" He/She just started working!\n")
}
// start the missing threads threads
var missingStars int = stars - (threadStarCount * threads)
fmt.Printf("A special worker was assigned to generate the last %d stars.\n", missingStars)
go generateGoMethods(missingStars, f, channel)
var starSlice []star
// Initialize a new progress bar
bar := pb.New(stars).Prefix("Stars: ")
bar.Start()
// get the stars
for i := 0; i < stars; i++ {
var newStar = <-channel
bar.Increment()
starSlice = append(starSlice, newStar)
}
bar.Finish()
// print all elements in the starslice
for _, element := range starSlice {
fmt.Println(element)
}
}
|
