Non-throughput-limited 8+ belt balancers?

[ribsngibs]

If you math out the desired division of the input, you see that after the first splitter its:
1/2 1/2 1
After the second:
1/2 3/2 (!) 0

...

I admit I haven't done a careful proof yet, but I did actually consider the idea of splitting the lanes into more lanes, and the problem inevitably shows right back up when you try to recombine the lanes (you'll end up with two belts needing to combine to one but they have >1 belt's worth of combined throughput between them)

Hi - I'm a bit behind on this thread but I disagree with this analysis. The bottleneck only should only (theoretically) happen when there are intermediate belts along the way that want to have >1 belt throughput. If you put 2 full belts into your forbidden triangle, you indeed get 1/2 1/2 1, then 1/2 3/2(!) 0, then a failure to get to 1 1. However, if you put 2 belts at half capacity (1/2 1/2), instead you get 1/4 1/4 1/2, then 1/4 3/4 0, then 1/2 1/2, non of which is a bottleneck. If you do this side by side and then recombine the inputs, a splitter will have no problem taking a 1/2 and 1/2 and merging it into 1 full belt.

Indeed:

dubthreesplit.gif (5.46 MiB) Viewed 13952 times

Similarly, splitting each input into 2 and sending one set of 8 to one 8 balancer and the other set to another 8 balancer, and then interleaving and recombining the outputs (output 1a and 1b > output 1, 2a and 2b > output 2). This shows that example (with only the first 4 belts hooked up because too lazy:

dubeightsplitfull.gif (12.63 MiB) Viewed 13952 times

And I agree with the others that simply placing two 8 balancers in series would work, as there is only a bottleneck in going from, say 4 inputs to 4 outputs, but not from 4 to 8, and not from going from 8 to 4*:

serieseight.gif (15.62 MiB) Viewed 13952 times

*- I did, actually, see some total throughput fails like the kind you saw. I believe sckuzzle is basically right - a splitter on a compressed belt will stabilize in putting all of one lane's items on one belt and all of the other lane's items on another belt, and sometimes a complicated series of belts can result in another pattern of 1/2 compressed but alternating items. Actually, in the image just above (the two 8 balancers in series image),if you look at the 4 belt segments just to the left of the player character, you can see those patterns - it starts with the 2 left belts with single lane items while the 2 right lanes have the alternating pattern, and then the 2 right ones somehow get "fixed" to the 2 single lane pattern.

The total throughput failures, I believe, are caused by the little hitches in the lane patterns (from left lane to right lane, or from left lane to alternating). If one were to split a single belt into two lanes, the two lanes will have perfectly complementary patterns (if the left belt has an alternating pattern, the right belt will have the exact opposite alternating pattern which will zipper right back with the left if combined again - if the left belt has items only on the left lane, then the right belt will have belts only on the right belt, which will also happily merge right back in if combined). However, in these balancers do not have equal path lengths for all belts. So if there is a hitch which changes the pattern (say, left belt from left lane only to right lane only), the other belt will also switch to the complementary pattern, but if the path lengths for the left and right belts are different, then the "left lane only pattern" on the left lane may collide with the "left lane only pattern" on the right lane. So I think the total throughput failure you see with 1/2 output is when two belts have items on the same lane, trying to merge into 1, and the failure you see with 3/4 output is when one belt with items on one side collides with a belt with items on alternating lanes..


e.g. the simplest case: one belt split into two, combined back into one works just fine obviously:

simplegood.gif (3.44 MiB) Viewed 13952 times

but simply adding a little dog leg to one belt (just to make it longer), and removing a single item from the belt (to switch the patterns), will result in the patterns getting offset and result in throughput failure. Sorry, big gif ahead:

simplebad.gif (14.26 MiB) Viewed 13952 times

Keep in mind that one does not actually need to supply a belt with errors in it - I have a video that shows a fully compressed belt which simply starts with a bit of a mistake (the first 5 items are a little funky), which results in a tiny bottleneck, which sends a shockwave down one lane, which switches the belt pattern, which later on causes another bottleneck, which sends another shockwave, switching the pattern again - so a single error may result in a perpetuating series of belt pattern switches. I can post this gif later if people are interested but I am late for work right now!

[Frightning]

~snip~
Keep in mind that one does not actually need to supply a belt with errors in it - I have a video that shows a fully compressed belt which simply starts with a bit of a mistake (the first 5 items are a little funky), which results in a tiny bottleneck, which sends a shockwave down one lane, which switches the belt pattern, which later on causes another bottleneck, which sends another shockwave, switching the pattern again - so a single error may result in a perpetuating series of belt pattern switches. I can post this gif later if people are interested but I am late for work right now!

NICE WORK!

That gif w/ the swapped lanes shows something really interesting about splitters I didn't know: They will only move items to the corresponding lane of the other belt.

The explains so much about the weirdness I was seeing, and why said weirdness was consistent across multiple trials: my start conditions were identical (I would just reload the save to run another trial), and if I didn't change the layout, then exactly the same things would happen for exactly the same reasons.

[Shokubai]

That gif w/ the swapped lanes shows something really interesting about splitters I didn't know: They will only move items to the corresponding lane of the other belt.

The explains so much about the weirdness I was seeing, and why said weirdness was consistent across multiple trials: my start conditions were identical (I would just reload the save to run another trial), and if I didn't change the layout, then exactly the same things would happen for exactly the same reasons.

The effect is only true on fully compressed belts. Any gap in throughput will throw this off since it alternates items 1 for 1.

[taiiat]

sorry if i missed something as i only read the first page, and bit of the second, last page:

i'm far from an expert on this game - but what should help significantly is having Splitters which are faster than the Belts they are attached to.
this will reduce gaps in flow significantly. the Splitters are always the bottleneck, as they do something other than just move forwards, so if they are functionally faster than the belts they're connected to, they are no longer the bottleneck.

expanding the system larger and larger compensates for the bottleneck on each Splitter. eventually getting small enough where it doesn't leave an open gap as it creates less gap than one item worth of space.
alternatively extra Splitters can be placed inline between exchanges to compensate for the gaps created, by splitting the Belt back to itself. that's a bandaid ofcourse...


obviously if you're already using Tier III Belts this is defunct... honestly having a 'Rapid Splitter' that ran on Electricity, would be a late game way to sort and balance things at maximum rate.
but that doesn't solve things currently ofcourse.

- - - - -

additionally, Splitters don't actually move things evenly between belts, you'll notice depending on which side of the Belt it comes into the Splitter, as to where it'll come out of it.
so a belt trying to fully compress one resource must note that. you'll probably end up with self looping Splitters in some form to compensate for it.



that's all i can contribute to this, giant scale spiderweb belts aren't something i've needed to deal with just yet.

[sckuzzle]

Taiiat,

Splitters can't split more items than are coming in nor can they combine more items than there is space for on the output. Splitters are never a bottleneck so long as they have as many output slots as there are inputs (so long as they are the same color as the belts they are with).

Try making a balancer system with yellow belts and splitters, then upgrade the splitters to red. You'll notice that any bottlenecks that were there previously are still there.

[hansinator]

So did anyone find an answer to this topic?

[ribsngibs]

Yes...ish. It seemed like the easiest solution and definitely most straightforward is to simply place two NxN balancers in series. If you pass only A belts in and take only B belts out, the first balancer will spread the A belts onto N, and the second one will put the N belts onto the B you're drawing from. Should be no throughput issues. Aside from the weird left-right side belt weirdness that you can see on this page of discussion (which can affect even a very simple 1->2->1 belt pattern, so that problem is basically unsolvable imo.

[Frightning]

So I got a pretty complete solution to the version of this problem I posted on math.stackexchange from one David Ketcheson, this solution ignores the 2-lane nature of belts and splitter memory, but models everything else. It shows that the classic 4x4 balancer is UTU without considering those effects (and in my tests, most of the oddities in throughput vanished eventually other than the rare spacing artifact that probably can be explained by the tick rate of the simulation and resulting rounding errors). He also gives 3x3 and 5x5 balancers that are UTU. Attached to his post is a link to a notebook he compiled while working on the problem, which contains algorithms that will iteratively test a given balancer for the UTU property.

Stack Exchange post: http://math.stackexchange.com/questions ... 16#1950616
Notebook: https://gist.github.com/ketch/b0e30aae8 ... 79d6b6ca5d

Unfortunately, he has not, as of yet, found an algorithm for producing UTU balancers, and I suspect it's not as straightforward as one might expect, based on what I understand of his solution and the example balancers he found that are UTU (note that the 5x5 UTU balancer he found may not be minimal in # of splitters used).

[hansinator]

He must be wrong. All the constructions the notebook says are UTU fail miserably when I test them.
Edit: And it is not because of the lanes of a belt. If I put lane rebalancers in between everywhere it fails, too. If you operate with one lane on all belts only, it will still fail.

Edit 2:
In the 4 lane balancer case it will work when there are lane balancers between input and exit splitters and if you make sure that it never reaches max compression on all belts. If you go from full flow of all 4 belts to 3 in 3 out it will fail.

I'm testing various configurations since weeks. You can get an UTU for any balancer if you put two in parallel and lance-balance the outputs. A series configuration will not work universally.

I suggest this lane balancer, it doesn't balance the output lanes but treats the inputs fair. A side-loading configuration does not work because it doesn't draw from input lanes equally.


This one also balances the output lanes but is only for one belt.

[ribsngibs]

I agree - it sounds like he is new to Factorio and may be solving a slightly different problem? I'm not sure. But for instance, his 3x3 balancer is indeed not throughput limited for any subset of active inputs and outputs (I think), but unfortunately it is not a balancer.

[hansinator]

Here's an example of what I meant with the parallelization and lane balancing. It is an 8-balancer that has 3 blue belt inputs and 1 yellow belt input. There is 1 yellow belt output, 2 half-lane blue outputs and 2 full blue belt outputs. The construction at the item sources detects belt stalls and lights up a red lamp to indicate overflow. It can detect even very short overflows. The input throughput equals the output throughput. Unfortunately the quality is so bad you can barely see the outputs flowing. But the red light indicators say everything is flowing. All other 3, 4 and 8 balancer configurations I've tried fail and by now I've got dozens of different balancer experiments in my test factory.



It becomes quite huge due to the parallel feeding. A 3-balancer built this way doesn't grow that much in size compared to the single version. My current experiments focus on circuit controlled balancers but the combinator-to-belt ratio is probably bad for less than 8 belts. However, I haven't got a working prototype yet..

[Frightning]

Indeed the question he answered was a simplified version of the actual problem, where belts have only 1 lane, and splitters have no item memory. I think the best way to test his theory in game is to use belts with different items in each lane (e.g. left copper plates, right iron plates) and run it through the balancer. He also did not consider whether or not the design would balance input to output in underloaded conditions (e.g. half input, all output available, does it distribute half to all belts?)

[TheRaph]

Why so complicated?

I've tried this:

Balancer.jpg (1.11 MiB) Viewed 12637 times

I've not discovered any throughput problems.

Due to belt going underground are so long it will not perfectly even all out - so if you start with one Belt (filled by a chest) and end with 8 Belts (each end in a chest) then the amount in the chests will not be even. But if it runs and you continusly provide one Belt with thins, they will evenly be provided on output.

The second issue (like with most of the other balancers too) ther is no balancing between lanes. If you provide only the lower lane with items, you'll get 8 Belts with lower lane filleded with 1/8th of Items.

[d4rkpl4y3r]

TheRalph your contraption is not a balancer, though it is pretty close to throughput unlimited. My tool gives following output:

Code: Select all

Loading a 8 to 8 balancer with dimensions 16x13 and 32 splitters
Output balance: 0/8
Input balance: 0/8
Throughput under full load: 100%
Min Throughput with all combinations: 92.1%

[impetus maximus]

the tool →Command line belt balancer analyzer

[TheRaph]

Hi,

Thanks for link to "command line belt analyzer" - I've try this and it told me the same as "d4rkpl4y3r" has posted.

But now my question to that: Why did this tool say it is not an "balancer" ???

What did "balancer" mean?
I think a balancer is a belt setup where I can input items on some (or all) input belts and they would be evenly balanced over the output belts.
If this definition is true, my balcer is a balancer too.
But if the definition is like as "give some different inputs (eg. red & green) will give a nice color pattern on output side" - thats not true for my setup.

I've tried the following test:

Balancer3.jpg (1.21 MiB) Viewed 12610 times

On the left side ther are some chests (filled from train). These one fill the (non)balancer with red and green circuits over two belts.
Then on the right side there are chests at the end of the 8 output belts.

Some circuit network prevents the destination chests from beeing unloded into the train again.

I start that setup by setting the constant combinator on the left side to "on".
I waited until the left hand chests are empty.

Now i rad the circuit network state for item per chest-group on the right side:
1st Belt => 5.4k red; 4.2k green = 9.6k
2nd Belt => 5.4k red; 4.2k green = 9.6k
3rd Belt => 5.4k red; 4.2k green = 9.6k
4th Belt => 4.2k red; 5.4k green = 9.6k
5th Belt => 4.2k red; 5.4k green = 9.6k
6th Belt => 4.1k red; 5.3k green = 9.6k
7th Belt => 4.1k red; 5.3k green = 9.6k
8rd Belt => 5.4k red; 4.2k green = 9.6k

So the individual parts of red and green are not the same per belt, but the total amount looks the same for me ...

were is my foult?

[golfmiketango]

Factorio is an open ended game and if something you created is providing enjoyment or useful functionality then it's not wrong.

However when people say "balancer" here on the forums and other factorio places, they mean a very particular thing. They are referring to a count-perfect belt-output-interleaving device which, if and only if the outputs of the device are never blocked, will sort items equally by type between belts (not lanes).

So an m→n balancer with all n output lanes unblocked, after perhaps a single "priming" load has passed through it, fed k*n items of a given type (whether or not other types of items are also fed to it) should pretty much always output precisely k items of that type onto each output belt. Further, it would be said to be "throughput unlimited" iff it's a balancer by that definition, and capable of processing min(m,n) fully compressed belts of materiel without limiting the rate of flow (a delay, or temporary rate-of-flow limitation is probably considered to be acceptable so long as the duration is O(1) relative to all variables).

A good way to test is to put a multiple of n items in a box, and feed this to various inputs of your balancer on only one side of the belt.

If your balancer really balances, then the output belts should all wind up with the exact same number of items on them, which is easy to confirm visually if they're all in a row right next to each other. However since balancers balance belts, and not necessarily lanes, if you supply both lanes with material, the results are much more difficult to interpret visually and you'll need something like what you've done above (ie: put the output into boxes) to test it's correctness.

I don't believe the .net framework tool folks are discussing, above, actually attempts to decide whether the blueprint you feed it is a balancer or not... although I could be wrong. Instead, my recollection is that it assumes your blueprint is a balancer, and tests its throughput properties. I'm sure, if I'm misremembering or confused, someone will set the record straight. I can't really use that thing, myself, without booting an emulator/Windows... perhaps should try to figure out how to build it with mono, as under wine the thing emits no carriage returns (only line-feeds) making it very difficult to understand the output.

[TheRaph]

Ok ... I've calculated my "balancer" in Excel. I understand now ... this tool from d4rkpl4y3r is right. My creation is not realy a 100% balancer. In some cases it has an inbalance of 30%.

So I do some calculating in Excel and think abaout this and that.

Now her is my solution.

The balancer-check-tool say:

Code: Select all

Loading a 8 to 8 balancer with dimensions 43x24 and 40 splitters
Output balance: 8/8
Input balance: 8/8
Throughput under full load: 100%
Min Throughput with all combinations: 100%

Her is BP:

Blueprint

Code: Select all

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

And here is a picture:

mega2.jpg (1017.22 KiB) Viewed 12588 times

The red marked square is a 8-belt-balancer with worst-case 50% througput. It is mutch smaller

Blueprint

Code: Select all

0eNqlm9tuGksQRf9lnvFR3y/8ShQd2ckoGskeEAxRLMv/fiAkR4loNLuXnxAGL6qrp7o2e4q34en5NO4P07wM27dh+rKbj8P209twnL7Nj8+Xvy2v+3HYDtMyvgybYX58uTwbf+wP4/H4sBwe5+N+d1gensbnZXjfDNP8dfwxbO37580wzsu0TOOV+PPJ67/z6eVpPJzfsMbaDPvd8fzvu/kSxRn5EDfD6+Xh/Clfp8P45fqae9/cwB2Gp7/hoQH3/fDUhLciDzfw0zmhh2+H3flxBX9JzK/d2p2W/emyHzcfEPuj97/xDVzCOCEZmSQjtK+S/1MzzXcyU/qXYuUrspKluJWl3N9la/BihH2xoHidTu+v3o7QPYULm2xvq/e4f56W5fziDdb8wv6jgPurtiPf/TWsl7DNFK6kpdC0KPDaDQ9yWlx/fUYdbik8rnc/52halL7dX51JjzxQuCAKXOwo/Yd85Xql9h1oseXKDwI9Y7oX6AULMSX2iulekHkG6zwhdm8xXci7d1iWhZbK80DzBj0XAUer5CJisaLQExZaCj1TtaLAS79accqJ5Svt+ULUwdCer8AtkOntAyusf+EIjvZpZSme9mkF3iN0e5pdiLRHC+dMSBSupKS/VPU+GgqFK2mpQLoYZTejweLCCnRuIbn19h+5h6TEzk0k22rQ8SO+kXtfP6si943aAXPjyDV5H/GKbLdXFAsWFU64OioWFQI9GRx7cysTaZq/47X93lbC/pCSHOwPCVWfgD8kHbQpUsWlpCRRxaXAM4Ur+S7gyvT0TEiVyjm73o6y4crU3VOm92ssW6oelbVgC0no29n3S1OpxjJpsQmfcjlSyScURk79ks9KScJ2khJ1oXAjwLGZJMCLoXAhLQVbSQrcUbiSFs9Fm+m/vxeoiaXkCevjpqYqWB6bJi5ziWb6z65S+N1Oq9zELpVK2GZ6KmmutnVpCK5PtVBhmvXmVx0WPP31VD2UbsLJUANkN6upRqjMhMKvCbKV7cxQKAkirBbIVuKu3RpMUhfWGOjgWQVuscAzZELDQYEnrcVDuFHggeowp9AjVRwSPVElJtEzlRgSvVBRINE/MKLkBQfR8pkkJXw+kyTRHY3dK3RqOknwAOFSXmK3oyXdQrR4KElKCTWdJDgdSmr62haPIQkjDhaPISnXhqMekgR3UAlIcNo9JTjunkGhgzmkIFUkn0OS6Jn2ZSkreA5Jir1SxaLQ+RySkhkyh+R1uqN6SKLjqSQp73gqSaLjqaTmgJblc0h3eJnGJ60ez9rHdrQVahxpqJu7Q6H/zosNFuoHpWQCN4hCt0FkA3WI2rscAr4HFsAXdDCL1Dy7msorUNtIumKpbyTBS7e5owmMUKGkk35AQZ0jparAJJKujCL1iW4i/7y5/opv+8eP/jbD9/Fw/PmGFIJL1QeXz99E/gPbEfEU

Code: Select all

Loading a 8 to 8 balancer with dimensions 15x12 and 12 splitters
Output balance: 8/8
Input balance: 8/8
Throughput under full load: 100%
Min Throughput with all combinations: 50%

[d4rkpl4y3r]

I don't believe the .net framework tool folks are discussing, above, actually attempts to decide whether the blueprint you feed it is a balancer or not... although I could be wrong. Instead, my recollection is that it assumes your blueprint is a balancer, and tests its throughput properties. I'm sure, if I'm misremembering or confused, someone will set the record straight.

My tool checks if it is a balancer. It does this by using only one input at a time and then checks wether all outputs have the same throughput.

Also for the people who haven't seen it, here is my tiny throughput unlimited 8 belt balancer:

blueprint string

0eNqlmt1u2zAMhd9F1+kg6l95laEIktYoDKROYDtDiyLvPmfZuiKlbOrkqmjTfCIp6oiU9KF2+1Nz7NtuVOsP1T4dukGtf36ooX3ptvvL38b3Y6PWqh2bV7VS3fb18lvzduybYXgY+203HA/9+LBr9qM6r1TbPTdvak3nlRgyHPftODb9l6+b8+NKNd3Yjm1zNejPL++b7vS6m/5zTUumrNTxMExfP3SX8Sfkg1up9+lHPl9Mu8GZslHfQfaHv6ISh7L1lpkZy1w9zs7gfI2jNOtoqLZMzxgW6/2kGVyq8FPPupmrDZubTtLVuDk3iSr8NLN+kqm2bC7RyMIrNLA8B/Miy/u+Ek6T9vQv/WH6ubBSw6RUfyXtcBqPp4vyfR8hICPYmhFizWr+nH4+Hgldzvx0ZXg9szyjUfNYbw3B5vE8A8x1TTIZCwxANQO4ilyi2VQyHlUSfuoDiuOti7CQuCmQz23fPF0/cxw9wXTPWpuhDduxlYm+Q5BufA+ClLIEl0L+ZjSObuDKSEK3SAHBh92h0sVmhPWwdPG8gEtXMSnarpQTES2nbibNcPCEFlcSeEZlyC2nm9MonJ1Th7dHZjkSzsB0K6DbOwozc15OQefukMHb8AiG87AKWnZuA6x7kuhHVKwkiZOQyNNC5MsbkMvAePp/rBYH8PoOh2QjECpphm3/DYpjc9FbVLZ46xyK463zyKmOZlEBljxieREWBZ6X7tA0Eoimz0A9xIYywJ0cLe+jAe/rJHQDnLbwQbB40SWZruDwdlHEh1s8Nn0DvLxYHQlwi8dbl/CKxEhEPmR89Zr6vixqVHxoeY+PhPtCkmBFA2/qkuowWnxLF/HRbpBNzQg3g5KpDGCvZpalNEZYoEx10xkTrLaylMywMyJ+QrtDVh0TgTQ2AxPcDLrlDEzwJYJdPqpLDjlaY494ksdFz1V3lCmg+m2XF2aKaHspgSPXcnzEq85F/6HYNiFrWB1cfU+aCRRV3na0nxMcBWS0uWMnLKO9He+3R4WBvWLIcP0pODjMES8fg6CiyHf0fiJ+RuXG8zfgGlUYQbBJE1hf8deY2qAFVoFnQfMKsXSoeQWeh7VQkkqkA1wpyfjo9YLgSog0er1QiDV6ocBnFqFFosT1qncmn0dp/DsTgitG/uECWaSOK9jmkBcVBbs8UOwUzELfWhUsgx9bFXgJOBcreJqBZwi8VQZdEAUcfKfGv48y8P11gQc/PCzw4K2lwPNgDhdwARTjAg7dOAq4BObehHtcXd/Jrr+8zV2p/Xb62vS3tEmb3Xa/7Z6afnOaPvjV9MNVuJ0zkaxOSZ/PvwGM+NOh

[TheRaph]

Also for the people who haven't seen it, here is my tiny throughput unlimited 8 belt balancer:

Hey that's a great design!

Until now I had change my design a little bit and now it is much smaller than my first one and do the 8/8 - 100% - job.

But is not as genial as yours

Mega3.jpg (349.59 KiB) Viewed 12557 times