MathPlotAI Logo MathPlotAI

Pouring Water into a Cylinder: Modeling Volume–Height Change

Pouring Water into a Cylinder: Modeling Volume–Height Change
Loading the math board and drawing, please wait…
2020-09-18 18:01
Solid GeometryCalculusDerivativeIntegralGeometric Construction
This example visually simulates pouring water into a cylinder and lets learners observe the relationship between the water volume and the water height as the process evolves. It emphasizes how geometric parameters translate into functional dependence and how changes can be analyzed through calculus. Key mathematical ideas include cylindrical geometry (volume–height proportional structure), parameter-driven modeling of evolving quantities (height h versus volume vol), and calculus tools to study variation and possible extremes. Construction in GeoGebra combines numerical and geometric components: Derivative is used to represent instantaneous rates of change; Max helps identify or compare extremal values of relevant quantities; Circle, Line, Intersect, Segment, Ellipse, Polygon, Arc, and Rotate build the cylinder’s cross-sectional geometry and auxiliary shapes; OrthogonalLine, Angle, and Distance compute measurements such as lengths and angles; Sequence generates parameter-dependent values; IntegralBetween models accumulated volume/height over a given interval; Vector and Text provide direction cues and labels for interpreting the evolving model. Suitable for advanced secondary education and early university calculus/modeling courses, especially for demonstrating how a physical process can be represented and analyzed with geometry and calculus in an interactive graphing environment.

GeoGebra Commands & Parameters

  1. Derivative(w) → r
  2. Max(r, 0, tmax) → maxrpt
  3. Circle(pcenter, 5) → pcircle
  4. Line(pcenter, (x(pcenter) + 1, y(pcenter))) → phline
  5. Intersect(pcircle, phline, 2) → phlinept
  6. Rotate(phlinept, pth, pcenter) → phlinept2
  7. Line(pcenter, phlinept2) → phline3
  8. Intersect(pcircle, phline3, 1) → ppt1
  9. OrthogonalLine(ppt1, phline3) → phline4
  10. Point(phline4) → ptippt1
  11. Circle(pcenter, ptipcircleradius) → ptipcircle
  12. Segment(pcenter, ptippt1) → ptipline
  13. Intersect(ptipcircle, ptipline) → ptippt,
  14. Distance(ptippt, pcenter) → ptipradius
  15. Angle(phlinept, pcenter, phlinept2) → pourangle
  16. Point({cradius, 0}) → cpt1
  17. Point({(-cradius), 0}) → cpt2
  18. Point({(-cradius), cheight}) → cpt3
  19. Segment(cpt2, cpt3) → cleftseg
  20. Point({0, wheight}) → wheightpt
  21. Point({cradius, wheight}) → wheightpt1
  22. Point({(-cradius), wheight}) → wheightpt2
  23. Point({0, cheight - cscalemin}) → cptellipsemidtop
  24. Ellipse((x(cpt) - 0.02, cheight), (x(cpt3) + 0.02, cheight), cptellipsemidtop) → cellipsetop
  25. Segment(cpt1, cpt) → crightseg
  26. Point({0, wheight - (cscalemax - (wheight / cheight * cscalerange))}) → wptellipsemid
  27. Ellipse((x(wheightpt1) - 0.02, wheight), (x(wheightpt2) + 0.02, wheight), wptellipsemid) → wellipsetop
  28. Point({0, (-cscalemax)}) → cptellipsemidbottom
  29. Ellipse((x(cpt1) - 0.02, 0), (x(cpt2) + 0.02, 0), cptellipsemidbottom) → cellipsebottom
  30. Polygon(wheightpt1, cpt1, cpt2, wheightpt2) → cwater, wheightpt1_1, cpt1_1, cpt2_1, wheightpt2_1
  31. Arc(cellipsebottom, cpt2, cpt1) → warcbottom
  32. Arc(wellipsetop, wheightpt1, wheightpt2) → warctop
  33. Point({((sscale * rscale) * r(t)), wheight}) → spt1
  34. Point({(((-sscale) * rscale) * r(t)), wheight}) → spt2
  35. Circle(pcenter, ptipradius - (((spscale * rscale) * ptipradius) * r(t))) → scircle
  36. Intersect(scircle, ptipline) → spt3,
  37. Polygon(ptippt, spt3, spt1, spt2) → swater, ptippt_1, spt3_1, spt1_1, spt2_1
  38. Point({0, wheight - (0.2 * (cscalemax - (wheight / cheight * cscalerange)))}) → sellipsept
  39. Ellipse(spt1, spt2, sellipsept) → sellipse
  40. Arc(sellipse, spt2, spt1) → sarc
  41. Arc(sellipse, spt2, spt1) → ssplash
  42. Arc(cellipsetop, cpt3, cpt) → cellipsetoparc
  43. Sequence(hstart + (k * dh), k, 0, n) → wheights
  44. Sequence(Point[{0, Element[wheights, k] - (cscalemax - (Element[wheights, k] / cheight * cscalerange))}], k, 2, n + 1) → wellipsemidpts
  45. Sequence(Ellipse[((-cradius) + 0.02, Element[wheights, k]), (cradius - 0.02, Element[wheights, k]), Element[wellipsemidpts, k - 1]], k, 2, n + 1) → wellipses
  46. Arc(cellipsebottom, cpt2, cpt1) → carcbottom
  47. Sequence(Arc[Element[wellipses, k], ((-cradius), Element[wheights, k + 1]), (cradius, Element[wheights, k + 1])], k, 1, n) → warcfront
  48. Sequence(Arc[Element[wellipses, k], (cradius, Element[wheights, k + 1]), ((-cradius), Element[wheights, k + 1])], k, 1, n) → warcback
  49. IntegralBetween(whitetopline, efuntop, (-cradius), cradius) → whitetop
  50. IntegralBetween(efunbottom, whitebottomline, (-cradius), cradius) → whitebottom
  51. Point({0, hstart - (cscalemax - (hstart / cheight * cscalerange))}) → wptstartellipsemid
  52. Ellipse(((-cradius) + 0.02, hstart), (cradius - 0.02, hstart), wptstartellipsemid) → wstartellipse
  53. Arc(wstartellipse, ((-cradius) + 0.02, hstart), (cradius - 0.02, hstart)) → wstartfrontellipse
  54. Arc(wstartellipse, (cradius - 0.02, hstart), ((-cradius) + 0.02, hstart)) → wstartbackellipse
  55. Sequence(Segment[((-cradius) - 0.36, Element[wheights, k]), ((-cradius) - 0.08, Element[wheights, k])], k, 1, n + 1) → hlines
  56. Sequence(Vector[((-cradius) - 0.22, Element[wheights, k]), ((-cradius) - 0.22, Element[wheights, k + 1])], k, 1, n) → wvecs
  57. Vector(((-cradius) - 0.22, (n * dh) + hstart), ((-cradius) - 0.22, wheight)) → wlastvec
  58. Segment(((-cradius) - 0.08, 0), ((-cradius) - 0.36, 0)) → wstartline
  59. Segment(((-cradius) - 0.36, wheight), ((-cradius) - 0.08, wheight)) → hendline
  60. Polygon(((-2 * cradius), ((j + 1) * dh) + hstart + 0.008), ((-2 * cradius), 10), ((-cradius) + 0.006, 10), ((-cradius) + 0.006, ((j + 1) * dh) + hstart + 0.008)) → cwhitetoprec, wr3, wr4, wr5, wr6
  61. Polygon(((-2 * cradius), (j * dh) + hstart - 0.008), ((-2 * cradius), -10), ((-cradius) + 0.006, -10), ((-cradius) + 0.006, (j * dh) + hstart - 0.008)) → cwhitebottomrec, f, g, h, i
  62. Polygon(((2 * cradius), (j * dh) + hstart - 0.008), ((2 * cradius), -10), (cradius - 0.006, -10), (cradius - 0.006, (j * dh) + hstart - 0.008)) → cwhitebottomrecright, wr11, wr12, wr1, wr2
  63. Polygon(((2 * cradius), ((j + 1) * dh) + hstart + 0.008), ((2 * cradius), 10), (cradius - 0.006, 10), (cradius - 0.006, ((j + 1) * dh) + hstart + 0.008)) → cwhiteroprecright, k, l, q, c
  64. Vector(((-cradius) - 0.22, 0), ((-cradius) - 0.22, hstart)) → wstartvec
  65. Vector(((-cradius) - 0.22, hstart), ((-cradius) - 0.22, wheight)) → wvec
  66. Segment(((-cradius) - 0.08, hstart), ((-cradius) - 0.36, hstart)) → hstartline
  67. Polygon((qxloc + ((p * dh) * j) - qos, -10), (qxloc - 2, -10), (qxloc - 2, 10), (qxloc + hstart + (j * dh) - qos, 10), (qxloc + hstart + (j * dh) - qos, qhloc - 0.16), (qxloc + ((p * dh) * j) - qos, qvloc + 0.16)) → qwhitebefore, d, e, f_1, g_1, h_1, i_1
  68. Polygon((qxloc + ((p * dh) * (j + 1)) + qos, -10), ((-2 * cradius), -10), ((-2 * cradius), 10), (qxloc + hstart + ((j + 1) * dh) + qos, 10), (qxloc + hstart + ((j + 1) * dh) + qos, qhloc - 0.16), (qxloc + ((p * dh) * (j + 1)) + qos, qvloc + 0.16)) → qwhiteafter, s, j_1, k_1, l_1, m_1, n_1
  69. Sequence(Point[{-0.18, y(Element[wellipsemidpts, k]) + (y(Element[wellipsemidpts, k + 1]) - y(Element[wellipsemidpts, k])) / 2 + 0.12}], k, 1, n) → cdvlabelpts
  70. Sequence(Text["\Delta v", Element[cdvlabelpts, k], true, true], k, 1, n) → cdvlabels
  71. Point({-0.18, y(wptstartellipsemid) + (y(Element[wellipsemidpts, 1]) - y(wptstartellipsemid)) / 2 + 0.12}) → cdvlabelstartpt
  72. Point({-0.18, y(Element[wellipsemidpts, n]) + (y(wptellipsemid) - y(Element[wellipsemidpts, n])) / 2 + 0.12}) → cdvlabelendpt
  73. Text("\Delta v", cdvlabelstartpt, true, true) → cdvlabelstart
  74. Text("\Delta v", cdvlabelendpt, true, true) → cdvlabelend
  75. Sequence(Point[{(-cradius) - 0.7, Element[wheights, k] + dh / 2 + 0.12}], k, 1, n) → cdhlabelpts
  76. Sequence(Text["\Delta h", Element[cdhlabelpts, k], true, true], k, 1, n) → cdhlabels
  77. Point({(-cradius) - 0.7, Element[wheights, n + 1] + (wheight - Element[wheights, n + 1]) / 2 + 0.12}) → cdhlabelendpt
  78. Text("\Delta h", cdhlabelendpt, true, true) → cdhlabelend
  79. Sequence(Point[{qxloc + Element[wheights, k] + (1 / 2 * dh) - 0.12, qhloc + 0.34}], k, 1, n) → qdhlabelpts
  80. Point({qxloc + Element[wheights, n + 1] + (wheight - Element[wheights, n + 1]) / 2 - 0.12, qhloc + 0.34}) → qdhlabelendpt
  81. Sequence(Text["\Delta h", Element[qdhlabelpts, k], true, true], k, 1, n) → qdhlabels
  82. Text("\Delta h", qdhlabelendpt, true, true) → qdhlabelend
  83. Sequence(Point[{qxloc + ((p * dh) * (k - 1 / 2)) - 0.135, qvloc - 0.16}], k, 1, n) → qdvlabelpts
  84. Point({qxloc + ((p * dh) * n) + (vol - ((p * dh) * n)) / 2 - 0.135, qvloc - 0.16}) → qdvlabelendpt
  85. Text("\Delta v", qdvlabelendpt, true, true) → qdvlabelend
  86. Sequence(Text["\Delta v", Element[qdvlabelpts, k], true, true], k, 1, n) → qdvlabels
  87. Point({-0.26, hstart + (wheight - hstart) / 2 + 0.07}) → cvlabelpt
  88. Text("\Delta v", cvlabelpt, true, true) → cvlabel
  89. Point({(-cradius) - 0.85, hstart + (wheight - hstart) / 2 + 0.2}) → chlabelpt
  90. Text("\Delta h", chlabelpt, true, true) → chlabel
  91. Point({qxloc + vol / 2 - 0.18, qvloc - 0.14}) → qvlabelpt
  92. Text("\Delta v", qvlabelpt, true, true) → qvlabel
  93. Point({qxloc + hstart + (wheight - hstart) / 2 - 0.17, qhloc + 0.38}) → qhlabelpt
  94. Text("\Delta h", qhlabelpt, true, true) → qhlabel
  95. Segment((qxloc + vol, qvloc + 0.16), (qxloc + vol, qvloc - 0.16)) → qvendline
  96. Vector((qxloc, qvloc), (qxloc + vol, qvloc)) → qvvec
  97. Segment((qxloc, qvloc + 0.16), (qxloc, qvloc - 0.16)) → qvstartline
  98. Segment((qxloc + wheight, qhloc - 0.16), (qxloc + wheight, qhloc + 0.16)) → qhendline
  99. Vector((qxloc + hstart, qhloc), (qxloc + wheight, qhloc)) → qhvec
  100. Segment((qxloc + hstart, qhloc - 0.16), (qxloc + hstart, qhloc + 0.16)) → qhstartline
  101. Segment((qxloc, qhloc - 0.16), (qxloc, qhloc + 0.16)) → qwstartline
  102. Segment((qxloc + vol, qvloc + 0.16), (qxloc + wheight, qhloc - 0.16)) → quplinelast
  103. Segment((qxloc, qvloc + 0.16), (qxloc + hstart, qhloc - 0.16)) → quplinefirst
  104. Segment((qxloc + hstart + vol, qhloc + 0.16), (qxloc + hstart + vol, qhloc - 0.16)) → qonhendline
  105. Sequence(Segment[(qxloc + hstart + (k * vol), qhloc + 0.16), (qxloc + hstart + (k * vol), qhloc - 0.16)], k, 0, m) → qonhlines
  106. Segment((qxloc + vol, qvloc + 0.16), (qxloc + hstart + vol, qhloc - 0.16)) → qonhendupline
  107. Sequence(Segment[(qxloc + Element[wheights, k], qhloc - 0.16), (qxloc + Element[wheights, k], qhloc + 0.16)], k, 1, n + 1) → qhlines
  108. Sequence(Vector[(qxloc + ((p * dh) * k), qvloc), (qxloc + ((p * dh) * (k + 1)), qvloc)], k, 0, n - 1) → qvvecs
  109. Vector((qxloc + ((p * dh) * n), qvloc), (qxloc + vol, qvloc)) → qvlastvec
  110. Sequence(Segment[(qxloc + ((p * dh) * k), qvloc + 0.16), (qxloc + ((p * dh) * k), qvloc - 0.16)], k, 0, n) → qvlines
  111. Sequence(Segment[(qxloc + ((p * dh) * k), qvloc + 0.16), (qxloc + Element[wheights, k + 1], qhloc - 0.16)], k, 0, n) → quplines
  112. Vector((qxloc + vol, qvloc), (qxloc + vol, qvloc + wheight - hstart)) → quphvec
  113. Sequence(Point[{qxloc + ((p * dh) * k), qvloc + dh}], k, 1, n) → qupvecpts
  114. Sequence(Point[{qxloc + Element[wheights, k], qhloc}], k, 2, n + 1) → qhvecendpts
  115. Sequence(Point[{x(Element[qhvecendpts, k]) + (rot * (x(Element[qupvecpts, k]) - x(Element[qhvecendpts, k]))), y(Element[qhvecendpts, k]) + (rot * (y(Element[qupvecpts, k]) - y(Element[qhvecendpts, k])))}], k, 1, n) → qhvecpts
  116. Sequence(Vector[((dh * cos(π + rota)) + x(Element[qhvecpts, k]), (dh * sin(π + rota)) + y(Element[qhvecpts, k])), Element[qhvecpts, k]], k, 1, n) → qhrotvecs
  117. Point({qxloc + wheight, qhloc}) → qhlastpt
  118. Point({qxloc + vol, qvloc + wheight - (n * dh) - hstart}) → quplastpt
  119. Point({x(qhlastpt) + (rot * (x(quplastpt) - x(qhlastpt))), y(qhlastpt) + (rot * (y(quplastpt) - y(qhlastpt)))}) → qhlastvecpt
  120. Vector(((qhlastveclength * cos(π + rota)) + x(qhlastvecpt), (qhlastveclength * sin(π + rota)) + y(qhlastvecpt)), qhlastvecpt) → qhlastrotvec
  121. Vector((((dh + hstart) * cos(π + rota)) + qxloc + hstart + dh - (rot * (hstart + dh)), ((dh + hstart) * sin(π + rota)) + qhloc - (rot * (qhloc - (qvloc + dh)))), ((dh * cos(π + rota)) + qxloc + hstart + dh - (rot * (hstart + dh)), (dh * sin(π + rota)) + qhloc - (rot * (qhloc - (qvloc + dh))))) → qhstartvec

AI Drawing Prompt Reference

Create a dynamic side-view construction that models pouring water into a cylinder. Start by drawing the cylinder cross-section circle with a fixed center and radius, then add a reference line through the center and form a rotated line to set the pouring direction, using their intersections on the circle to define key points. Build the initial water boundary with circle arcs and a polygonal water region inside the cylinder. Generate a stack of intermediate liquid levels: at multiple heights, place points on the vertical axis and construct corresponding ellipses whose endpoints lie near the left and right interior sides, then connect these ellipses using arc segments to form top “wave” arcs. Include short segments and arc annotations that link the liquid-level points to the cylinder boundary so the evolving water shape reflects the height–volume geometric dependence.
The prompt above was compiled from the original drawing commands and is for reference only.