<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="1:1">
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      background: #f8fafc;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      width: 100%;
      min-height: 100%;
      padding: 16px;
      user-select: none;
      -webkit-user-select: none;
    }
    .header {
      text-align: center;
    }
    .badge {
      display: inline-block;
      font-size: 13px;
      font-weight: 700;
      letter-spacing: 0.5px;
      text-transform: uppercase;
      color: #0284c7;
      background: #e0f2fe;
      padding: 4px 12px;
      border-radius: 20px;
    }
    .canvas-container {
      position: relative;
      width: 100%;
      max-width: 320px;
      aspect-ratio: 1 / 1;
      display: flex;
      justify-content: center;
      align-items: center;
    }
    canvas {
      width: 100%;
      height: 100%;
      touch-action: none;
      border-radius: 8px;
    }
    .caption-box {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 8px;
      padding: 10px 14px;
      text-align: center;
      font-size: 13px;
      font-weight: 600;
      color: #334155;
      max-width: 320px;
      box-shadow: 0 1px 3px rgba(0,0,0,0.04);
    }
    .caption-highlight {
      color: #0284c7;
    }
  </style>
</head>
<body>

  <div class="header">
    <span class="badge">Liquid State</span>
  </div>

  <div class="canvas-container">
    <canvas id="beakerCanvas" width="320" height="320"></canvas>
  </div>

  <div class="caption-box">
    Closely packed • Random arrangement<br>
    <span class="caption-highlight">Particles slide past each other</span>
  </div>

  <script>
    const canvas = document.getElementById('beakerCanvas');
    const ctx = canvas.getContext('2d');

    // Beaker Geometry (Canvas space: 320 x 320)
    const beaker = {
      x: 50,
      y: 40,
      w: 220,
      h: 240,
      lipW: 12,
      cornerRadius: 16
    };

    const liquidTopY = beaker.y + beaker.h * 0.48; // Confined to bottom half
    const radius = 17;
    const particleCount = 16;
    const particles = [];

    // Initialize 16 particles packed at bottom in irregular positions
    const rows = 4;
    const cols = 4;
    const startX = beaker.x + 32;
    const startY = liquidTopY + 22;
    const spacingX = (beaker.w - 64) / 3;
    const spacingY = (beaker.y + beaker.h - liquidTopY - 44) / 3;

    for (let r = 0; r < rows; r++) {
      for (let c = 0; c < cols; c++) {
        particles.push({
          x: startX + c * spacingX + (Math.random() - 0.5) * 8,
          y: startY + r * spacingY + (Math.random() - 0.5) * 8,
          vx: (Math.random() - 0.5) * 0.8,
          vy: (Math.random() - 0.5) * 0.8,
          phase: Math.random() * Math.PI * 2
        });
      }
    }

    let mouseX = -1000;
    let mouseY = -1000;
    let isTouching = false;

    function handlePointer(e) {
      const rect = canvas.getBoundingClientRect();
      const clientX = e.touches ? e.touches[0].clientX : e.clientX;
      const clientY = e.touches ? e.touches[0].clientY : e.clientY;
      mouseX = (clientX - rect.left) * (canvas.width / rect.width);
      mouseY = (clientY - rect.top) * (canvas.height / rect.height);
    }

    canvas.addEventListener('pointerdown', (e) => { isTouching = true; handlePointer(e); });
    canvas.addEventListener('pointermove', (e) => { if (isTouching) handlePointer(e); });
    window.addEventListener('pointerup', () => { isTouching = false; mouseX = -1000; mouseY = -1000; });

    function update() {
      const minX = beaker.x + radius + 4;
      const maxX = beaker.x + beaker.w - radius - 4;
      const minY = liquidTopY + radius + 4;
      const maxY = beaker.y + beaker.h - radius - 6;

      const gravity = 0.05;

      for (let i = 0; i < particles.length; i++) {
        const p = particles[i];

        // Downward gravity to keep them packed at bottom
        p.vy += gravity;

        // Gentle fluid thermal wander / rolling motion
        p.phase += 0.03;
        p.vx += Math.cos(p.phase) * 0.08;
        p.vy += Math.sin(p.phase * 1.3) * 0.06;

        // Touch/Pointer disturbance
        if (isTouching) {
          const dx = p.x - mouseX;
          const dy = p.y - mouseY;
          const dist = Math.hypot(dx, dy);
          if (dist < 60 && dist > 0) {
            const force = (60 - dist) / 60 * 0.8;
            p.vx += (dx / dist) * force;
            p.vy += (dy / dist) * force;
          }
        }

        // Particle-to-particle soft collision & sliding
        for (let j = i + 1; j < particles.length; j++) {
          const p2 = particles[j];
          const dx = p2.x - p.x;
          const dy = p2.y - p.y;
          const dist = Math.hypot(dx, dy);
          const minDist = radius * 2 + 1;

          if (dist < minDist && dist > 0) {
            const overlap = (minDist - dist);
            const nx = dx / dist;
            const ny = dy / dist;

            // Push apart softly
            const separation = overlap * 0.45;
            p.x -= nx * separation;
            p.y -= ny * separation;
            p2.x += nx * separation;
            p2.y += ny * separation;

            // Tangential sliding flow
            const tx = -ny;
            const ty = nx;
            const slideSpeed = 0.05;
            p.vx -= tx * slideSpeed;
            p.vy -= ty * slideSpeed;
            p2.vx += tx * slideSpeed;
            p2.vy += ty * slideSpeed;

            // Damping normal relative velocity
            const rvx = p2.vx - p.vx;
            const rvy = p2.vy - p.vy;
            const dot = rvx * nx + rvy * ny;
            if (dot < 0) {
              p.vx += nx * dot * 0.3;
              p.vy += ny * dot * 0.3;
              p2.vx -= nx * dot * 0.3;
              p2.vy -= ny * dot * 0.3;
            }
          }
        }

        // Damping / Viscosity
        p.vx *= 0.94;
        p.vy *= 0.94;

        // Speed limit
        const speed = Math.hypot(p.vx, p.vy);
        if (speed > 2.5) {
          p.vx = (p.vx / speed) * 2.5;
          p.vy = (p.vy / speed) * 2.5;
        }

        p.x += p.vx;
        p.y += p.vy;

        // Boundary containment
        if (p.x < minX) { p.x = minX; p.vx *= -0.4; }
        if (p.x > maxX) { p.x = maxX; p.vx *= -0.4; }
        if (p.y < minY) { p.y = minY; p.vy *= -0.2; }
        if (p.y > maxY) { p.y = maxY; p.vy *= -0.2; }
      }
    }

    function draw() {
      ctx.clearRect(0, 0, canvas.width, canvas.height);

      // 1. Draw Liquid Fill background
      ctx.save();
      ctx.beginPath();
      ctx.rect(beaker.x + 3, liquidTopY, beaker.w - 6, (beaker.y + beaker.h) - liquidTopY - 3);
      ctx.fillStyle = 'rgba(186, 230, 253, 0.45)';
      ctx.fill();

      // Liquid surface meniscus line
      ctx.beginPath();
      ctx.moveTo(beaker.x + 3, liquidTopY);
      ctx.quadraticCurveTo(beaker.x + beaker.w / 2, liquidTopY + 3, beaker.x + beaker.w - 3, liquidTopY);
      ctx.strokeStyle = '#0284c7';
      ctx.lineWidth = 2.5;
      ctx.stroke();
      ctx.restore();

      // 2. Draw Measurement Marks on Beaker
      ctx.save();
      ctx.strokeStyle = '#94a3b8';
      ctx.fillStyle = '#64748b';
      ctx.font = '9px system-ui, sans-serif';
      ctx.lineWidth = 1.5;

      const marks = [
        { y: beaker.y + beaker.h * 0.3, label: '300 ml' },
        { y: beaker.y + beaker.h * 0.5, label: '200 ml' },
        { y: beaker.y + beaker.h * 0.7, label: '100 ml' }
      ];

      marks.forEach(m => {
        ctx.beginPath();
        ctx.moveTo(beaker.x + 4, m.y);
        ctx.lineTo(beaker.x + 18, m.y);
        ctx.stroke();
        ctx.fillText(m.label, beaker.x + 22, m.y + 3);
      });
      ctx.restore();

      // 3. Draw 16 Particles
      particles.forEach(p => {
        ctx.save();
        ctx.beginPath();
        ctx.arc(p.x, p.y, radius, 0, Math.PI * 2);

        // 3D sphere gradient
        const grad = ctx.createRadialGradient(
          p.x - radius * 0.35, p.y - radius * 0.35, radius * 0.1,
          p.x, p.y, radius
        );
        grad.addColorStop(0, '#7dd3fc');
        grad.addColorStop(0.5, '#0284c7');
        grad.addColorStop(1, '#0369a1');

        ctx.fillStyle = grad;
        ctx.fill();

        ctx.strokeStyle = '#075985';
        ctx.lineWidth = 1.2;
        ctx.stroke();

        // Highlight shine
        ctx.beginPath();
        ctx.arc(p.x - radius * 0.32, p.y - radius * 0.32, radius * 0.28, 0, Math.PI * 2);
        ctx.fillStyle = 'rgba(255, 255, 255, 0.45)';
        ctx.fill();
        ctx.restore();
      });

      // 4. Draw Glass Beaker Outline
      ctx.save();
      ctx.strokeStyle = '#64748b';
      ctx.lineWidth = 3;
      ctx.lineCap = 'round';
      ctx.lineJoin = 'round';

      ctx.beginPath();
      // Top left spout / lip
      ctx.moveTo(beaker.x - beaker.lipW, beaker.y);
      ctx.lineTo(beaker.x, beaker.y);
      // Left wall
      ctx.lineTo(beaker.x, beaker.y + beaker.h - beaker.cornerRadius);
      // Bottom left corner
      ctx.quadraticCurveTo(beaker.x, beaker.y + beaker.h, beaker.x + beaker.cornerRadius, beaker.y + beaker.h);
      // Bottom wall
      ctx.lineTo(beaker.x + beaker.w - beaker.cornerRadius, beaker.y + beaker.h);
      // Bottom right corner
      ctx.quadraticCurveTo(beaker.x + beaker.w, beaker.y + beaker.h, beaker.x + beaker.w, beaker.y + beaker.h - beaker.cornerRadius);
      // Right wall
      ctx.lineTo(beaker.x + beaker.w, beaker.y);
      // Top right lip
      ctx.lineTo(beaker.x + beaker.w + 6, beaker.y);
      ctx.stroke();

      // Glass specular reflection stroke
      ctx.beginPath();
      ctx.moveTo(beaker.x + 10, beaker.y + 16);
      ctx.lineTo(beaker.x + 10, beaker.y + beaker.h - 24);
      ctx.strokeStyle = 'rgba(255, 255, 255, 0.65)';
      ctx.lineWidth = 2.5;
      ctx.stroke();
      ctx.restore();
    }

    function loop() {
      update();
      draw();
      requestAnimationFrame(loop);
    }

    loop();
  </script>
</body>
</html>

How Particles Behave in Solids, Liquids, and Gases

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <style>
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
    }
    body {
      width: 100%;
      height: 100%;
      background: #ffffff;
      font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      padding: 12px 16px;
      user-select: none;
      -webkit-user-select: none;
      overflow: hidden;
    }
    .header-badge {
      font-size: 14px;
      font-weight: 600;
      color: #1e2945;
      background: #f1f5f9;
      border: 1px solid #cbd5e1;
      border-radius: 20px;
      padding: 6px 14px;
      text-align: center;
      letter-spacing: -0.2px;
      box-shadow: 0 1px 3px rgba(0,0,0,0.04);
    }
    .box-container {
      position: relative;
      width: 100%;
      flex: 1;
      max-height: 380px;
      margin: 10px 0;
      border: 3px solid #334155;
      border-radius: 8px;
      background: #f8fafc;
      overflow: hidden;
      box-shadow: inset 0 0 12px rgba(0, 0, 0, 0.04);
    }
    canvas {
      display: block;
      width: 100%;
      height: 100%;
    }
    .controls {
      display: flex;
      gap: 10px;
      align-items: center;
      justify-content: center;
    }
    .btn {
      background: #ffffff;
      border: 1px solid #cbd5e1;
      border-radius: 6px;
      padding: 6px 14px;
      font-size: 13px;
      font-weight: 600;
      color: #1e2945;
      cursor: pointer;
      display: inline-flex;
      align-items: center;
      gap: 6px;
      transition: background 0.15s, border-color 0.15s;
    }
    .btn:hover {
      background: #f1f5f9;
      border-color: #94a3b8;
    }
    .btn:active {
      background: #e2e8f0;
    }
  </style>
</head>
<body>

  <div class="header-badge">
    Gas: Random arrangement, far apart, rapid random motion
  </div>

  <div class="box-container" id="boxContainer">
    <canvas id="gasCanvas"></canvas>
  </div>

  <div class="controls">
    <button class="btn" id="toggleBtn" aria-label="Pause or resume motion">
      <span id="btnIcon">⏸</span> <span id="btnText">Pause</span>
    </button>
  </div>

  <script>
    const canvas = document.getElementById('gasCanvas');
    const ctx = canvas.getContext('2d');
    const container = document.getElementById('boxContainer');
    const toggleBtn = document.getElementById('toggleBtn');
    const btnIcon = document.getElementById('btnIcon');
    const btnText = document.getElementById('btnText');

    let width = 0;
    let height = 0;
    let isRunning = true;
    let animationId = null;

    const PARTICLE_COUNT = 7;
    const PARTICLE_RADIUS = 13;
    const SPEED = 3.6;

    let particles = [];

    function resize() {
      const rect = container.getBoundingClientRect();
      const dpr = window.devicePixelRatio || 1;
      width = rect.width;
      height = rect.height;
      
      canvas.width = width * dpr;
      canvas.height = height * dpr;
      ctx.resetTransform();
      ctx.scale(dpr, dpr);

      // Clamp particles within newly sized bounds
      particles.forEach(p => {
        p.x = Math.max(p.r, Math.min(width - p.r, p.x));
        p.y = Math.max(p.r, Math.min(height - p.r, p.y));
      });
    }

    function initParticles() {
      particles = [];
      const cols = 4;
      const rows = 2;
      const cellW = (width - 40) / cols;
      const cellH = (height - 40) / rows;

      for (let i = 0; i < PARTICLE_COUNT; i++) {
        const col = i % cols;
        const row = Math.floor(i / cols);
        const angle = Math.random() * Math.PI * 2;
        
        particles.push({
          x: 20 + col * cellW + Math.random() * (cellW - 2 * PARTICLE_RADIUS) + PARTICLE_RADIUS,
          y: 20 + row * cellH + Math.random() * (cellH - 2 * PARTICLE_RADIUS) + PARTICLE_RADIUS,
          vx: Math.cos(angle) * SPEED,
          vy: Math.sin(angle) * SPEED,
          r: PARTICLE_RADIUS,
          trail: []
        });
      }
    }

    function update() {
      // Move and record trails
      for (let i = 0; i < particles.length; i++) {
        const p = particles[i];

        p.trail.push({ x: p.x, y: p.y });
        if (p.trail.length > 8) {
          p.trail.shift();
        }

        p.x += p.vx;
        p.y += p.vy;

        // Container wall reflections
        if (p.x - p.r <= 0) {
          p.x = p.r;
          p.vx = Math.abs(p.vx);
        } else if (p.x + p.r >= width) {
          p.x = width - p.r;
          p.vx = -Math.abs(p.vx);
        }

        if (p.y - p.r <= 0) {
          p.y = p.r;
          p.vy = Math.abs(p.vy);
        } else if (p.y + p.r >= height) {
          p.y = height - p.r;
          p.vy = -Math.abs(p.vy);
        }
      }

      // Elastic particle-particle collisions
      for (let i = 0; i < particles.length; i++) {
        for (let j = i + 1; j < particles.length; j++) {
          const p1 = particles[i];
          const p2 = particles[j];

          const dx = p2.x - p1.x;
          const dy = p2.y - p1.y;
          const dist = Math.hypot(dx, dy);
          const minDist = p1.r + p2.r;

          if (dist < minDist && dist > 0) {
            // Normal vector
            const nx = dx / dist;
            const ny = dy / dist;

            // Separate overlapping particles
            const overlap = (minDist - dist) / 2;
            p1.x -= nx * overlap;
            p1.y -= ny * overlap;
            p2.x += nx * overlap;
            p2.y += ny * overlap;

            // Relative velocity along normal
            const kx = p1.vx - p2.vx;
            const ky = p1.vy - p2.vy;
            const p = 2 * (nx * kx + ny * ky) / 2;

            p1.vx -= p * nx;
            p1.vy -= p * ny;
            p2.vx += p * nx;
            p2.vy += p * ny;
          }
        }
      }
    }

    function draw() {
      ctx.clearRect(0, 0, width, height);

      // Draw straight-line motion trails (demonstrates straight trajectory)
      particles.forEach(p => {
        if (p.trail.length > 1) {
          for (let i = 0; i < p.trail.length - 1; i++) {
            const alpha = ((i + 1) / p.trail.length) * 0.28;
            ctx.beginPath();
            ctx.moveTo(p.trail[i].x, p.trail[i].y);
            ctx.lineTo(p.trail[i + 1].x, p.trail[i + 1].y);
            ctx.strokeStyle = `rgba(37, 99, 235, ${alpha})`;
            ctx.lineWidth = p.r * 1.4 * (i / p.trail.length);
            ctx.lineCap = 'round';
            ctx.stroke();
          }
        }
      });

      // Draw particles
      particles.forEach(p => {
        ctx.save();
        ctx.beginPath();
        ctx.arc(p.x, p.y, p.r, 0, Math.PI * 2);

        // Spherical radial gradient
        const grad = ctx.createRadialGradient(
          p.x - p.r * 0.35,
          p.y - p.r * 0.35,
          p.r * 0.1,
          p.x,
          p.y,
          p.r
        );
        grad.addColorStop(0, '#60a5fa');
        grad.addColorStop(0.6, '#2563eb');
        grad.addColorStop(1, '#1d4ed8');

        ctx.fillStyle = grad;
        ctx.shadowColor = 'rgba(37, 99, 235, 0.25)';
        ctx.shadowBlur = 6;
        ctx.shadowOffsetY = 2;
        ctx.fill();

        // Subtle specular highlight
        ctx.beginPath();
        ctx.arc(p.x - p.r * 0.3, p.y - p.r * 0.3, p.r * 0.25, 0, Math.PI * 2);
        ctx.fillStyle = 'rgba(255, 255, 255, 0.7)';
        ctx.shadowColor = 'transparent';
        ctx.fill();

        ctx.restore();
      });
    }

    function loop() {
      if (isRunning) {
        update();
        draw();
      }
      animationId = requestAnimationFrame(loop);
    }

    toggleBtn.addEventListener('click', () => {
      isRunning = !isRunning;
      btnIcon.textContent = isRunning ? '⏸' : '▶';
      btnText.textContent = isRunning ? 'Pause' : 'Resume';
    });

    window.addEventListener('resize', resize);
    
    // Initialize
    resize();
    initParticles();
    loop();
  </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <style>
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
    }

    body {
      background: #ffffff;
      color: #1e2945;
      padding: 8px;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      min-height: 100%;
    }

    .grid-container {
      display: grid;
      grid-template-columns: repeat(3, 1fr);
      gap: 8px;
      width: 100%;
      max-width: 680px;
    }

    @media (max-width: 460px) {
      .grid-container {
        grid-template-columns: 1fr;
        gap: 12px;
      }
    }

    .state-card {
      background: #f8fafc;
      border: 1px solid #e2e8f0;
      border-radius: 12px;
      padding: 10px 8px;
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 8px;
    }

    .state-title {
      font-size: 15px;
      font-weight: 700;
      letter-spacing: 0.3px;
      display: flex;
      align-items: center;
      gap: 6px;
    }

    .state-title.solid { color: #2563eb; }
    .state-title.liquid { color: #0891b2; }
    .state-title.gas { color: #d97706; }

    .canvas-wrap {
      width: 100%;
      aspect-ratio: 1 / 1;
      max-width: 150px;
      background: #ffffff;
      border: 2px solid #cbd5e1;
      border-radius: 8px;
      position: relative;
      overflow: hidden;
      box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.03);
    }

    canvas {
      display: block;
      width: 100%;
      height: 100%;
    }

    .tag-list {
      display: flex;
      flex-direction: column;
      gap: 4px;
      width: 100%;
      font-size: 12px;
    }

    .tag-item {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 6px;
      padding: 3px 6px;
      display: flex;
      flex-direction: column;
      line-height: 1.25;
    }

    .tag-label {
      font-size: 10px;
      font-weight: 700;
      text-transform: uppercase;
      color: #64748b;
    }

    .tag-val {
      font-weight: 600;
      color: #1e2945;
    }
  </style>
</head>
<body>

  <div class="grid-container">
    
    <div class="state-card">
      <div class="state-title solid">🧱 Solid</div>
      <div class="canvas-wrap">
        <canvas id="solidCanvas" width="150" height="150"></canvas>
      </div>
      <div class="tag-list">
        <div class="tag-item">
          <span class="tag-label">Arrangement</span>
          <span class="tag-val">Regular lattice</span>
        </div>
        <div class="tag-item">
          <span class="tag-label">Spacing</span>
          <span class="tag-val">Touching / close</span>
        </div>
        <div class="tag-item">
          <span class="tag-label">Movement</span>
          <span class="tag-val">Vibrates in place</span>
        </div>
      </div>
    </div>

    
    <div class="state-card">
      <div class="state-title liquid">💧 Liquid</div>
      <div class="canvas-wrap">
        <canvas id="liquidCanvas" width="150" height="150"></canvas>
      </div>
      <div class="tag-list">
        <div class="tag-item">
          <span class="tag-label">Arrangement</span>
          <span class="tag-val">Random</span>
        </div>
        <div class="tag-item">
          <span class="tag-label">Spacing</span>
          <span class="tag-val">Mostly touching</span>
        </div>
        <div class="tag-item">
          <span class="tag-label">Movement</span>
          <span class="tag-val">Slides past</span>
        </div>
      </div>
    </div>

    
    <div class="state-card">
      <div class="state-title gas">💨 Gas</div>
      <div class="canvas-wrap">
        <canvas id="gasCanvas" width="150" height="150"></canvas>
      </div>
      <div class="tag-list">
        <div class="tag-item">
          <span class="tag-label">Arrangement</span>
          <span class="tag-val">Random</span>
        </div>
        <div class="tag-item">
          <span class="tag-label">Spacing</span>
          <span class="tag-val">Far apart</span>
        </div>
        <div class="tag-item">
          <span class="tag-label">Movement</span>
          <span class="tag-val">Fast straight lines</span>
        </div>
      </div>
    </div>
  </div>

  <script>
    // SOLID PARTICLES (12 in a 4x3 grid vibrating)
    const solidCanvas = document.getElementById('solidCanvas');
    const sCtx = solidCanvas.getContext('2d');
    const solidParticles = [];
    const sCols = 4, sRows = 3;
    const sSpacingX = 26, sSpacingY = 26;
    const sOffsetX = (150 - (sCols - 1) * sSpacingX) / 2;
    const sOffsetY = 45;

    for (let r = 0; r < sRows; r++) {
      for (let c = 0; c < sCols; c++) {
        solidParticles.push({
          baseX: sOffsetX + c * sSpacingX,
          baseY: sOffsetY + r * sSpacingY,
          phase: Math.random() * Math.PI * 2,
          radius: 11
        });
      }
    }

    // LIQUID PARTICLES (12 closely packed sliding particles at bottom)
    const liquidCanvas = document.getElementById('liquidCanvas');
    const lCtx = liquidCanvas.getContext('2d');
    const liquidParticles = [];
    const lRadius = 11;
    
    // Distribute 12 particles in the lower region of the container
    for (let i = 0; i < 12; i++) {
      liquidParticles.push({
        x: 20 + (i % 4) * 30 + (Math.random() - 0.5) * 8,
        y: 75 + Math.floor(i / 4) * 23 + (Math.random() - 0.5) * 6,
        vx: (Math.random() - 0.5) * 0.75,
        vy: (Math.random() - 0.5) * 0.65,
        radius: lRadius
      });
    }

    // GAS PARTICLES (4 particles moving rapidly all over)
    const gasCanvas = document.getElementById('gasCanvas');
    const gCtx = gasCanvas.getContext('2d');
    const gasParticles = [];
    const gRadius = 9;
    const gasPositions = [
      { x: 30, y: 35, vx: 2.2, vy: 1.8 },
      { x: 120, y: 40, vx: -2.0, vy: 2.3 },
      { x: 40, y: 115, vx: 2.4, vy: -1.7 },
      { x: 110, y: 110, vx: -1.9, vy: -2.2 }
    ];

    gasPositions.forEach(p => {
      gasParticles.push({
        x: p.x,
        y: p.y,
        vx: p.vx,
        vy: p.vy,
        radius: gRadius,
        trail: []
      });
    });

    function drawParticle(ctx, x, y, r, color, strokeColor) {
      ctx.beginPath();
      ctx.arc(x, y, r, 0, Math.PI * 2);
      ctx.fillStyle = color;
      ctx.fill();
      ctx.lineWidth = 1.5;
      ctx.strokeStyle = strokeColor;
      ctx.stroke();

      // Shading reflection
      ctx.beginPath();
      ctx.arc(x - r * 0.3, y - r * 0.3, r * 0.25, 0, Math.PI * 2);
      ctx.fillStyle = 'rgba(255, 255, 255, 0.6)';
      ctx.fill();
    }

    let t = 0;
    function animate() {
      t += 0.08;

      // 1. Render Solid
      sCtx.clearRect(0, 0, 150, 150);
      solidParticles.forEach(p => {
        const vx = Math.sin(t * 4 + p.phase) * 1.6;
        const vy = Math.cos(t * 3.5 + p.phase * 1.5) * 1.6;
        drawParticle(sCtx, p.baseX + vx, p.baseY + vy, p.radius, '#3b82f6', '#1d4ed8');
      });

      // 2. Render Liquid
      lCtx.clearRect(0, 0, 150, 150);
      // Soft container fill hint for liquid level
      lCtx.fillStyle = 'rgba(6, 182, 212, 0.05)';
      lCtx.fillRect(0, 55, 150, 95);
      
      liquidParticles.forEach((p, idx) => {
        p.x += p.vx;
        p.y += p.vy;

        // Container bounds (contained in lower 2/3)
        const minY = 62;
        const maxY = 150 - p.radius;
        const minX = p.radius;
        const maxX = 150 - p.radius;

        if (p.x < minX) { p.x = minX; p.vx *= -1; }
        if (p.x > maxX) { p.x = maxX; p.vx *= -1; }
        if (p.y < minY) { p.y = minY; p.vy *= -1; }
        if (p.y > maxY) { p.y = maxY; p.vy *= -1; }

        // Slight gravity / cohesion toward bottom
        p.vy += 0.015;

        // Repel from other liquid particles (soft fluid collision)
        for (let j = idx + 1; j < liquidParticles.length; j++) {
          const p2 = liquidParticles[j];
          const dx = p2.x - p.x;
          const dy = p2.y - p.y;
          const dist = Math.hypot(dx, dy);
          const minDist = p.radius + p2.radius;
          if (dist < minDist && dist > 0) {
            const overlap = (minDist - dist) * 0.5;
            const nx = dx / dist;
            const ny = dy / dist;
            p.x -= nx * overlap;
            p.y -= ny * overlap;
            p2.x += nx * overlap;
            p2.y += ny * overlap;
            // Swap some velocity
            const p1v = (p.vx * nx + p.vy * ny);
            const p2v = (p2.vx * nx + p2.vy * ny);
            p.vx += (p2v - p1v) * nx * 0.6;
            p.vy += (p2v - p1v) * ny * 0.6;
            p2.vx -= (p2v - p1v) * nx * 0.6;
            p2.vy -= (p2v - p1v) * ny * 0.6;
          }
        }

        drawParticle(lCtx, p.x, p.y, p.radius, '#06b6d4', '#0e7490');
      });

      // 3. Render Gas
      gCtx.clearRect(0, 0, 150, 150);
      gasParticles.forEach((p, idx) => {
        // Record trail
        p.trail.push({ x: p.x, y: p.y });
        if (p.trail.length > 5) p.trail.shift();

        // Draw trail lines
        if (p.trail.length > 1) {
          gCtx.beginPath();
          gCtx.moveTo(p.trail[0].x, p.trail[0].y);
          for (let k = 1; k < p.trail.length; k++) {
            gCtx.lineTo(p.trail[k].x, p.trail[k].y);
          }
          gCtx.strokeStyle = 'rgba(245, 158, 11, 0.25)';
          gCtx.lineWidth = 2.5;
          gCtx.stroke();
        }

        p.x += p.vx;
        p.y += p.vy;

        // Gas bounce full container
        const minX = p.radius;
        const maxX = 150 - p.radius;
        const minY = p.radius;
        const maxY = 150 - p.radius;

        if (p.x <= minX) { p.x = minX; p.vx *= -1; }
        if (p.x >= maxX) { p.x = maxX; p.vx *= -1; }
        if (p.y <= minY) { p.y = minY; p.vy *= -1; }
        if (p.y >= maxY) { p.y = maxY; p.vy *= -1; }

        // Gas particle-particle bounce
        for (let j = idx + 1; j < gasParticles.length; j++) {
          const p2 = gasParticles[j];
          const dx = p2.x - p.x;
          const dy = p2.y - p.y;
          const dist = Math.hypot(dx, dy);
          const minDist = p.radius + p2.radius;
          if (dist < minDist && dist > 0) {
            const nx = dx / dist;
            const ny = dy / dist;
            const overlap = (minDist - dist) * 0.5;
            p.x -= nx * overlap;
            p.y -= ny * overlap;
            p2.x += nx * overlap;
            p2.y += ny * overlap;
            // Elastic collision
            const kx = p.vx - p2.vx;
            const ky = p.vy - p2.vy;
            const pVal = 2 * (nx * kx + ny * ky) / 2;
            p.vx -= pVal * nx;
            p.vy -= pVal * ny;
            p2.vx += pVal * nx;
            p2.vy += pVal * ny;
          }
        }

        drawParticle(gCtx, p.x, p.y, p.radius, '#f59e0b', '#b45309');
      });

      requestAnimationFrame(animate);
    }

    requestAnimationFrame(animate);
  </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="1:1">
  <style>
    * {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
    }
    html, body {
      width: 100%;
      height: 100%;
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      background: #ffffff;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      padding: 16px;
      user-select: none;
    }
    .header {
      text-align: center;
    }
    .title {
      font-size: 15px;
      font-weight: 700;
      color: #0f172a;
      letter-spacing: -0.2px;
    }
    .sub {
      font-size: 13px;
      color: #64748b;
      margin-top: 2px;
    }
    .stage {
      position: relative;
      width: 260px;
      height: 260px;
      display: flex;
      align-items: center;
      justify-content: center;
    }
    svg.connections {
      position: absolute;
      inset: 0;
      width: 100%;
      height: 100%;
      pointer-events: none;
      opacity: 0;
      transition: opacity 0.3s ease;
    }
    svg.connections.visible {
      opacity: 1;
    }
    .grid {
      display: grid;
      grid-template-columns: repeat(4, 1fr);
      grid-template-rows: repeat(4, 1fr);
      gap: 16px;
      width: 220px;
      height: 220px;
      position: relative;
      z-index: 2;
    }
    .particle-slot {
      display: flex;
      align-items: center;
      justify-content: center;
      width: 100%;
      height: 100%;
    }
    .particle {
      width: 36px;
      height: 36px;
      border-radius: 50%;
      background: radial-gradient(circle at 35% 35%, #60a5fa 0%, #2563eb 70%, #1d4ed8 100%);
      box-shadow: 0 2px 5px rgba(37, 99, 235, 0.35);
      will-change: transform;
    }
    /* Subtle continuous vibration on spot */
    @keyframes jiggle1 {
      0%, 100% { transform: translate(0px, 0px); }
      25% { transform: translate(1.2px, -1px); }
      50% { transform: translate(-1px, 1.2px); }
      75% { transform: translate(-0.8px, -0.8px); }
    }
    @keyframes jiggle2 {
      0%, 100% { transform: translate(0px, 0px); }
      25% { transform: translate(-1.2px, 1px); }
      50% { transform: translate(0.9px, -1.1px); }
      75% { transform: translate(1.1px, 0.7px); }
    }
    @keyframes jiggle3 {
      0%, 100% { transform: translate(0px, 0px); }
      25% { transform: translate(0.8px, 1.2px); }
      50% { transform: translate(-1.2px, -0.9px); }
      75% { transform: translate(1px, -1px); }
    }
    .p-1 { animation: jiggle1 0.18s infinite ease-in-out; }
    .p-2 { animation: jiggle2 0.22s infinite ease-in-out; }
    .p-3 { animation: jiggle3 0.16s infinite ease-in-out; }
    .p-4 { animation: jiggle1 0.2s infinite ease-in-out reverse; }

    .controls {
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 8px;
    }
    .btn {
      background: #f1f5f9;
      color: #1e2945;
      border: 1px solid #cbd5e1;
      padding: 8px 16px;
      border-radius: 20px;
      font-size: 13px;
      font-weight: 600;
      cursor: pointer;
      display: inline-flex;
      align-items: center;
      gap: 6px;
      transition: background 0.2s, border-color 0.2s, color 0.2s;
    }
    .btn.active {
      background: #2563eb;
      color: #ffffff;
      border-color: #1d4ed8;
      box-shadow: 0 2px 8px rgba(37, 99, 235, 0.3);
    }
  </style>
</head>
<body>

  <div class="header">
    <div class="title">Solid: Regular Lattice</div>
    <div class="sub">Tightly packed &bull; Fixed spots &bull; Vibrating</div>
  </div>

  <div class="stage">
    
    <svg class="connections" id="connectionsSvg" viewBox="0 0 260 260">
      
      <g stroke="#3b82f6" stroke-width="2.5" stroke-dasharray="4 2" stroke-linecap="round" opacity="0.85">
        
        <line x1="47" y1="47" x2="103" y2="47" />
        <line x1="103" y1="47" x2="157" y2="47" />
        <line x1="157" y1="47" x2="213" y2="47" />
        
        <line x1="47" y1="103" x2="103" y2="103" />
        <line x1="103" y1="103" x2="157" y2="103" />
        <line x1="157" y1="103" x2="213" y2="103" />
        
        <line x1="47" y1="157" x2="103" y2="157" />
        <line x1="103" y1="157" x2="157" y2="157" />
        <line x1="157" y1="157" x2="213" y2="157" />
        
        <line x1="47" y1="213" x2="103" y2="213" />
        <line x1="103" y1="213" x2="157" y2="213" />
        <line x1="157" y1="213" x2="213" y2="213" />

        
        
        <line x1="47" y1="47" x2="47" y2="103" />
        <line x1="47" y1="103" x2="47" y2="157" />
        <line x1="47" y1="157" x2="47" y2="213" />
        
        <line x1="103" y1="47" x2="103" y2="103" />
        <line x1="103" y1="103" x2="103" y2="157" />
        <line x1="103" y1="157" x2="103" y2="213" />
        
        <line x1="157" y1="47" x2="157" y2="103" />
        <line x1="157" y1="103" x2="157" y2="157" />
        <line x1="157" y1="157" x2="157" y2="213" />
        
        <line x1="213" y1="47" x2="213" y2="103" />
        <line x1="213" y1="103" x2="213" y2="157" />
        <line x1="213" y1="157" x2="213" y2="213" />
      </g>
    </svg>

    
    <div class="grid">
      
      <div class="particle-slot"><div class="particle p-1"></div></div>
      <div class="particle-slot"><div class="particle p-2"></div></div>
      <div class="particle-slot"><div class="particle p-3"></div></div>
      <div class="particle-slot"><div class="particle p-4"></div></div>
      
      <div class="particle-slot"><div class="particle p-3"></div></div>
      <div class="particle-slot"><div class="particle p-4"></div></div>
      <div class="particle-slot"><div class="particle p-1"></div></div>
      <div class="particle-slot"><div class="particle p-2"></div></div>
      
      <div class="particle-slot"><div class="particle p-2"></div></div>
      <div class="particle-slot"><div class="particle p-1"></div></div>
      <div class="particle-slot"><div class="particle p-4"></div></div>
      <div class="particle-slot"><div class="particle p-3"></div></div>
      
      <div class="particle-slot"><div class="particle p-4"></div></div>
      <div class="particle-slot"><div class="particle p-3"></div></div>
      <div class="particle-slot"><div class="particle p-2"></div></div>
      <div class="particle-slot"><div class="particle p-1"></div></div>
    </div>
  </div>

  <div class="controls">
    <button class="btn" id="toggleBonds" type="button">
      <span>✦</span> Show Strong Attractive Forces
    </button>
  </div>

  <script>
    const btn = document.getElementById('toggleBonds');
    const bonds = document.getElementById('connectionsSvg');
    let show = false;

    btn.addEventListener('click', () => {
      show = !show;
      bonds.classList.toggle('visible', show);
      btn.classList.toggle('active', show);
    });
  </script>
</body>
</html>

Mikroskopowy mechanizm rozszerzalności cieplnej — asymetria potencjału drgań sieci

Współczynnik rozszerzalności liniowej — definicja, jednostka i interpretacja fizyczna

Obliczanie zmiany długości prętów: wzór Δl = l_0 · α · ΔT

Rozszerzalność powierzchniowa — wzór i zachowanie otworów w ogrzewanych płytkach

Współczynnik rozszerzalności objętościowej ciał stałych: zależność β ≈ 3α

Rozszerzalność objętościowa cieczy i porównanie jej z ciałami stałymi

Rozszerzalność pozorna a rzeczywista cieczy w naczyniach pomiarowych

Rozszerzalność termiczna gazów przy stałym ciśnieniu — ujęcie prawa Gay-Lussaca

science

Fizyczne podstawy rozszerzalności cieplnej ciał stałych, cieczy i gazów

¿Qué es la materia y cómo la percibimos?

Propiedades generales o extrínsecas de los cuerpos

Medición de la masa con balanzas y grameras

Medición del volumen de líquidos y sólidos regulares

Volumen de sólidos irregulares por desplazamiento de agua

La materia y sus propiedades generales

Particle Arrangements and Density in Solids, Liquids, and Gases

How Thermal Energy Changes Particle Motion

Thermal Expansion in Liquids: How Heating Changes Liquid Volume

Diffusion and Brownian Motion in Fluids

Measuring Mass and Volume in the Laboratory

Calculating Density Using Water Displacement

Calculating Pressure from Atomic Collision Forces

Matter, Density, and Kinetic-Molecular Theory

Particle Arrangement in Solids

Particle Arrangement in Liquids

Particle Arrangement in Gases

Particle Motion and Kinetic Energy

Attraction Between Particles in Different States

How Temperature Affects Particle Motion

Using Particle Models to Explain State Changes

Particle Theory: The Particle Model and State Changes

Mikroskopowy mechanizm rozszerzalności cieplnej — asymetria drgań sieci

Współczynnik rozszerzalności liniowej — definicja i jednostki

Obliczanie zmiany długości ciała stałego pod wpływem temperatury

Rozszerzalność powierzchniowa ciał stałych — wzór i zastosowanie

Rozszerzalność objętościowa ciał stałych — związek beta = 3 alfa

Doświadczenie: demonstracja rozszerzalności liniowej — pierścień Gravesandego

Bimetale — zasada działania i zastosowanie w termostatach

Naprężenia termiczne w konstrukcjach budowlanych i szynach kolejowych

Rozszerzalność cieplna ciał stałych

Explaining Density with Particle Theory

Explaining Compressibility with Particle Theory

Diffusion and Particle Theory

Particle Theory and Pressure in Gases

Using Particle Models to Explain Dissolving

Using Particle Models to Explain Conservation

Relating Particle Behaviour to Substance Properties

Investigating State Changes with Particle Models

Particle Theory: Explaining Substance Properties and Behaviours

Propiedades específicas o intrínsecas de la materia

Propiedades organolépticas y pruebas cualitativas

Dureza, tenacidad y maleabilidad en sólidos

Elasticidad, ductilidad y plasticidad de los materiales

Conductividad térmica y eléctrica en materiales

Puntos de fusión y ebullición como huellas de las sustancias

Solubilidad y factores que afectan la disolución

Propiedades específicas de los materiales

Rozszerzalność objętościowa cieczy — współczynnik beta

Rozszerzalność pozorna i rzeczywista cieczy — wpływ rozszerzalności naczynia

Zmiana gęstości substancji w funkcji temperatury

Rozszerzalność termiczna gazów przy stałym ciśnieniu

Szczeliny dylatacyjne w mostach i rurociągach — inżynieria

Zadania złożone z rozszerzalności liniowej i objętościowej

Rozszerzalność cieplna cieczy i gazów oraz zagadnienia złożone

Termometry cieczowe i bimetaliczne — praktyczne wykorzystanie rozszerzalności

Paski bimetaliczne w termostatach i wyłącznikach termicznych

Szczeliny dylatacyjne w mostach, szynach kolejowych i budownictwie kubaturowym

Naprężenia termiczne w materiałach sztywnych i pękanie szkła pod wpływem zmian temperatury

Doświadczenie: demonstracja rozszerzalności prętów metalowych za pomocą aparatu Musschenbroeka

Doświadczenie: demonstracja rozszerzalności objętościowej za pomocą kuli i pierścienia Gravesandego

Doświadczenie: wyznaczanie współczynnika rozszerzalności liniowej rurki metalowej za pomocą czujnika mikrometrycznego

Synteza wiedzy: analiza zagadnień inżynierskich i zjawisk rozszerzalności cieplnej

Zastosowania inżynierskie i doświadczenia z rozszerzalności cieplnej

Concepto de densidad: relación entre masa y volumen

Cálculo experimental de la densidad de sólidos y líquidos

Densidad y flotabilidad: ¿por qué flotan los barcos?

Torre de líquidos inmiscibles y comparación de densidades

Densidad de materiales y flotabilidad

What Makes a Pure Substance?

Elements and Compounds as Pure Substances

What Is a Mixture?

Particle Model of Pure Substances vs Mixtures

Pure Substances and Mixtures

水浴加热装置的组装与实验规范

海波（或冰）熔化过程的温度采集与状态记录

绘制并分析晶体熔化的温度—时间图象

石蜡熔化对比实验与晶体/非晶体特征辨析

熔化吸热与凝固放热规律的实际应用

晶体与非晶体熔化规律实验探究

Metales: propiedades, brillo, conducción y reactividad

No metales y metaloides: características y usos

Los gases nobles: estabilidad y capas llenas

Familias químicas: alcalinos, alcalinotérreos y halógenos

Los elementos clave para la vida: CHONPS y oligoelementos

Elementos sintéticos y la frontera de la tabla periódica

Uso de la tabla periódica para predecir comportamientos químicos

Diversidad y propiedades de los elementos

Electrización por frotamiento, contacto e inducción

Ley de cargas: atracción y repulsión electrostática

La fuerza electrostática y la distancia entre cargas

¿Por qué se unen los átomos?: la búsqueda de estabilidad

Enlace iónico: atracción electrostática entre iones opuestos

Enlace covalente: electrones compartidos y moléculas

Enlace metálico: el mar de electrones móviles

Representación de moléculas: fórmulas químicas y modelos 3D

Moléculas diatómicas y gases comunes de la atmósfera

Moléculas gigantes: polímeros y macromoléculas

Relación entre enlace y propiedades macroscópicas

Fuerzas electrostáticas, enlace químico y moléculas

Gaz doskonały — mikroskopowe założenia kinetyczno-cząsteczkowe

Temperatura a energia wewnętrzna i ruch cząsteczek

Podstawowe równanie kinetycznej teorii gazów — ciśnienie p = 1/3 n m v_sr^2

Średnia energia kinetyczna ruchu postępowego cząsteczki: E_k = 3/2 k_B T

Prędkość średnia kwadratowa cząsteczek gazu: v_rms = sqrt(3RT/M)

Energia wewnętrzna jednoatomowego gazu doskonałego: U = 3/2 n R T

Stopnie swobody cząsteczek jedno-, dwu- i wieloatomowych

Energia wewnętrzna gazu dwuatomowego i wieloatomowego: U = i/2 n R T

Podstawy kinetycznej teorii gazów i energia wewnętrzna

El modelo cinético de partículas en la materia

Fuerzas intermoleculares: cohesión y repulsión entre partículas

Estado sólido: forma y volumen definidos, redes rígidas

Estado líquido: volumen constante, fluidez y tensión superficial

Estado gaseoso: expansión, compresibilidad y caos molecular

El plasma: el cuarto estado de la materia en el universo

Cambios de estado progresivos: fusión, vaporización y sublimación

Cambios de estado regresivos: solidificación, condensación y deposición

Curvas de calentamiento y temperatura constante durante cambios de fase

El agua y su anomalía: densidad del hielo frente al agua líquida

Presión de vapor y ebullición según la altitud

Estados de agregación y fuerzas intermoleculares

Rozkład prędkości cząsteczek Maxwella-Boltzmanna

Zjawisko dyfuzji w gazach, cieczach i ciałach stałych — prawo Ficka

Ruchy Browna — doświadczalny dowód ziarnistej struktury materii

Pojęcie fluktuacji statystycznych w układach wielocząsteczkowych

Średnia droga swobodna cząsteczki lambda i częstość zderzeń

Efuzja gazów i prawo Grahama

Zadania rachunkowe ze statystycznego i kinetycznego opisu gazu

Statystyczny opis gazów i zjawiska transportu

Imanes naturales y artificiales: polos norte y sur

El campo magnético y líneas de fuerza con limaduras de hierro

Materiales ferromagnéticos, paramagnéticos y diamagnéticos

La Tierra como un gigante imán: la brújula y orientación

El experimento de Oersted: la corriente eléctrica crea magnetismo

Construcción de un electroimán: factores que aumentan su fuerza

Aplicaciones de los electroimanes: timbres, grúas y trenes maglev

Inducción electromagnética: Faraday y los generadores eléctricos

Comparación entre fuerzas gravitacionales, electrostáticas y magnéticas

Auroras boreales y el escudo magnético de la Tierra

Magnetismo y fuerzas electromagnéticas

Budowa dipolowa cząsteczki wody i przestrzenna sieć wiązań wodorowych

Anomalna rozszerzalność cieplna wody — maksimum gęstości w temperaturze 4°C

Ażurowa struktura heksagonalna lodu i spadek gęstości podczas krzepnięcia

Stratyfikacja termiczna zbiorników wodnych zimą i przetrwanie organizmów wodnych

Siły powstające przy zamarzaniu wody: wietrzenie mrozowe i pękanie rur

Duże ciepło właściwe wody i jego rola w łagodzeniu klimatu Ziemi

Klimat morski a kontynentalny — analiza dobowych i rocznych amplitud temperatur

Rola wody w termoregulacji organizmów stałocieplnych i buforowaniu cieplnym komórek

Struktura molekularna i właściwości termiczne wody

Duże ciepło parowania wody i fizyczny mechanizm chłodzenia przez pocenie i transpirację

Wysokie ciepło topnienia lodu a ochrona przed katastrofalnymi powodziami roztopowymi

Duże napięcie powierzchniowe wody — kohezja, adhezja i zjawiska kapilarne w roślinach

Woda jako uniwersalny rozpuszczalnik polarny — wysoka względna przenikalność elektryczna ε_r ≈ 81

Doświadczenie: badanie anomalnej rozszerzalności termicznej wody w aparacie Hope'a

Doświadczenie: porównanie dynamiki stygnięcia wody i oleju roślinnego o jednakowej masie

Zadania problemowe i obliczeniowe z właściwości cieplnych wody i lodu

Synteza: unikalne właściwości fizykochemiczne wody jako warunek sine qua non istnienia życia

Przemiany fazowe, zjawiska międzycząsteczkowe i eksperymenty z wodą

How Moving Objects Carry Energy

What Is the Kinetic Energy of Particles?

Temperature Measures How Fast Particles Move

Higher Temperature Means Faster Particles

Visualizing Particle Motion at Different Temperatures

How Kinetic Energy Relates to States of Matter

Measuring Temperature During State Changes

Temperature, Kinetic Energy, and States of Matter

Prawo ciśnień cząstkowych Daltona dla mieszanin gazów doskonałych

Równanie stanu gazu dla stałej masy: (p1 * V1) / T1 = (p2 * V2) / T2

Zbiorniki połączone i wyrównanie ciśnień w układach wielozbiornikowych

Gaz pod ruchomym tłokiem — wpływ ciśnienia atmosferycznego i ciężaru tłoka

Odstępstwa gazu rzeczywistego od doskonałego — równanie van der Waalsa

Skraplanie gazów i izotermy Andrewsa — granice stosowalności modelu

Zadania z równania Clapeyrona z ubytkiem masy i zmianą parametrów

Zaawansowane układy gazowe i model gazu rzeczywistego

Temperature vs Heat vs Thermal Energy

Calculating Kinetic Energy of Particles

Investigating Particle Speed and Temperature

Explaining the Temperature-Kinetic Energy Relationship

Temperature and Kinetic Energy Review

Heat, Thermal Energy, and the Temperature-Kinetic Energy Relationship

Podstawowe założenia kinetyczno-cząsteczkowej teorii budowy materii

Temperatura bezwzględna jako miara średniej energii kinetycznej ruchu postępowego: E_k = (3/2)·k_B·T

Ruchy Browna jako bezpośredni dowód istnienia i chaotycznego ruchu cząsteczek

Teoria Einsteina-Smoluchowskiego ruchów Browna i wyznaczenie liczby Avogadra

Kinetyczno-cząsteczkowa teoria materii i ruchy Browna

Definicja i mikroskopowy mechanizm dyfuzji — samorzutne wyrównywanie stężeń

Dyfuzja i zjawiska transportu w materii

OGS.8.PS.1

Aligned learning resources

Related diagrams