From PESWiki

You are here: PES Network (http://pureenergysystems.com) > PESWiki > Directory > PaulL > Computer Simulation

---

Status 

This project was commenced publicly on Feb. 28th 2005.

THIS PAGE IS LOCKED FROM EDITING. If you have a change to recommend, then please send me an email at Energy_Mover-owner@yahoogroups.co*m (remove the star). If you are doing research in this field then please add to the Research and Development Questions web page.

This page is a continuation from Synopsize

COMPUTER SIMULATION:

Presently I am writing the final version of the magnetic field simulation software. Earlier version had severe limitations and I was pushing them to upper limits in my search for a real and viable solid-state free energy design. I discovered a few designs but due to limitations, I could not ascertain just how much I needed to saturate the magnetic materials. Additionally, due to the fact that I was pushing the software beyond limits, I could not verify if the software was entirely correct at such saturation extremes. I could build the machine but before spending a lot of time and money on expensive magnetic materials, I need to know what's going on. I guess it's just my very nature. I'm not one for guessing games. Also, I very much dislike building. For me, going from the world of thought to physical things is like diving into a sea of thick slim. The current version of the program is almost complete and if successful, it is a program I would be more than happy to freely distribute.

STARTING YOU OWN RESEACH:

Please by all means, I welcome anyone into this research. Nothing would make me happier than if somebody who's a builder would enter this research and build a free energy machine. If you can write computer code, then below are some initial high performance math equations in the form of VC++ that will aid you.

The following code computes the magnetic field at any 3D space point [x,y,z] from an infitesimally small loop current. You will need this for every magnetic particle segment. For example, if a magnetic particle has a field strength of 0.001 and its magnetic field is pointing in a certain direction, and you need to know the magnetic strength and the direction that the magnetic field will point at a certain [x,y,z] point, then you would use this code. You can add a k-factor if you wish to calibrate the software to real world values. Although you won't really need to since free energy results in a positive value. You will need this code. I've included the major section of the loop. This section is complete, but the part that feeds current to the wires and some other parts are not finished yet. Below you'll see create_ferrites function, which for now has hard coded values just to test the program. Also there's a dummy loop, which will be replaced with appropriate "for" loop. It may not seem like miles of code, but its highly compressed code for what it does. I spent a great deal of time on the mathematical part to achieve high-speed simulations. Initial simulations consisted of straight forward coding, rotating this and that etc.. That was very slow but easy to understand. The following is fast but the math is compressed and difficult to follow despite the large amounts of comments. Please feel free to send me an email if you have questions. Enjoy!

Source Code 

The following code computes the magnetic field at any 3D space point [x,y,z] from an infitesimally small loop current.

// Arrays
// x, y, z coordinates of ferrites
long double f_x[Total_ferrites], f_y[Total_ferrites], f_z[Total_ferrites];
// x,y,z B field slope of the ferrites.  This is the direction the field is pointing
long double bs_x[Total_ferrites], bs_y[Total_ferrites], bs_z[Total_ferrites];
// working temp buffer that holds x,y,z B field strengths of ferrites
long double b_x_temp[Total_ferrites], b_y_temp[Total_ferrites], b_z_temp[Total_ferrites];
// B field strength of ferrites
long double bf[Total_ferrites];


create_ferrites();

loop:

for(i1 = 0; i1 < Total_ferrites; i1++) {
   b_x_temp[i1] = b_y_temp[i1] = b_z_temp[i1] = 0.0;
}

for(i1 = 0; i1 < Total_ferrites; i1++)

{
   b_f = bf[i1];
   if(b_f == 0.0) {
      continue;
   }

   for(i2 = 0; i2 < Total_ferrites; i2++)
   {
      if(i1 == i2) {
         continue;
      }

      // Get closet distance from a point to a line
      // [xp,yp,zp] = point
      // [x1,y1,z1] = location of ferrite piece
      // [x2,y2,z2] = point that extends out from ferrite piece to represent it's magnetic field direction
      // Note that the line from [[x1,y1,z1] to [x2,y2,z2]] and [[x2,y2,z2] to [xp,yp,zp]] are at right angles on the plane that exists on the three points -> [x1,y1,z1] & [x2,y2,z2] & [xp,yp,zp]
      // xs & ys & zs = slop of magnetic field that extends from [x1,y1,z1] to [x2,y2,z2]
      // The following was used to calculate equation from xmaxima:
      // string( diff(sqrt((x1+k*xs-xp)^2 + (y1+k*ys-yp)^2 + (z1+k*zs-zp)^2), k) );
      // string(solve((2*zs*(k*zs-zp+z1)+2*ys*(k*ys-yp+Y1)+2*xs*(k*xs-xp+x1))/(2*SQRT((k*zs-zp+z1)^2+(k*ys-yp+Y1)^2+(k*xs-xp+x1)^2)) = 0, k));
      // and returned:
      // k = ((zp-z1)*zs+(yp-y1)*ys+(xp-x1)*xs)/(zs^2+ys^2+xs^2)
      // k = factor value used for the diff function to move magnetic field line by point [xp,yp,zp] so diff can find closest distance.
      xp = f_x[i2]; yp = f_y[i2]; zp = f_z[i2];
      x1 = f_x[i1]; y1 = f_y[i1]; z1 = f_z[i1];
      xs = bs_x[i1]; ys = bs_y[i1]; zs = bs_z[i1];
      k =  ( (zp-z1)*zs + (yp-y1)*ys + (xp-x1)*xs ) / (zs*zs + ys*ys + xs*xs);
      // [x2,y2,z2] is closest point from magnetic line to [xp,yp,zp]
      x2 =  x1 + xs*k;
      y2 =  y1 + ys*k;
      z2 =  z1 + zs*k;
      // y = distance from [xp,yp,zp] to [x2,y2,z2]
      y = powl( powl(xp-x2, 2.0) + powl(yp-y2, 2.0) + powl(zp-z2, 2.0), 0.5 );
      // x = distance from [x1,y1,z1] to [x2,y2,z2]
      x = powl( powl(x1-x2, 2.0) + powl(y1-y2, 2.0) + powl(z1-z2, 2.0), 0.5 );
      // r = distance from [x1,y1,z1] to [xp,yp,zp]
      r = powl(y*y + x*x, 0.5);

      // Get magnetic field vetors for a flat x/y plane
      // verified with http://www.netdenizen.com/emagnet/offaxis/iloopcalculator.htm
      // below line is simplified of -> b_amp = powl(x*x*4.0 + y*y, 0.5) / r / r^3; // r^3 is for distance
      b_amp = b_f * powl(x*x*4.0 + y*y, 0.5) / powl(r, 4.0);
      b_angle = atan(y / x / 1.4142135623730950488016887242097) * 2.0;
      b_x = cos(b_angle);
      b_y = sin(b_angle);

      // Get magnetic field vectors at the actual [xp,yp,zp] point, rotated correctly.
      // note that the line from [[x1,y1,z1] to [x2,y2,z2]] and [[x2,y2,z2] to [xp,yp,zp]] are at right angles on the plane that exists on the three points -> [x1,y1,z1] & [x2,y2,z2] & [xp,yp,zp]
      // move according to magnetic line slop [xs,ys,zs]
      b_x_new = b_x * xs;
      b_y_new = b_x * ys;
      b_z_new = b_x * zs;
      // move according to slop from distance at [xp,yp,zp] to [x2,y2,z2].
      if(y != 0.0) {
         b_x_new += b_y * (xp - x2) / y;
         b_y_new += b_y * (yp - y2) / y;
         b_z_new += b_y * (zp - z2) / y;
      }
      // factor in amplitude
      b_x_new *= b_amp;
      b_y_new *= b_amp;
      b_z_new *= b_amp;

      b_x_temp[i2] += b_x_new;
      b_y_temp[i2] += b_y_new;
      b_z_temp[i2] += b_z_new;
   }
}



// Set applied fields
for(i1 = 0; i1 < Total_ferrites; i1++) {
   r = powl( powl(b_x_temp[i1], 2.0) + powl(b_y_temp[i1], 2.0) + powl(b_z_temp[i1], 2.0), 0.5 );
   bf[i1] = Perm * r;
   if(r != 0) {
      bs_x[i1] = b_x_temp[i1] / r;
      bs_y[i1] = b_y_temp[i1] / r;
      bs_z[i1] = b_z_temp[i1] / r;
   }
}


wire_update();

goto loop;



void create_ferrites()
{
   // Initialize the locations and strengths of the ferrite materials.
   long x;

   for(x = 0; x < Total_ferrites; x++) {
      // set coordinates
      f_x[x] = x;
      f_y[x] = f_z[x] = 0.0;
      // set magnetic field slopes. Note, the radius sqrt(bs_x[x]^2 + bs_y[x]^2 + bs_z[x]^2) must equal 1.0
      bs_x[x] = 1.0;
      bs_y[x] = 0.0;
      bs_z[x] = 0.0;
   }
   bf[0] = 1.0;
}

Contact

Paul Lowrance <Energy_Mover-owner@yahoogroups.co*m>