Meshing a stranded winding

Wohoo, I made my first Youtube video this week! It visualizes the process of packing round conductors inside the slot of an electrical machine, and you can check it below.

Cool, innit? At least it looks quite relaxing, with all the honeycomb-like shapes and stuff.

But what is really going on there?

Let’s start at the beginning.

### Analysis of a Stranded Winding

Most small-to-medium sized electrical machines have a *stranded winding*. A stranded winding means that the stator (and possibly rotor) coils are made wound from thin copper wire. They are easy and economical to make, and place practically no requirement on the slot shapes or other machine dimensions whatsoever.

However, their numerical analysis is far from simple. As I mentioned, the wires – or strands – in question are indeed *thin*. That means there are often hundreds of them in each slot, resulting in thousands of extra unknowns in the model. Hence, they have traditionally been analyzed via gross oversimplifications, by simply assuming a constant uniform current density over the entire slot. Although indeed simple, this approach fully ignores several significant loss components, such as the proximity effect and circulating current losses.

Luckily, times they are slowly a-changing. Thanks to advancements of both computing power and modelling techniques (*cough*, my work, *cough*), stranded winding analysis is becoming quite feasible indeed.

### Meshing Problems

However, we still need to mesh said stranded winding before analysis. And this is far from being a trivial task.

Firstly, thousands of elements have to be generated due to the sheer number of the strands. But this task is easily handled by automatic mesh generation software. Takes some seconds at most, no biggie.

But, before they can be used, the model geometry obviously has to be described for them. The strands can be represented by simple circles of the right radius, but we still have to define the center point for each circle. Now imagine doing this by hand for a hundred or more separate strands per slot, times tens of slots. *Not gonna happen.*

So, we have to take an algorithmic approach. In other words, code our solution.

However, there are some requirements we have to consider.

- The strands obviously have to fit inside the slot. That much is obvious.
- They cannot overlap with each other either. Duh.
- Now it gets interesting:
*preferably*they shouldn’t touch each other at all. If they do, we get*cusp-nodes*in our problem, which are all kinds of un-cool. - Optimally, they should be as far from each other as possible. This improves the quality of the mesh, and makes the final numerical problem easier to solve.

Here’s how I did it.

### How to Pack’em

**1) We begin** with the slot shape that’s been provided to us. That’s illustrated below in blue. We also know our strand radius, at least tentatively.

So, we move all slot boundaries *inwards* by the strand radius. That gives us the smaller polygon drawn in red.

**2) Next**, we determine the height available for the strands. In this case, I assumed that the slot lies in the horizontal direction. But, in general we could begin with an arbitrary slot and then define its long axis.

For our simpler problem, it’s easy to define where a horizontal line intersects with our contracted red polygon. The line between those two points (illustrated in black below) will serve as a starting point for the packing process.

**3) Now**, we begin to stack the conductors in the vertical direction. For that purpose, we draw a *vertical* line going through our rightmost black *x*-point in the figure, and determine where that line intersects the red polygon.

In this example, that line obviously has a length of zero – it lies on the bottom corner of the slot after all.

So, we move *up* (i.e. left in the figure direction) by one conductor radius, and repeat the process. That yields us the vertical line shown below.

**4) Then**, we simply place as many conductors as possible on that line. In our case, that’d be three:

**5) And next**, we repeat the same process. Only this time, we do a couple of tricks.

Firstly, we move left only by times the strand radius. In other words, less than the conductor diameter. Again, we determine a similar vertical line as before, shown below.

And again, we fill place conductors on that line. Only, we have to shift this layer of conductors sideways (towards the side of the slot) by one conductor radius, to make them fit nicely in the wedges between the conductors of the first layer.

The figure below probably does a better job explaining than I ever could.

In other words, we have a hexagonal packing of the strands – all the strands are equally far from each other.

**6) And on and on we go**, until we run out of strands, or the slot gets full. This part of the process has been illustrated in the video.

### Adaptivity

In practice, there are some things to consider.

The hexagonal packing I described has quite a huge filling factor – approximately 90 % of the slot are could be covered by the strands (under optimal conditions). Of course, the gaps left between the conductor layers and the slot walls decrease the factor quite a bit, but it still remains high.

Indeed, it will be far from realistic. In actual machines with stranded windings, the filling factor typically varies between 35 and 45 percent, mostly depending on the strand size (and machine price).

To match the realistic packing density with the algorithm I described, we have to use a *virtual* strand radius in the process. Meaning something slightly higher than the true one.

How much higher, depends on the problem geometry.

### Video Explained

That’s what’s happening in the video. Well of course, the packing algorithm itself has been visualized, layer by layer.

But if you actually watch through the whole whopping 20 seconds, you see that the slot is re-packed several times. If you watch carefully, you see that the virtual strand radius changes between iterations, too.

What happens under the hood is a simple bisection search. The algorithm adjusts the virtual strand radius based on two criteria:

**a)** All the strands should fit in the slot.

**b)** The slot should be as full as possible – meaning the strands extend as close to the slot opening on the left as possible.

In the end, it produces a very nice packing, that we can use in simulations later on.

Which is exactly what I’m working on right now.

Until next time!

-Antti

*Need help with electric motor design or design software? Let's get in touch - satisfaction guaranteed!*