DEV Community: fakelaboratory

Physics: boiling water

fakelaboratory — Tue, 23 Jan 2024 16:33:39 +0000

Idea

This simulation about thermodynamics. Basic boiling of water, I was interested in bubbles, how they "born" and then moves to the surface. A simple heating element and water:

In result I have the Jupyter/Colab notebook and the animation:

And sure the code, because it made by moderngl, library for python.

I was mistaken, in first, by pressure... I thought Archimedes force in bubbles versus pressure(ye I only study physics). But it is was start and I wrote this algorithm:

Algorithm, transformation cycle of molecule(group):

if molecule temperature > 100,then check neighbors, if near exist gas then connect, else randomly can transform to gas(change state and remove from the common array). if connected to someone - register the new transformation group and try to reorginize to a big cube shape

check registered groups the archimed force(1), if the archimed force more than pressure(!my error) of water then this group now in the transportation state(moving up)

check groups which in the transportation state: if not on the surface then move up, else(on surface) check can be free or not(2). can be free if pressure inside the group more than surface tension force. if near other groups - connect(merge)

Algorithm for all molecules(water):
1.Fill holes(shift down if bottom now the gas and not in the common array)
2.Try to make the water surface flat

But I dropped the part when count surface tension on surface.
In this algorithm I found an interesting "philosophical" interpretation - bubbles trying to connect to each other after transformation to gas on the bottom, and then together going up to the surface... Also interesting is constants about size and mass of molecules - because with some parameters it works but with some not, but sure they still near to which I found in tables and the internet.

Code

Possible to split for four parts:

Import libraries

!pip install moderngl
!pip install pyrr
!pip install moviepy
import moderngl as gl
import numpy as np
import random
import pyrr as pyrr
from PIL import Image
import moviepy.editor as mpy
from google.colab import files

ModernGL library for GL, pyrr for matrix transformations, moviepy and PIL - for animation creating. Also in the full code you can see creating context in this part, because if something failed then context will not creates.

Shader and vertices

ctx.enable(gl.BLEND)
prog = ctx.program(
    vertex_shader="""
        #version 330
        in vec4 in_vert;
        void main() {
            gl_Position = in_vert;
        }
    """,
    fragment_shader="""
        #version 330
        uniform vec4 u_color;
        out vec4 f_color;
        void main() {
            f_color = u_color;
        }
    """,
)
vertices = np.asarray([
    [-0.5 , -0.5 , -0.5, 1.0] ,
    [ 0.5 , -0.5 , -0.5, 1.0] ,
    [ 0.5 ,  0.5 , -0.5, 1.0] ,
    [ 0.5 ,  0.5 , -0.5, 1.0] ,
    [-0.5 ,  0.5 , -0.5, 1.0] ,
    [-0.5 , -0.5 , -0.5, 1.0] ,

    [-0.5 , -0.5 ,  0.5, 1.0] ,
    [ 0.5 , -0.5 ,  0.5, 1.0] ,
    [ 0.5 ,  0.5 ,  0.5, 1.0] ,
    [ 0.5 ,  0.5 ,  0.5, 1.0] ,
    [-0.5 ,  0.5 ,  0.5, 1.0] ,
    [-0.5 , -0.5 ,  0.5, 1.0] ,

    [-0.5 ,  0.5 ,  0.5, 1.0] ,
    [-0.5 ,  0.5 , -0.5, 1.0] ,
    [-0.5 , -0.5 , -0.5, 1.0] ,
    [-0.5 , -0.5 , -0.5, 1.0] ,
    [-0.5 , -0.5 ,  0.5, 1.0] ,
    [-0.5 ,  0.5 ,  0.5, 1.0] ,

    [ 0.5 ,  0.5 ,  0.5, 1.0] ,
    [ 0.5 ,  0.5 , -0.5, 1.0] ,
    [ 0.5 , -0.5 , -0.5, 1.0] ,
    [ 0.5 , -0.5 , -0.5, 1.0] ,
    [ 0.5 , -0.5 ,  0.5, 1.0] ,
    [ 0.5 ,  0.5 ,  0.5, 1.0] ,

    [-0.5 , -0.5 , -0.5, 1.0] ,
    [ 0.5 , -0.5 , -0.5, 1.0] ,
    [ 0.5 , -0.5 ,  0.5, 1.0] ,
    [ 0.5 , -0.5 ,  0.5, 1.0] ,
    [-0.5 , -0.5 ,  0.5, 1.0] ,
    [-0.5 , -0.5 , -0.5, 1.0] ,

    [-0.5 ,  0.5 , -0.5, 1.0] ,
    [ 0.5 ,  0.5 , -0.5, 1.0] ,
    [ 0.5 ,  0.5 ,  0.5, 1.0] ,
    [ 0.5 ,  0.5 ,  0.5, 1.0] ,
    [-0.5 ,  0.5 ,  0.5, 1.0] ,
    [-0.5 ,  0.5 , -0.5, 1.0]
],dtype='f4')

Here basic shader, with the uniform color and vertices for cube. All elements in simulation is cube, and this is the original cube. Also:

def transform(v,type,args):
  if(type=="rotation"):
    mat = pyrr.matrix44.create_from_axis_rotation([args[0],args[1],args[2]],args[3])
  if(type=="scale"):
    mat = pyrr.matrix44.create_from_scale([args[0],args[1],args[2]])
  if(type=="translation"):
    mat = pyrr.matrix44.create_from_translation([args[0],args[1],args[2]])
  for i in range(len(v)):
    v[i]= pyrr.matrix44.apply_to_vector(mat, v[i])

It is basic transformation, they are used while all code.

Main logic

This is most complex part, but in general two classes: Molecule and Water. Molecule is basic "object" with position, size, and state. State 0 it is water, the state 1 is gas. It is needed in render and in logic.

Water contains all molecules and also group_transform, group_transport. When molecules change own state and connected with neighbors gas molecules - they are group.

#in general if both molecules not in groups, create group
#if first in group but second not then connect second
#if in different groups, merge groups and delete second group
#with adding element to group_transform arrays, with id's of groups

Also function reorganize, which contain physics calcs and logic with moving from group to group, moving in group. When group in transportation phase, then it is big molecule, and acceleration is force/mass.

Render

Here just render by creating VAO,VBO for molecules, few colors. And in each frame calling the reorganize function. Also after render - export to GIF.

End

When I tried to count 100000 molecules, RAM(13gb) was crashed. What I think about it? I still code without optimization with idea to be scalable, for more RAM and for more logic, because for more interesting interactions will need a data about each molecules. I mean first what in the head: it is not render all molecules, but only which really need, create illusion, but it is not what I trying to achieve.
Achieved idea of recursive process, in all scales of the water object the logic will works. Maybe needed to add more layers for the transformation layer, then will heats not only one level of molecules, but millimeter of molecules for example. It'll give big bubbles, because now it in molecular level.
Big bubbles is big groups.

Modern GL + Google Colab = triangle animation

fakelaboratory — Mon, 18 Dec 2023 16:54:50 +0000

Rendered not in my PC image:

*i mean not this gif here in your browser but in colab cloud?

Link to colab:
https://colab.research.google.com/drive/10Ig1Nqbwqd1lF7HAF0rJuxpZpThgjHcB?usp=sharing

This notebook restored from old(2018) google notebook, with some changes in code. Links to references in comments of the notebook.

!pip install moderngl
!pip install moviepy
import moderngl as gl
import numpy as np
from PIL import Image
import moviepy.editor as mpy

ctx = gl.create_context(standalone=True, backend='egl')
print(ctx.info)

prog = ctx.program(
    vertex_shader="""
        #version 330
        in vec2 in_vert;
        in vec3 in_color;
        out vec3 v_color;
        void main() {
            v_color = in_color;
            gl_Position = vec4(in_vert, 0.0, 1.0);
        }
    """,
    fragment_shader="""
        #version 330
        in vec3 v_color;
        out vec3 f_color;
        void main() {
            f_color = v_color;
        }
    """,
)

vertices = np.asarray([

    -0.75, -0.75,  1, 0, 0,
    0.75, -0.75,  0, 1, 0,
    0.0, 0.649,  0, 0, 1

], dtype='f4')

def render_frame(time):
  vbo = ctx.buffer(vertices.tobytes())
  vao = ctx.vertex_array(prog, vbo, "in_vert", "in_color")

  fbo = ctx.framebuffer(
    color_attachments=[ctx.texture((512, 512), 3)]
  )
  fbo.use()
  fbo.clear(0.0+time, 0.0+time, 0.0+time, 1.0)
  vao.render()

  return np.array(Image.frombytes(
    "RGB", fbo.size, fbo.color_attachments[0].read(),
    "raw", "RGB", 0, -1
  ))

clip = mpy.VideoClip(render_frame, duration=2) # 2 seconds
clip.write_gif("anim.gif",fps=15)
#now in files anim.gif

May the new year bless you with health, wealth, and happiness.
from "65 Happy New Year Wishes for Friends and Family 2024" countryliving article

Physics: Momentum

fakelaboratory — Thu, 14 Dec 2023 14:39:48 +0000

In this experiment - the simple collision. With transferring momentum from one object to another. I split the application of momentum to the block object(see next picture) for two parts: the rotating part and the general motion part

*by coefficients of collision's point to radius

Calcs of momentum transferring, is general, thanks to:

I tried to solve it in my way, looks similar to these calcs...

Not only similar, but the same, same in Khan, same In Wolfram, same by hands, same by tables, same by code, three tests passed

Code
Just a cube directed to the wide block, possible to set masses and move the cube(left/right)

Link to play around:
https://fakelaboratory.github.io/publish/Momentum/
Source:
https://github.com/fakelaboratory/publish/tree/main/Momentum

In general same code like in the last experiment with Newton's laws, because it is a same framework, I mean masses, friction and speed(acceleration), move and rotate points. If interested in - please read the code, for notes 'll be usefull in the last article something(https://dev.to/fakelaboratory/newtons-laws-of-motion-232p)

Physics: Newton's Laws of motion

fakelaboratory — Mon, 27 Nov 2023 13:53:10 +0000

Physics

Force of gravity = mass * gravity acceleration
Force of slide = force(gravity)*cos(plane angle)
Force of friction(opposite to slide) = friction coefficient *force(gravity) * sin(plane angle)

Additional force(custom push) from top of view:

//horizontal application(from top of view) of setted in ui the force
cube.force_x = force.magnitude*Math.cos(Math.PI*force.angle/180+Math.PI)*-1;
cube.force_result = cube.force_slide + cube.force_friction + cube.force_x; 
cube.acceleration_x = cube.force_result/ cube.mass; // from F = m*a
cube.init_velocity_x = 0; // set start point

//vertical(from top of view) application of setted in ui the force
cube.force_y = force.magnitude*Math.sin(Math.PI*force.angle/180);
cube.acceleration_y = cube.force_y/ cube.mass; // from F = m*a
cube.init_velocity_y = 0; // set start point

Start the simuluation by moving with the initial speed equal to zero, then with Δd=V(init)*time + (1/2)*acceleration*time^2 move points to delta and increase the init speed through acceleration.
The time is frame iteration, 1000/24, for example.

Code

Idea:

Sketch of UI:

Real screenshot:

Structure:

objects_render is for buffers, program, shaders of WebGL
glmjs are helping files, glmjs library(matrix operations) and helper file, where code for rotate object, move by glmjs.
objects_logic files of plane, cube, time, force...

plane {
   vertices; //array positions, colors
   angle; //degree
   inclane(angle) {
      //inclane plane and cube
      cube.inclane()
   } 
}
cube {
   vertices;
   mass; //kg
   build_physics(); //calculate forces and accelerations 
   inclane(); //also
}
force {
   vertices; //vizualiation, blue line
   angle; //degree
   magnitude; //newton
   inclane();
}  
time {
   //some coefficients and iter of time
}

for example plane object:

As possible to see in the screenshot this simulation is using additional arrays for vertices, in example of the plane it is just a "backup" of original vertices, but for the cube: more easy just move cube in x,y(top of view),store this position and render it in another array with x,y + inclane...

Tried to test with real physics(I mean in the room with paper and matches) looks the similar. Also I added acceleration coefficient for "slow motion" because all happening so fast. But it is my philosophy interpretations...

Code here:
https://github.com/fakelaboratory/publish/tree/main/Newton's%20laws%20of%20motion
Test through browser:
https://fakelaboratory.github.io/publish/Newton's laws of motion/