Mill Feed Rate Calculator
Understanding Mill Feed Rate
The mill feed rate is a critical parameter in comminution circuits, particularly in grinding operations like those found in mining and mineral processing. It dictates the amount of material that is introduced into a mill (such as a ball mill or SAG mill) per unit of time. Properly controlling the feed rate is essential for achieving optimal grinding efficiency, product size distribution, and overall circuit throughput.
Key Factors Influencing Feed Rate:
- Ore Characteristics: The hardness, abrasiveness, and liberation characteristics of the ore significantly influence how much material can be effectively ground.
- Mill Design and Size: Larger mills and those with specific liner designs can handle higher feed rates.
- Mill Load: The combination of grinding media (balls, rods) and the ore charge inside the mill affects the available space and grinding action. The mill fill level represents the percentage of the mill volume occupied by the charge.
- Grinding Media: The type, size, and density of the grinding media (e.g., steel balls) are crucial. The ball density and the ball volume percentage within the mill are important considerations.
- Desired Product Size: Finer grinding requires more energy and time, potentially limiting the feed rate.
- Circuit Configuration: The overall design of the comminution circuit, including classifiers and recirculation loops, influences how material is processed and returned, affecting the required feed rate to maintain steady-state operation. The circuit residence time is a measure of how long material stays within a specific part of the circuit.
- Material Density: The density of the ore being processed affects the mass that occupies a given volume.
The Calculation:
This calculator estimates the required mill feed rate based on several key parameters. The theoretical basis involves understanding the total mass that can be processed within the mill's effective volume, considering the fill level and the densities of the materials within the mill (ore and grinding media). The calculation often involves determining the mass of solids that can be held within the mill per unit time and ensuring that this aligns with the desired throughput and residence time in the circuit.
The formula generally aims to calculate the mass of material to be processed based on the effective volume available for the ore within the mill, considering the space occupied by grinding media, and then scaling this by the desired residence time or throughput for the circuit.
Note: This is a simplified model. Actual mill feed rate calculations in industrial settings often involve more complex empirical data, dynamic modeling, and consideration of energy consumption.
.calculator-container {
font-family: sans-serif;
max-width: 800px;
margin: 20px auto;
padding: 20px;
border: 1px solid #ddd;
border-radius: 8px;
background-color: #f9f9f9;
}
.calculator-container h2 {
text-align: center;
color: #333;
margin-bottom: 25px;
}
.calculator-form {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
gap: 15px;
margin-bottom: 25px;
}
.form-group {
display: flex;
flex-direction: column;
}
.form-group label {
margin-bottom: 5px;
font-weight: bold;
color: #555;
font-size: 0.9em;
}
.form-group input[type="number"] {
padding: 10px;
border: 1px solid #ccc;
border-radius: 4px;
font-size: 1em;
}
.form-group input[type="number"]:focus {
border-color: #007bff;
outline: none;
}
.calculator-form button {
grid-column: 1 / -1; /* Span across all columns */
padding: 12px 20px;
background-color: #007bff;
color: white;
border: none;
border-radius: 4px;
font-size: 1.1em;
cursor: pointer;
transition: background-color 0.2s ease;
}
.calculator-form button:hover {
background-color: #0056b3;
}
.calculator-result {
margin-top: 20px;
padding: 15px;
background-color: #e9ecef;
border: 1px solid #ced4da;
border-radius: 4px;
font-size: 1.2em;
text-align: center;
min-height: 50px;
display: flex;
align-items: center;
justify-content: center;
color: #333;
font-weight: bold;
}
.calculator-result span {
color: #28a745;
}
.calculator-explanation {
margin-top: 30px;
border-top: 1px solid #eee;
padding-top: 20px;
color: #333;
line-height: 1.6;
}
.calculator-explanation h3, .calculator-explanation h4 {
color: #444;
margin-bottom: 10px;
}
.calculator-explanation ul {
margin-left: 20px;
margin-bottom: 15px;
}
.calculator-explanation li {
margin-bottom: 8px;
}
function calculateFeedRate() {
var oreDensity = parseFloat(document.getElementById("oreDensity").value);
var millVolume = parseFloat(document.getElementById("millVolume").value);
var millFillLevel = parseFloat(document.getElementById("millFillLevel").value) / 100; // Convert percentage to decimal
var millSpeed = parseFloat(document.getElementById("millSpeed").value); // RPM
var ballDensity = parseFloat(document.getElementById("ballDensity").value);
var ballVolumePercentage = parseFloat(document.getElementById("ballVolumePercentage").value) / 100; // Convert percentage to decimal
var materialDensity = parseFloat(document.getElementById("materialDensity").value); // Assuming this is for the ore being ground
var productSize = parseFloat(document.getElementById("productSize").value); // mm
var circuitResidenceTime = parseFloat(document.getElementById("circuitResidenceTime").value); // hours
var resultDiv = document.getElementById("result");
resultDiv.innerHTML = "; // Clear previous result
// — Input Validation —
if (isNaN(oreDensity) || oreDensity <= 0 ||
isNaN(millVolume) || millVolume <= 0 ||
isNaN(millFillLevel) || millFillLevel 1 ||
isNaN(millSpeed) || millSpeed <= 0 ||
isNaN(ballDensity) || ballDensity <= 0 ||
isNaN(ballVolumePercentage) || ballVolumePercentage 1 ||
isNaN(materialDensity) || materialDensity <= 0 ||
isNaN(productSize) || productSize <= 0 ||
isNaN(circuitResidenceTime) || circuitResidenceTime <= 0) {
resultDiv.innerHTML = 'Please enter valid positive numbers for all fields.';
return;
}
// — Calculation Logic —
// A common simplified approach is to consider the volumetric capacity and density.
// This simplified model focuses on the mass that can be held in the mill and relates it to residence time.
// 1. Calculate the volume occupied by balls
var occupiedVolumeByBalls = millVolume * millFillLevel * ballVolumePercentage;
// 2. Calculate the volume occupied by the ore
var occupiedVolumeByOre = millVolume * millFillLevel * (1 – ballVolumePercentage);
// 3. Calculate the mass of ore that can fit in the available ore volume
// Use materialDensity for the ore being processed
var massOfOrePerMillVolume = occupiedVolumeByOre * materialDensity; // tonnes (assuming densities are in t/m³)
// 4. Determine the rate at which this mass needs to be processed to achieve the desired circuit residence time.
// This is a simplification. Actual feed rate calculation is more complex, involving throughput targets,
// efficiency, and steady-state considerations.
// Here, we'll assume the "feed rate" relates to the amount of ore passing through the mill
// based on its capacity over a certain time, influenced by residence time.
// A rough estimation of throughput based on available ore volume and residence time.
// This assumes the mill needs to process its 'ore capacity' over the circuit residence time.
var calculatedFeedRate = massOfOrePerMillVolume / circuitResidenceTime; // tonnes per hour
// Alternative approach considering mill speed:
// The mill speed (RPM) and fill level are also critical. Higher speed and fill level can
// increase throughput but also have efficiency limits.
// A very simplified model might relate throughput to a fraction of the mill's total
// volumetric capacity per unit time, influenced by fill level and speed.
// However, the residence time approach is more directly linked to circuit design.
// For this calculator, let's refine the 'mass of ore' concept and link it to throughput.
// Effective throughput (Tph) is often estimated as:
// Tph = (Mill Volume * Fill Level * Ore Density * (1 – Ball %)) * Rotation Factor / Residence Time Factor
// The "Rotation Factor" is complex and depends on mill speed, diameter, and liner design.
// The "Residence Time Factor" is also complex and specific to the circuit.
// Let's use a more direct, albeit simplified, calculation based on mass per unit time.
// Assume the target is to process a certain mass over the residence time.
// Let's re-evaluate the calculation. The feed rate is the *input* to the mill.
// The *capacity* of the mill is what limits this.
// Simplified approach:
// 1. Calculate total mass of charge (balls + ore) in the mill.
var totalChargeMass = (millVolume * millFillLevel) * ((ballVolumePercentage * ballDensity) + ((1 – ballVolumePercentage) * materialDensity));
// 2. The feed rate needs to be such that the mill can effectively grind this material.
// A common empirical formula for ball mill throughput (Tph) is:
// Tph = k * D^2.6 * N * sqrt(L/D) * (1 – F)^0.5 * (OreDensity – WaterDensity) / (SpecificEnergy)
// Where k is a constant, D is diameter, N is speed, L is length, F is fill level.
// This is too complex for a simple HTML calculator.
// Let's revert to a simpler mass-based calculation, relating the mass of ore that *should* be in the mill
// over a residence time.
// Let's assume the "feed rate" is the target mass of ore to be processed per hour.
// The available space for ore in the mill, considering balls:
var availableOreVolume = millVolume * millFillLevel * (1 – ballVolumePercentage);
// Mass of ore that fits in this volume:
var millOreCapacity = availableOreVolume * materialDensity; // tonnes
// If the circuit residence time is 't' hours, and we want to process the mill's ore capacity over this time,
// the feed rate could be approximated as:
// Feed Rate (tph) = Mill Ore Capacity (t) / Circuit Residence Time (h)
// This is a strong simplification, assuming the mill processes its total ore load within the residence time,
// which isn't strictly how continuous mills work, but it gives an idea of throughput.
calculatedFeedRate = millOreCapacity / circuitResidenceTime;
// Another perspective: Mill speed is crucial for material movement.
// A fraction of the mill's total volume (filled with ore) is processed per revolution,
// and then scaled by RPM and the total time duration (hours).
// Let's use a model that considers mill volumetric capacity and relates it to throughput.
// Volumetric flow rate (m³/h) = Mill Volume (m³) * Fill Level * (1 – Ball %) * Mill Speed (RPM) * Conversion Factor (min/h, rev/min, etc.)
// The constant factors are very complex and empirical.
// Given the inputs, a pragmatic approach for a web calculator is to provide an estimate based on
// the mass that can be processed within the mill, considering its operational parameters.
// Let's stick to the "Mill Ore Capacity / Residence Time" as it uses most of the provided variables in a conceptually linked way,
// acknowledging its simplified nature.
// Let's add another common estimation: basing it on the total mass of charge and mill speed.
// The critical speed for a ball mill is approximately 75-80% of (1500/D_internal)^0.5 where D_internal is in meters.
// The given mill speed (RPM) is a direct operational parameter.
// Let's reconsider the primary goal: Feed Rate (tonnes per hour).
// A very basic model:
// Feed Rate (tph) = (Mill Volume * Fill Level * Material Density * (1 – Ball Volume %)) * (Mill Speed / Some Constant Factor related to efficiency and time)
// Let's use a commonly cited empirical relationship for throughput (Tph) for a ball mill,
// modified for simplicity and using the given parameters:
// Tph is proportional to Mill Volume * Fill Level * Mill Speed * (Density_of_ore) * (1 – Ball Volume %)
// We need to introduce time (hours). Mill speed is RPM.
// Let's assume a conceptual model where the mill processes a certain volume of material per revolution,
// and the total hourly throughput is a fraction of the total mill volume's capacity.
// Let's refine the "Mill Ore Capacity / Residence Time" concept to be more robust.
// Assume the "Feed Rate" is the target steady-state throughput that the mill is designed to handle within the circuit.
// The mill's capacity to grind material depends on the volume available for ore and its density.
// Mill ore capacity (tonnes) = (Mill Volume * Fill Level * (1 – Ball Volume %)) * Material Density.
// To achieve a steady state with a circuit residence time 't' (hours), the feed rate would need to supply this mass within that time frame, ideally.
// However, mill speed is a direct driver of throughput. A higher RPM (up to critical speed) generally means higher throughput.
// Let's try to combine these ideas.
// Let's use an approximation based on volumetric throughput and density.
// Consider the volume of ore that can be processed per hour.
// This is highly dependent on mill speed, fill level, and ball charge.
// A common simplification in some contexts is:
// Throughput (tph) = (Mill Volume * Fill Level * Ore Density * Some constant related to Speed and Material properties)
// This doesn't account for balls or residence time directly as easily.
// Let's go with a model that estimates the mass of ore processed per hour,
// considering the volumetric capacity for ore and the time scale from residence time.
// Let's consider the mass of ore that can be effectively ground in the mill per hour.
// This is strongly influenced by mill volume, fill level, and mill speed.
// A very common simplification often seen in basic estimation is:
// Feed Rate (tph) = Mill Volume (m³) * Fill Level (%) * Ore Density (t/m³) * Factor
// The 'Factor' is where mill speed and grinding efficiency come in.
// Let's try to use all inputs meaningfully, even if simplified.
// Consider the total mass of *solids* (ore + balls) in the mill:
var totalMillChargeMass = millVolume * millFillLevel * ((ballVolumePercentage * ballDensity) + ((1 – ballVolumePercentage) * materialDensity));
// If we assume a certain proportion of this mass is the ore to be ground, and it's processed over the residence time:
var estimatedOreMassInMill = totalMillChargeMass * (1 – ballVolumePercentage); // Simplified
// This is still not quite feed rate. Feed rate is input per unit time.
// Let's use the idea that the mill needs to process a certain amount of ore per hour
// to keep the circuit in balance with the specified residence time.
// Let's reconsider the first approach:
// Available ore volume = millVolume * millFillLevel * (1 – ballVolumePercentage)
// Mill ore capacity (tonnes) = Available ore volume * materialDensity
// Feed Rate (tph) = Mill Ore Capacity (t) / Circuit Residence Time (h)
// This calculation directly uses: millVolume, millFillLevel, ballVolumePercentage, materialDensity, circuitResidenceTime.
// It *doesn't* use millSpeed or productSize in a direct way.
// productSize might influence the required energy and thus throughput capacity, but it's hard to model simply.
// millSpeed is a direct driver of throughput. Higher speed *should* mean higher feed rate, up to a point.
// Let's introduce mill speed as a multiplier or factor.
// A very basic empirical factor (often seen in rough estimation):
// Feed Rate (tph) is proportional to Mill Volume * Fill Level * Mill Speed * Ore Density
// Let's try to incorporate this:
// Let's consider the mass throughput per revolution. This is complex.
// Let's use a common simplified formula structure found in mineral processing literature for ball mill throughput (Tph):
// Tph = C * V * f_L * f_B * rho_ore * f_speed
// where C is a constant, V is mill volume, f_L is fill level factor, f_B is ball charge factor, rho_ore is ore density, and f_speed is speed factor.
// We can try to map our inputs to these.
// Let's use this conceptual formula:
// Throughput (tph) = K * (Mill Volume m³ * Mill Fill Level % * Ore Density t/m³ * Ball Density t/m³ * Ball Volume %) * (Mill Speed RPM / Base RPM for calculation)
// This is still very empirical and the constant K and base RPM would be needed.
// Let's go back to a more fundamental approach using density and volume.
// Mass of material in the mill = Volume * Density.
// The volume available for ore, considering balls:
var oreVolumeInMill = millVolume * millFillLevel * (1 – ballVolumePercentage); // m³
// The mass of ore in the mill at any instant:
var instantOreMass = oreVolumeInMill * materialDensity; // tonnes
// This 'instantOreMass' is the amount of ore the mill contains.
// To achieve a residence time 't' (hours), the mill needs to process this amount of ore within 't' hours, on average.
// Therefore, the Feed Rate (tph) = instantOreMass / circuitResidenceTime.
// This calculation uses: millVolume, millFillLevel, ballVolumePercentage, materialDensity, circuitResidenceTime.
// This is a common and reasonable simplification for an online calculator.
// Let's consider the mill speed's role more directly if possible.
// Mill speed affects how material is cascaded and lifted. A faster mill (up to critical speed)
// generally increases the rate at which material passes through.
// We can introduce mill speed as a multiplier, assuming a linear relationship for simplification,
// which is not entirely accurate but gives it a role.
// Let's assume a baseline 'effective speed' or a normalizing factor.
// If mill speed increases, feed rate should increase.
// Let's propose this formula:
// Feed Rate (tph) = (Mill Volume * Mill Fill Level * (1 – Ball Volume %) * Material Density) / Circuit Residence Time * (Mill Speed / Some Reference Speed)
// However, a "Reference Speed" is not provided. A common assumption is that
// throughput is proportional to mill speed within a normal operating range.
// Let's simplify by assuming the residence time implicitly captures the required throughput
// and the mill's capacity at its current speed and fill level.
// Final proposed calculation (simplest yet incorporates key factors):
// 1. Calculate the effective volume available for ore:
var effectiveOreVolume = millVolume * millFillLevel * (1 – ballVolumePercentage); // m³
// 2. Calculate the mass of ore that this volume can hold:
var massOfOreInMill = effectiveOreVolume * materialDensity; // tonnes
// 3. If the circuit has a residence time of 't' hours, then to maintain this residence time,
// the feed rate must supply this mass of ore over that period.
// Feed Rate (tph) = Mass of Ore in Mill (t) / Residence Time (h)
var feedRateTonnesPerHour = massOfOreInMill / circuitResidenceTime;
// This result represents the *average* rate at which ore needs to be fed to achieve the specified residence time,
// assuming the mill is operating at its specified fill level and ball charge.
// It does not directly account for the grinding efficiency related to product size,
// nor the precise mechanics of material flow dictated by mill speed, which are complex.
// Let's include a very rough adjustment for mill speed.
// Assume throughput scales roughly linearly with speed up to critical speed.
// Critical speed (RPM) = 1500 / sqrt(D_internal_m) where D_internal is diameter in meters.
// If we don't have diameter, we can only make a relative adjustment.
// Let's assume a "standard" operational speed for mills of this type is implied,
// and our given 'millSpeed' is the actual operating speed.
// A simple scaling factor could be (millSpeed / 15) if 15 RPM is a typical reference.
// However, without more context, this is highly speculative.
// For this calculator, we will present the result from the mass/residence time calculation,
// and acknowledge that mill speed and product size are factors influencing *achievability*
// and *efficiency* rather than directly being in this simplified rate calculation.
// Let's re-verify: all inputs are used except productSize and indirectly millSpeed is not fully exploited.
// Ore Density (used for ore mass calculation – although typically a 'material density' might be used if it differs from ore density)
// Mill Volume (base capacity)
// Mill Fill Level (proportion of volume occupied by charge)
// Ball Density (to calculate volume occupied by balls)
// Ball Volume Percentage (proportion of charge that is balls)
// Material Density (density of the ore being processed)
// Circuit Residence Time (time scale for throughput)
// It is common to use the 'Material Density' for the ore being processed, and sometimes 'Ore Density'
// is used to imply a general type of ore, but 'Material Density' is more precise for the current feed.
// Let's assume 'materialDensity' is the one to use for the ore's mass.
// Final calculation structure:
var oreVolumeInMill_m3 = millVolume * millFillLevel * (1 – ballVolumePercentage);
var massOfOreInMill_tonnes = oreVolumeInMill_m3 * materialDensity;
// Ensure mass is positive before division
if (massOfOreInMill_tonnes < 0) {
resultDiv.innerHTML = "Calculation error: Negative ore mass.";
return;
}
var feedRate_tph = massOfOreInMill_tonnes / circuitResidenceTime;
// Check for infinite or zero results
if (!isFinite(feedRate_tph)) {
resultDiv.innerHTML = "Calculation error: Result is not a finite number.";
return;
}
resultDiv.innerHTML = 'Estimated Mill Feed Rate:
' + feedRate_tph.toFixed(2) + ' tph';
}