Balancer mechanics - Revision history

Bilka: /* Throughput */ Improved gallery description wording

2025-05-30T11:28:45Z

Throughput: Improved gallery description wording

← Older revision		Revision as of 11:28, 30 May 2025
Line 25:		Line 25:

	<gallery class="center" widths=200px heights=300px>		<gallery class="center" widths=200px heights=300px>
	4to4_balancer_throughput_limit_demo.gif\|Figure 1: a 4 to 4 balancer with 2 belts being fed.		4to4_balancer_throughput_limit_demo.gif\|Figure 1: a 4 to 4 balancer with 2 belts being fed but only one total belt of output.
	4to4_balancer_throughput_full_demo.gif\|Figure 2: the improved 4 to 4 balancer ~~allows all~~ output ~~ports fully loaded~~.		4to4_balancer_throughput_full_demo.gif\|Figure 2: the improved 4 to 4 balancer fully saturates both output belts.
	</gallery>		</gallery>

Bilka: /* Lane balancers */ Kept only one example balancer to show the behaviour - the second balancer seems to be more of a mixer

2025-05-30T11:27:00Z

Lane balancers: Kept only one example balancer to show the behaviour - the second balancer seems to be more of a mixer

← Older revision		Revision as of 11:27, 30 May 2025
Line 40:		Line 40:
	<gallery class="center" widths=200px heights=300px>		<gallery class="center" widths=200px heights=300px>
	Lane_balancer_mechanics.png\|This output balanced lane balancer distributes the items evenly among the output lanes, achieving output balance. {{BlueprintString\|bp-string=0eNqd01GLwyAMAOD/kmc3qlU7+1fGcbRbOIQ2LeqOG8X/PruN3cNZuPmmknwmhCzQDxecnaUA7QL2NJGH9riAt1/UDesbdSNCC8F15OfJhV2PQ4DIwNIZf6Dl8YMBUrDB4iP3frl+0mXs0aUAtmEwmCef0iZa/0nUTlZ8rxhc01Ec9ipG9kcTZZrJa/U7mnhpTdIYnK3D0yNEZmxZZut8paqs7yav6Xe0artvLjJ4U4ZvNH4oa1z/Z0TmZft5sCGkt+xwnqbKV8irshLlBle4MPXKpV20AceU+7vYDL7R+XuW0sJIY5QSSteCx3gD6bVJ7A==}}		Lane_balancer_mechanics.png\|This output balanced lane balancer distributes the items evenly among the output lanes, achieving output balance. {{BlueprintString\|bp-string=0eNqd01GLwyAMAOD/kmc3qlU7+1fGcbRbOIQ2LeqOG8X/PruN3cNZuPmmknwmhCzQDxecnaUA7QL2NJGH9riAt1/UDesbdSNCC8F15OfJhV2PQ4DIwNIZf6Dl8YMBUrDB4iP3frl+0mXs0aUAtmEwmCef0iZa/0nUTlZ8rxhc01Ec9ipG9kcTZZrJa/U7mnhpTdIYnK3D0yNEZmxZZut8paqs7yav6Xe0artvLjJ4U4ZvNH4oa1z/Z0TmZft5sCGkt+xwnqbKV8irshLlBle4MPXKpV20AceU+7vYDL7R+XuW0sJIY5QSSteCx3gD6bVJ7A==}}
	Lane_balancer2.png\|This lane balancer distributes all kinds of input items evenly amont both lanes of the output belts. {{BlueprintString\|bp-string=0eNqdl+uKwyAQhd/F32mJYzSaVynL0ossQmpCYpctJe++9kKXpQ7V+ZeE+OU4c4zHC9v1JztOzgfWXZjbD35m3ebCZvflt/31md8eLetYmLZ+HocprHa2D2ypmPMH+8M6vnxUzPrggrP3sbeb86c/HXd2ii9UCKNi4zDHYYO/fieiVkLrtazY+XrZrOWyVC80oNFEmiaetHnsXQjxWYpjHhRIU5oCTaZ+aopXsYwHN9n9/ZUmwZa0+fK0UkWj1WlaW0Iz77RpGg3RZkpoLd4TDgk4r0kdB5PWykuWiOH/cG8NxIEG14hWQZu6zitsQzLBayXSdEmjY6VQJI+hLmhpOEydpjVKIThDs5HK8SjUWf9hUz+gLbI30LaaTI1AM4/KsiYIWvOxShStI1UqVtLEItYCRbOWRHAtzfgyb+6a5jFMrKG5CsGJwoWEhCzBafbBVAHNLzJnXYrMDKffTLmh9RULlrTcBkjCFIpmE0wdLbmh6nRRjAYkAApDqxmSAJuahOO37TmeaVywxzj274BUsW87zbdRUoFpjJESpBLAl+UXi2FA1w==}}
	</gallery>		</gallery>

Bilka: /* Universal balancers */ These are not universal balancers, they are only throughput unlimited. Furthermore, the wiki is not a design host. An example gif showing the behaviour similar to 4to4 balancer would be better than just listing designs

2025-05-30T11:24:30Z

Universal balancers: These are not universal balancers, they are only throughput unlimited. Furthermore, the wiki is not a design host. An example gif showing the behaviour similar to 4to4 balancer would be better than just listing designs

← Older revision		Revision as of 11:24, 30 May 2025
Line 34:		Line 34:
	Many balancers fail to balance properly once an output backs up or if an output is not used. In essence this means that an n-n balancer is not a functional n-(n-1) balancer. Sometimes this can be fixed by looping the unused output back around the balancer and distributing it among the inputs. Other times, this is not an option. Universal balancers solve this issue by having the back-looping built in. These balancers can balance evenly between any inputs and any outputs. Universal balancers can be throughput limited. If a universal balancer is throughput limited, the bottleneck may be in the loops or the balancer itself. A throughput limited universal balancer may only have the capacity for a few unused outputs. When more than the number of allowed outputs backs up, the universal balancer behaves like a normal balancer, and may not balance properly.		Many balancers fail to balance properly once an output backs up or if an output is not used. In essence this means that an n-n balancer is not a functional n-(n-1) balancer. Sometimes this can be fixed by looping the unused output back around the balancer and distributing it among the inputs. Other times, this is not an option. Universal balancers solve this issue by having the back-looping built in. These balancers can balance evenly between any inputs and any outputs. Universal balancers can be throughput limited. If a universal balancer is throughput limited, the bottleneck may be in the loops or the balancer itself. A throughput limited universal balancer may only have the capacity for a few unused outputs. When more than the number of allowed outputs backs up, the universal balancer behaves like a normal balancer, and may not balance properly.

	~~The following are some designs for universal balancers:~~
	~~<gallery class="center" widths=200px heights=300px>~~
	3to2 balancer.png\|A 3→2 universal balancer. {{BlueprintString\|bp-string=0eNqdlm2PgyAMx79LX7NFEFT8KpfLZW5kIXFoEC9nFr/74UxuywY37CsfUn4t/7aUKzTtqHqrjYP6CvrYmQHqjysM+mwO7fLPHC4KanD2YIa+s27XqNbBTECbk/qBms4kYD70rXZO2QdDNn8SUMZpp9Xq5PYxfZnx0njLmpKIMwJ9N/hlnVk8eNQuL4u9IDD5V5rvxbzE8ERjW2j8j8Y8jcBJW3VcTaoAO9/CFu8i5eRFteCOHyIMUMSWmPL4fikLwAtcarJwqCWORsO0Cpfo7HnjPMCWODZNEpVmuDKK6EA39Q+LCxGqeMpw5ZWkMr330+jPCnu2nX+m4Feh3dQva7vR9eNyNL064KiKkxGhRVrDvqEUm9q+ilBKVNKrpJxXKLZMYktkyuVjxrWJJJxlaeLyf8VluIlURmi4iRSj4WZQjMZR7R2jCVThlIFT018ZtFMXT7pfVAh8KzvcLETBJJdSCCaKnNF5/gVDYNZh}}
	3to4_balancer.png\|A 3→4 universal balancer. {{BlueprintString\|bp-string=0eNqdl9tuwyAMht+Fa1YFEhLIq0zT1AOqkFISJWRaVeXdR9pp7RrcgK96kPvZ/vHvkgvZNaPuemMdqS/E7Fs7kPr9QgZztNtm/s5uT5rUxPVbO3Rt7952unFkosTYg/4mNZtoIHzoGuOc7h8C+fRBibbOOKNvSa4fzp92PO18ZM0okIySrh38z1o7Z/Cot1zKjaDk7N+yfCOmuYYnGk+hlWu0PIVWrdEKutAp2OMvhYcpIqUmsVZTGVdT+bqmCneGLEyTKTT1j0bJwfR6fwspAmyFY2fhSln2hxv9uPfHvvWvMa1nz8UyP7nu3M2odnTdOJttmY/FHVf1WmCGdAmkAtImEK7ATTjUrEg7IxF1RsZCRxTpqOJe93OSEDXJYfmrFkJ0nONUjOEYznESWO8ZatPIKBk4Q7p5KcT6nHCcBxWgS46iQSoXKENDNIGiQZ2WqO0gY2aVV8hV8WIA4GXOZeKmUBEdKNSeALTOMxRtobUMsXH3vhKoFOcmiIb7Q4Noafe+CqDg7n1QTUkuKh5p63s0r1DwKmpsZNKFFRITZ5Mq0L5/ujFOnzzp/kxFyZfuh2uEKLkqlBKCizLnbJp+AAYgVgk=}}
	4to3_balancer.png\|A 4→3 universal balancer. {{BlueprintString\|bp-string=0eNqdl9uOgyAQht+Fa9sIiIqvstlseiANiUWDuNmm8d0X213btEwLc9VD4JsD/8/omWzbUfVWG0eaM9G7zgyk+TiTQR/Mpp3/M5ujIg1xdmOGvrNutVWtI1NGtNmrH9LQKQssH/pWO6fs3UI2fWZEGaedVtcglx+nLzMet35lQzMgWEb6bvDbOjNH8KgVr+VaZOTkv+Zr4WPstVW764p6TugBzVLQNYimLMDmKezynh2AFSmw6g1MpMDEG1iZAJP5H4w+drAIkCsMOerYa4yi4k5dYhRFw62lOUZCEIxiJATBbsZZHB0scOlcCMIxOoQySnJIAekweKZUxFVbvqwWZRQWYxSKcgoH8ryZY/QXtD3Yzn++1zB/bmVG3KmfQd3o+nEeDs/RJC7ac1+WYNoAsVged4z/hmfvO88oxqFA5xnDwBgA4xi7Q5mhxg+UmcA4lUc5lZUYNpRolaZNEeEEWJw1LtgLI8CuY6gpVcQ99iS6rIhh0jhmteQZgiTNLAFAUDOriLnFOWqCQcUmjSyo2BIjkxKAVZjbDYLVmAsJgknMmV5g/s1FO3X0O2/vSxn5Vna47BElk4WUQjBRckan6Rf0c1Ey}}
	4to4_balancer.png\|A 4→4 universal balancer. {{BlueprintString\|bp-string=0eNqdlutugzAMhd/Fv9OKOIQWXmWapl6iKhINKIRpVcW7L9BqnVa8Ev/iouTzAZ+j+Ar7ujetty5AdQV7aFwH1dsVOntyu3p853ZnAxUEv3Nd2/iw2ps6wCDAuqP5gkoOYmZ519Y2BON/LcThXYBxwQZrbkWmh8uH68/7uLKSgigmoG26uK1xY4WIWqkiX2sBl3iLeq2HUcMfGqbQ8BVNpdDUK1ounv7T7DfeKfk8Radokq80Fcs04f+aNrweqnnalkfDeVrJc8RIE3C03hxuS/IZtsx4BnmCS5yjP6LRxzD5k2/idYl4NfHDpR33Nn1o+zG7zwUwrYBKLqB4ZiWMIXMejnCG1DyjZYusUfB8lxFaNzynUbjtstyrO0YSmJLXkGyR/zFj9UeWxNHAO2nklsAhM52Tvp/wWEdkBxUznEv5eZIFyN/AO4/IJhU8HKWOdzLJgsBtWaEmcSUr1BROZUkDhtwQGMlrAaUKk0aMm6o4M9pgznHPY1IV8Gl8N+3RBZZ5WWqNulAoh+EbnvV36g==}}
	~~</gallery>~~
	{{clear}}		{{clear}}

Cardinal: /* Throughput */ Added animation.

2025-03-13T09:17:10Z

Throughput: Added animation.

← Older revision		Revision as of 09:17, 13 March 2025
Line 22:		Line 22:
	#Any arbitrary amount of input belts should be able to go to any arbitrary amount of output belts.		#Any arbitrary amount of input belts should be able to go to any arbitrary amount of output belts.

	Balancers often do not fulfill the second condition because of internal bottlenecks. The figure 1 below on the left shows a 4 → 4 balancer being fed by two belts, but only outputting one belt which means that its throughput in that arrangement is 50%. The bottleneck in this balancer is that the two middle belts only get input from one splitter. So, if only one side of that splitter gets input, as can be seen in the ~~gif~~, it can only output one belt even though the side of the splitter is fed by a splitters which gets two full belts of input. In this particular case, the bottleneck can be fixed by feeding the two middle output belts with more splitters. This is done by adding two more splitters at the end of the balancer, as it can be seen at figure 2 below:		Balancers often do not fulfill the second condition because of internal bottlenecks. The figure 1 below on the left shows a 4 → 4 balancer being fed by two belts, but only outputting one belt which means that its throughput in that arrangement is 50%. The bottleneck in this balancer is that the two middle belts only get input from one splitter. So, if only one side of that splitter gets input, as can be seen in the figure 1, it can only output one belt even though the side of the splitter is fed by a splitters which gets two full belts of input. In this particular case, the bottleneck can be fixed by feeding the two middle output belts with more splitters. This is done by adding two more splitters at the end of the balancer, as it can be seen at figure 2 below on the right:

	<gallery class="center" widths=200px heights=300px>		<gallery class="center" widths=200px heights=300px>
	4to4_balancer_throughput_limit_demo.gif\|Figure 1: a 4 to 4 balancer with 2 belts being fed.		4to4_balancer_throughput_limit_demo.gif\|Figure 1: a 4 to 4 balancer with 2 belts being fed.
	~~4to4_balancer~~.~~png~~\|Figure 2: a 4 to 4 balancer allows all output ports fully loaded.		4to4_balancer_throughput_full_demo.gif\|Figure 2: the improved 4 to 4 balancer allows all output ports fully loaded.
	</gallery>		</gallery>

Cardinal: /* Lane balancers */ miswords.

2025-03-13T08:37:33Z

Lane balancers: miswords.

← Older revision		Revision as of 08:37, 13 March 2025
Line 47:		Line 47:
	<gallery class="center" widths=200px heights=300px>		<gallery class="center" widths=200px heights=300px>
	Lane_balancer_mechanics.png\|This output balanced lane balancer distributes the items evenly among the output lanes, achieving output balance. {{BlueprintString\|bp-string=0eNqd01GLwyAMAOD/kmc3qlU7+1fGcbRbOIQ2LeqOG8X/PruN3cNZuPmmknwmhCzQDxecnaUA7QL2NJGH9riAt1/UDesbdSNCC8F15OfJhV2PQ4DIwNIZf6Dl8YMBUrDB4iP3frl+0mXs0aUAtmEwmCef0iZa/0nUTlZ8rxhc01Ec9ipG9kcTZZrJa/U7mnhpTdIYnK3D0yNEZmxZZut8paqs7yav6Xe0artvLjJ4U4ZvNH4oa1z/Z0TmZft5sCGkt+xwnqbKV8irshLlBle4MPXKpV20AceU+7vYDL7R+XuW0sJIY5QSSteCx3gD6bVJ7A==}}		Lane_balancer_mechanics.png\|This output balanced lane balancer distributes the items evenly among the output lanes, achieving output balance. {{BlueprintString\|bp-string=0eNqd01GLwyAMAOD/kmc3qlU7+1fGcbRbOIQ2LeqOG8X/PruN3cNZuPmmknwmhCzQDxecnaUA7QL2NJGH9riAt1/UDesbdSNCC8F15OfJhV2PQ4DIwNIZf6Dl8YMBUrDB4iP3frl+0mXs0aUAtmEwmCef0iZa/0nUTlZ8rxhc01Ec9ipG9kcTZZrJa/U7mnhpTdIYnK3D0yNEZmxZZut8paqs7yav6Xe0artvLjJ4U4ZvNH4oa1z/Z0TmZft5sCGkt+xwnqbKV8irshLlBle4MPXKpV20AceU+7vYDL7R+XuW0sJIY5QSSteCx3gD6bVJ7A==}}
	Lane_balancer2.png\|This ~~output~~ distributes all kinds of items evenly amont both lanes of the output belts. {{BlueprintString\|bp-string=0eNqdl+uKwyAQhd/F32mJYzSaVynL0ossQmpCYpctJe++9kKXpQ7V+ZeE+OU4c4zHC9v1JztOzgfWXZjbD35m3ebCZvflt/31md8eLetYmLZ+HocprHa2D2ypmPMH+8M6vnxUzPrggrP3sbeb86c/HXd2ii9UCKNi4zDHYYO/fieiVkLrtazY+XrZrOWyVC80oNFEmiaetHnsXQjxWYpjHhRIU5oCTaZ+aopXsYwHN9n9/ZUmwZa0+fK0UkWj1WlaW0Iz77RpGg3RZkpoLd4TDgk4r0kdB5PWykuWiOH/cG8NxIEG14hWQZu6zitsQzLBayXSdEmjY6VQJI+hLmhpOEydpjVKIThDs5HK8SjUWf9hUz+gLbI30LaaTI1AM4/KsiYIWvOxShStI1UqVtLEItYCRbOWRHAtzfgyb+6a5jFMrKG5CsGJwoWEhCzBafbBVAHNLzJnXYrMDKffTLmh9RULlrTcBkjCFIpmE0wdLbmh6nRRjAYkAApDqxmSAJuahOO37TmeaVywxzj274BUsW87zbdRUoFpjJESpBLAl+UXi2FA1w==}}		Lane_balancer2.png\|This lane balancer distributes all kinds of input items evenly amont both lanes of the output belts. {{BlueprintString\|bp-string=0eNqdl+uKwyAQhd/F32mJYzSaVynL0ossQmpCYpctJe++9kKXpQ7V+ZeE+OU4c4zHC9v1JztOzgfWXZjbD35m3ebCZvflt/31md8eLetYmLZ+HocprHa2D2ypmPMH+8M6vnxUzPrggrP3sbeb86c/HXd2ii9UCKNi4zDHYYO/fieiVkLrtazY+XrZrOWyVC80oNFEmiaetHnsXQjxWYpjHhRIU5oCTaZ+aopXsYwHN9n9/ZUmwZa0+fK0UkWj1WlaW0Iz77RpGg3RZkpoLd4TDgk4r0kdB5PWykuWiOH/cG8NxIEG14hWQZu6zitsQzLBayXSdEmjY6VQJI+hLmhpOEydpjVKIThDs5HK8SjUWf9hUz+gLbI30LaaTI1AM4/KsiYIWvOxShStI1UqVtLEItYCRbOWRHAtzfgyb+6a5jFMrKG5CsGJwoWEhCzBafbBVAHNLzJnXYrMDKffTLmh9RULlrTcBkjCFIpmE0wdLbmh6nRRjAYkAApDqxmSAJuahOO37TmeaVywxzj274BUsW87zbdRUoFpjJESpBLAl+UXi2FA1w==}}
	</gallery>		</gallery>

Cardinal: /* Lane balancers */ typo

2025-03-13T08:23:57Z

Lane balancers: typo

← Older revision		Revision as of 08:23, 13 March 2025
Line 47:		Line 47:
	<gallery class="center" widths=200px heights=300px>		<gallery class="center" widths=200px heights=300px>
	Lane_balancer_mechanics.png\|This output balanced lane balancer distributes the items evenly among the output lanes, achieving output balance. {{BlueprintString\|bp-string=0eNqd01GLwyAMAOD/kmc3qlU7+1fGcbRbOIQ2LeqOG8X/PruN3cNZuPmmknwmhCzQDxecnaUA7QL2NJGH9riAt1/UDesbdSNCC8F15OfJhV2PQ4DIwNIZf6Dl8YMBUrDB4iP3frl+0mXs0aUAtmEwmCef0iZa/0nUTlZ8rxhc01Ec9ipG9kcTZZrJa/U7mnhpTdIYnK3D0yNEZmxZZut8paqs7yav6Xe0artvLjJ4U4ZvNH4oa1z/Z0TmZft5sCGkt+xwnqbKV8irshLlBle4MPXKpV20AceU+7vYDL7R+XuW0sJIY5QSSteCx3gD6bVJ7A==}}		Lane_balancer_mechanics.png\|This output balanced lane balancer distributes the items evenly among the output lanes, achieving output balance. {{BlueprintString\|bp-string=0eNqd01GLwyAMAOD/kmc3qlU7+1fGcbRbOIQ2LeqOG8X/PruN3cNZuPmmknwmhCzQDxecnaUA7QL2NJGH9riAt1/UDesbdSNCC8F15OfJhV2PQ4DIwNIZf6Dl8YMBUrDB4iP3frl+0mXs0aUAtmEwmCef0iZa/0nUTlZ8rxhc01Ec9ipG9kcTZZrJa/U7mnhpTdIYnK3D0yNEZmxZZut8paqs7yav6Xe0artvLjJ4U4ZvNH4oa1z/Z0TmZft5sCGkt+xwnqbKV8irshLlBle4MPXKpV20AceU+7vYDL7R+XuW0sJIY5QSSteCx3gD6bVJ7A==}}
	Lane_balancer2.png\|This output distributes all kinds of items evenly amont both lanes of the ~~belt~~. {{BlueprintString\|bp-string=0eNqdl+uKwyAQhd/F32mJYzSaVynL0ossQmpCYpctJe++9kKXpQ7V+ZeE+OU4c4zHC9v1JztOzgfWXZjbD35m3ebCZvflt/31md8eLetYmLZ+HocprHa2D2ypmPMH+8M6vnxUzPrggrP3sbeb86c/HXd2ii9UCKNi4zDHYYO/fieiVkLrtazY+XrZrOWyVC80oNFEmiaetHnsXQjxWYpjHhRIU5oCTaZ+aopXsYwHN9n9/ZUmwZa0+fK0UkWj1WlaW0Iz77RpGg3RZkpoLd4TDgk4r0kdB5PWykuWiOH/cG8NxIEG14hWQZu6zitsQzLBayXSdEmjY6VQJI+hLmhpOEydpjVKIThDs5HK8SjUWf9hUz+gLbI30LaaTI1AM4/KsiYIWvOxShStI1UqVtLEItYCRbOWRHAtzfgyb+6a5jFMrKG5CsGJwoWEhCzBafbBVAHNLzJnXYrMDKffTLmh9RULlrTcBkjCFIpmE0wdLbmh6nRRjAYkAApDqxmSAJuahOO37TmeaVywxzj274BUsW87zbdRUoFpjJESpBLAl+UXi2FA1w==}}		Lane_balancer2.png\|This output distributes all kinds of items evenly amont both lanes of the output belts. {{BlueprintString\|bp-string=0eNqdl+uKwyAQhd/F32mJYzSaVynL0ossQmpCYpctJe++9kKXpQ7V+ZeE+OU4c4zHC9v1JztOzgfWXZjbD35m3ebCZvflt/31md8eLetYmLZ+HocprHa2D2ypmPMH+8M6vnxUzPrggrP3sbeb86c/HXd2ii9UCKNi4zDHYYO/fieiVkLrtazY+XrZrOWyVC80oNFEmiaetHnsXQjxWYpjHhRIU5oCTaZ+aopXsYwHN9n9/ZUmwZa0+fK0UkWj1WlaW0Iz77RpGg3RZkpoLd4TDgk4r0kdB5PWykuWiOH/cG8NxIEG14hWQZu6zitsQzLBayXSdEmjY6VQJI+hLmhpOEydpjVKIThDs5HK8SjUWf9hUz+gLbI30LaaTI1AM4/KsiYIWvOxShStI1UqVtLEItYCRbOWRHAtzfgyb+6a5jFMrKG5CsGJwoWEhCzBafbBVAHNLzJnXYrMDKffTLmh9RULlrTcBkjCFIpmE0wdLbmh6nRRjAYkAApDqxmSAJuahOO37TmeaVywxzj274BUsW87zbdRUoFpjJESpBLAl+UXi2FA1w==}}
	</gallery>		</gallery>

Cardinal: Added images for gallery and blueprint strings.

2025-03-13T08:20:14Z

Added images for gallery and blueprint strings.

← Older revision		Revision as of 08:20, 13 March 2025
Line 22:		Line 22:
	#Any arbitrary amount of input belts should be able to go to any arbitrary amount of output belts.		#Any arbitrary amount of input belts should be able to go to any arbitrary amount of output belts.

	Balancers often do not fulfill the second condition because of internal bottlenecks. The figure 1 below on the ~~right~~ shows a 4 → 4 balancer being fed by two belts, but only outputting one belt which means that its throughput in that arrangement is 50%. The bottleneck in this balancer is that the two middle belts only get input from one splitter. So, if only one side of that splitter gets input, as can be seen in the gif, it can only output one belt even though the side of the splitter is fed by a splitters which gets two full belts of input. In this particular case, the bottleneck can be fixed by feeding the two middle output belts with more splitters. This is done by adding two more splitters at the end of the balancer, as it can be seen ~~here~~:		Balancers often do not fulfill the second condition because of internal bottlenecks. The figure 1 below on the left shows a 4 → 4 balancer being fed by two belts, but only outputting one belt which means that its throughput in that arrangement is 50%. The bottleneck in this balancer is that the two middle belts only get input from one splitter. So, if only one side of that splitter gets input, as can be seen in the gif, it can only output one belt even though the side of the splitter is fed by a splitters which gets two full belts of input. In this particular case, the bottleneck can be fixed by feeding the two middle output belts with more splitters. This is done by adding two more splitters at the end of the balancer, as it can be seen at figure 2 below:

	<gallery class="center" widths=200px heights=300px>		<gallery class="center" widths=200px heights=300px>
	4to4_balancer_throughput_limit_demo.gif\|Figure 1: a 4 to 4 balancer with 2 belts being fed.		4to4_balancer_throughput_limit_demo.gif\|Figure 1: a 4 to 4 balancer with 2 belts being fed.
	4to4_balancer.png\|Figure 2:		4to4_balancer.png\|Figure 2: a 4 to 4 balancer allows all output ports fully loaded.
	</gallery>		</gallery>

Line 32:		Line 32:

	=== Universal balancers ===		=== Universal balancers ===
	Many balancers fail to balance properly once an output backs up or if an output is not used. In essence this means that an n-n balancer is not a functional n-(n-1) balancer. Sometimes this can be fixed by looping the unused output back around the balancer and distributing it among the inputs. Other times, this is not an option. Universal balancers solve this issue by having the back-looping built in. These balancers can balance evenly between any inputs and any outputs. Universal balancers can be throughput limited. If a universal balancer is throughput limited, the bottleneck may be in the loops or the balancer itself. A throughput limited universal balancer may only have the capacity for a few unused outputs. When more than the number of allowed outputs backs up, the universal balancer behaves like a normal balancer, and may not balance properly. {{clear}}		Many balancers fail to balance properly once an output backs up or if an output is not used. In essence this means that an n-n balancer is not a functional n-(n-1) balancer. Sometimes this can be fixed by looping the unused output back around the balancer and distributing it among the inputs. Other times, this is not an option. Universal balancers solve this issue by having the back-looping built in. These balancers can balance evenly between any inputs and any outputs. Universal balancers can be throughput limited. If a universal balancer is throughput limited, the bottleneck may be in the loops or the balancer itself. A throughput limited universal balancer may only have the capacity for a few unused outputs. When more than the number of allowed outputs backs up, the universal balancer behaves like a normal balancer, and may not balance properly.

			The following are some designs for universal balancers:
			<gallery class="center" widths=200px heights=300px>
			3to2 balancer.png\|A 3→2 universal balancer. {{BlueprintString\|bp-string=0eNqdlm2PgyAMx79LX7NFEFT8KpfLZW5kIXFoEC9nFr/74UxuywY37CsfUn4t/7aUKzTtqHqrjYP6CvrYmQHqjysM+mwO7fLPHC4KanD2YIa+s27XqNbBTECbk/qBms4kYD70rXZO2QdDNn8SUMZpp9Xq5PYxfZnx0njLmpKIMwJ9N/hlnVk8eNQuL4u9IDD5V5rvxbzE8ERjW2j8j8Y8jcBJW3VcTaoAO9/CFu8i5eRFteCOHyIMUMSWmPL4fikLwAtcarJwqCWORsO0Cpfo7HnjPMCWODZNEpVmuDKK6EA39Q+LCxGqeMpw5ZWkMr330+jPCnu2nX+m4Feh3dQva7vR9eNyNL064KiKkxGhRVrDvqEUm9q+ilBKVNKrpJxXKLZMYktkyuVjxrWJJJxlaeLyf8VluIlURmi4iRSj4WZQjMZR7R2jCVThlIFT018ZtFMXT7pfVAh8KzvcLETBJJdSCCaKnNF5/gVDYNZh}}
			3to4_balancer.png\|A 3→4 universal balancer. {{BlueprintString\|bp-string=0eNqdl9tuwyAMht+Fa1YFEhLIq0zT1AOqkFISJWRaVeXdR9pp7RrcgK96kPvZ/vHvkgvZNaPuemMdqS/E7Fs7kPr9QgZztNtm/s5uT5rUxPVbO3Rt7952unFkosTYg/4mNZtoIHzoGuOc7h8C+fRBibbOOKNvSa4fzp92PO18ZM0okIySrh38z1o7Z/Cot1zKjaDk7N+yfCOmuYYnGk+hlWu0PIVWrdEKutAp2OMvhYcpIqUmsVZTGVdT+bqmCneGLEyTKTT1j0bJwfR6fwspAmyFY2fhSln2hxv9uPfHvvWvMa1nz8UyP7nu3M2odnTdOJttmY/FHVf1WmCGdAmkAtImEK7ATTjUrEg7IxF1RsZCRxTpqOJe93OSEDXJYfmrFkJ0nONUjOEYznESWO8ZatPIKBk4Q7p5KcT6nHCcBxWgS46iQSoXKENDNIGiQZ2WqO0gY2aVV8hV8WIA4GXOZeKmUBEdKNSeALTOMxRtobUMsXH3vhKoFOcmiIb7Q4Noafe+CqDg7n1QTUkuKh5p63s0r1DwKmpsZNKFFRITZ5Mq0L5/ujFOnzzp/kxFyZfuh2uEKLkqlBKCizLnbJp+AAYgVgk=}}
			4to3_balancer.png\|A 4→3 universal balancer. {{BlueprintString\|bp-string=0eNqdl9uOgyAQht+Fa9sIiIqvstlseiANiUWDuNmm8d0X213btEwLc9VD4JsD/8/omWzbUfVWG0eaM9G7zgyk+TiTQR/Mpp3/M5ujIg1xdmOGvrNutVWtI1NGtNmrH9LQKQssH/pWO6fs3UI2fWZEGaedVtcglx+nLzMet35lQzMgWEb6bvDbOjNH8KgVr+VaZOTkv+Zr4WPstVW764p6TugBzVLQNYimLMDmKezynh2AFSmw6g1MpMDEG1iZAJP5H4w+drAIkCsMOerYa4yi4k5dYhRFw62lOUZCEIxiJATBbsZZHB0scOlcCMIxOoQySnJIAekweKZUxFVbvqwWZRQWYxSKcgoH8ryZY/QXtD3Yzn++1zB/bmVG3KmfQd3o+nEeDs/RJC7ac1+WYNoAsVged4z/hmfvO88oxqFA5xnDwBgA4xi7Q5mhxg+UmcA4lUc5lZUYNpRolaZNEeEEWJw1LtgLI8CuY6gpVcQ99iS6rIhh0jhmteQZgiTNLAFAUDOriLnFOWqCQcUmjSyo2BIjkxKAVZjbDYLVmAsJgknMmV5g/s1FO3X0O2/vSxn5Vna47BElk4WUQjBRckan6Rf0c1Ey}}
			4to4_balancer.png\|A 4→4 universal balancer. {{BlueprintString\|bp-string=0eNqdlutugzAMhd/Fv9OKOIQWXmWapl6iKhINKIRpVcW7L9BqnVa8Ev/iouTzAZ+j+Ar7ujetty5AdQV7aFwH1dsVOntyu3p853ZnAxUEv3Nd2/iw2ps6wCDAuqP5gkoOYmZ519Y2BON/LcThXYBxwQZrbkWmh8uH68/7uLKSgigmoG26uK1xY4WIWqkiX2sBl3iLeq2HUcMfGqbQ8BVNpdDUK1ounv7T7DfeKfk8Radokq80Fcs04f+aNrweqnnalkfDeVrJc8RIE3C03hxuS/IZtsx4BnmCS5yjP6LRxzD5k2/idYl4NfHDpR33Nn1o+zG7zwUwrYBKLqB4ZiWMIXMejnCG1DyjZYusUfB8lxFaNzynUbjtstyrO0YSmJLXkGyR/zFj9UeWxNHAO2nklsAhM52Tvp/wWEdkBxUznEv5eZIFyN/AO4/IJhU8HKWOdzLJgsBtWaEmcSUr1BROZUkDhtwQGMlrAaUKk0aMm6o4M9pgznHPY1IV8Gl8N+3RBZZ5WWqNulAoh+EbnvV36g==}}
			</gallery>
			{{clear}}

	== Lane balancers ==		== Lane balancers ==

Cardinal at 08:02, 13 March 2025

2025-03-13T08:02:47Z

← Older revision		Revision as of 08:02, 13 March 2025
Line 6:		Line 6:
	== Belt balancers ==		== Belt balancers ==

	~~[[File:Balancer_Mechanics1.png\|thumb\|200px\|right\|1 full input belt gets split into two 50% full belts which get split into 4 belts that are each 25% full.]]~~
	Belt balancers utilize the mechanic that splitters output items in a 1:1 ratio onto both their output belts. That means that a splitter can be used to put an equal amount of items on two belts. Since the process can be repeated infinitely, balancers with 2<sup>n</sup> output belts are easy to create.		Belt balancers utilize the mechanic that splitters output items in a 1:1 ratio onto both their output belts. That means that a splitter can be used to put an equal amount of items on two belts. Since the process can be repeated infinitely, balancers with 2<sup>n</sup> output belts are easy to create.
	~~{{clear}}~~
	[[File:Balancer_Mechanics2b.png\|thumb\|450px\|right\|First the belts A and B go through a splitter so that the output belts contain an equal amount of items from each input belt (AB). The same is done with belts C and D. Then the mixed belts AB and CD go through splitters so that their output belts contain items from each input belt (ABCD)!]]
	Balancers also use the mechanic that splitters take an equal amount of items from both input belts. That means that a splitter connected to two input belts will evenly distribute those items onto the the two output belts. To balance belts it has to be made sure that the output belts contain an equal number of items from each input belt.		Balancers also use the mechanic that splitters take an equal amount of items from both input belts. That means that a splitter connected to two input belts will evenly distribute those items onto the the two output belts. To balance belts it has to be made sure that the output belts contain an equal number of items from each input belt.

			<gallery class="center" widths=200px heights=300px>
			File:Balancer_Mechanics1.png\|1 full input belt gets split into two 50% full belts which get split into 4 belts that are each 25% full
			Balancer_Mechanics2b.png\|First the belts A and B go through a splitter so that the output belts contain an equal amount of items from each input belt (AB). The same is done with belts C and D. Then the mixed belts AB and CD go through splitters so that their output belts contain items from each input belt (ABCD)!
			</gallery>

	{{clear}}		{{clear}}

	=== Throughput ===		=== Throughput ===
	~~[[File:4to4_balancer_throughput_limit_demo.gif\|right\|262px]]~~
	Balancers that are '''throughput limited''' may not be able to provide maximum output if one or more outputs are blocked. To be '''throughput ''un''limited''', a balancer must fulfil the following conditions:		Balancers that are '''throughput limited''' may not be able to provide maximum output if one or more outputs are blocked. To be '''throughput ''un''limited''', a balancer must fulfil the following conditions:
	#100% throughput under full load.		#100% throughput under full load.
	#Any arbitrary amount of input belts should be able to go to any arbitrary amount of output belts.		#Any arbitrary amount of input belts should be able to go to any arbitrary amount of output belts.

	Balancers often do not fulfill the second condition because of internal bottlenecks. The ~~gif~~ on the right shows a 4 → 4 balancer being fed by two belts, but only outputting one belt which means that its throughput in that arrangement is 50%. The bottleneck in this balancer is that the two middle belts only get input from one splitter. So, if only one side of that splitter gets input, as can be seen in the gif, it can only output one belt even though the side of the splitter is fed by a splitters which gets two full belts of input. In this particular case, the bottleneck can be fixed by feeding the two middle output belts with more splitters. This is done by adding two more splitters at the end of the balancer, as it can be seen here: ~~[[File~~:4to4_balancer.png\|~~center\|125px]]~~		Balancers often do not fulfill the second condition because of internal bottlenecks. The figure 1 below on the right shows a 4 → 4 balancer being fed by two belts, but only outputting one belt which means that its throughput in that arrangement is 50%. The bottleneck in this balancer is that the two middle belts only get input from one splitter. So, if only one side of that splitter gets input, as can be seen in the gif, it can only output one belt even though the side of the splitter is fed by a splitters which gets two full belts of input. In this particular case, the bottleneck can be fixed by feeding the two middle output belts with more splitters. This is done by adding two more splitters at the end of the balancer, as it can be seen here:

			<gallery class="center" widths=200px heights=300px>
			4to4_balancer_throughput_limit_demo.gif\|Figure 1: a 4 to 4 balancer with 2 belts being fed.
			4to4_balancer.png\|Figure 2:
			</gallery>

	However most balancers' bottlenecks can't be solved as easily. A guaranteed method to achieve throughput unlimited balancers is to place two balancers back to back that fulfil the first condition for throughput unlimited balancers (100% throughput under full load). The resulting balancer is usually larger than a balancer that was initially designed to be throughput unlimited. This is the case because they use more splitters than the minimum required amount of splitters for a throughput unlimited balancer. For n → n balancers where n is a power of two numbers, <code>n×log<sub>2</sub>(n)−n÷2</code> can be used to calculate how many splitters are needed. This formula is based on the number of nodes in a [[WIKIPEDIA:Clos_network#Bene%C5%A1_network_(m_=_n_=_2)\|Beneš network]], which is essentially the same as a throughput unlimited balancer — it allows any input to reach any output.		However most balancers' bottlenecks can't be solved as easily. A guaranteed method to achieve throughput unlimited balancers is to place two balancers back to back that fulfil the first condition for throughput unlimited balancers (100% throughput under full load). The resulting balancer is usually larger than a balancer that was initially designed to be throughput unlimited. This is the case because they use more splitters than the minimum required amount of splitters for a throughput unlimited balancer. For n → n balancers where n is a power of two numbers, <code>n×log<sub>2</sub>(n)−n÷2</code> can be used to calculate how many splitters are needed. This formula is based on the number of nodes in a [[WIKIPEDIA:Clos_network#Bene%C5%A1_network_(m_=_n_=_2)\|Beneš network]], which is essentially the same as a throughput unlimited balancer — it allows any input to reach any output.
Line 27:		Line 35:

	== Lane balancers ==		== Lane balancers ==
	~~[[File:Lane_balancer_mechanics.png\|thumb\|right\|This output balanced lane balancer distributes the items evenly among the output lanes, achieving output balance.]]~~
	Lane balancers may be output balanced or input balanced. Input balanced lane balancers draw evenly from each side of the input belt, while output balanced lane balancers output evenly onto each lane of the output belt. {{clear}}		Lane balancers may be output balanced or input balanced. Input balanced lane balancers draw evenly from each side of the input belt, while output balanced lane balancers output evenly onto each lane of the output belt. {{clear}}
			<gallery class="center" widths=200px heights=300px>
			Lane_balancer_mechanics.png\|This output balanced lane balancer distributes the items evenly among the output lanes, achieving output balance. {{BlueprintString\|bp-string=0eNqd01GLwyAMAOD/kmc3qlU7+1fGcbRbOIQ2LeqOG8X/PruN3cNZuPmmknwmhCzQDxecnaUA7QL2NJGH9riAt1/UDesbdSNCC8F15OfJhV2PQ4DIwNIZf6Dl8YMBUrDB4iP3frl+0mXs0aUAtmEwmCef0iZa/0nUTlZ8rxhc01Ec9ipG9kcTZZrJa/U7mnhpTdIYnK3D0yNEZmxZZut8paqs7yav6Xe0artvLjJ4U4ZvNH4oa1z/Z0TmZft5sCGkt+xwnqbKV8irshLlBle4MPXKpV20AceU+7vYDL7R+XuW0sJIY5QSSteCx3gD6bVJ7A==}}
			Lane_balancer2.png\|This output distributes all kinds of items evenly amont both lanes of the belt. {{BlueprintString\|bp-string=0eNqdl+uKwyAQhd/F32mJYzSaVynL0ossQmpCYpctJe++9kKXpQ7V+ZeE+OU4c4zHC9v1JztOzgfWXZjbD35m3ebCZvflt/31md8eLetYmLZ+HocprHa2D2ypmPMH+8M6vnxUzPrggrP3sbeb86c/HXd2ii9UCKNi4zDHYYO/fieiVkLrtazY+XrZrOWyVC80oNFEmiaetHnsXQjxWYpjHhRIU5oCTaZ+aopXsYwHN9n9/ZUmwZa0+fK0UkWj1WlaW0Iz77RpGg3RZkpoLd4TDgk4r0kdB5PWykuWiOH/cG8NxIEG14hWQZu6zitsQzLBayXSdEmjY6VQJI+hLmhpOEydpjVKIThDs5HK8SjUWf9hUz+gLbI30LaaTI1AM4/KsiYIWvOxShStI1UqVtLEItYCRbOWRHAtzfgyb+6a5jFMrKG5CsGJwoWEhCzBafbBVAHNLzJnXYrMDKffTLmh9RULlrTcBkjCFIpmE0wdLbmh6nRRjAYkAApDqxmSAJuahOO37TmeaVywxzj274BUsW87zbdRUoFpjJESpBLAl+UXi2FA1w==}}
			</gallery>

	== See also ==		== See also ==

Ickputzdirwech: category

2023-09-24T17:56:23Z

Bilka: /* Throughput */ `tag instead of abusing key template`


2020-11-23T11:18:07Z
Throughput:  <code> tag instead of abusing key template

				
				
				
				
				
				← Older revision
				Revision as of 11:18, 23 November 2020
				
Line 21:
Line 21:
Balancers often do not fulfill the second condition because of internal bottlenecks. The gif on the right shows a 4 &rarr; 4 balancer being fed by two belts, but only outputting one belt which means that its throughput in that arrangement is 50%. The bottleneck in this balancer is that the two middle belts only get input from one splitter. So, if only one side of that splitter gets input, as can be seen in the gif, it can only output one belt even though the side of the splitter is fed by a splitters which gets two full belts of input. In this particular case, the bottleneck can be fixed by feeding the two middle output belts with more splitters. This is done by adding two more splitters at the end of the balancer, as it can be seen here: [[File:4to4_balancer.png|center|125px]] Balancers often do not fulfill the second condition because of internal bottlenecks. The gif on the right shows a 4 &rarr; 4 balancer being fed by two belts, but only outputting one belt which means that its throughput in that arrangement is 50%. The bottleneck in this balancer is that the two middle belts only get input from one splitter. So, if only one side of that splitter gets input, as can be seen in the gif, it can only output one belt even though the side of the splitter is fed by a splitters which gets two full belts of input. In this particular case, the bottleneck can be fixed by feeding the two middle output belts with more splitters. This is done by adding two more splitters at the end of the balancer, as it can be seen here: [[File:4to4_balancer.png|center|125px]]



However most balancers' bottlenecks can't be solved as easily. A guaranteed method to achieve throughput unlimited balancers is to place two balancers back to back that fulfil the first condition for throughput unlimited balancers (100% throughput under full load). The resulting balancer is usually larger than a balancer that was initially designed to be throughput unlimited. This is the case because they use more splitters than the minimum required amount of splitters for a throughput unlimited balancer. For n &rarr; n balancers where n is a power of two numbers, {{Key|n×log<sub>2</sub>(n)−n÷2}} can be used to calculate how many splitters are needed. This formula is based on the number of nodes in a [[WIKIPEDIA:Clos_network#Bene%C5%A1_network_(m_=_n_=_2)|Beneš network]], which is essentially the same as a throughput unlimited balancer — it allows any input to reach any output. However most balancers' bottlenecks can't be solved as easily. A guaranteed method to achieve throughput unlimited balancers is to place two balancers back to back that fulfil the first condition for throughput unlimited balancers (100% throughput under full load). The resulting balancer is usually larger than a balancer that was initially designed to be throughput unlimited. This is the case because they use more splitters than the minimum required amount of splitters for a throughput unlimited balancer. For n &rarr; n balancers where n is a power of two numbers, <code>n×log<sub>2</sub>(n)−n÷2</code> can be used to calculate how many splitters are needed. This formula is based on the number of nodes in a [[WIKIPEDIA:Clos_network#Bene%C5%A1_network_(m_=_n_=_2)|Beneš network]], which is essentially the same as a throughput unlimited balancer — it allows any input to reach any output.



=== Universal balancers === === Universal balancers ===

← Older revision		Revision as of 17:56, 24 September 2023
Line 40:		Line 40:
	* [https://forums.factorio.com/61424 Belt Balancers - how they work and how to make them]		* [https://forums.factorio.com/61424 Belt Balancers - how they work and how to make them]
	* [https://forums.factorio.com/63462 Finding balance: A guide to belt balancers]		* [https://forums.factorio.com/63462 Finding balance: A guide to belt balancers]

			{{C\|Belt transport system{{!}}#Balancer mechanics}}

← Older revision		Revision as of 11:18, 23 November 2020
Line 21:		Line 21:
	Balancers often do not fulfill the second condition because of internal bottlenecks. The gif on the right shows a 4 → 4 balancer being fed by two belts, but only outputting one belt which means that its throughput in that arrangement is 50%. The bottleneck in this balancer is that the two middle belts only get input from one splitter. So, if only one side of that splitter gets input, as can be seen in the gif, it can only output one belt even though the side of the splitter is fed by a splitters which gets two full belts of input. In this particular case, the bottleneck can be fixed by feeding the two middle output belts with more splitters. This is done by adding two more splitters at the end of the balancer, as it can be seen here: [[File:4to4_balancer.png\|center\|125px]]		Balancers often do not fulfill the second condition because of internal bottlenecks. The gif on the right shows a 4 → 4 balancer being fed by two belts, but only outputting one belt which means that its throughput in that arrangement is 50%. The bottleneck in this balancer is that the two middle belts only get input from one splitter. So, if only one side of that splitter gets input, as can be seen in the gif, it can only output one belt even though the side of the splitter is fed by a splitters which gets two full belts of input. In this particular case, the bottleneck can be fixed by feeding the two middle output belts with more splitters. This is done by adding two more splitters at the end of the balancer, as it can be seen here: [[File:4to4_balancer.png\|center\|125px]]

	However most balancers' bottlenecks can't be solved as easily. A guaranteed method to achieve throughput unlimited balancers is to place two balancers back to back that fulfil the first condition for throughput unlimited balancers (100% throughput under full load). The resulting balancer is usually larger than a balancer that was initially designed to be throughput unlimited. This is the case because they use more splitters than the minimum required amount of splitters for a throughput unlimited balancer. For n → n balancers where n is a power of two numbers, ~~{{Key\|~~n×log<sub>2</sub>(n)−n÷2}} can be used to calculate how many splitters are needed. This formula is based on the number of nodes in a [[WIKIPEDIA:Clos_network#Bene%C5%A1_network_(m_=_n_=_2)\|Beneš network]], which is essentially the same as a throughput unlimited balancer — it allows any input to reach any output.		However most balancers' bottlenecks can't be solved as easily. A guaranteed method to achieve throughput unlimited balancers is to place two balancers back to back that fulfil the first condition for throughput unlimited balancers (100% throughput under full load). The resulting balancer is usually larger than a balancer that was initially designed to be throughput unlimited. This is the case because they use more splitters than the minimum required amount of splitters for a throughput unlimited balancer. For n → n balancers where n is a power of two numbers, <code>n×log<sub>2</sub>(n)−n÷2</code> can be used to calculate how many splitters are needed. This formula is based on the number of nodes in a [[WIKIPEDIA:Clos_network#Bene%C5%A1_network_(m_=_n_=_2)\|Beneš network]], which is essentially the same as a throughput unlimited balancer — it allows any input to reach any output.

	=== Universal balancers ===		=== Universal balancers ===