DEV Community: cylinder volume-calculator

Cylindrical Tank Volume in Gallons: How to Work Out Exactly What Your Tank Holds

cylinder volume-calculator — Thu, 22 Oct 2026 06:01:05 +0000

The label says 500 gallons. The delivery driver, the rainwater harvester, and the fuel supplier all plan around that number. But a "500-gallon" tank almost never gives you 500 usable gallons, and if the label is missing entirely (a second-hand tank, a farm tank that has been there for decades), you have no number at all. The good news: calculating cylindrical tank volume in gallons takes two measurements and one formula. This guide covers the formula in feet, inches, and metric, a capacity chart for common tank sizes, the weight of a full tank, US versus imperial gallons, horizontal tanks, and the two traps that catch nearly everyone.

The cylindrical tank volume formula

A cylindrical tank is a cylinder standing on end, so its volume is the familiar:

V = π × r² × h

Measure the diameter across the top (inside, if you can), halve it to get the radius r, and measure the height h. Work in feet and the answer comes out in cubic feet. Then apply the single conversion this whole topic hangs on:

1 cubic foot = 7.48052 US gallons

So the full recipe is: gallons = π × r² × h × 7.48052, with r and h in feet.

Worked example. A vertical water tank is 4 feet across and 6 feet tall. Radius = 2 feet.

V = π × 2² × 6 = 75.40 cubic feet
Gallons = 75.40 × 7.48052 = 564 gallons

That is the tank's total (brim-full) capacity. Hold on to that word "total"; it matters below.

If you would rather not do the arithmetic twice, a cylinder volume calculator runs the same formula with the unit conversion built in: enter diameter and height, choose gallons, done. The formula above is all it is doing under the hood.

Tank volume in gallons from inches

Small tanks, drums, and stock tanks are usually measured in inches. The formula is identical, but the conversion changes: a US gallon is exactly 231 cubic inches, so:

Gallons = π × r² × h / 231 (r and h in inches)

Worked example. A tank measures 36 inches across and 48 inches tall. Radius = 18 inches.

V = π × 18² × 48 = 48,858 cubic inches
Gallons = 48,858 / 231 = 211.5 gallons

This also explains a small mystery: a standard "55-gallon drum" (about 22.5 inches across, 33.5 inches tall) computes to 57.7 gallons brim-full. The 55 on the label is the nominal fill, not the geometry. Use whichever unit your tape measure gives you, but never mix them: radius in inches with height in feet is the quietest way to produce a nonsense answer.

If reaching across the top is awkward, wrap a tape around the tank instead and divide by pi: our guide to diameter from circumference walks through that method step by step, including the direct volume formula V = C squared times h divided by 4 pi.

Cylindrical tank capacity chart (vertical tanks, US gallons)

Diameter	Height	Total capacity
2 ft	3 ft	70.5 gal
3 ft	5 ft	264.4 gal
4 ft	6 ft	564 gal
5 ft	5 ft	734 gal
6 ft	4 ft	846 gal
8 ft	6 ft	2,256 gal
10 ft	8 ft	4,700 gal
12 ft	10 ft	8,460 gal

Two patterns in the chart are worth memorizing. Doubling the diameter roughly quadruples the capacity (a 4 ft tank holds about four times a 2 ft tank of similar height), because the diameter feeds the formula squared. And doubling the height exactly doubles it. When you are choosing between a wider tank and a taller one, wider wins per foot.

How much does a full tank weigh?

Gallons become pounds faster than people expect. One US gallon of water weighs 8.34 pounds, so the 564-gallon tank above holds 564 × 8.34 = 4,704 pounds of water, about 2.35 tons, before counting the tank itself. Diesel is a little lighter (about 7.1 pounds per gallon), heating oil similar, but the order of magnitude is the same. Before you fill any large tank on a deck, a stand, or a suspended floor, run this multiplication. Structures are rarely rated for the weight of the water people casually plan to store on them.

US gallons vs imperial gallons

Every number in this guide is in US gallons. If you are in the UK, Canada (older references), or anywhere the imperial gallon survives, multiply US gallons by 0.832674: the 564-gallon tank is 469.6 imperial gallons. The imperial gallon is about 20 percent larger, which makes it the single biggest conversion error in this entire topic; we wrote a full breakdown of the two-gallon trap and how it corrupts calculations in our Gallon Bug guide. Check which gallon a label, a supplier, or a second-hand listing means before you plan around its number.

Trap 1: total capacity is not usable capacity

The formula gives the volume to the brim. Real tanks are never used brim-full:

Headspace. Tanks are filled to about 90 to 95 percent to leave room for expansion and to keep the vent clear. A brim-full 564-gallon tank is realistically a 508 to 536 gallon tank in service.
The outlet sits above the floor. Anything below the outlet level never drains. On a typical vertical tank that dead zone is another 2 to 5 percent.

Put together, usable capacity is usually about 90 percent of the label. The 500-gallon tank from the introduction delivers roughly 450. Size for the usable number, not the printed one, or your "three days of reserve" quietly becomes two and a half.

Trap 2: the diameter is not the radius

The most expensive slip in this calculation is entering the diameter where the radius belongs. Because the radius is squared, the error squares too: using the 4-foot diameter as the radius in the worked example gives 2,256 gallons instead of 564, an answer exactly four times too big. If a result ever looks surprisingly generous, check this first. Halve the diameter before you do anything else, every time.

Horizontal cylindrical tank volume in gallons

Everything above assumes the tank stands upright. Horizontal cylindrical tanks (fuel bowsers, septic tanks, many farm tanks) follow the same formula for total capacity: π × r² × length × 7.48052, with the length in place of the height. The hard part is a partially filled horizontal tank, where volume does not rise evenly with depth: the first quarter of the depth holds only about a fifth of the volume (19.6 percent), exactly half depth is exactly half full, and the last quarter adds less than the middle quarters. A dipstick reading therefore cannot be converted with a simple percentage. If your tank lies down and you need the volume at a given fill depth, use the dedicated method for horizontal cylinder volume rather than adapting the upright formula and guessing.

Need litres instead?

Multiply US gallons by 3.78541. The 564-gallon tank above is 2,135 litres. Or skip gallons entirely and work in metric from the start: with diameter and height in metres, V = π × r² × h gives cubic metres, and one cubic metre is exactly 1,000 litres. A tank 1 metre across and 1.5 metres tall holds π × 0.5² × 1.5 = 1.178 m³ = 1,178 litres (311.2 US gallons, if you ever need to compare it against an American label). Pick one unit system at the start and stay in it to the end; most wrong answers in this topic are born mid-calculation, in a half-finished conversion.

Sizing a tank backwards

The same formula runs in reverse when you are buying rather than measuring. Suppose you need 1,000 usable gallons. Divide by 0.9 to undo the usable-capacity discount: you need a tank with a total capacity of about 1,111 gallons. Fix the diameter your space allows, say 5 feet. Its cross-section is π × 2.5² = 19.63 square feet, so every foot of height adds 19.63 cubic feet, or 146.9 gallons. Required height: 1,111 / 146.9 ≈ 7.6 feet. Three numbers (target, diameter, gallons per foot) and you can spec a tank on the phone with a supplier instead of guessing from a brochure photo.

Frequently asked questions

How many gallons does a 4 ft by 6 ft cylindrical tank hold?
564 US gallons brim-full, and about 508 gallons usable once headspace and the outlet dead zone are allowed for.

What is the formula for cylindrical tank volume in gallons?
Gallons = π × r² × h × 7.48052 with radius and height in feet, or π × r² × h / 231 with both in inches. Always halve the diameter to get the radius first.

How many gallons is a 10-foot diameter tank?
It depends on the height: at 8 feet tall, 4,700 US gallons. Every additional foot of height adds about 587 gallons at that diameter.

Is a horizontal tank half full at half depth?
Yes, exactly half by volume at exactly half depth. But a quarter depth is only about 19.6 percent of the volume, not 25 percent, which is why dipstick charts for horizontal tanks are never evenly spaced.

How much does 500 gallons of water weigh?
500 × 8.34 = 4,170 pounds, just over 2 tons, not counting the tank.

The 60-second version

Measure the inside diameter and the height.
Halve the diameter to get the radius. (Do not skip this.)
Gallons = π × r² × h × 7.48052 (feet) or / 231 (inches).
Take 90 percent of the result as your usable capacity.
If the tank lies on its side, use the horizontal-tank method for partial fills.

A round tank hides nothing once you know the recipe: two measurements, one squared radius, one conversion. The label's job is marketing. The formula's job is the truth.

The Gallon Bug: US vs Imperial Gallons in Your Code

cylinder volume-calculator — Tue, 20 Oct 2026 06:24:00 +0000

A user in London opens your tank volume calculator, enters the dimensions of a standard cylindrical tank, and gets a result that is 20 percent too high. A user in Texas enters the same dimensions into the same calculator and gets the correct answer. Same code, same inputs, wildly different correctness. The bug is not in your math. It is in your gallon.

There are two different gallons in common use, they differ by about 20 percent, and most code treats them as if they were the same thing. This post walks through where the two gallons come from, how the bug shows up in real code, how much damage it does in litres, and how to design your conversion layer so it never bites you.

Two gallons, one name

Unit	Litres	Cubic inches
US liquid gallon	3.785411784	231 (exact)
Imperial gallon	4.54609	about 277.4

The imperial gallon is 20.09 percent larger than the US gallon. That is not a rounding difference you can ignore. It is the difference between a correct result and a wrong one on every single conversion.

A short history explains the split. Britain standardized the imperial gallon in 1824, defining it by the volume of 10 pounds of water. The United States kept the older Queen Anne wine gallon of 231 cubic inches, which it had inherited from colonial practice. Neither side was wrong; they simply froze different definitions in law. Your code, unfortunately, has to pick one, and it has to pick knowingly.

How the bug looks in code

Here is the pattern that causes the trouble. It appears in calculators, IoT dashboards, aquarium tools, fuel trackers, and brewing apps:

function litresToGallons(litres) {
  return litres / 3.785; // which gallon is this?
}

The constant 3.785 is the US gallon, but nothing in the function says so. A developer in Manchester copies the snippet, the math checks out in testing (the function does convert litres to a gallon), and the bug ships. Every imperial user gets results inflated by 20 percent, forever, until someone files a very confused bug report.

The reverse direction is just as common:

function gallonsToLitres(gallons) {
  return gallons * 4.546; // imperial constant, US audience
}

The damage, in real numbers

Take a cylindrical tank with a radius of 0.5 m and a height of 1.2 m. Its volume is:

V = π × 0.5² × 1.2 = 0.9425 m³ = 942.5 litres

Now convert that volume to gallons both ways:

US gallons: 942.5 / 3.785411784 = 249.0 gallons
Imperial gallons: 942.5 / 4.54609 = 207.3 gallons

The difference is 41.7 gallons, on one ordinary tank. Scale it up and it gets worse. A 500-gallon fuel order means 1,892.7 litres in the US but 2,273.0 litres in imperial terms, a gap of 380.3 litres. If your software sizes deliveries, doses chemicals, or bills customers by the gallon, the wrong definition is a financial bug, not a cosmetic one.

There is a useful sanity check here: 1,000 litres is 264.17 US gallons but only 219.97 imperial gallons. If a conversion in your app ever returns a number near 264 for a British user, you have found the bug.

The fix: make the unit part of the API

The root cause is an unnamed constant carrying an unstated assumption. The fix is to make the gallon variant explicit everywhere it matters:

const LITRES_PER_GALLON = {
  US: 3.785411784,
  IMPERIAL: 4.54609,
};

function litresToGallons(litres, system) {
  const factor = LITRES_PER_GALLON[system];
  if (!factor) throw new Error(`Unknown gallon system: ${system}`);
  return litres / factor;
}

litresToGallons(942.5, 'US');       // 249.0
litresToGallons(942.5, 'IMPERIAL'); // 207.3

Three design choices do the heavy lifting:

Named constants in one place. Both definitions live in a single object. Nobody copy-pastes a bare 3.785 ever again.
A required parameter, not a default. If system is optional, someone will forget it, and the default will be wrong for half your users. Force the caller to decide. (If you must default, default from the user's locale, and log it.)
Fail loudly on unknown values. A typo like 'UK' should throw, not silently fall through to whichever branch happens to catch it.

If you are building or checking a reference implementation, a public cylinder volume calculator shows the expected behaviour: dimensions in, volume out, with the unit system chosen explicitly by the user rather than assumed by the code.

Lock it down with tests

Unit bugs survive because conversions are rarely tested with real-world values. Two test cases with known answers would have caught the gallon bug on day one:

test('1000 litres in US gallons', () => {
  expect(litresToGallons(1000, 'US')).toBeCloseTo(264.17, 2);
});

test('1000 litres in imperial gallons', () => {
  expect(litresToGallons(1000, 'IMPERIAL')).toBeCloseTo(219.97, 2);
});

Add a round-trip test as well: converting litres to gallons and back should return the starting value in both systems. And whenever you write a conversion test, take the expected value from a published reference (a cylinder volume in litres reference table, for example) instead of computing it with the same constant you are testing. A test that derives its expectation from the code under test proves nothing.

Can you detect the right gallon automatically?

A tempting shortcut is to infer the system from the user's locale: en-US gets US gallons, en-GB gets imperial, done. Locale detection is a reasonable default, but treat it as a hint, not a verdict:

Expats and travellers routinely run devices in a foreign locale. An American engineer working in Dubai may have an en-GB browser and US expectations.
Canada is genuinely mixed. Officially metric, but US gallons dominate in practice near the border, while older imperial references linger in some industries. No locale string resolves that.
Shared machines and screenshots in industrial settings mean the person reading the number is often not the person whose locale configured it.

The robust pattern is: default from locale, display the active variant next to every result ("249.0 gal (US)"), and let the user switch it in one tap, remembering their choice. The label matters as much as the default. Half of the gallon bug's damage comes from users never learning that a choice existed. A bare number invites trust; a labelled number invites a second look, and that second look is what catches the mismatch before it reaches an invoice.

Other traps in the same family

The gallon split is the famous one, but it has relatives worth knowing:

The US dry gallon is 4.4048838 litres, a third definition, used for dry goods. Rare in software, devastating when it appears.
Cubic feet conversions inherit the ambiguity: 1 ft³ = 7.48052 US gallons but 6.22884 imperial gallons. If your ft³-to-gallons constant came from an American source and your users are British, the same 20 percent error rides along.
Miles per gallon comparisons between US and UK car reviews are meaningless without the variant. A car rated 40 mpg (imperial) achieves about 33.3 mpg (US). Automotive content that ignores this misleads readers on two continents.
Fluid ounces differ too: the US fluid ounce is 29.5735 mL, the imperial is 28.4131 mL. Smaller stakes, same disease.

A one-line audit for your own codebase

Before the next deploy, grep your codebase for bare conversion numbers and ask one question about each: which definition is this?

grep -rn "3.785\|4.546\|264.17\|219.97\|7.48052\|6.22884" src/

Every bare match is a candidate gallon bug. For each hit, check three things: is the constant named, is the variant explicit in the function signature or the UI label, and is there a test with a known real-world value? Most codebases fail at least one of the three on the first audit. The ones that fail all three are usually the ones with a confused user in London and a calm user in Texas, and neither of them can tell you what is wrong.

The rule to take away

Any unit with a regional variant is a parameter, not a constant. Gallons, fluid ounces, tons (short, long, metric), and even calories all have multiple live definitions. When you catch yourself typing a bare conversion factor into a function, stop and ask: which definition is this, who decided, and where would a user tell me otherwise?

Your London user and your Texas user are both right. Your code just has to know which gallon each of them means.

Why a One-Page Calculator Outranks Big Brands: An SEO Playbook for Developers

cylinder volume-calculator — Wed, 07 Oct 2026 09:43:27 +0000

I run a tiny single-purpose calculator website. No blog empire, no brand budget, no backlink machine. One of its queries pulled more than 450,000 impressions in a recent Search Console window, sitting at position 5.3 above sites with ten times the domain authority.

I did not buy links or hire an agency. The whole playbook fits in this post, and every piece of it is something a developer can implement in a weekend. All the numbers below are from my own Search Console, not a case study I read somewhere.

1. Tool queries are a different game

Most SEO advice assumes the searcher wants to read something. Tool queries are different. Someone typing the volume of a cylinder into Google does not want a history of geometry. They want to type two numbers and get an answer, ideally before their coffee cools.

Google knows this. For these queries it rewards the page that resolves the intent fastest, not the page with the biggest brand. That is the entire opening. A focused page that does one calculation well can outrank a famous domain whose page buries the answer under three paragraphs of introduction. I have watched it happen on my own site for months.

So the first rule: match the intent shape, not the keyword. If the query wants a tool, ship a tool. If it wants a number, show the number first and explain second.

2. Read your own Search Console like a lab notebook

The data told me things no guru did. That 450k-impression query? It also had a click-through rate under 0.01 percent. Hundreds of thousands of people saw the listing and almost nobody clicked. That is not a ranking problem. That is a title and meta description problem, and it is the cheapest fix in SEO.

I also learned to filter by language before drawing conclusions. The raw export had a thousand queries, but a few hundred were in Arabic, Russian, Malay, and French. My English pages were never going to win those, and averaging them into my analysis just produced noise. Once I isolated the 617 true English queries, the priority list wrote itself: a handful of queries carried almost all the impressions, and each one mapped to exactly one page.

The title rewrite deserves a concrete example. The old title for the formula page was descriptive but flat, something like "Cylinder Volume Formula." The new one leads with the outcome the searcher wants and the proof they can trust: the formula, a worked example, and a calculator, named right in the title. Same ranking, visibly better CTR within weeks. The lesson generalizes: at positions 4 through 8, you are not fighting for relevance, you already have it. You are fighting for the click, and the click is won in 60 characters.

Lesson for developers: export the data, filter ruthlessly, and let the top ten queries dictate your roadmap. Opinions are cheap. Impressions are not.

3. One intent, one page, no exceptions

The site has around 75 pages, and each one targets exactly one query pattern. Volume in liters. Volume in gallons. Volume from diameter. And the long tail gets its own pages too, because long-tail intent is specific. A search for volume of hollow cylinder comes from someone sizing a pipe or a tube, doing outer minus inner. That is not the same person as a student doing homework, and they should not land on the same page.

This is programmatic SEO done honestly: templates plus real data, one intent per URL, every page genuinely useful on its own. It is an engineering problem as much as a marketing one, data modeling plus template design plus internal linking. This Jekyll-based programmatic SEO build walks through the same architecture with a different dataset, and it is worth studying for the template discipline alone.

The failure mode is publishing 75 near-duplicate pages. The difference between that and what works is whether each page would still deserve to exist if search engines disappeared tomorrow. If the answer is yes for every page, you are building a resource. If not, you are building spam, and Google is better at telling the difference than you are.

4. The UX is the ranking factor

Here is the uncomfortable part for developers who think SEO is metadata. For tool pages, the user experience is the SEO. My checklist, learned the hard way:

Server-render the answer path. If your calculator only works after three seconds of JavaScript hydration, you are slower than every competitor and Google measures it. Interaction to Next Paint is a ranking input now, and heavy client bundles are the usual suspect.

No signup walls, no interstitials, no cookie banners the size of a novel. Every obstacle between the query and the answer costs you the click and eventually the ranking.

Mobile first is not a slogan for tool pages, it is the whole audience. A contractor on a job site is not opening a laptop to convert cubic inches to liters. If the inputs are fiddly on a phone, you lose. One change that mattered more than any redesign: setting inputmode="decimal" on the number fields so mobile keyboards show digits instead of the full QWERTY layout. It is a single HTML attribute. It cut input errors visibly, because half of mobile typos come from the wrong keyboard, not the wrong user.

This developer SEO checklist covers the deployment side well: semantic HTML, sitemaps, schema, performance. Do all of it, but understand that for tool pages it is table stakes. The differentiator is how fast a stranger gets their answer.

5. Speak schema to the crawlers

There is one more developer-shaped advantage: structured data. A calculator page can tell Google exactly what it is with a few lines of JSON-LD, and most competitors never bother.

{
  "@context": "https://schema.org",
  "@type": "WebApplication",
  "name": "Cylinder Volume Calculator",
  "applicationCategory": "UtilitiesApplication",
  "operatingSystem": "Any",
  "offers": { "@type": "Offer", "price": "0" }
}

That block does two jobs. It makes you eligible for rich results, and it removes ambiguity about the page's purpose. For tool pages I also mark up the worked examples as HowTo steps where they genuinely are step-by-step. Do not fake it. Schema that describes real page content gets rewarded; schema that describes content that is not there gets ignored at best.

6. Internal linking is a topic graph, not a chore

With 75 pages, internal linking is what turns a pile of URLs into a site. I treat it as a graph problem: a hub page for the core topic, spokes for each variant, and every page linking to its closest siblings. The hollow cylinder page links to the pipe volume guide. The liters page links to the gallons page. A crawler can reach everything in two hops, and so can a human.

This compounds. Each new page strengthens the cluster, and the cluster lifts every page in it. One developer's content engine case study shows the same compounding effect with real traffic numbers, going from a couple thousand monthly visitors to nearly twenty thousand in a quarter by publishing consistently into a tight cluster.

7. What I got wrong

Honesty requires the failures too. My first version of the site tried to rank the homepage for everything, and it ranked for nothing. Splitting intent across dedicated pages was the fix, and it took me months to accept because it felt like more work. It was less work than the months of flat traffic.

I also ignored non-English queries for too long. The Arabic version of one page quietly became a top performer while I was busy optimizing English titles. If your data shows demand in another language, serve it instead of admiring the numbers.

And I underestimated how much the title matters at position 5 versus position 2. Same ranking, different title, wildly different clicks. I now rewrite titles based on Search Console CTR the way other people A/B test landing pages.

Takeaway

A one-page calculator outranks big brands when it does four things: match the intent shape exactly, earn its pages from real query data, resolve the need faster than anyone else, and link its pages into a coherent graph. None of that requires permission, budget, or a brand. It requires a developer willing to read the data and ship the boring fixes.