Using computational parallelism to solve engineering problems: Structural Analysis with OpenMPI

By: Cleir Araujo Jr. <cajaraujo@gmail.com>

Statement: seeking for a new job. Please, share this article... ;-)

I'm an enthusiast of parallel programming to solve engineering problems. So, i hope that you like this brief article, because it uses a library almost always encountered on HPC environments: the OpenMPI. My intention with that, isn't explain by details the techniques, necessary infrastructure to reproduce it (the IT environment) or also, mathematics concepts used, then, the goal is to show enough to understand the hypothesis of use through a homemade parallel program. We have few lines to describe them, so...let's go ahead!

Introduction:

When a structure, such as a bridge, is submitted to different loads (weights), these forces are propagated to whole structure. So, the engineers must carefully to size each one of the elements to support a lot of internal and external factors that can cause, for example, shear (rupture) of them. The pictures below, show an example of this propagation (from the left) and a partial collapse (from the right) of huge floats in Rio de Janeiro, during carnival in 2017.

About the purely-analytical methods used for the determination of complex loads in structural elements, these, invariably, may incurs in practical limitations or in a certain kind of "observational shrewdness of engineer". For these reasons, the algebra contributes as a valuable tool to solve linear systems, and consequently, for the sizing to support structures. So, this article proposes the application of numerical/algebraic approaches to the known "method of joints", with the intention to develop a parallel program able to determine the efforts that internals elements of a 2D trusses are submitted, as well define some properties related to the material to build them.

About the library MPI/OpenMPI:

The MPI (Message Passing Interface) is a library to build programs capable to distribute tasks (process) among a large number of computers and their alone resources (basically, memory and CPUs). The main idea is make a cluster of machines (simultaneously working) to increase these capabilities and be able to run exigent programs (high loads-processing)

Below, the general scheme presents the concept used by the MPI to distribute the processes and their calculates among different hosts through a network computers. This organization method permits split the calculates to reduce the end time-processing.

"  A truss  is a structure composed of slender members joined together at their end points" (Hibbeler 2011).

In accordance with description above, as we can see just below, the pictures respectively show, some commonly used forms at the joints (from the left), a bridge made by 2D trusses (center) and a lateral view of this structure (from the right).

Even though the center picture has shown to us a 3D plan-bridge, all their loads are propagated until the lateral joints through the transverse and longitudinal beams on floor. So, the structural analysis stays restricted to the 2D-plan. Now, we can see a minimal truss with their basic elements to understand what the program will be able to do.

The emphasis of the homemade parallel program:

A significant time at this work (the sizing) is expended to determine (for each member) the type of effort (Traction or Compression) and their resultants values from applied loads. Not using a purely analytical approaches, the problem occurs when we have a biggest number of joints and consequently, a huge number of linear equations to solve.

So, we can affirm that the emphasis of the developed program was structured on two "macro-aims", respectively labeled as:

• RESMAT 1: to classify (in Traction or Compression) all efforts of the members and determine their values to support a previously-informed load;
• RESMAT 2: to size the section-area of a predefined material to build and supports this load.

I wanna be a bit more specific and clear about the functionality of the program. So, take a look on the next section to increase your perception about it.

A blocks view and the strategy used by parallel program:

The brief way to understand how the program works, is shown on the splitted figure in four steps/blocks, just below:

The "core" is: each joint/node has a linear system to be solved. So, the program uses a matrixial approach to solve them, by distribution of their matrices among some computers labeled "slaves". The results are sent to a central computer labeled as "master" that consolidates and presents the results.

Important notice 1:

Bear in mind that, not all joints can be calculated in parallel, but the program is sufficiently smart to find these cases and whenever possible, process them that's way.

About the IT resources used to run the program:

The experiments were made using a pi-based cluster. They were placed in an improvised rack and interconnected through a simple network, as you can see. The raspberries were enough and the basics examples ran without problems.

<notice>

About the .xml input-file, i realized that was extremely boring when i had that manually do an equivalence between it and a static truss to be submitted to the analysis. I did a fast research looking for some programs able to draw the trusses, similar to the encountered on functionalities of commercials CADs, like the programs made by the enterprises Ansys, Autodesk and Comsol. Also, my intent was to export the truss properties, as well, the project to a .xml file, but i didn't find anything related to.

The above explained, resulted in several limitations at capacity of do tests with different geometries, and consequently, at the variation of numbers of joints to be process by the small computers.

</notice>

Running the program:

The used example to do a test at the program, can be viewed by the following picture. The representation of this structure was described in the .xml file "warrem.xml". In this case, the emphasis consists to provide to the program two loads values at the joints 2 and joint 4, leaving the program solves the equations to find all efforts and define the diameter of material to be used to support these loads.

Important notice 2:

All printed outputs by the program are in console-text mode. Anywise, the final file (the itself warren.xml) will be updated with the necessary informations to able to that any CAD (in the future) might reveals some significant characteristics about the problem, like the generic gradient below.

Finally, we have the last screen with the outputs showing some tips to run it, as well, the master computer "pi1" that's gathering and showing the processed and sent results from the slaves computers.

Concluding...

The hypothesis to apply parallelism techniques to solve specific problems related to engineering isn't so easy to be assimilated, because it must consider a series of factors, that must be carefully studied.

Even though there we've not performed specific tests to measure the processing performance, the experiment reveals to us some interesting improvements through resources that might be add to the program in the future, such as:

• optimization algorithms like a stage of pre-processing, to previously map the potentially parallelizable joints (defining points of seeds) and define the shortest path to navigate in the structure;
•  the capacity to make replicas and simulate a large amount of different materials (to build the same structure), combining optimization methods by multi-objectives criteria’s to find the closest values of optimal solutions, naturally, including the involved prices to building it (the costs);

Coming soon, other articles combining OpenMPI and CUDA-NVidia!

Notice: seeking for a new job. Please, don't forget it and share!

Thanks and see ya!