eytelwein.belt_conveyor_design package

Subpackages

Submodules

Module contents

class eytelwein.belt_conveyor_design.IdlerSets(*values)[source]

Bases: Enum

DEEP_TROUGH = 4
FIVE_TROUGH = 5
FLAT_TROUGH = 1
THREE_TROUGH = 3
V_TROUGH = 2
to_int() → int[source]
eytelwein.belt_conveyor_design.angle_of_inclination_from_height_difference_and_section_length(height_difference: Quantity, section_length: Quantity, unit: str = 'radian', precision: int = 3) → Quantity[source]

Calculate the angle of inclination from the height difference and section length.

This function calculates the angle of inclination of a conveyor section based on its height difference and section length using the formula:

α = arcsin(H / L)

Where: - α is the angle of inclination - H is the height difference - L is the section length

Parameters:

  • height_difference (Quantity) – The vertical height difference of the conveyor section (typically in meters).

  • section_length (Quantity) – The length of the conveyor section (typically in meters).

  • unit (str, optional) – The desired unit for the output angle. Default is “radian”. Common alternatives are “degree”.

  • precision (int, optional) – The number of decimal places for the result. Default is 3.

Returns:

The calculated angle of inclination with the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting units: {e} If the section length is negative or zero. If the height difference is greater than the section length in magnitude.

eytelwein.belt_conveyor_design.belt_edge_distance(belt_width: Quantity, used_belt_width: Quantity, unit: str = 'millimeter', precision: int = 2) → Quantity[source]

Calculate the distance between the edge of the belt and the used belt width on each side.

This function assumes that the belt is symmetric, so the distance is the same on both sides. It calculates half the difference between the total belt width and the used belt width.

Parameters: belt_width (Quantity): The total width of the belt as a Quantity. used_belt_width (Quantity): The width of the belt that is actually used or the usable belt width. unit (str, optional): The unit for the returned distance. Defaults to “millimeter”. precision (int, optional): The number of decimal places to round the result to. Defaults to 2.

Returns: Quantity: The calculated distance from the belt edge to the used belt width on one side.

Raises: ValueError: If there is an error in converting units.

eytelwein.belt_conveyor_design.belt_mass_per_strand(belt_linear_mass: Quantity, center_distance: Quantity, unit: str = 'kilogram', precision: int = 2) → Quantity[source]

Calculate belt mass for one strand.

Parameters:

  • belt_linear_mass (Quantity) – Belt linear mass quantity.

  • center_distance (Quantity) – Conveyor center distance quantity.

  • unit (str, optional) – Output unit, by default "kilogram".

  • precision (int, optional) – Decimal rounding precision, by default 2. Use None to skip rounding.

Returns:

Belt mass per strand in requested unit.

Return type:

Quantity

Raises:

ValueError – If unit conversion fails, inputs are not physically meaningful, or the requested output unit is invalid.

eytelwein.belt_conveyor_design.belt_speed_from_pulley_revolutions(revolutions: Quantity, pulley_diameter: Quantity, unit: str = 'meter/second', precision: int = 2) → Quantity[source]

Calculate the belt speed from the pulley revolutions.

Parameters:

  • revolutions (Quantity) – The number of revolutions value with units.

  • pulley_diameter (Quantity) – The pulley diameter value with units.

  • unit (str, optional) – The unit for the output belt speed (default is “meter/second”).

  • precision (int, optional) – The precision for rounding the result (default is 2).

Returns:

The belt speed in the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting units or if the unit is invalid.

eytelwein.belt_conveyor_design.belt_weight_per_square_meter(tension_member_weight: Quantity, top_cover_thickness: Quantity, bottom_cover_thickness: Quantity, rubber_density: Quantity, unit: str = 'kilogram/meter**2', precision: int = 2) → Quantity[source]

Calculate the total weight per square meter of a conveyor belt.

This function computes the total weight per square meter by summing the weight of the tension member and the combined weight of the top and bottom rubber covers.

Parameters:

  • tension_member_weight – Weight per square meter of the tension member (e.g., fabric or steel cords) as a Quantity with units of kg/m².

  • top_cover_thickness – Thickness of the top rubber cover as a Quantity with units of length (e.g., millimeters or meters).

  • bottom_cover_thickness – Thickness of the bottom rubber cover as a Quantity with units of length (e.g., millimeters or meters).

  • rubber_density – Density of the rubber material as a Quantity with units of kg/m³.

  • unit – The unit for the returned weight. Defaults to “kilogram/meter**2”.

  • precision – The number of decimal places to round the result to. Defaults to 2.

Returns:

The calculated total weight per square meter of the conveyor belt as a Quantity with the specified unit.

Raises:

  • ValueError – If there is an error in converting units or if the input values

  • are not physically meaningful. –

eytelwein.belt_conveyor_design.compensation_length_at_transition_zone(distance_belt_edge_to_deepest_level_of_trough: Quantity, pulley_lift: Quantity, maximal_allowed_pulley_lift: Quantity, unit: str = 'meter', precision: int = 2) → Quantity[source]

Calculates the compensation length at the transition zone of a conveyor belt. This function computes the compensation length based on the distance from the belt edge to the deepest level of the trough, the pulley lift, and the maximal allowed pulley lift. The result is returned in the specified unit with an optional precision. :param distance_belt_edge_to_deepest_level_of_trough: The distance from the belt edge to the deepest level of the trough. :type distance_belt_edge_to_deepest_level_of_trough: Quantity :param pulley_lift: The lift of the pulley. :type pulley_lift: Quantity :param maximal_allowed_pulley_lift: The maximum allowed lift of the pulley. :type maximal_allowed_pulley_lift: Quantity :param unit: The unit in which the result should be returned. Defaults to “meter”. :type unit: str, optional :param precision: The number of decimal places to round the result to. Defaults to 2. :type precision: int, optional

Returns:

The compensation length at the transition zone in the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting input values or if the unit is invalid.

eytelwein.belt_conveyor_design.convert_equivalent_angle_of_slope_to_surcharge_angle(equivalent_slope_angle: Quantity, unit: str = 'degree', precision: int = 5) → Quantity[source]
eytelwein.belt_conveyor_design.convert_surcharge_angle_to_equivalent_angle_of_slope(surcharge_angle: Quantity, unit: str = 'degree', precision: int = 5) → Quantity[source]
eytelwein.belt_conveyor_design.convert_surcharge_angles(slope_angle: Quantity | None = None, surcharge_angle: Quantity | None = None, unit: str = 'degree', precision: int = 5) → dict[source]
eytelwein.belt_conveyor_design.cross_section_from_mass_flow_speed_density(mass_flow: Quantity, belt_speed: Quantity, bulk_density: Quantity, unit: str = 'meter**2', precision: int = 5) → Quantity[source]
eytelwein.belt_conveyor_design.cross_section_from_volume_flow_speed(volume_flow: Quantity, belt_speed: Quantity, unit: str = 'meter**2', precision: int = 5) → Quantity[source]
eytelwein.belt_conveyor_design.cross_section_of_fill(center_roll_length: Quantity, usable_belt_width: Quantity, troughing_angle: Quantity, equivalent_slope_angle: Quantity, unit: str = 'millimeter**2', precision: int = 5) → Quantity[source]

Calculate the total cross-sectional area of the belt fill.

This function calculates the total cross-sectional area by summing the partial cross-sectional areas at water fill and above water fill. The calculations are based on the given center roll length, usable belt width, troughing angle, and equivalent slope angle.

Parameters: center_roll_length (Quantity): The length of the center roll as a Quantity with units of millimeters. usable_belt_width (Quantity): The usable width of the belt as a Quantity with units of millimeters. troughing_angle (Quantity): The troughing angle as a Quantity with units of degrees. equivalent_slope_angle (Quantity): The equivalent slope angle as a Quantity with units of degrees. unit (str, optional): The unit for the returned area. Defaults to “millimeter**2”. precision (int, optional): The number of decimal places to round the result to. Defaults to 5.

Returns: Quantity: The calculated total cross-sectional area as a Quantity with the specified unit.

Raises: ValueError: If there is an error in converting units or if the calculated area is negative.

eytelwein.belt_conveyor_design.difference_edge_and_center_belt_tensions_steel_cord_belts(length_of_belt_edge_in_transition_zone: Quantity, minimal_transition_length: Quantity, reference_length_of_transition_zone_for_steel_cord_belts: Quantity, elastic_modulus: Quantity, unit: str = 'newton / millimeter', precision: int = 2) → Quantity[source]

Calculate the difference between edge and center belt tensions for steel cord belts. This function computes the difference in tensions between the edge and center of a steel cord belt based on the provided parameters. The calculation considers the length of the belt edge in the transition zone, the minimal transition length, a reference length for steel cord belts, and the elastic modulus of the belt material. :param length_of_belt_edge_in_transition_zone: The length of the belt edge in the transition zone,

specified as a Pint Quantity.

Parameters:

  • minimal_transition_length (Quantity) – The minimal transition length, specified as a Pint Quantity.

  • reference_length_of_transition_zone_for_steel_cord_belts (Quantity) – The reference length of the transition zone for steel cord belts, specified as a Pint Quantity.

  • elastic_modulus (Quantity) – The elastic modulus of the belt material, specified as a Pint Quantity.

  • unit (str, optional) – The desired output unit for the result. Defaults to “newton / milimeter”.

  • precision (int, optional) – The number of decimal places to round the result to. Defaults to 6.

Returns:

The difference between edge and center belt tensions, expressed as a Pint Quantity in the specified unit.

Return type:

Quantity

Raises:

  • ValueError – If there is an error in converting input values to the required units or if the

  • specified unit is invalid. –

Notes

  • The function internally uses a helper function _difference_edge_and_center_belt_tensions_steel_cord_belts to perform the core calculation.

  • The input quantities must be compatible with the expected units for proper conversion and calculation.

eytelwein.belt_conveyor_design.difference_edge_and_center_belt_tensions_textile_belts(length_of_belt_edge_in_transition_zone: Quantity, minimal_transition_length: Quantity, elastic_modulus: Quantity, unit: str = 'newton / millimeter', precision: int = 2) → Quantity[source]

Calculate the difference between edge and center belt tensions for steel cord belts. This function computes the difference in tensions between the edge and center of a steel cord belt based on the provided parameters. The calculation considers the length of the belt edge in the transition zone, the minimal transition length, a reference length for steel cord belts, and the elastic modulus of the belt material. :param length_of_belt_edge_in_transition_zone: The length of the belt edge in the transition zone,

specified as a Pint Quantity.

Parameters:

  • minimal_transition_length (Quantity) – The minimal transition length, specified as a Pint Quantity.

  • elastic_modulus (Quantity) – The elastic modulus of the belt material, specified as a Pint Quantity.

  • unit (str, optional) – The desired output unit for the result. Defaults to “newton / milimeter”.

  • precision (int, optional) – The number of decimal places to round the result to. Defaults to 6.

Returns:

The difference between edge and center belt tensions, expressed as a Pint Quantity in the specified unit.

Return type:

Quantity

Raises:

  • ValueError – If there is an error in converting input values to the required units or if the

  • specified unit is invalid. –

Notes

  • The function internally uses a helper function _difference_edge_and_center_belt_tensions_steel_cord_belts to perform the core calculation.

  • The input quantities must be compatible with the expected units for proper conversion and calculation.

eytelwein.belt_conveyor_design.distance_belt_edge_deepest_level_of_trough(part_of_belt_lying_on_side_idler: Quantity, troughing_angle: Quantity, unit: str = 'millimeter', precision: int = 2) → Quantity[source]

Calculates the distance from the belt edge to the deepest level of the trough. This function computes the distance based on the part of the belt lying on the side idler and the troughing angle. The result is returned in the specified unit with the desired precision. :param part_of_belt_lying_on_side_idler: The portion of the belt lying

on the side idler, provided as a Pint Quantity.

Parameters:

  • troughing_angle (Quantity) – The troughing angle, provided as a Pint Quantity.

  • unit (str, optional) – The desired unit for the result. Defaults to “millimeter”.

  • precision (int, optional) – The number of decimal places to round the result to. If None, no rounding is applied. Defaults to 2.

Returns:

The calculated distance from the belt edge to the deepest level of the trough, in the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting the input values or if the specified unit is invalid.

eytelwein.belt_conveyor_design.distance_belt_edge_to_pulley_surface_level(distance_belt_edge_to_deepest_level_of_trough: Quantity, pulley_lift: Quantity, unit: str = 'millimeter', precision: int = 2) → Quantity[source]

Calculates the distance from the belt edge to the pulley surface level. This function computes the distance from the edge of a belt to the surface level of a pulley, taking into account the distance to the deepest level of the trough and the pulley lift. The result is returned in the specified unit with the desired precision. :param distance_belt_edge_to_deepest_level_of_trough: The distance from the belt edge to the deepest level of the trough,

expressed as a Pint Quantity.

Parameters:

  • pulley_lift (Quantity) – The lift of the pulley, expressed as a Pint Quantity.

  • unit (str, optional) – The unit in which the result should be returned. Defaults to “millimeter”.

  • precision (int, optional) – The number of decimal places to round the result to. If None, no rounding is applied. Defaults to 2.

Returns:

The calculated distance from the belt edge to the pulley surface level, expressed as a Pint Quantity in the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting the input values to the desired unit or if the specified unit is invalid.

eytelwein.belt_conveyor_design.effective_filling_ratio(filling_ratio_operations: float, reduction_factor_inclined_fill: Quantity, unit: str = 'dimensionless', precision: int = 5) → Quantity[source]

Calculate the effective filling ratio of a conveyor belt.

The effective filling ratio represents how much of a conveyor belt’s theoretical cross-section is actually filled with material under operational conditions, considering both the operational filling ratio and the reduction due to inclined fill.

The formula used is: effective_filling_ratio = filling_ratio_operations * reduction_factor_inclined_fill

Parameters: filling_ratio_operations (float): The filling ratio under operational conditions,

a dimensionless value typically between 0 and 1 representing the operational filling level compared to the theoretical maximum.

reduction_factor_inclined_fill (Quantity): The reduction factor for inclined fill,

a dimensionless quantity that accounts for material distribution on inclined belts.

unit (str, optional): The unit for the returned value. Must be dimensionless.

Defaults to “dimensionless”.

precision (int, optional): The number of decimal places to round the result to.

Defaults to 5.

Returns: Quantity: The calculated effective filling ratio as a dimensionless Quantity.

Raises: ValueError: If there is an error in converting units or if the input values are invalid.

eytelwein.belt_conveyor_design.effective_filling_ratio_from_areas(theoretical_cross_section_of_fill: Quantity, actual_cross_section: Quantity, unit: str = 'dimensionless', precision: int = 5) → Quantity[source]

Calculate the effective filling ratio based on the areas of the cross-section.

This function computes the effective filling ratio by dividing the actual cross-section by the theoretical cross-section. It is used in material handling or bulk solids transport to determine how full the conveyor belt is compared to its theoretical capacity.

Parameters:

  • theoretical_cross_section_of_fill (Quantity) – The theoretical maximum cross-sectional area of the fill. Can be in any area unit.

  • actual_cross_section (Quantity) – The actual cross-sectional area of the fill. Should have the same unit as theoretical_cross_section_of_fill.

  • unit (str, optional) – The desired output unit, defaults to “dimensionless”. Must be a dimensionless unit.

  • precision (int, optional) – The precision of the result (number of decimal places). Default is 5.

Returns:

The effective filling ratio as a dimensionless value typically between 0 and 1.

Return type:

Quantity

Raises:

ValueError – If the theoretical_cross_section_of_fill is zero or negative. If the units of theoretical_cross_section_of_fill and actual_cross_section are not compatible. If the specified output unit is not dimensionless.

eytelwein.belt_conveyor_design.friction_resistance_of_skirting_board_from_material_flow(material_mass_flow: Quantity, belt_velocity: Quantity, material_density: Quantity, rankine_coefficient: Quantity, skirting_board_width: Quantity, skirting_board_length: Quantity, central_roller_length: Quantity, troughing_angle: Quantity, friction_coefficient_material_skirting: Quantity, unit: str = 'newton', precision: int | None = 2) → Quantity[source]

Calculate friction resistance between material and lateral skirting board.

Computes the friction resistance force occurring between conveyed material and the lateral skirting (chute) boards outside the acceleration zone of feeding points. This force arises from the material’s inertia and friction with the skirting surface as material flows through the troughed conveyor.

This calculation is based on the friction resistance formula, which accounts for complex interactions between material velocity, geometry, and friction properties.

Parameters:

  • material_mass_flow (Quantity) – Mass flow of conveyed material (typically in kg/s)

  • belt_velocity (Quantity) – Velocity of the conveyor belt (typically in m/s)

  • material_density (Quantity) – Bulk material density (typically in kg/m³)

  • rankine_coefficient (Quantity) – Rankine coefficient (empirical dimensionless factor)

  • skirting_board_width (Quantity) – Width of the lateral skirting board (typically in m)

  • skirting_board_length (Quantity) – Length of the lateral skirting board (typically in m)

  • central_roller_length (Quantity) – Length of the central roller in the 3-roller idler set (typically in m)

  • troughing_angle (Quantity) – Troughing angle of the conveyor belt (angle of trough formation). Typically in degrees or radians.

  • friction_coefficient_material_skirting (Quantity) – Coefficient of friction between material and skirting surface (dimensionless)

  • unit (str, optional) – The unit for the returned resistance. Default is “newton”.

  • precision (int or None, optional) – The number of decimal places for the result. Default is 2. If None, no rounding is applied.

Returns:

Friction resistance force with the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting units. If any required parameter has incorrect dimensions. If any input values are physically invalid.

See also

friction_resistance_per_meter_of_skirting_board_from_material_flow

Calculate the friction resistance per unit length (distributed force).

Notes

This function calculates the friction resistance between material conveyed and lateral chutes outside the acceleration zone of feeding points, based on the skirting friction formula:

\[F_{\text{Sch}} = c_{\text{Rank}} \left[ \frac{I_m}{v \rho} - \frac{(b_{\text{Sch}}^{2} - l_{M}^{2}) \tan \lambda}{4} \right]^{2} \cdot \frac{\rho g l_{\text{Sch}} \mu_2}{b_{\text{Sch}}^{2}}\]

Where: - \(F_{\text{Sch}}\) is the friction resistance [N] - \(c_{\text{Rank}}\) is the Rankine coefficient [] - \(I_m\) is the material mass flow [kg/s] - \(v\) is the belt velocity [m/s] - \(\rho\) is the bulk material density [kg/m³] - \(b_{\text{Sch}}\) is the skirting board width [m] - \(l_M\) is the central roller length [m] - \(\lambda\) is the troughing angle [radians] - \(g\) is gravitational acceleration [m/s²] - \(l_{\text{Sch}}\) is the skirting board length [m] - \(\mu_2\) is the friction coefficient []

The formula consists of two main components: 1. A complex term involving material dynamics and geometry (squared) 2. A term accounting for normal force and friction on the skirting surface

Physical Interpretation: - Higher material flow → higher resistance - Higher belt velocity → lower resistance (dilution effect) - Larger troughing angle → reduces the dynamic component - Longer/wider skirting → increases resistance from friction

eytelwein.belt_conveyor_design.get_material_bed_depth(length_of_material_on_side_roll: Quantity, troughing_angle: Quantity, center_roll_length: Quantity, slope_angle: Quantity, unit: str = 'millimeter', precision: int = 2) → Quantity[source]

Calculate the material bed depth on a conveyor belt based on the geometry of the belt and material.

This function calculates the material bed depth using the formula:

material_bed_depth = length_of_material_on_side_roll * sin(troughing_angle) +

(center_roll_length/2 + length_of_material_on_side_roll * cos(troughing_angle)) * tan(slope_angle)

Parameters: length_of_material_on_side_roll (Quantity): The length of material on the side roll. troughing_angle (Quantity): The troughing angle of the conveyor belt. center_roll_length (Quantity): The length of the center roll. slope_angle (Quantity): The slope angle of the material. unit (str, optional): The unit for the returned depth. Defaults to “millimeter”. precision (int, optional): The number of decimal places to round the result to. Defaults to 2.

Returns: Quantity: The calculated material bed depth with the specified unit.

Raises: ValueError: If there is an error in converting units.

Calculate the maximum width-related tension at the point of maximum belt tension in the zone of Group A pulleys in the steady operating condition.

Parameters:

  • nominal_belt_strength (Quantity) – The nominal belt strength in newton per millimeter.

  • pulley_load_factor (PulleyLoadFactor, optional) – The pulley load factor, default is PulleyLoadFactor.above_60_up_to_100.

  • unit (str, optional) – The unit for the result, default is “kilonewton”.

  • precision (int, optional) – The precision for rounding the result, default is 2.

Returns:

The maximum width-related tension at the point of maximum belt tension in the zone of Group A pulleys in the steady operating condition.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting nominal_belt_strength or if the unit is invalid.

eytelwein.belt_conveyor_design.get_usable_belt_width_from_skirt_board_width(skirt_board_width: Quantity, center_roll_length: Quantity, troughing_angle: Quantity, unit: str = 'millimeter', precision: int = 5) → Quantity[source]
eytelwein.belt_conveyor_design.gradient_resistance(height_difference: Quantity, line_load_belt: Quantity, line_load_material: Quantity | None = None, unit: str = 'newton', precision: int = 2) → Quantity[source]

Calculate the gradient resistance of a belt conveyor.

This function computes the gradient resistance based on the height difference, line load of the belt, and line load of the material.

The gradient resistance is calculated as:

F_St = H · g · (m’G + m’L)

Where: - F_St is the gradient resistance - H is the height difference - g is the standard gravity (9.81 m/s²) - m’G is the line load of the belt - m’L is the line load of the material

When line_load_material is None, a value of 0 kg/m is used (representing an empty belt).

Parameters:

  • height_difference (Quantity) – The height difference in the conveyor path (typically in meters). line_load_belt : Quantity The line load of the belt (typically in kg/m).

  • line_load_material (Optional[Quantity]) – The line load of the material (typically in kg/m). When None, a value of 0 kg/m is used (representing an empty belt).

  • unit (str, optional) – The unit for the returned resistance. Default is “newton”.

  • precision (int, optional) – The number of decimal places for the result. Default is 2.

Returns:

The gradient resistance with the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting units. If any of the input values are invalid (e.g., negative height difference).

eytelwein.belt_conveyor_design.gradient_resistance_sections(height_differences: Quantity | ndarray, line_load_belt: Quantity | ndarray, line_load_material: Quantity | ndarray | None = None, unit: str = 'newton', precision: int = 2) → Quantity[source]

Calculate gradient resistance for multiple conveyor sections.

This function computes the gradient resistance based on the height differences, line loads of the belt, and line loads of the material for multiple sections

, using vectorized calculations.

The gradient resistance is calculated as:

F_St = H · g · (m’G + m’L)

Where: - F_St is the gradient resistance - H is the height difference - g is the standard gravity (9.81 m/s²) - m’G is the line load of the belt - m’L is the line load of the material

height_differencesQuantity or np.ndarray

The height differences for each section (typically in meters). Can be a single Quantity or a numpy array of Quantities.

line_load_beltQuantity or np.ndarray

The line load of the belt (typically in kg/m). Can be a single value applied to all sections or section-specific values.

line_load_materialOptional[Quantity or np.ndarray]

The line load of the material (typically in kg/m). Can be a single value, section-specific values, or None for return strands. When None, a value of 0 kg/m is used for all sections (representing empty belts).

unitstr, optional

The unit for the returned resistance array. Default is “newton”.

precisionint, optional

The number of decimal places for the results. Default is 2.

Quantity

Array of gradient resistances for each section with the specified unit.

ValueError

If there is an error in converting units. If array dimensions don’t match. If any input values are invalid (e.g., negative height differences).

eytelwein.belt_conveyor_design.height_difference_from_section_length_and_inclination_angle(section_length: Quantity, inclination_angle: Quantity, unit: str = 'meter', precision: int = 3) → Quantity[source]

Calculate the height difference from the section length and inclination angle.

This function calculates the vertical height difference of a conveyor section based on its length and inclination angle using the formula:

H = L * sin(α)

Where: - H is the height difference - L is the section length - α is the inclination angle

Parameters:

  • section_length (Quantity) – The length of the conveyor section (typically in meters).

  • inclination_angle (Quantity) – The angle of inclination of the conveyor (typically in degrees).

  • unit (str, optional) – The desired unit for the output height difference. Default is “meter”.

  • precision (int, optional) – The number of decimal places for the result. Default is 3.

Returns:

The calculated height difference with the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting units: {e} If the section length is negative.

eytelwein.belt_conveyor_design.inertia_per_drive(inertia_total_motor_shaft: Quantity, motor_count: int, unit: str = 'kilogram * meter**2', precision: int = 2) → Quantity[source]

Calculate reflected inertia per drive motor.

Parameters:

  • inertia_total_motor_shaft (Quantity) – Total reflected motor-shaft inertia quantity.

  • motor_count (int) – Number of drives sharing load.

  • unit (str, optional) – Output unit, by default "kilogram * meter**2".

  • precision (int, optional) – Decimal rounding precision, by default 2. Use None to skip rounding.

Returns:

Per-drive reflected inertia in requested unit.

Return type:

Quantity

Raises:

ValueError – If unit conversion fails, total inertia is negative, motor count is less than 1, or requested output unit is invalid.

eytelwein.belt_conveyor_design.length_of_belt_edge_in_transition_zone(minimal_transition_length: Quantity, pulley_lift: Quantity, part_of_belt_lying_on_side_idler: Quantity, troughing_angle: Quantity, unit: str = 'meter', precision: int = 6) → Quantity[source]

Calculate the length of the belt edge in the transition zone. This function computes the length of the belt edge in the transition zone based on the minimal transition length, pulley lift, part of the belt lying on the side idler, and the troughing angle. The result can be returned in a specified unit with a given precision. :param minimal_transition_length: The minimal transition length,

provided as a Pint Quantity.

Parameters:

  • pulley_lift (Quantity) – The vertical lift of the pulley, provided as a Pint Quantity.

  • part_of_belt_lying_on_side_idler (Quantity) – The portion of the belt lying on the side idler, provided as a Pint Quantity.

  • troughing_angle (Quantity) – The troughing angle, provided as a Pint Quantity.

  • unit (str, optional) – The desired unit for the result. Defaults to “meter”.

  • precision (int, optional) – The number of decimal places to round the result to. If None, no rounding is applied. Defaults to 2.

Returns:

The length of the belt edge in the transition zone, as a Pint Quantity in the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting input values to the required units or if the specified unit is invalid.

eytelwein.belt_conveyor_design.length_of_material_on_side_roll(part_of_belt_lying_on_side_idler: Quantity, belt_edge_distance: Quantity, unit: str = 'millimeter', precision: int = 2) → Quantity[source]

Calculate the length of material on the side roll of a conveyor belt.

This function calculates the effective length of material on the side roll by subtracting the belt edge distance from the part of belt lying on the side idler.

Parameters: part_of_belt_lying_on_side_idler (Quantity): The length of the belt segment that lies on the side idler. belt_edge_distance (Quantity): The distance from the edge of the belt to the point where the material ends. unit (str, optional): The unit for the returned length. Defaults to “millimeter”. precision (int, optional): The number of decimal places to round the result to. Defaults to 2.

Returns: Quantity: The calculated effective length of material on the side roll with the specified unit.

Raises: ValueError: If there is an error in converting units.

eytelwein.belt_conveyor_design.line_load_belt(tension_member_weight: Quantity, belt_width: Quantity, top_cover_thickness: Quantity, bottom_cover_thickness: Quantity, rubber_density: Quantity, unit: str = 'kilogram/meter', precision: int = 2) → Quantity[source]

Calculate the line load of a conveyor belt.

This function computes the total line load (weight per unit length) of a conveyor belt by calculating the weight per square meter and multiplying by the belt width.

Parameters:

  • tension_member_weight – Weight per square meter of the tension member (e.g., fabric or steel cords) as a Quantity with units of kg/m².

  • belt_width – Width of the belt as a Quantity with units of length (e.g., meters).

  • top_cover_thickness – Thickness of the top rubber cover as a Quantity with units of length (e.g., millimeters or meters).

  • bottom_cover_thickness – Thickness of the bottom rubber cover as a Quantity with units of length (e.g., millimeters or meters).

  • rubber_density – Density of the rubber material as a Quantity with units of kg/m³.

  • unit – The unit for the returned line load. Defaults to “kilogram/meter”.

  • precision – The number of decimal places to round the result to. Defaults to 2.

Returns:

The calculated line load of the conveyor belt as a Quantity with the specified unit.

Raises:

  • ValueError – If there is an error in converting units or if the input values

  • are not physically meaningful. –

eytelwein.belt_conveyor_design.line_load_belt_from_belt_weight_per_square_meter(belt_weight_per_square_meter: Quantity, belt_width: Quantity, unit: str = 'kilogram/meter', precision: int = 2) → Quantity[source]

Calculate the line load of a conveyor belt from its weight per square meter.

This function computes the total line load (weight per unit length) of a conveyor belt by multiplying the belt weight per square meter by the belt width.

Parameters:

  • belt_weight_per_square_meter – Weight of the belt per square meter as a Quantity with units of kg/m².

  • belt_width – Width of the belt as a Quantity with units of length (e.g., meters).

  • unit – The unit for the returned line load. Defaults to “kilogram/meter”.

  • precision – The number of decimal places to round the result to. Defaults to 2.

Returns:

The calculated line load of the conveyor belt as a Quantity with the specified unit.

Raises:

  • ValueError – If there is an error in converting units or if the input values

  • are not physically meaningful. –

eytelwein.belt_conveyor_design.line_load_from_nominal_load(theoretical_cross_section: Quantity, effective_filling_ratio: float, bulk_density: Quantity, unit: str = 'kilogram/meter', precision: int = 5) → Quantity[source]
eytelwein.belt_conveyor_design.line_load_from_nominal_mass_flow_speed(nominal_mass_flow: Quantity, belt_speed: Quantity, unit: str = 'kilogram/meter', precision: int = 5) → Quantity[source]

Calculate the local belt force related to the belt width.

Parameters:

  • mean_belt_tension (Quantity) – The mean belt tension value with units.

  • belt_width (Quantity) – The width of the belt with units.

  • unit (str, optional) – The unit for the output local belt force (default is “kilonewton”).

  • precision (int, optional) – The precision for rounding the result (default is 2).

Returns:

The local belt force related to the belt width in the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting values or if the unit is invalid.

eytelwein.belt_conveyor_design.local_center_belt_force(mean_belt_tension_related_to_belt_width: Quantity, part_of_belt_lying_on_side_idler: Quantity, belt_width: Quantity, difference_edge_and_center_belt_tensions: Quantity, unit: str = 'newton / millimeter', precision: int = 2) → Quantity[source]

Calculate the center belt force based on various parameters. This function computes the center belt force using the mean belt tension related to the belt width, the portion of the belt lying on the side idler, the belt width, and the difference between edge and center belt tensions. The result is returned in the specified unit with optional precision. :param mean_belt_tension_related_to_belt_width: The mean belt tension per unit width of the belt, expressed as a

Pint Quantity.

Parameters:

  • part_of_belt_lying_on_side_idler (Quantity) – The portion of the belt lying on the side idler, expressed as a Pint Quantity.

  • belt_width (Quantity) – The total width of the belt, expressed as a Pint Quantity.

  • difference_edge_and_center_belt_tensions (Quantity) – The difference between the edge and center belt tensions, expressed as a Pint Quantity.

  • unit (str, optional) – The desired unit for the output force. Defaults to “kilonewton”.

  • precision (int, optional) – The number of decimal places to round the result to. If None, no rounding is applied. Defaults to 2.

Returns:

The calculated center belt force as a Pint Quantity in the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting input values to the required units or if the specified unit is invalid.

eytelwein.belt_conveyor_design.local_edge_belt_force(local_center_belt_force: Quantity, difference_edge_and_center_belt_tensions: Quantity, unit: str = 'newton / millimeter', precision: int = 2) → Quantity[source]

Calculate the local edge belt force based on the local center belt force and the difference between edge and center belt tensions. :param local_center_belt_force: The local center belt force,

expected to be a Pint Quantity with units convertible to “newton / millimeter”.

Parameters:

  • difference_edge_and_center_belt_tensions (Quantity) – The difference between edge and center belt tensions, expected to be a Pint Quantity with units convertible to “newton / millimeter”.

  • unit (str, optional) – The desired output unit for the result. Defaults to “newton / millimeter”.

  • precision (int, optional) – The number of decimal places to round the result to. If None, no rounding is applied. Defaults to 2.

Returns:

The calculated local edge belt force as a Pint Quantity in the specified unit.

Return type:

Quantity

Raises:

  • ValueError – If the input quantities cannot be converted to “newton / millimeter”.

  • ValueError – If the specified unit is invalid.

eytelwein.belt_conveyor_design.mass_flow_from_cross_section_speed_density(cross_section_of_fill: Quantity, belt_speed: Quantity, bulk_density: Quantity, unit: str = 'kilogram/second', precision: int = 5) → Quantity[source]
eytelwein.belt_conveyor_design.mass_flow_from_volume_flow_density(volume_flow: Quantity, bulk_density: Quantity, unit: str = 'kilogram/second', precision: int = 5) → Quantity[source]
eytelwein.belt_conveyor_design.maximal_allowable_pulley_lift(distance_from_edge_to_deepest_trough_level: Quantity, unit: str = 'millimeter', precision: int = 2) → Quantity[source]

Calculate the maximal allowable pulley lift based on the distance from the edge to the deepest trough level. :param distance_from_edge_to_deepest_trough_level: The distance from the edge to the deepest trough level, provided as a

Pint Quantity object.

Parameters:

  • unit (str, optional) – The desired output unit for the result. Defaults to “millimeter”.

  • precision (int, optional) – The number of decimal places to round the result to. If None, no rounding is applied. Defaults to 2.

Returns:

The maximal allowable pulley lift as a Pint Quantity object, converted to the specified unit.

Return type:

Quantity

Raises:

  • ValueError – If the input distance cannot be converted to meters or if the

  • specified unit is invalid. –

eytelwein.belt_conveyor_design.maximal_cross_section_skirt_board_known_geometry(center_roll_length: Quantity, skirt_board_width: Quantity, skirt_board_height: Quantity, troughing_angle: Quantity, equivalent_slope_angle: Quantity, unit: str = 'millimeter**2', precision: int = 5) → Quantity[source]

Calculate the mean belt tension related to the belt width.

Parameters:

  • local_belt_force (Quantity) – The local belt force value with units.

  • belt_width (Quantity) – The width of the belt with units.

  • unit (str, optional) – The unit for the output mean belt tension (default is “newton / millimeter”).

  • precision (int, optional) – The precision for rounding the result (default is 2).

Returns:

The mean belt tension related to the belt width in the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting local belt force or if the unit is invalid.

eytelwein.belt_conveyor_design.mechanical_power_from_torque_and_belt_speed(torque: Quantity, belt_speed: Quantity, pulley_diameter: Quantity, unit: str = 'kilowatt', precision: int = 2) → Quantity[source]

Calculate the mechanical power from the torque, belt speed, and pulley diameter.

Parameters:

  • torque (Quantity) – The torque value with units.

  • belt_speed (Quantity) – The belt speed value with units.

  • pulley_diameter (Quantity) – The pulley diameter value with units.

  • unit (str, optional) – The unit for the output mechanical power (default is “kilowatt”).

  • precision (int, optional) – The precision for rounding the result (default is 2).

Returns:

The mechanical power in the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting units or if the unit is invalid.

eytelwein.belt_conveyor_design.mechanical_torque_from_belt_force(belt_force: Quantity, pulley_diameter: Quantity, unit: str = 'newton * meter', precision: int = 2) → Quantity[source]

Calculate the mechanical torque from the belt force and pulley diameter.

Parameters:

  • belt_force (Quantity) – The belt force value with units.

  • pulley_diameter (Quantity) – The pulley diameter value with units.

  • unit (str, optional) – The unit for the output mechanical torque (default is “newton * meter”).

  • precision (int, optional) – The precision for rounding the result (default is 2).

Returns:

The mechanical torque in the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting units or if the unit is invalid.

eytelwein.belt_conveyor_design.minimal_transition_length(coefficient_minimum_transition_length: CoefficientMinimumTransitionLength, distance_belt_edge_pulley_surface_level: Quantity, unit: str = 'meter', precision: int = 2) → Quantity[source]

Calculate the minimal transition length for a belt system. This function computes the minimal transition length required for a belt system based on the coefficient of minimum transition length and the distance between the belt edge and the pulley surface level. :param coefficient_minimum_transition_length: The coefficient used to calculate the minimal transition length. :type coefficient_minimum_transition_length: CoefficientMinimumTransitionLength :param distance_belt_edge_pulley_surface_level: The distance between the belt edge and the pulley surface level,

provided as a Pint Quantity.

Parameters:

  • unit (str, optional) – The desired unit for the result. Defaults to “meter”.

  • precision (int, optional) – The number of decimal places to round the result to. If None, no rounding is applied. Defaults to 2.

Returns:

The minimal transition length as a Pint Quantity in the specified unit.

Return type:

Quantity

Raises:

ValueError – If the input distance cannot be converted to meters or if the specified unit is invalid.

eytelwein.belt_conveyor_design.minimum_belt_tension_from_sag_carry(line_load_belt: Quantity, line_load_material: Quantity, idler_spacing: Quantity, allowable_sag: Quantity, unit: str = 'kilonewton', precision: int | None = 5) → Quantity[source]

Calculate minimum belt tension from sag during carry run.

This function applies the relationship between belt tension, belt and material line loads, idler spacing, and allowable sag. All inputs must be strict Quantity objects with explicit units.

Parameters:

  • line_load_belt (Quantity) – Belt line load (mass per unit length) in kg/m or equivalent units.

  • line_load_material (Quantity) – Material line load (mass per unit length) in kg/m or equivalent units.

  • idler_spacing (Quantity) – Distance between consecutive idlers (e.g., 1.5 meter).

  • allowable_sag (Quantity) – Allowable sag as a dimensionless fraction of idler spacing (e.g., 0.01 for 1%). Must be a Quantity with dimensionless units.

  • unit (str, optional) – Output unit for tension result (default: “kilonewton”). Common values: “newton”, “kilonewton”. Must be a force unit.

  • precision (int or None, optional) – Decimal places to round the result to (default: 5). If None, no rounding is applied.

Returns:

Minimum belt tension in the specified output unit.

Return type:

Quantity

Raises:

  • ValueError – If unit conversion fails due to incompatible input units.

  • ValueError – If line_load_belt is negative.

  • ValueError – If line_load_material is negative.

  • ValueError – If idler_spacing is negative.

  • ValueError – If allowable_sag is not positive or invalid.

Examples

>>> from pint import Quantity
>>> from eytelwein.main.units import get_unit_registry
>>> u = get_unit_registry()
>>> result = minimum_belt_tension_from_sag_carry(
...     line_load_belt=Quantity(5.0, u.kilogram / u.meter),
...     line_load_material=Quantity(10.0, u.kilogram / u.meter),
...     idler_spacing=Quantity(1.5, u.meter),
...     allowable_sag=Quantity(0.01, u.dimensionless),
... )
>>> result
2.75812... kilonewton
eytelwein.belt_conveyor_design.minimum_diameter_of_group_A_B_C_pulleys(minimum_diameter_of_group_A_pulleys: Quantity, pulley_load_factor: PulleyLoadFactor, unit: str = 'millimeter', precision: int = 2) → dict[str, Quantity | None][source]

Calculate the minimum diameters of group A, B, and C pulleys.

Parameters:

  • minimum_diameter_of_group_A_pulleys (Quantity) – The minimum diameter of group A pulleys.

  • pulley_load_factor (PulleyLoadFactor) – The pulley load factor.

  • unit (str, optional) – The unit for the result, default is “millimeter”. precision : int, optional The precision for rounding the result, default is 2.

Returns:

A dictionary with the minimum diameters of group A, B, and C pulleys.

Return type:

Dict[str, Quantity[int, None]]

Raises:

ValueError – If there is an error in converting the minimum diameter or if the unit is invalid.

eytelwein.belt_conveyor_design.minimum_diameter_of_group_A_pulleys(minimum_pulley_diameter_coefficient: MinimumPulleyDiameterCoefficient, tension_member_thickness: Quantity, unit: str = 'millimeter', precision: int = 2) → Quantity[source]

Calculate the minimum diameter of a group A pulley.

Parameters:

  • minimum_pulley_diameter_coefficient (MinimumPulleyDiameterCoefficient) – The minimum pulley diameter coefficient, dimensionless.

  • tension_member_thickness (Quantity) – The thickness of the tension member inmillimeters.

  • unit (str, optional) – The unit for the result, default is “millimeter” and “meter” is a useful alternative. precision : int, optional The precision for rounding the result, default is 2 for millimeters, while 1 or 2 would be suitable for “m”.

Returns:

The minimum diameter of a group A pulley usually in millimeters.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting tension_member_thickness or if the unit is invalid.

eytelwein.belt_conveyor_design.motion_resistance_from_torque(torque: Quantity, pulley_diameter: Quantity, unit='kilonewton', precision=2) → Quantity[source]
eytelwein.belt_conveyor_design.motor_shaft_inertia_total(translating_mass: Quantity, drive_pulley_radius: Quantity, gear_ratio_motor_to_pulley: Quantity, unit: str = 'kilogram * meter**2', precision: int = 2) → Quantity[source]

Calculate reflected total inertia at motor shaft.

Parameters:

  • translating_mass (Quantity) – Translating mass quantity.

  • drive_pulley_radius (Quantity) – Drive pulley radius quantity.

  • gear_ratio_motor_to_pulley (Quantity) – Gear ratio quantity defined as omega_motor / omega_pulley.

  • unit (str, optional) – Output unit, by default "kilogram * meter**2".

  • precision (int, optional) – Decimal rounding precision, by default 2. Use None to skip rounding.

Returns:

Reflected total inertia in requested unit.

Return type:

Quantity

Raises:

ValueError – If unit conversion fails, inputs are not physically meaningful, or the requested output unit is invalid.

eytelwein.belt_conveyor_design.nominal_mass_flow(theoretical_volume_flow: Quantity, effective_filling_ratio: float, bulk_density: Quantity, unit: str = 'kilogram/second', precision: int = 5) → Quantity[source]
eytelwein.belt_conveyor_design.nominal_volume_flow(theoretical_volume_flow: Quantity, effective_filling_ratio: float, unit: str = 'meter**3/second', precision: int = 5) → Quantity[source]
eytelwein.belt_conveyor_design.number_of_revolutions_from_translatory_speed(translatory_speed: Quantity, radius: Quantity, unit: str = 'rps', precision: int = 2) → Quantity[source]

Calculate the number of revolutions from the translatory speed.

Parameters:

  • translatory_speed (Quantity) – The translatory speed value with units.

  • radius (Quantity) – The radius value with units.

  • unit (str, optional) – The unit for the output number of revolutions (default is “revolution”).

  • precision (int, optional) – The precision for rounding the result (default is 2).

Returns:

The number of revolutions in the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting units or if the unit is invalid.

eytelwein.belt_conveyor_design.part_of_belt_lying_on_side_idler(belt_width: Quantity, length_center_roller: Quantity, unit: str = 'millimeter', precision: int = 2) → Quantity[source]

Calculate the part of the belt lying on the side idler based on the belt width and the length of the center roller.

For flat trough configurations where the center roller length equals or exceeds the belt width, returns 0 as there are no side idlers.

Parameters:

  • belt_width (Quantity) – The width of the belt as a Pint Quantity.

  • length_center_roller (Quantity) – The length of the center roller as a Pint Quantity.

  • unit (str, optional) – The desired unit for the result. Defaults to “millimeter”.

  • precision (int, optional) – The number of decimal places to round the result to. If None, no rounding is applied. Defaults to 2.

Returns:

The calculated part of the belt lying on the side idler in the specified unit.

Returns 0 for flat trough configurations (length_center_roller >= belt_width).

Return type:

Quantity

Raises:

  • ValueError – If there is an error in converting the input values to meters.

  • ValueError – If belt_width is zero or negative.

  • ValueError – If length_center_roller is negative.

  • ValueError – If the specified unit is invalid.

eytelwein.belt_conveyor_design.partial_cross_section_above_water_fill(center_roll_length: Quantity, usable_belt_width: Quantity, troughing_angle: Quantity, equivalent_slope_angle: Quantity, unit: str = 'millimeter**2', precision: int = 5) → Quantity[source]
eytelwein.belt_conveyor_design.partial_cross_section_at_water_fill(center_roll_length: Quantity, usable_belt_width: Quantity, troughing_angle: Quantity, unit: str = 'millimeter**2', precision: int = 5) → Quantity[source]

Calculate the partial cross-sectional area of the belt at water fill.

This function calculates the area based on the given center roll length, usable belt width, and troughing angle. The formula used takes into account the geometry of the belt and the troughing angle to determine the area.

Parameters: center_roll_length (Quantity): The length of the center roll as a Quantity with units of millimeters. usable_belt_width (Quantity): The usable width of the belt as a Quantity with units of millimeters. troughing_angle (Quantity): The troughing angle as a Quantity with units of degrees. unit (str, optional): The unit for the returned area. Defaults to “millimeter**2”. precision (int, optional): The number of decimal places to round the result to. Defaults to 5.

Returns: Quantity: The calculated partial cross-sectional area as a Quantity with the specified unit.

Raises: ValueError: If there is an error in converting units or if the calculated area is negative.

eytelwein.belt_conveyor_design.payload_mass_total(payload_mass_per_meter: Quantity, center_distance: Quantity, unit: str = 'kilogram', precision: int = 2) → Quantity[source]

Calculate total payload mass over conveyor center distance.

Parameters:

  • payload_mass_per_meter (Quantity) – Payload mass per meter quantity.

  • center_distance (Quantity) – Conveyor center distance quantity.

  • unit (str, optional) – Output unit, by default "kilogram".

  • precision (int, optional) – Decimal rounding precision, by default 2. Use None to skip rounding.

Returns:

Total payload mass in requested unit.

Return type:

Quantity

Raises:

ValueError – If unit conversion fails, inputs are not physically meaningful, or the requested output unit is invalid.

eytelwein.belt_conveyor_design.pulley_load_factor(max_width_related_belt_tension_at_pulleys: Quantity, nominal_belt_breaking_strength: Quantity) → float[source]

Calculate the pulley load factor.

Parameters:

  • max_width_related_belt_tension_at_pulleys (Quantity) – The mean width-related tension at the point of maximum belt tension in the zone of Group A pulleys in the steady operating condition in kilonewton.

  • nominal_belt_breaking_strength (Quantity) – The nominal belt breaking strength in kilonewton.

Returns:

The pulley load factor as a percentage.

Return type:

float

eytelwein.belt_conveyor_design.pulley_radius(drive_pulley_diameter: Quantity, unit: str = 'meter', precision: int = 2) → Quantity[source]

Calculate drive pulley radius from drive pulley diameter.

Parameters:

  • drive_pulley_diameter (Quantity) – Drive pulley diameter quantity.

  • unit (str, optional) – Output unit, by default "meter".

  • precision (int, optional) – Decimal rounding precision, by default 2. Use None to skip rounding.

Returns:

Drive pulley radius in requested unit.

Return type:

Quantity

Raises:

ValueError – If unit conversion fails, diameter is not positive, or the requested output unit is invalid.

eytelwein.belt_conveyor_design.pulley_revolutions_from_belt_speed(belt_speed: Quantity, pulley_diameter: Quantity, unit: str = 'rps', precision: int = 2) → Quantity[source]

Calculate the pulley revolutions from the belt speed.

Parameters:

  • belt_speed (Quantity) – The belt speed value with units.

  • pulley_diameter (Quantity) – The pulley diameter value with units.

  • unit (str, optional) – The unit for the output pulley revolutions (default is “revolution”).

  • precision (int, optional) – The precision for rounding the result (default is 2).

Returns:

The pulley revolutions in the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting units or if the unit is invalid.

eytelwein.belt_conveyor_design.reduction_factor_inclined_fill(theoretical_partial_cross_section_above_water_fill: Quantity, theoretical_cross_section_of_fill: Quantity, reduction_factor_inclined_fill_1: Quantity, unit: str = 'dimensionless', precision: int = 5) → Quantity[source]

Calculate the reduction factor for inclined fill on a conveyor belt.

This function calculates a reduction factor used to adjust the cross-sectional area of material on an inclined conveyor belt. It accounts for the proportion of material above the water fill line and applies a reduction factor based on the inclination.

The formula used is: 1 - (theoretical_partial_cross_section_above_water_fill / theoretical_cross_section_of_fill)

  • (1 - reduction_factor_inclined_fill_1)

Parameters: theoretical_partial_cross_section_above_water_fill (Quantity): The theoretical partial

cross-section above water fill as a Quantity with area units.

theoretical_cross_section_of_fill (Quantity): The theoretical total cross-section of

fill as a Quantity with area units.

reduction_factor_inclined_fill_1 (Quantity): The first reduction factor for inclined fill

as a dimensionless Quantity.

unit (str, optional): The unit for the returned factor. Defaults to “dimensionless”. precision (int, optional): The number of decimal places to round the result to. Defaults to 5.

Returns: Quantity: The calculated reduction factor as a dimensionless Quantity.

Raises: ValueError: If theoretical_cross_section_of_fill is zero or if there is an error

in converting units.

eytelwein.belt_conveyor_design.reduction_factor_inclined_fill_1(maximal_inclination_angle: Quantity, dynamic_angle_of_slope: Quantity, unit: str = 'dimensionless', precision: int = 5) → Quantity[source]

Calculate the reduction factor for inclined fill based on the maximal inclination angle and the dynamic angle of slope.

This function computes a reduction factor used in material handling or bulk solids transport, where the inclination of the fill affects the flow characteristics. The calculation is based on the cosine squared of the provided angles.

The formula used is sqrt((cos²(maximal_inclination_angle) - cos²(dynamic_angle_of_slope)) /

(1 - cos²(maximal_inclination_angle)))

Parameters: maximal_inclination_angle (Quantity): The maximal inclination angle of the fill as a Quantity with units of degrees. dynamic_angle_of_slope (Quantity): The dynamic angle of slope as a Quantity with units of degrees. unit (str, optional): The unit for the returned factor. Defaults to “dimensionless”. precision (int, optional): The number of decimal places to round the result to. Defaults to 5.

Returns: Quantity: The calculated reduction factor as a dimensionless Quantity.

Raises: ValueError: If the maximal inclination angle is greater than the dynamic angle of slope,

if there is an error in converting units, or if the calculation results in an invalid value.

eytelwein.belt_conveyor_design.reference_length_of_transition_zone_for_steel_cord_belts(minimal_transition_length: Quantity, compensation_length: Quantity, unit: str = 'meter', precision: int = 2) → Quantity[source]

Calculate the reference length of the transition zone for steel cord belts. This function computes the reference length of the transition zone based on the minimal transition length and the compensation length. The result is returned in the specified unit with an optional precision. :param minimal_transition_length: The minimal transition length,

provided as a Pint Quantity object.

Parameters:

  • compensation_length (Quantity) – The compensation length, provided as a Pint Quantity object.

  • unit (str, optional) – The unit in which the result should be returned. Defaults to “meter”.

  • precision (int, optional) – The number of decimal places to round the result to. If None, no rounding is applied. Defaults to 2.

Returns:

The reference length of the transition zone as a Pint Quantity object in the specified unit.

Return type:

Quantity

Raises:

ValueError – If the input values cannot be converted to meters or if the specified unit is invalid.

eytelwein.belt_conveyor_design.required_skirtboard_height_from_cross_section(center_roll_length: Quantity, skirt_board_width: Quantity, troughing_angle: Quantity, equivalent_slope_angle: Quantity, cross_section: Quantity, unit: str = 'millimeter', precision: int = 5) → Quantity[source]
eytelwein.belt_conveyor_design.section_length_from_height_difference_and_inclination_angle(height_difference: Quantity, inclination_angle: Quantity, unit: str = 'meter', precision: int = 3) → Quantity[source]

Calculate the section length from the height difference and inclination angle.

This function calculates the length of a conveyor section based on its height difference and inclination angle using the formula:

L = H / sin(α)

Where: - L is the section length - H is the height difference - α is the inclination angle

Parameters:

  • height_difference (Quantity) – The vertical height difference of the conveyor section (typically in meters).

  • inclination_angle (Quantity) – The angle of inclination of the conveyor (typically in degrees).

  • unit (str, optional) – The desired unit for the output section length. Default is “meter”.

  • precision (int, optional) – The number of decimal places for the result. Default is 3.

Returns:

The calculated section length with the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting units: {e} If the height difference is negative. If the inclination angle is zero or very close to zero.

eytelwein.belt_conveyor_design.solve_for_used_belt_width_from_cross_section(target_cross_section: Quantity, center_roll_length: Quantity, troughing_angle: Quantity, equivalent_slope_angle: Quantity, initial_guess: Quantity | None = None, unit: str = 'millimeter', precision: int = 2) → Quantity[source]

Calculate the used belt width required to achieve a specific cross-section area.

This function uses numerical methods to find the used belt width that would result in the specified target cross-section area, given the center roll length, troughing angle, and equivalent slope angle.

Parameters: target_cross_section (Quantity): The desired cross-section area as a Quantity. center_roll_length (Quantity): The length of the center roll as a Quantity. troughing_angle (Quantity): The troughing angle as a Quantity. equivalent_slope_angle (Quantity): The equivalent slope angle as a Quantity. initial_guess (Quantity, optional): Initial guess for used belt width. unit (str, optional): The unit for the returned width. Defaults to “millimeter”. precision (int, optional): The number of decimal places to round the result to. Defaults to 2.

Returns: Quantity: The calculated used belt width as a Quantity with the specified unit.

Raises: ValueError: If there is an error in converting units or if the solution doesn’t converge.

eytelwein.belt_conveyor_design.total_power_at_drive_pulley_due_to_motion_resistances(motion_resistance: Quantity, belt_speed: Quantity, unit: str = 'watt', precision: int = 2) → Quantity[source]

Calculate the total power at the drive pulley due to motion resistances.

This function computes the total power required at the drive pulley based on the given motion resistance and belt speed.

The power is calculated as:

P = F_w * v

Where: - P is the power at the drive pulley - F_w is the motion resistance - v is the belt speed

Parameters:

  • motion_resistance (Quantity) – The motion resistance (typically in newtons).

  • belt_speed (Quantity) – The speed of the belt (typically in meters per second).

  • unit (str, optional) – The unit for the returned power. Default is “watt”.

  • precision (int, optional) – The number of decimal places for the result. Default is 2.

Returns:

The total power at the drive pulley with the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting units.

eytelwein.belt_conveyor_design.translating_mass_empty(idler_mass_upper_total: Quantity, idler_mass_lower_total: Quantity, belt_mass_per_strand_value: Quantity, unit: str = 'kilogram', precision: int = 2) → Quantity[source]

Calculate translating mass for empty conveyor.

Parameters:

  • idler_mass_upper_total (Quantity) – Upper-strand total idler mass quantity.

  • idler_mass_lower_total (Quantity) – Lower-strand total idler mass quantity.

  • belt_mass_per_strand_value (Quantity) – Belt mass per strand quantity.

  • unit (str, optional) – Output unit, by default "kilogram".

  • precision (int, optional) – Decimal rounding precision, by default 2. Use None to skip rounding.

Returns:

Empty-conveyor translating mass in requested unit.

Return type:

Quantity

Raises:

ValueError – If unit conversion fails, inputs are not physically meaningful, or the requested output unit is invalid.

eytelwein.belt_conveyor_design.translating_mass_full(translating_mass_empty_value: Quantity, payload_mass_total_value: Quantity, unit: str = 'kilogram', precision: int = 2) → Quantity[source]

Calculate translating mass for loaded conveyor.

Parameters:

  • translating_mass_empty_value (Quantity) – Empty-conveyor translating mass quantity.

  • payload_mass_total_value (Quantity) – Total payload mass quantity.

  • unit (str, optional) – Output unit, by default "kilogram".

  • precision (int, optional) – Decimal rounding precision, by default 2. Use None to skip rounding.

Returns:

Full-conveyor translating mass in requested unit.

Return type:

Quantity

Raises:

ValueError – If unit conversion fails, inputs are not physically meaningful, or the requested output unit is invalid.

eytelwein.belt_conveyor_design.translatory_speed_from_number_of_revolutions(revolutions: Quantity, radius: Quantity, unit: str = 'meter/second', precision: int = 2) → Quantity[source]

Calculate the translatory speed from the number of revolutions.

Parameters:

  • revolutions (Quantity) – The number of revolutions value with units.

  • radius (Quantity) – The radius value with units.

  • unit (str, optional) – The unit for the output translatory speed (default is “meter/second”).

  • precision (int, optional) – The precision for rounding the result (default is 2).

Returns:

The translatory speed in the specified unit.

Return type:

Quantity

Raises:

ValueError – If there is an error in converting units or if the unit is invalid.

eytelwein.belt_conveyor_design.usable_belt_width(belt_width: Quantity, unit: str = 'millimeter', precision: int = 2) → Quantity[source]

Calculate the usable belt width based on the given belt width.

This function serves as a wrapper for the _usable_belt_width function, ensuring that the input is a Quantity with units of millimeters.

Parameters: belt_width (Quantity): The total width of the belt as a Quantity with units of millimeters. unit (str, optional): The unit for the returned width. Defaults to “millimeter”. precision (int, optional): The number of decimal places to round the result to. Defaults to 2.

Returns: Quantity: The usable width of the belt as a Quantity with the specified unit.

eytelwein.belt_conveyor_design.volume_flow_from_cross_section_speed(cross_section_of_fill: Quantity, belt_speed: Quantity, unit: str = 'meter**3/second', precision: int = 5) → Quantity[source]
eytelwein.belt_conveyor_design.volume_flow_from_mass_flow_density(m_flow: Quantity, bulk_density: Quantity, unit: str = 'meter**3/second', precision: int = 5) → Quantity[source]

Calculate the volume flow of material from mass flow and bulk density.

This function calculates the volume flow rate by dividing the mass flow by the bulk density. It is the inverse of mass_flow_from_volume_flow_density and is useful when you have the mass flow and density and need to find the volumetric flow rate.

Parameters:

  • m_flow (Quantity) – The mass flow of material in kilograms per second [kg/s]

  • bulk_density (Quantity) – The bulk density of the material in kilograms per cubic meter [kg/m³]

  • unit (str, optional) – The unit for the returned volume flow. Defaults to “meter**3/second”.

  • precision (int, optional) – The number of decimal places to round the result to. Defaults to 5.

Returns:

The calculated volume flow in the specified unit [m³/s]

Return type:

Quantity

Raises:

ValueError – If bulk_density is zero or negative If unit conversion fails If invalid output unit is specified

Notes

The calculation follows the formula:

\[Q =\]

rac{m}{ ho}

Where: - Q is the volume flow [m³/s] - m is the mass flow [kg/s] - ρ is the bulk density [kg/m³]

This function is the inverse of mass_flow_from_volume_flow_density.

Examples

>>> import eytelwein.main.units as u
>>> from eytelwein.belt_conveyor_design import volume_flow_from_mass_flow_density
>>> m_flow = 1800 * u.kilogram / u.second
>>> density = 1200 * u.kilogram / u.meter**3
>>> volume_flow = volume_flow_from_mass_flow_density(m_flow, density)
>>> print(volume_flow)
1.5 meter ** 3 / second