367 lines
8.2 KiB
V
367 lines
8.2 KiB
V
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
||
|
// sim.v * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
||
|
// created by: jordan bonecutter * * * * * * * * * * * * * * * * * * *
|
||
|
// jpbonecutter@gmail.com * * * * * * * * * * * * * * * * * * * * * *
|
||
|
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
||
|
//
|
||
|
// I wrote the pendulum simulator to learn V, I think it could be a
|
||
|
// good addition to the examples directory.
|
||
|
// Essentially, the pendulum sim runs a simulation of a pendulum with
|
||
|
// a metallic tip swinging over three magnets.
|
||
|
// I run this simulation with the initial position at each pixel in an
|
||
|
// image and color the pixel according to the magnet over which it
|
||
|
// finally rests.
|
||
|
// I used some fun features in V like coroutines, channels,
|
||
|
// struct embedding, mutability, methods, and the like.
|
||
|
import math
|
||
|
import os
|
||
|
import term
|
||
|
import runtime
|
||
|
|
||
|
// customisable through setting VJOBS
|
||
|
const parallel_workers = runtime.nr_jobs()
|
||
|
|
||
|
const width = 800
|
||
|
|
||
|
const height = 600
|
||
|
|
||
|
struct Vec3D {
|
||
|
x f64
|
||
|
y f64
|
||
|
z f64
|
||
|
}
|
||
|
|
||
|
fn (v Vec3D) add(v2 Vec3D) Vec3D {
|
||
|
return Vec3D{
|
||
|
x: v.x + v2.x
|
||
|
y: v.y + v2.y
|
||
|
z: v.z + v2.z
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fn (v Vec3D) dot(v2 Vec3D) f64 {
|
||
|
return (v.x * v2.x) + (v.y * v2.y) + (v.z * v2.z)
|
||
|
}
|
||
|
|
||
|
fn (v Vec3D) scale(scalar f64) Vec3D {
|
||
|
return Vec3D{
|
||
|
x: v.x * scalar
|
||
|
y: v.y * scalar
|
||
|
z: v.z * scalar
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fn (v Vec3D) norm_squared() f64 {
|
||
|
return v.dot(v)
|
||
|
}
|
||
|
|
||
|
fn (v Vec3D) norm() f64 {
|
||
|
return math.sqrt(v.norm_squared())
|
||
|
}
|
||
|
|
||
|
struct SimState {
|
||
|
mut:
|
||
|
position Vec3D
|
||
|
velocity Vec3D
|
||
|
accel Vec3D
|
||
|
}
|
||
|
|
||
|
// magnets lie at [
|
||
|
// math.cos(index * 2 * math.pi / 3) * magnet_spacing
|
||
|
// math.sin(index * 2 * math.pi / 3) * magnet_spacing
|
||
|
// -magnet_height
|
||
|
// ]
|
||
|
struct SimParams {
|
||
|
rope_length f64
|
||
|
bearing_mass f64
|
||
|
magnet_spacing f64
|
||
|
magnet_height f64
|
||
|
magnet_strength f64
|
||
|
gravity f64
|
||
|
}
|
||
|
|
||
|
fn (params SimParams) get_rope_vector(state SimState) Vec3D {
|
||
|
rope_origin := Vec3D{
|
||
|
x: 0
|
||
|
y: 0
|
||
|
z: params.rope_length
|
||
|
}
|
||
|
|
||
|
return state.position.add(rope_origin.scale(-1))
|
||
|
}
|
||
|
|
||
|
fn (mut state SimState) satisfy_rope_constraint(params SimParams) {
|
||
|
mut rope_vector := params.get_rope_vector(state)
|
||
|
rope_vector = rope_vector.scale(params.rope_length / rope_vector.norm())
|
||
|
state.position = Vec3D{
|
||
|
x: 0
|
||
|
y: 0
|
||
|
z: params.rope_length
|
||
|
}.add(rope_vector)
|
||
|
}
|
||
|
|
||
|
fn (params SimParams) get_grav_force(state SimState) Vec3D {
|
||
|
return Vec3D{
|
||
|
x: 0
|
||
|
y: 0
|
||
|
z: -params.bearing_mass * params.gravity
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fn (params SimParams) get_magnet_position(theta f64) Vec3D {
|
||
|
return Vec3D{
|
||
|
x: math.cos(theta) * params.magnet_spacing
|
||
|
y: math.sin(theta) * params.magnet_spacing
|
||
|
z: -params.magnet_height
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fn (params SimParams) get_magnet_force(theta f64, state SimState) Vec3D {
|
||
|
magnet_position := params.get_magnet_position(theta)
|
||
|
mut diff := magnet_position.add(state.position.scale(-1))
|
||
|
distance_squared := diff.norm_squared()
|
||
|
diff = diff.scale(1.0 / math.sqrt(distance_squared))
|
||
|
return diff.scale(params.magnet_strength / distance_squared)
|
||
|
}
|
||
|
|
||
|
fn (params SimParams) get_magnet_dist(theta f64, state SimState) f64 {
|
||
|
return params.get_magnet_position(theta).add(state.position.scale(-1)).norm()
|
||
|
}
|
||
|
|
||
|
fn (params SimParams) get_magnet1_force(state SimState) Vec3D {
|
||
|
return params.get_magnet_force(0.0 * math.pi / 3.0, state)
|
||
|
}
|
||
|
|
||
|
fn (params SimParams) get_magnet2_force(state SimState) Vec3D {
|
||
|
return params.get_magnet_force(2.0 * math.pi / 3.0, state)
|
||
|
}
|
||
|
|
||
|
fn (params SimParams) get_magnet3_force(state SimState) Vec3D {
|
||
|
return params.get_magnet_force(4.0 * math.pi / 3.0, state)
|
||
|
}
|
||
|
|
||
|
fn (params SimParams) get_tension_force(state SimState, f_passive Vec3D) Vec3D {
|
||
|
rope_vector := params.get_rope_vector(state)
|
||
|
rope_vector_norm := rope_vector.scale(1.0 / rope_vector.norm())
|
||
|
return rope_vector_norm.scale(-1.0 * rope_vector_norm.dot(f_passive))
|
||
|
}
|
||
|
|
||
|
fn (mut state SimState) increment(delta_t f64, params SimParams) {
|
||
|
// basically just add up all forces =>
|
||
|
// get an accelleration =>
|
||
|
// add to velocity =>
|
||
|
// ensure rope constraint is satisfied
|
||
|
|
||
|
// force due to gravity
|
||
|
f_gravity := params.get_grav_force(state)
|
||
|
|
||
|
// force due to each magnet
|
||
|
f_magnet1 := params.get_magnet1_force(state)
|
||
|
|
||
|
// force due to each magnet
|
||
|
f_magnet2 := params.get_magnet2_force(state)
|
||
|
|
||
|
// force due to each magnet
|
||
|
f_magnet3 := params.get_magnet3_force(state)
|
||
|
|
||
|
// passive forces
|
||
|
f_passive := f_gravity.add(f_magnet1.add(f_magnet2.add(f_magnet3)))
|
||
|
|
||
|
// force due to tension of the rope
|
||
|
f_tension := params.get_tension_force(state, f_passive)
|
||
|
|
||
|
// sum up all the fores
|
||
|
f_sum := f_tension.add(f_passive)
|
||
|
|
||
|
// get the acceleration
|
||
|
accel := f_sum.scale(1.0 / params.bearing_mass)
|
||
|
state.accel = accel
|
||
|
|
||
|
// update the velocity
|
||
|
state.velocity = state.velocity.add(accel.scale(delta_t))
|
||
|
|
||
|
// update the position
|
||
|
state.position = state.position.add(state.velocity.scale(delta_t))
|
||
|
|
||
|
// ensure the position satisfies rope constraint
|
||
|
state.satisfy_rope_constraint(params)
|
||
|
}
|
||
|
|
||
|
fn (state SimState) done() bool {
|
||
|
return state.velocity.norm() < 0.05 && state.accel.norm() < 0.01
|
||
|
}
|
||
|
|
||
|
struct PPMWriter {
|
||
|
mut:
|
||
|
file os.File
|
||
|
}
|
||
|
|
||
|
struct ImageSettings {
|
||
|
width int
|
||
|
height int
|
||
|
}
|
||
|
|
||
|
struct Pixel {
|
||
|
r byte
|
||
|
g byte
|
||
|
b byte
|
||
|
}
|
||
|
|
||
|
fn (mut writer PPMWriter) start_for_file(fname string, settings ImageSettings) {
|
||
|
writer.file = os.create(fname) or { panic("can't create file $fname") }
|
||
|
writer.file.writeln('P6 $settings.width $settings.height 255') or {}
|
||
|
}
|
||
|
|
||
|
fn (mut writer PPMWriter) next_pixel(p Pixel) {
|
||
|
writer.file.write([p.r, p.g, p.b]) or {}
|
||
|
}
|
||
|
|
||
|
fn (mut writer PPMWriter) finish() {
|
||
|
writer.file.close()
|
||
|
}
|
||
|
|
||
|
fn sim_runner(mut state SimState, params SimParams) Pixel {
|
||
|
// do the simulation!
|
||
|
for _ in 0 .. 1000 {
|
||
|
state.increment(0.0005, params)
|
||
|
if state.done() {
|
||
|
println('done!')
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// find the closest magnet
|
||
|
m1_dist := params.get_magnet_dist(0, state)
|
||
|
m2_dist := params.get_magnet_dist(2.0 * math.pi / 3.0, state)
|
||
|
m3_dist := params.get_magnet_dist(4.0 * math.pi / 3.0, state)
|
||
|
|
||
|
if m1_dist < m2_dist && m1_dist < m3_dist {
|
||
|
return Pixel{
|
||
|
r: 255
|
||
|
g: 0
|
||
|
b: 0
|
||
|
}
|
||
|
} else if m2_dist < m1_dist && m2_dist < m3_dist {
|
||
|
return Pixel{
|
||
|
r: 0
|
||
|
g: 255
|
||
|
b: 0
|
||
|
}
|
||
|
} else {
|
||
|
return Pixel{
|
||
|
r: 0
|
||
|
g: 0
|
||
|
b: 255
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
struct SimResult {
|
||
|
id u64
|
||
|
p Pixel
|
||
|
}
|
||
|
|
||
|
struct SimRequest {
|
||
|
id u64
|
||
|
params SimParams
|
||
|
mut:
|
||
|
initial SimState
|
||
|
}
|
||
|
|
||
|
fn sim_worker(request_chan chan SimRequest, result_chan chan SimResult) {
|
||
|
// serve sim requests as they come in
|
||
|
for {
|
||
|
mut request := <-request_chan or { break }
|
||
|
|
||
|
result_chan <- SimResult{
|
||
|
id: request.id
|
||
|
p: sim_runner(mut request.initial, request.params)
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
struct ValidPixel {
|
||
|
Pixel
|
||
|
mut:
|
||
|
valid bool
|
||
|
}
|
||
|
|
||
|
fn image_worker(mut writer PPMWriter, result_chan chan SimResult, total_pixels u64) {
|
||
|
// as new pixels come in, write them to the image file
|
||
|
mut current_index := u64(0)
|
||
|
mut pixel_buf := []ValidPixel{len: int(total_pixels), init: ValidPixel{
|
||
|
valid: false
|
||
|
}}
|
||
|
for {
|
||
|
result := <-result_chan or { break }
|
||
|
pixel_buf[result.id].Pixel = result.p
|
||
|
pixel_buf[result.id].valid = true
|
||
|
|
||
|
for current_index < total_pixels && pixel_buf[current_index].valid {
|
||
|
writer.next_pixel(pixel_buf[current_index].Pixel)
|
||
|
current_index++
|
||
|
}
|
||
|
|
||
|
if current_index >= total_pixels {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fn main() {
|
||
|
params := SimParams{
|
||
|
rope_length: 0.25
|
||
|
bearing_mass: 0.03
|
||
|
magnet_spacing: 0.05
|
||
|
magnet_height: 0.03
|
||
|
magnet_strength: 10.0
|
||
|
gravity: 4.9
|
||
|
}
|
||
|
|
||
|
mut writer := PPMWriter{}
|
||
|
writer.start_for_file('test.ppm', ImageSettings{
|
||
|
width: width
|
||
|
height: height
|
||
|
})
|
||
|
defer {
|
||
|
writer.finish()
|
||
|
}
|
||
|
|
||
|
result_chan := chan SimResult{}
|
||
|
request_chan := chan SimRequest{}
|
||
|
|
||
|
// start a worker on each core
|
||
|
for _ in 0 .. parallel_workers {
|
||
|
go sim_worker(request_chan, result_chan)
|
||
|
}
|
||
|
|
||
|
go fn (request_chan chan SimRequest, params SimParams) {
|
||
|
mut index := u64(0)
|
||
|
println('')
|
||
|
for y in 0 .. height {
|
||
|
term.clear_previous_line()
|
||
|
println('Line: $y')
|
||
|
for x in 0 .. width {
|
||
|
// setup initial conditions
|
||
|
mut state := SimState{}
|
||
|
state.position = Vec3D{
|
||
|
x: 0.1 * ((f64(x) - 0.5 * f64(width - 1)) / f64(width - 1))
|
||
|
y: 0.1 * ((f64(y) - 0.5 * f64(height - 1)) / f64(height - 1))
|
||
|
z: 0.0
|
||
|
}
|
||
|
state.velocity = Vec3D{}
|
||
|
state.satisfy_rope_constraint(params)
|
||
|
request_chan <- SimRequest{
|
||
|
id: index
|
||
|
initial: state
|
||
|
params: params
|
||
|
}
|
||
|
index++
|
||
|
}
|
||
|
}
|
||
|
request_chan.close()
|
||
|
}(request_chan, params)
|
||
|
|
||
|
image_worker(mut writer, result_chan, width * height)
|
||
|
}
|