A computer model of the atom

I suppose that you would expect me to begin this page with an acceptable theory and then go on to express the mathematics with extensive proofs.

This is about the opposite of what is here. The majority of people simply will not like my theory. So, I have put it near the end of the page.

The goal of this work is to create a computer program that will allow a person to put a few high density areas into a 3D array and be able to watch as they progress into atoms, particles or photons.

The proof of this model would be to increase the start mass of a small region by a linear amount over successive runs with the result being a match of the atoms in the periodic table. A further proof would be to use one stable atom and send lower density, high velocity zones to intersect, the result being a match for the photon absorption spectrum of the atom.

Much of the proof for the lighter atoms can be done on a home desktop computer where the operating system, development system and software are available for free as downloads from the Internet.

This web page documents this software, and will evolve as the project evolves. Unfortunately, the model has not been proven yet, but the model has progressed to the point where it is awaiting a well written algorithm.

The software necessary for the proof of the model is now running well enough to support trial algorithms. The code is available here for download. It has not been modified in a long time. I do work on it occasionally, with the most major change being the increase in the available computer cores on my new desktop computer. A more professional and more widely used modeling program is available (free and open source) from www.openfoam.com

It is not necessary to agree with the theory in order to use this computer model. It will be entirely useful even if you use the same names for most of the particles.

Space – time

The computer model will necessarily be composed of many cube shaped boxes, or voxels. There will need to be enough of these, so that an image made from them will appear to have reasonably smooth 3D surfaces. The limit on the number of voxels is just the available processing power and the time a person is willing to wait for the processing to complete.

The code that can change these voxels into an image that can be displayed on your computer is available for free. The program is called slicer and was created with the capability to display medical images from 3D xray machines. The program will read many different formats. One format that has been well defined is the .nrrd format, and this is the one that we will be using.

Slicer can display slices through the 3D model and also display the shapes in a simulated 3D window.

Slicer expects to have a number in each voxel that will determine how bright that area will be when it is displayed on the screen. It is highly desirable to output a file that is compatible with the slicer program because of the time that it would require to write a custom display program. The slicer program has been perfected over a period of many years.

In order to become compatible with Slicer, we will need to have one data format for the modeling program and another for the display program. The conversion from the model data to the display format (.nrrd) will strip out all of the data accept the brightness. The Slicer program can add color later, based on the single brightness number in each voxel.

In order to figure out what should be in each voxel, we can look at Einstein's formula of E=MC2. The formula has energy, mass and some algorithm, therefor, our model will need to have a number for the amount of mass in the voxel, and a vector for the amount of motion. The motion vector will need three numbers that represent the magnitude in the x, y and z direction. While this may seem simplistic, and it is tempting to add all sorts of other things like energy, momentum, spin, charge and other UN-definable things, Einstein did not include anything else in the formula, and the formula has been well verified. The reason that motion was chosen to be the vector quantity is because the actual percent of mass that will flow from/to one voxel will depend mainly on the present motion. The actual energy is a function of the mass and the motion.

At this time, it is better to focus on what data is required in order to represent space-time in each box, rather than the formula that will define the interactions between the boxes. It is sufficient for now to just say that some algorithm will be necessary in order to progress the model from one clock tick to the next.

We have now defined the data format for one instant in time. Each voxel will have 4 floating point numbers, one for mass and three for the motion vector. The data will be held in a 3D array in memory and written to disk in one of two formats, one format will have both the mass and the motion vector and one format will have only the mass number. While both files will be stored in the .nrrd format, only the file without vectors will be readable with the Slicer program. The file with the motion vector may be read back into the modeling program at some later time.

The three custom written programs will be named as follows:

FillSpace: this program will input a text file that will define the initial conditions. The text file will contain the amount of mass in the background voxels. The text file will also contain descriptions of spheres of a certain diameter with a certain mass and motion vector. At this time, each description will be assumed to be a sphere and all voxels inside the sphere will have the same mass and motion vectors. Any spheres that overlap each other will just be overwritten, rather than added in any way.

The FillSpace program will create an array that matches these conditions and store it as a file in .nrrd format. Note: the present program does not yet actually input a text file. The diameter and mass of two zones have been written into the source code.

ClockTick: this program will input the .nrrd file and store it into array (A) in memory. The program will then manage the running of an algorithm that will output to each voxel of a second array (B) in memory. Once every voxel of the B array has been updated, one tick of the clock will have been processed. The program will then clear out array A and run the algorithm from the B array with output to the A array. After a settable number of clock ticks, the program will store the most recently updated array onto disk and keep going until the requested number of ticks have been completed. Note: this program is presently running.

SpaceToView: This program will convert a file that contains vector and mass, into a new file that only contains mass, and is compatible with the slicer program. Note: this program is presently running.

Details of the ClockTick program:

The ClockTick program will need to have two arrays in memory. One array will hold the state of space-time at the present clock tick and the other array will hold the state of space-time at the next clock tick. The algorithm will look at the numbers in the surrounding voxels of the present clock tick (only) in order to determine the values of the mass and vector for one voxel in the array for the next clock tick. No numbers in the present clock tick array will be changed. One running of the algorithm will only effect one voxel of the next clock tick array. This rule will prevent two threads from trying to update the same memory address at the same time.

This algorithm will need to be run once for each voxel that is in the array for the next clock tick. The array for the present clock tick must not be changed by the algorithm. Since each instance of the algorithm will only change it's assigned voxel in the next clock tick array, many instances of the algorithm may be run at the same time. This will speed up the processing. A part of the modeling program will need to know the number of processor cores that are available and create an appropriate number of threads. The Linux kernel will assign these threads to the available processors. This part of the modeling program will assign voxels in the next clock tick array to the algorithm threads until the algorithm has been run on every voxel in the next clock tick array.

When the algorithm has been run on every voxel in array B (while using the corresponding voxel and surrounding voxels in array A as input), the program will consider one clock tick to have been completed. The program will then clear out array A and run instances of the algorithm that will output to array A (while using the corresponding voxel and surrounding voxels in array B as input). The latest array may be stored to disk between clock ticks, and the program can be set to store an array once every N clock ticks. This way a person can let the program run overnight and review the progress of the model at any time during the run, such as the next morning.

A probe file will be written every 5 clockticks. This is a text file of the values of each voxel in +/-x with y and z equal to the middle of the array. It is really helpful to view this file in a text editor while the clocktick program is running. If the user is not happy with the progress, based on this probe file, The file “killClockTick.txt” can be deleted and the clocktick program will exit gracefully when it has completed it’s present tick.

The algorithm:

A section of the clockTick program will be well marked so that the algorithm may be easily modified. The algorithm will have two sections, one for updating array A from B, and the other section for updating array B from A. This will save on the processor cycles that would be required to write one function that would work for both cases.

A pointer to a set of variables that are specific to the thread will be passed to the algorithm. If you need to add a static variable, it should be added to the structure named threadPassVar, near the beginning of the program. An array of these structures will be created when the program starts and each thread will be passed a pointer to one element of the array. The algorithm threads will share the global arrays spaceArrayA and spaceArrayB. The sections of the algorithm will be further subdivided into sections that handle the array boundary conditions. At one boundary of the array, X when myX = 0, there will be no spaceArrayB[0][myX – 1][myY][myZ]. In this version, all boundary voxels will be equal to the background mass with a motion vector of 0,0,0, and no algorithm threads will ever be run with an output to a boundary voxel. The values of a boundary voxel will not change ever.

The data in the arrays are arranged so that the first dimension of the array is 0 through 3 where 0 is a floating point number for mass, 1 is a floating point number for motion in the X direction, 2 is motion in the Y direction and 3 is motion in the Z direction.

The simplest algorithm will need to treat the voxel as if it’s state at clockTick + 1 is only dependent on the 6 surrounding voxels. These are myX+/-1, myY+/-1 and myZ+/-1. In order to avoid vector arithmetic, only the X component of the myX-1 voxel will be used in the calculation for the part of the new voxel values that are dependent on the myX-1 voxel. While it is true that better accuracy could be obtained by factoring in the induced motion in the Y and Z directions, based on calculating the difference between the myX-1 vector and the new voxel’s vector, it is also true that this would require many more processor cycles and an excessive knowledge of vector math.

It is also true that a more accurate model would consider the new voxel to have 14 faces instead of the 6 faces of a simple cube. This would change the corners of the cube into faces, so that the voxel at arrayA[myX-1][myY-1][myZ] would be one face. With my limited budget for computing power, it is my sincere hope that this level of accuracy is not really necessary for the model to be useful.

In order to save time, I wrote a test program for the algorithm. It reads a text file that contains the information about the center and surrounding voxels. The program will run the algorithm using the data from the text file and output the result of the new voxel. The algorithm is written so that it will add the mass and calculate one component of the vector for the output voxel. This allows the same function to be called three times to do all 6 of the surrounding voxels. The same data structure that is used in the test program is used in the clockTick program so that the function with the algorithm may included in the build for clocktick without changing the names of the variables.

This version of the algorithm will ignore the other components of the vector, and only use the information from the minus X velocity when calculating the minus X voxel. This will probably need to be changed later because the velocity in the other two directions of the velocity vector would have some effect in the real world. For example, if the mass in the minus X voxel is moving in the Y direction, some of this motion should be transferred to the center voxel in the Y direction, but with this present algorithm this transfer of motion is ignored.

The code is available here for download.

The Theory

I came up with the original for this around 1980. The following text is the same as was posted on my first web page (www.rhwebco.com) in 2005. I removed it from there a couple of years ago, around 2014).

Some years ago, I found that Jean de Climont had posted a video entitled “Space” on his web page: https://www.youtube.com/watch?v=_jSLxrpwt3k

This wonderful video closely matches my own theory, accept that there is no mention of my proposed atomic model. After I saw this video, I began to look at my idea for the atom model again. In all of these years, I have not heard any real argument that states that my theory is not possible. I began to search the web for the things that I would need, just in case I were to want to attempt the creation of the model. My home gaming computer with it’s 8 cores that are 64bits wide and run at 3.5Ghz is so far beyond what I thought I would need back in the 1980s that computer power should not be an issue. The operating system that I use, Ubuntu Linux, has an available GNU C compiler (free) and there is a great development system available for free also: https://www.eclipse.org/

I also found the slicer program (mentioned above) https://www.slicer.org/

available as a free download. Even the method of programming with multiple threads so that Linux can distribute the calculations to multiple cores is built into the GNU compiler (pthread) and there are many examples of coding on the web.

In other words, I found that everything that was necessary to create the model was there for me.

What Is Gravity ?

Gravity was defined by Newton. It is the name for the acceleration between any object that has mass and all other objects that have mass.

There are a lot of names for what must be between two massive objects in order for them to attract each other. It has been called space-time, the ether, gravitational force, and other things. Some people seem to think that there is really nothing in between the objects, but then those people need to resort to a mystical forth dimensional force to explain gravity, of course, there is no real answer when you need to explain how there can be both a "mystical force" and "nothing" between the two objects at the same time.

Let's face it, there really must be something between two objects in order for one object to affect the other one. I really like Einstein's name for it the best: "space-time".

There have been many experiments done that will allow space- time to be better defined. The best one is what happens when a particle of mass is accelerated to a speed that approaches the propagation speed in the space-time. When this is done, the particle begins to take on mass.

Where does the mass come from ? according to Einstein, the energy is converted into mass. Great - now we need to define energy before we can further define space- time. Ok, let's keep it simple. Energy is what causes mass to move. That is all of the definition that is needed.  Energy can be converted into a motion or a compression of mass.

If causing a mass to move (near light speed) makes the mass become more massive, then whatever the mass is moving through must also be mass.

The particle must be made of the same stuff as what it is moving through, or you will really get lost in trying to explain it. E=MC2 pretty much says this, and I think that Einstein knew, but didn't write it down.

One single type of stuff makes up both the particle and what it is traveling through (weather the stuff is composed of particles or one substance is a good question).

Ok, now we have this stuff called space-time that looks like ordinary mass when it is compressed. The particle - wave duality is solved because, in order for a compressed zone of mass to be stable, it must be in constant motion.

Einstein's famous equation E=MC2 is satisfied for atoms because the center mass of an atom accelerates to near light speed before bouncing back on itself, thus sustaining the constant motion required to maintain a zone of space-time that is more dense than the ambient space time. Energy of motion is maintained as a stable oscillation of the mass. The propagation speed is in Einstein's formula because that determines where the bounce-back occurs (and this determines how much energy a certain amount of mass needs to maintain a stable oscillation). The sphere expands and contracts with a period of oscillation that
depends on the amount of mass in the sphere and the density of the ambient medium.

When the sphere is expanding and the rate of expansion approaches light speed, the sphere bounces back toward it's center. A shock wave, or shell is also created. This shell consists of the ambient medium that was displaced by the expanding sphere.

Shells are formed that are at different energy levels for each atom (because of the oscillation frequency and the diameter). These different densities determine what frequencies of light will be absorbed by the atom - the density of the crest of the light must be close to the density of the outer shell of the atom in order to be absorbed. Photons will be emitted when the center mass of the atom is not able to sustain the density of the outer shell. Personally, I like this allot better than trying to count electrons that you are not supposed to know the location and speed at the same time.

The atom allows something else to be added to our definition of space-time. Time can be defined as the relative motion of objects. We choose a certain type of object (a cesium atom) and count the oscillations of the atom. The problem is that the frequency of the atom depends on the ambient density of the surrounding space-time. This has been verified by experiment. If you have two atomic clocks, one on earth's surface and the other in synchronous orbit, the clocks will run at different speeds. This was put forth by Einstein. As the density of space-time increases, time slows down because the amount of energy that is required for a certain frequency of motion is greater. If more energy is required to move at the same rate and there is no extra energy applied, the rate will slow down. If a photon of a certain energy moves from a higher density to a lower density zone,  the speed of the light will increase and the wavelength will also increase. In Einstein's words "light will shift towards the red as it leaves a massive object".

So now we have enough information about the space-time to be useful. Any mass will produce a higher density in the surrounding space-time as it looses energy, and all of the density gradients will combine to produce acceleration of the objects towards each other. Particles travel through the space-time as oscillating spherical compression waves, and some types of particles travel as a motion that is a sustained high density zone (like the wake of a boat sometimes produces a hump that stays a hump as long as the speed is maintained). Matter begins as a compressed zone and anti-matter begins as a rarefied zone.

Unlike other theories, this one has no elaborate "proof", but it describes a method of constructing a computer model of a single substance by describing the properties of each voxel (small area in space) and how the voxels inter-relate. It is a premise of this theory that by modeling this single substance, all of the complex atoms and particles may be viewed by inserting a stimulus (a compressed zone of the same substance that is being modeled). As the model is allowed to progress into time, the compressed zone(s) will behave similar to real world photons, electrons, atoms and all of the other particles and "fields" that are observable within our present four dimensions.

Ronald Heath