Gravitational field on the surface of bodies of irregular shape on the example of the comet Churyumov-Gerasimenko

It is known from the law of world wideness that on the surface of spherical bodies the acceleration of free fall is constant in magnitude and is directed to the center of the ball. For bodies of irregular shape, this rule is obviously not satisfied. In this article I will show the method of calculating and visualizing the acceleration of free fall for such bodies. The calculation will be done in JavaScript, visualized - in WebGL using the library three.js .

As a result, we get the following (in red, areas with high acceleration of gravity are marked, blue - with small):




To calculate the gravitational potential of the planets, the following formula is used :



But, unfortunately, at small r, this series converges slowly, and at very small r, it generally diverges. Therefore, this formula is not suitable for calculating the gravitational potential on the surface of celestial bodies. In general, it is necessary to integrate over the entire volume of the body.
A three-dimensional body can be represented as a set of triangular faces, with given coordinates of the vertices. Further we will assume that the density of the body is constant (for a comet, this approximately corresponds to the truth). The gravitational potential at a given point will be equal to the sum of the potentials of all tetrahedra, with a base in these faces and with a vertex at a given point (we are not looking for the gravitational potential, but the gravitational acceleration, which is the potential gradient, but the reasoning remains the same).

First we need to find the acceleration that the mass of the tetrahedron produces to the point at its top. To do this, integrate over the entire volume of the tetrahedron. Unfortunately, this integral is not taken in elementary functions, so you have to go for a trick.



The force acting on a point at the top of a tetrahedron is approximately three times greater than the force caused by the gravity of a ball placed in the middle of the base of the tetrahedron (the mass of the ball is equal to the mass of the tetrahedron). That is, F ₁ ≈3 * F ₂ . This equality is better fulfilled with a small angle of the tetrahedron solution. To estimate the value of the deviation of equality from the strict one, I generated several thousand random tetrahedra and calculated this value for them.



The graph on the abscissa axis shows the ratio of the perimeter of the triangular base to the distance from the top to the center of the base. The ordinate is the magnitude of the error. As you can see, the magnitude of the error can be represented by a quadratic function. With rare exceptions, all points are below the parabola (exceptions will not spoil the weather for us).

The magnitude of the gravitational acceleration will be calculated with a given relative error. If the calculation error exceeds this error, then we divide our tetrahedron into four parts along the base and calculate the acceleration for these parts separately, then sum it up.



Acceleration we find up to a certain constant, for a given body, a coefficient depending on the mass (or density) of the body, the gravitational constant, and some other parameters. We will take this factor into account later.


We calculate the acceleration from a three-dimensional body by summing over all tetrahedra formed by the edges of the body and a given point (which I wrote earlier).


We calculate the gravitational and centrifugal accelerations on the comet (the rotation of the comet causes an acceleration of about 25% of the gravitational acceleration, therefore, it cannot be neglected). I set the relative error to 0.01. It would seem a lot, but in fact, the error is calculated three times less and the difference is not noticeable when visualizing (since the minimum difference in the color of the pixels is 1 / 256≈0.004). And if you set the error less, the calculation time increases.

With an error of 0.01, the calculation is performed for 1-2 seconds, so we make it through setInterval, in order to avoid browser hangs.


Now it's worth talking about the format of working with a 3D body. It's simple. This is an object consisting of three arrays: vertices, normals, and triangular faces.

 var obj = { vertices: [], normals: [], faces: [] }; 

A vertex array stores vertex coordinate objects. The array of normals is the vertex normal vectors. An array of faces is an array of three numbers that store vertex numbers.

I downloaded the model of comet Churyumov-Gerasimenko from the ESA website and simplified it in 3Ds Max. In the original model there were several tens of thousands of vertices and faces, but for our task this is too much, because the computational complexity of the algorithm depends on the product of the number of vertices and the number of faces. The model is saved in obj format.

In the library three.js there is an OBJLoader function for loading this format, but only the information about the vertices remains at loading, and the information about the faces is lost, which is not suitable for our task. Therefore, I modified it somewhat.


So, we loaded the object from the file, then we calculated the acceleration vector at each of its vertices, now we need to visualize it. To do this, you need to create a scene, adjust the camera and the light, add and color our model.

The scene is created simply.

 scene = new THREE.Scene(); 

There are no problems with the camera either.

 var fieldWidth = 500; //     var fieldHeight = 500; camera = new THREE.PerspectiveCamera(50, fieldWidth / fieldHeight, 0.01, 10000); scene.add(camera); cameraZ = 3 * boundingSphereRadius; // boundingSphereRadius -  ,     camera.position.x = 0; camera.position.y = 0; camera.position.z = cameraZ; camera.lookAt(new THREE.Vector3(0, 0, 0)); //      

To create a camera, we used the THREE.PerspectiveCamera function (fov, aspect, near, far), where:

fov is the height of the field of view of the camera in degrees;
aspect - the ratio of the horizontal angle of view of the camera to the vertical;
near - distance to the near plane (the one that is closer will not be rendered);
far - distance to the far plan.

We put the light.

 var ambientLight = new THREE.AmbientLight(0xffffff); scene.add(ambientLight); 

Create a visualizer.

 renderer = new THREE.WebGLRenderer({antialias: true}); renderer.setClearColor(0xffffff); //   renderer.setPixelRatio(window.devicePixelRatio); renderer.setSize(fieldWidth, fieldHeight); //    container.appendChild(renderer.domElement); //    

For working with models in three.js it is convenient to use the BufferGeometry class.

 var geometry = new THREE.BufferGeometry(); 

We set the material.

 var material = new THREE.MeshLambertMaterial( { side: THREE.FrontSide, //       vertexColors: THREE.VertexColors //        }); 

Load the vertex coordinates.

 var vertices = new Float32Array(9 * object3d.faces.length); for (var i = 0; i < object3d.faces.length; i++) { for (var j = 0; j < 3; j++) { vertices[9*i + 3*j ] = object3d.vertices[object3d.faces[i][j] - 1].x; vertices[9*i + 3*j + 1] = object3d.vertices[object3d.faces[i][j] - 1].y; vertices[9*i + 3*j + 2] = object3d.vertices[object3d.faces[i][j] - 1].z; } } geometry.addAttribute('position', new THREE.BufferAttribute(vertices, 3)); 

Calculate the color of the vertices.

 var colors = addColor(); geometry.addAttribute('color', new THREE.BufferAttribute(colors, 3)); function addColor() { var colorMin = [0.0, 0.6, 1.0]; //      var colorMax = [1.0, 0.0, 0.0]; //     var colors = new Float32Array(9 * object3d.faces.length); for (var i = 0; i < object3d.faces.length; i++) { for (var j = 0; j < 3; j++) { var intensity = (abs_force[object3d.faces[i][j] - 1] - forceMin) / (forceMax - forceMin); colors[9*i + 3*j ] = colorMin[0] + (colorMax[0] - colorMin[0]) * intensity; colors[9*i + 3*j + 1] = colorMin[1] + (colorMax[1] - colorMin[1]) * intensity; colors[9*i + 3*j + 2] = colorMin[2] + (colorMax[2] - colorMin[2]) * intensity; } } return colors; } 

We will also need to display the directions of the acceleration of free fall at each vertex.


With visualization finished. We look what happened.

Demo 1 .

As we see, the acceleration of free fall on a comet is from 40 to 80 thousand times less than on Earth. The maximum deviation of the acceleration vector from the normal is about 60-70 degrees. Small and large stones in these areas probably do not linger and slowly roll into areas where the angle is not so large.

You can play with the bodies of another form. Demo 2 .

We see that for a cube the maximum acceleration (in the center of the face) is 1.002 acceleration for a ball of the same mass, but in fact this value is slightly less than one (what we considered with a relative error of 0.01 played a role). For a cube, unlike a tetrahedron, there are exact formulas for calculating accelerations and the exact value for the center of the face is (for a cube with a side equal to 1):



For a ball of the same volume:



Their ratio is 0.999376 and only slightly less than one.

In conclusion, the question. Are there any bodies that have at least one point the ratio of the absolute value of the gravitational acceleration to the acceleration on the surface of the ball of the same mass and volume greater than one? If so, for which body is this relationship maximal? How many times is this ratio greater than one, at times or by percent?