|
Foamy Ether - A Framework for a Theory Of Everything Conceived and written by
Peter C.M. Hahn
C.E.T. |
//////////////////////////////////////////////////
// GravitationalWaveEllipse3Lasers.thd
// Particle in an elliptical orbit generating g wave.
//////////////////////////////////////////////////
// set background color
scene.backColor=RGB(42, 42, 42);
// turn gravity off
scene.gravity={0,0,0};
// remove shadows for faster rendering
scene.shadow = false;
// use degrees as metric for angles
factory.useDegrees = true;
// turn collision detection off so things don't blow up
factory.detectCollision = false;
// set colors
var green = RGB(0, 255, 0);
var white = RGB(255, 255, 255);
var red = RGB(255, 0, 0);
var yellow = RGB(255, 255, 0);
var blue = RGB(0, 255, 255);
// choose some default material
//Material (density, springConstant, dampingConstant,
staticFriction, dynamicFriction, thresholdVelocity);
var mat = Material(1e-8, .0001,
.00001, 1, 1);
factory.material = mat ;
// set spring and damper constants
var spngCnst = 1e-8;
var dmpCnst = 5e-8;
// set dimensions of array
var width = 31; // enter odd number of balls for
array width 21
var depth = 61; // enter odd number of balls for
array depth 51
var spacing = 10; // enter spacing between balls
var lineIncr = 8; // enter even number increment
for line coloring
var ball = "";
var xLong = spacing*2;
var xShort = spacing;
var xOffset = spacing/2;
var zOffset = cos(30)*spacing;
// position camera in middle of array
// consider camera to be hovering over array looking
down on x z plane
scene.camera = {spacing*width*1.9,
-spacing*width*1.1, spacing*depth*0.4}; //1.1
// point camera down at middle of array
scene.lookAt = {spacing*width*1.9, 0,
spacing*depth*0.4};
// build array of spheres
var z = 0;
var place = 0;
var s = array();
for (z=0; z < depth; z++) {
s.append(array());
for
(var x=0; x < width; x++) {
if
(z%2 == 1){
ball = Sphere(1, {place,0,z*zOffset});
ball.visible = false;
s[z].append(ball);
place += xLong;
ball = Sphere(1, {place,0,z*zOffset});
ball.visible = false;
s[z].append(ball);
place += xShort;
}else{
ball = Sphere(1,
{place+xOffset,0,z*zOffset});
ball.visible = false;
s[z].append(ball);
place += xShort;
ball = Sphere(1,
{place+xOffset,0,z*zOffset});
ball.visible = false;
s[z].append(ball);
place += xLong;
}
}
place = 0;
}
// build array of springs and dampers attaching to
balls on x axis
//build x springs on odd rows
var spx = array();
var dpx = array();
var dmpr = "";
var sprng = "";
var i = 0;
for (z=0; z < depth; z+=2) {
spx.append(array());
dpx.append(array());
for
(var x=0; x < width*2-1; x+=2) {
// make spring and attach to adjacent spheres
sprng = Spring(s[z][x],{0,0,0},s[z][x+1],{0,0,0});
sprng.springConstant
= spngCnst;
spx[i].append(sprng);
// make damper and attach to adjacent spheres
dmpr = Damper(s[z][x],{0,0,0},s[z][x+1],{0,0,0});
dmpr.damperConstant = dmpCnst;
dmpr.color = white;
dpx[i].append(dmpr);
}
i++;
}
//build x springs on even rows
var spx2 = array();
var dpx2 = array();
i = 0;
for (z=1; z < depth; z+=2) {
spx2.append(array());
dpx2.append(array());
for
(var x=1; x < width*2-1; x+=2) {
// make spring and attach to adjacent spheres
sprng = Spring(s[z][x],{0,0,0},s[z][x+1],{0,0,0});
sprng.color = white;
sprng.springConstant = spngCnst;
spx2[i].append(sprng);
// make damper and attach to adjacent spheres
dmpr = Damper(s[z][x],{0,0,0},s[z][x+1],{0,0,0});
dmpr.damperConstant = dmpCnst;
dmpr.color = white;
dpx2[i].append(dmpr);
}
i++;
}
//build z springs
var spz = array();
var dpz = array();
i = 0;
for (z=0; z < depth-1; z++) {
spz.append(array());
dpz.append(array());
for
(var x=0; x < width*2; x++) {
// make spring and attach to adjacent spheres
sprng = Spring(s[z][x],{0,0,0},s[z+1][x],{0,0,0});
sprng.springConstant = spngCnst;
sprng.color = white;
spz[i].append(sprng);
// make damper and attach to adjacent spheres
dmpr = Damper(s[z][x],{0,0,0},s[z+1][x],{0,0,0});
dmpr.damperConstant = dmpCnst;
dmpr.color = white;
dpz[i].append(dmpr);
}
i++;
}
//make outer balls stationary
//top
for (i=0; i < width*2; i++) {
s[0][i].static = true;
}
//bottom
for (i=0; i < width*2; i++) {
s[depth-1][i].static
= true;
}
//left
for (i=0; i < depth; i++) {
s[i][0].static = true;
}
//right
for (i=0; i < depth; i++) {
s[i][width*2-1].static
= true;
}
//make every lineIncr ball and damper green: verticle
for (var x=0; x < width*2; x+=lineIncr)
{
for
(z=0; z < depth-1; z++) {
dpz[z][x].color
= green;
s[z][x].color
= green;
dpz[z][x+1].color
= green;
s[z+1][x+1].color
= green;
}
}
//make every lineIncr damper green: horizontal
for (z=0; z < depth/2; z+=lineIncr/2) {
for
(x=0; x < width; x++) {
dpx[z][x].color
= green;
dpx[z+1][x].color
= green;
}
for
(x=0; x < width-1; x++) {
dpx2[z][x].color
= green;
}
}
//make green to attach to horizontal line
for (x=0; x < width*2; x++) {
for
(z=0; z < depth-1; z+=lineIncr) {
dpz[z][x].color
= green;
dpz[z+1][x].color
= green;
}
}
// color balls for horizontal line
for (z=0; z < depth-1; z+=lineIncr) {
for
(x=0; x < width*2; x++) {
s[z][x].color
= green;
s[z+1][x].color
= green;
s[z+2][x].color
= green;
//WaitFrame();
}
}
//make red line
for (x=0; x < width; x++) {
dpx[depth/4][x].color
= red;
dpx[depth/4+1][x].color
= red;
}
for (x=0; x < width-1; x++) {
dpx2[depth/4][x].color
= red;
}
for (x=0; x < width*2; x++) {
dpz[depth/2-1][x].color
= red;
dpz[depth/2][x].color
= red;
}
// make particle in middle of array
var imp = 0.95; // enter implode ratio
var rad = 5; // enter radius of particle (by
number of spacings). (i.e. 2.2)
var lowerX = ceil(width - rad-1); //
calc lower limit of array index
var upperX = ceil(width + rad); //
calc upper limit of array index
var lowerZ = ceil(width - rad+3); //
calc lower limit of array index
var upperZ = ceil(width + rad+5); //
calc upper limit of array index
var center = {width*spacing*1.5-xOffset,0,depth*zOffset/2-zOffset/2}; //
calc center location of array
var centerX = width*spacing*1.5-xOffset;
var centerZ = depth*zOffset/2-zOffset/2;
var particle = array();
var counter = 0;
for (x=lowerX; x<upperX; x++) {
particle.append(array());
for (var
z=lowerZ; z<upperZ; z++) {
if(
norm(s[z][x].position-center)
<= rad*spacing ){ // only move if balls are within
radius (round off corners)
print("Row: ", counter, " x=", x, " z=", z, " . ", s[z][x].position,
" . ", norm(s[z][x].position-center),
" : ", newline);
//print((centerX-x*spacing*1.5)*imp, " . ", (centerZ-z*zOffset)*imp,newline);
s[z][x].visible = true;
s[z][x].color = red;
s[z][x].move( (centerX-x*spacing*1.5)*imp,
0, (centerZ-z*zOffset)*imp*0.97 );
s[z][x].static = true;
//store particle in array
particle[0].append(x);
particle[1].append(z);
counter++;
}
}//z
}//x
//Print the array:
print(particle.count(),newline);
for (i=0; i < particle.count()*2;
i++) {
print("Row
"+i+":");
print("x=",
particle[0][i], "
");
print("z=",
particle[1][i]);
print(newline);
}
print("---------------------------");
// simulate scene
simulator.stepsize = .1;
while (simulator.time
< 100) {
simulator.run(1);
//WaitFrame();
}
//reduce damper value except along outer border
dmpCnst = 1e-8;
for (x=2; x < width*2-2; x++) {
for
(z=2; z < depth-3; z++) {
dpz[z][x].damperConstant
= dmpCnst;
}
}
for (z=2; z < depth/2-1; z++) {
for
(x=1; x < width-1; x++) {
dpx[z][x].damperConstant
= dmpCnst;
}
}
for (z=1; z < depth/2-1; z++) {
for
(x=0; x < width-1; x++) {
dpx2[z][x].damperConstant
= dmpCnst;
}
}
//trace movement of a node
var tr1 = Trace(s[25][47], {0,0,0},
255);
tr1.color = RGB(0,
255, 255);
s[25][47].color = RGB(0,
255, 255);
s[25][47].visible = true;
//add gw detector
// make lasers
var texLaser = Texture("laser2j.jpg");
var laserLeft = Box({40,1,15},{650,1,300});
laserLeft.useTexture(texLaser);
laserLeft.rotate(0,30,0);
var laserRight = Box({40,1,15},{800,1,300});
laserRight.useTexture(texLaser);
laserRight.rotate(0,-30,0);
var laserTop = Box({40,1,15},{725,1,200});
laserTop.useTexture(texLaser);
laserTop.rotate(0,90,0);
// simulate scene
WaitFrame();
simulator.stepsize = .1;
//move particle in elliptical orbit
for (var m=0; m <= 360; m+=20)
{
simulator.resetTime();
for
(i=0; i < counter; i++) {
s[particle[1][i]][particle[0][i]].move(-25*sin(m),0,10*cos(m));
}
while
(simulator.time
< 5) {
simulator.run(2);
WaitFrame();
}
print(m, ": ",
20*cos(m), " : ", s[particle[1][0]][particle[0][0]].position,
newline);
}
simulator.resetTime();
while (simulator.time
< 100) {
simulator.run(2);
WaitFrame();
}
//pause for one second
for (var p=0; p<15; p++) {
WaitFrame();
};
|
Peter C.M. Hahn C.E.T. |
|