물리 시뮬레이션 — 이제 수치로 검증한다 (차시 5-6)

트랙 A · 차시 5-6: 물리 시뮬레이션 — 이제 수치로 검증한다 (2시간)

“눈으로 봤던 검증을, 이제 숫자로 증명한다”

차시 개요

차시: 트랙 A — 5~6/8차시
주제: 물리 시뮬레이션의 수치적 검증
핵심 루프: 이론값 계산 → AI에게 시뮬레이션 시키기 → 수치 비교 → 오차 판정 → 규칙 추가
학습목표: 교사가 제공한 물리 공식으로 AI 시뮬레이션 결과를 수치적으로 검증하고, 오차 허용 범위를 포함한 수용 기준을 작성한다
규칙 파일: 기존 ~~12개 → 이 차시 후 +3~~5개
준비물: 교사: 물리 공식 치트시트 인쇄물, 3단계 시나리오 코드 사전 테스트 완료 / 학생: 노트북, 계산기(또는 스마트폰 계산기), 종이, 연필
플랫폼: GlowScript (glowscript.org)

이 장에서 배우는 것

교사가 제공한 물리 공식(포물선, 단진자 등)을 사용하여 이론값을 직접 계산할 수 있다
AI가 만든 시뮬레이션의 결과값과 이론값을 비교하여 오차율을 계산할 수 있다
오차 허용 범위(±5%)를 포함한 수치 기반 수용 기준을 작성할 수 있다
규칙 파일에 “이론값 대조 필수”, “dt 값 명시” 등의 검증 규칙을 추가할 수 있다

왜 이걸 배우나요?

이 차시의 핵심은 **"보기에 괜찮다 ≠ 정확하다"**라는 전환입니다. 검증 방법이 시각에서 수치로 올라가면, 수용 기준도 "예뻐 보이는가"에서 "오차 ±5% 이내인가"로 정밀해집니다. 이것은 트랙 B(데이터 분석)에서 "논리적 타당성"이라는 더 모호한 기준을 세우기 위한 발판이 됩니다.

**물리 공식은 학생이 외울 필요 없습니다.** 교사가 제공하며, 학생은 공식을 **"검증 도구"**로만 사용합니다. 공식을 이해하는 것이 목표가 아니라, "기준이 되는 정답을 가지고 AI 결과를 판정하는 경험"이 목표입니다.

핵심 개념

개념 1: 이론값 = 검증의 기준선

차시 1-2에서 학생은 “종이에 그린 그림”이 기준이었습니다. 내가 원하는 모습과 AI 결과를 비교했죠.

물리 시뮬레이션에서는 물리 공식이 기준입니다. 공을 45도 각도로 초속 20m/s로 던지면, 공식이 “최고점은 10.2m”라고 알려줍니다. AI가 만든 시뮬레이션에서 공이 12m까지 올라갔다면? 틀린 겁니다. 아무리 예쁘게 날아가는 것처럼 보여도요.

정확한 정의: 이론값이란, 물리 법칙(공식)에 초기 조건을 대입하여 계산한 “정답”입니다. 시뮬레이션 결과가 이 정답에 얼마나 가까운지로 품질을 판정합니다.

개념 2: 오차율 — “얼마나 틀렸는가”의 언어

두 값이 다를 때, “다르다”만으로는 부족합니다. “얼마나 다른가”를 숫자로 말해야 합니다.

오차율 공식:

오차율(%) = |시뮬레이션 값 − 이론값| ÷ 이론값 × 100

예시: 이론값 = 10.2m, 시뮬레이션 값 = 11.3m → 오차율 = |11.3 − 10.2| ÷ 10.2 × 100 = 10.8%

이 숫자가 있어야 “합격인가, 불합격인가”를 판정할 수 있습니다. “좀 다른 것 같은데…”가 아니라 “10.8% 차이, 기준 5% 초과, 불합격”이 됩니다.

개념 3: dt — 시뮬레이션의 정밀도 조절 장치

시뮬레이션은 시간을 잘게 쪼개서 한 조각(dt)씩 계산합니다.

flowchart LR
    A["t = 0"] --> B["t = dt"]
    B --> C["t = 2×dt"]
    C --> D["t = 3×dt"]
    D --> E["..."]
    E --> F["t = 끝"]

dt가 0.1초면 1초를 10조각으로, dt가 0.01초면 100조각으로 계산합니다. 조각이 작을수록 정밀하지만 느려집니다. AI가 dt를 너무 크게 잡으면(예: 0.5초) 공이 순간이동하듯 움직이고, 결과값도 부정확해집니다.

개념 4: 수치 기반 수용 기준

차시 1-2의 수용 기준은 이랬습니다:

“도형끼리 관통하지 않는다” — 눈으로 확인
“좌우 대칭이다” — 눈으로 확인

이제는 이렇게 바뀝니다:

“최고점 높이가 이론값 대비 오차 ±5% 이내”
“도달 거리가 이론값 대비 오차 ±5% 이내”
“dt 값이 0.01초 이하”
“단위가 SI 단위(m, s, kg)로 통일”

검증이 “감각적”에서 “측정 가능”으로 진화한 것입니다.

따라하기

차시 5 (50분): 물리 공식 = 검증 도구

Step 1: 선생님 시연 — “그럴듯하게 보이지만 틀린 시뮬레이션” (10분)

선생님 스크립트

“자, 오늘은 AI에게 물리 시뮬레이션을 시킬 거예요. 먼저 제가 하나 보여드릴게요.”

(GlowScript에서 포물선 운동 시뮬레이션을 실행한다 — 공이 예쁘게 날아간다)

“어때요? 공이 잘 날아가죠?”

예상 반응:

“예쁘게 날아가요!” / “괜찮아 보이는데요?”

“그렇죠? 보기엔 괜찮아 보여요. 그런데 이 시뮬레이션, AI에게 ‘공을 45도로 초속 20m/s로 던져줘’라고 시켜서 만든 거예요.

자, 이제 수학으로 확인해볼게요.”

(칠판이나 화면에 공식을 보여주며 계산)

“최고점 높이 공식: H = (v₀ × sin45°)² ÷ (2 × 9.8) = (20 × 0.707)² ÷ 19.6 = (14.14)² ÷ 19.6 = 200 ÷ 19.6 = 10.2m

그런데 AI가 만든 시뮬레이션에서 공의 최고점을 찍어보면… 11.5m예요. 오차율은? |11.5 − 10.2| ÷ 10.2 × 100 = 12.7%

보기엔 괜찮았는데, 13%나 틀려 있었어요. 이게 바로 눈으로 보는 것만으로는 부족한 이유입니다.”

Step 2: 물리 공식 치트시트 배부 + 3단계 시나리오 선택 (5분)

물리 시뮬레이션 치트시트 (인쇄하여 배부)

포물선 운동 (기초)

최고점 높이: H = (v₀ × sinθ)² ÷ (2 × g)
도달 거리: R = v₀² × sin(2θ) ÷ g
체공 시간: T = 2 × v₀ × sinθ ÷ g
g = 9.8 m/s²

단진자 (중간)

주기: T = 2π × √(L ÷ g)
π = 3.14159
소각도 근사: θ < 15° 에서만 정확

탄성 충돌 (심화)

충돌 후 v₁’ = (m₁−m₂)×v₁÷(m₁+m₂) + 2×m₂×v₂÷(m₁+m₂)
충돌 후 v₂’ = 2×m₁×v₁÷(m₁+m₂) + (m₂−m₁)×v₂÷(m₁+m₂)
운동에너지 보존: 충돌 전 총 에너지 = 충돌 후 총 에너지

선생님 스크립트

“오늘은 3단계 중 하나를 선택하세요. 어렵다고 좋은 게 아니에요. 내가 검증할 수 있는 수준을 고르는 거예요.”

flowchart TD
    A["3단계 시나리오 선택"] --> B["기초: 포물선 운동"]
    A --> C["중간: 단진자"]
    A --> D["심화: 탄성 충돌"]
    B --> B1["공식 1개, 검증 포인트 2개"]
    C --> C1["공식 1개, 주기 검증"]
    D --> D1["공식 2개, 에너지 보존까지"]

Step 3: 이론값 직접 계산 (15분)

선생님 스크립트

“시뮬레이션을 AI에게 시키기 전에, 먼저 계산기로 정답을 구해요. 정답을 모르면 AI가 틀려도 모르잖아요?

기초 선택한 사람은 이 초기 조건을 쓰세요:”

v₀ = 20 m/s, θ = 45°, g = 9.8 m/s²

“치트시트를 보면서 이 세 가지를 계산하세요: ① 최고점 높이 H = ? ② 도달 거리 R = ? ③ 체공 시간 T = ?”

포물선 모범 계산 (교사용):

sin45° = 0.7071, sin90° = 1.0
H = (20 × 0.7071)² ÷ (2 × 9.8) = 14.14² ÷ 19.6 = 200 ÷ 19.6 = 10.2m
R = 20² × 1.0 ÷ 9.8 = 400 ÷ 9.8 = 40.8m
T = 2 × 20 × 0.7071 ÷ 9.8 = 28.28 ÷ 9.8 = 2.89초

단진자 모범 계산 (교사용):

L = 1m, g = 9.8 m/s² 일 때
T = 2 × 3.14159 × √(1 ÷ 9.8) = 6.283 × 0.3194 = 2.01초

학생 반응	교사 대응
”sin이 뭐예요?"	"스마트폰 계산기에서 sin 45를 누르면 0.707이 나와요. 이 숫자를 공식에 넣으면 됩니다."
"계산이 안 맞아요"	"단위 확인하세요. 속도는 m/s, 거리는 m, 시간은 s예요."
"이거 수학 시간이에요?"	"아니요, 수학을 배우는 게 아니라 검증 도구를 준비하는 거예요. 이 숫자가 있어야 AI를 판정할 수 있어요.”

(계산 마친 후) “계산한 값을 종이에 크게 적어두세요. 이게 정답이에요. 이따 AI가 만든 시뮬레이션의 값이 이 정답과 얼마나 다른지 비교할 거예요.”

Step 4: AI에게 시뮬레이션 요청 + 수치 비교 (20분)

선생님 스크립트

“자, 이제 AI에게 시킬 거예요. 이번엔 명세를 쓰는 연습은 충분히 했으니까, 바로 요청해도 돼요. 단, 반드시 이 세 가지를 포함하세요:

① 초기 조건 (속도, 각도, 중력) ② dt 값 (0.01초로 지정) ③ ‘최고점 높이와 도달 거리를 print로 출력해줘’”

AI 요청 예시 (포물선):

GlowScript VPython으로 포물선 운동 시뮬레이션을 만들어줘.

초기 조건:
- 초기 속도: 20 m/s
- 발사 각도: 45도
- 중력 가속도: 9.8 m/s²
- 공의 시작 위치: (0, 0, 0)

시뮬레이션 요구사항:
- dt = 0.01초
- 공이 지면(y=0)에 닿으면 멈출 것
- 공의 궤적을 trail로 표시할 것

출력:
- 최고점 높이를 print로 출력
- 도달 거리(x값)를 print로 출력
- 체공 시간을 print로 출력

“AI가 준 코드를 GlowScript에 붙여넣고 실행하세요. print 결과를 보고, 아까 계산한 이론값과 비교하세요.”

**초기 조건**: v₀ = ___ m/s, θ = ___°, g = ___ m/s²

| 검증 포인트 | 이론값 | 시뮬레이션 값 | 오차율 |
|------------|--------|-------------|--------|
| 최고점 높이 | ___m | ___m | ___% |
| 도달 거리 | ___m | ___m | ___% |
| 체공 시간 | ___초 | ___초 | ___% |

- **AI가 사용한 dt**: ___ 초
- **전체 판정**: [ ] 합격 (전 항목 ±5% 이내) / [ ] 불합격

(학생들이 비교하는 중에) “오차가 5% 이상인 사람? 왜 그런 것 같아요?”

학생 반응	교사 대응
”dt가 0.1로 되어 있었어요"	"그렇죠! AI가 dt를 제멋대로 잡았어요. 이것 자체가 규칙이 될 수 있어요."
"공이 땅을 뚫고 가요"	"종료 조건이 제대로 안 된 거예요."
"오차 2%예요!"	"훌륭해요! 합격이네요.”

차시 6 (50분): 수치 기반 수용 기준

Step 5: 수치 기반 수용 기준 작성법 (10분)

선생님 스크립트

“차시 1-2에서 수용 기준을 세웠죠? ‘관통 금지’, ‘좌우 대칭’ 같은 거요. 그땐 눈으로 확인했어요.

오늘부터는 수용 기준이 숫자가 됩니다. 이런 식이에요:”

flowchart LR
    A["차시 1-2 수용 기준<br/>시각적"] --> B["차시 5-6 수용 기준<br/>수치적"]
    A1["관통하지 않는다"] -.-> B1["오차 ±5% 이내"]
    A2["좌우 대칭이다"] -.-> B2["dt ≤ 0.01초"]
    A3["색이 맞다"] -.-> B3["단위 SI 통일"]

“수치 기반 수용 기준을 세울 때 네 가지를 반드시 정합니다:”

“첫째, 오차 허용 범위. 기초는 ±5%, 심화는 ±3%. 둘째, dt 값. 0.01초 이하. 셋째, 단위 통일. m, s, kg — SI 단위. 넷째, 초기 조건 명시. 속도, 각도, 중력 모두 적어야 합니다.”

**필수 항목**

- [ ] 모든 검증 포인트의 오차가 ±___% 이내
- [ ] dt 값이 ___초 이하
- [ ] 단위가 SI 단위(m, s, kg)로 통일
- [ ] 초기 조건(v₀, θ, g 등)이 코드에 명시

**선호 항목**

- [ ] 궤적(trail)이 시각적으로 표시됨
- [ ] 최고점/도달 거리가 print로 출력됨
- [ ] _________________________________

**미충족 시 대응**

| 상황 | 대응 |
|------|------|
| 오차 초과 | dt를 줄여서 재요청 |
| 단위 불일치 | "모든 값을 SI 단위로" 재요청 |
| 초기 조건 누락 | 정확한 값을 명시하여 재요청 |

Step 6: AI 결과 검증 → 수정 요청 반복 (20분)

선생님 스크립트

“아까 AI에게 시킨 시뮬레이션 결과를, 방금 세운 수용 기준으로 판정하세요. 합격이면 축하! 불합격이면 구체적으로 뭘 고쳐야 하는지 AI에게 수정 요청하세요.”

수정 요청 예시 (학생에게 보여줄 것):

시뮬레이션 결과 최고점이 11.5m인데, 이론값은 10.2m입니다. (오차 12.7%)
원인: dt가 0.1초로 너무 큽니다.
수정 요청:
1. dt를 0.01초로 변경
2. 최고점 높이, 도달 거리, 체공 시간을 print로 출력
3. 나머지 초기 조건은 동일하게 유지

“핵심은 **‘뭐가 틀렸는지, 왜 틀렸다고 생각하는지, 어떻게 고쳐달라는지’**를 구체적으로 쓰는 거예요. ‘다시 해줘’는 수정 요청이 아닙니다.”

Step 7: 규칙 파일 업데이트 + 검증의 진화 정리 (20분)

규칙 파일 업데이트 (15분)

선생님 스크립트

“오늘 AI가 시뮬레이션에서 어떤 실수를 했나요? 몇 명만 발표해볼까요?”

예상 발표:

“dt를 0.1로 잡아서 오차가 컸어요”
“중력 방향이 반대였어요”
“print를 안 넣어줬어요”
“단위가 뒤섞여 있었어요”

“좋아요. 그 실수들에서 규칙을 뽑아서, 규칙 파일의 ‘3D 창작/시뮬레이션’ 섹션에 추가하세요.”

이 차시에서 추가할 규칙 예시 (3~5개):

## 3D 창작/시뮬레이션에서의 규칙 (시뮬레이션 추가분)

- AI에게 시뮬레이션을 시킬 때 dt 값을 반드시 명시해야 한다 (0.01초 이하 권장)
  ← 사건: AI가 dt를 0.1초로 잡아서 최고점 오차가 12.7%였음

- 시뮬레이션 결과는 반드시 이론값과 대조해야 한다
  ← 사건: 포물선이 예쁘게 보였지만 실제로는 높이가 13% 틀렸음

- 모든 물리량의 단위를 SI 단위(m, s, kg)로 통일하라고 명시해야 한다
  ← 사건: AI가 속도를 km/h로, 거리를 cm로 뒤섞어서 결과가 엉뚱했음

- 초기 조건(속도, 각도, 중력 등)을 모두 코드에 명시하게 요청해야 한다
  ← 사건: AI가 중력을 10으로 어림잡아서 9.8과 결과가 달랐음

- 검증 포인트(최고점, 도달 거리 등)를 print로 출력하라고 요청해야 한다
  ← 사건: 수치를 확인할 방법이 없어서 눈으로만 판단해야 했음

검증의 진화 정리 (5분)

선생님 스크립트

“차시 1-2에서 오늘까지 온 길을 돌아봅시다.”

flowchart LR
    A["차시 1-2<br/>눈으로 검증<br/>'팔이 머리에서 나왔어!'"] --> B["차시 3-4<br/>눈+의도 검증<br/>'회전축이 틀렸어!'"]
    B --> C["차시 5-6<br/>수치로 검증<br/>'오차 12.7%, 불합격!'"]
    C --> D["차시 7-8<br/>자유 프로젝트<br/>'내 기준으로 판정!'"]

“검증이 점점 정밀해지고 있죠? 처음엔 ‘이건 아닌데’였고, 지금은 ‘오차 몇 퍼센트, 합격/불합격’이에요.

다음 트랙(데이터 분석)에서는 더 어려운 검증을 합니다. ‘이 분석에 논리적 비약이 없는가’ — 숫자도 아니고 눈도 아닌, 논리로 검증해야 해요. 그때도 오늘 배운 ‘기준을 먼저 세우고 → 결과를 판정하는’ 구조는 똑같이 적용됩니다.”

전체 코드

포물선 운동 시뮬레이션 (기초 시나리오 모범 코드)

GlowScript 3.2 VPython

# === 초기 조건 ===
v0 = 20          # 초기 속도 (m/s)
theta = 45       # 발사 각도 (도)
g = 9.8          # 중력 가속도 (m/s²)
dt = 0.01        # 시간 간격 (초)

# 각도를 라디안으로 변환
theta_rad = theta * pi / 180

# === 장면 설정 ===
scene.width = 800
scene.height = 400
scene.range = 25

# 바닥
ground = box(pos=vector(20, -0.5, 0), size=vector(50, 1, 10),
             color=vector(0.3, 0.8, 0.3))

# 공
ball = sphere(pos=vector(0, 0, 0), radius=0.5,
              color=color.red, make_trail=True)

# === 초기 속도 설정 ===
ball.velocity = vector(v0 * cos(theta_rad), v0 * sin(theta_rad), 0)

# === 검증용 변수 ===
max_height = 0
t = 0

# === 시뮬레이션 루프 ===
while ball.pos.y >= 0:
    rate(1000)

    # 중력에 의한 속도 변화
    ball.velocity.y = ball.velocity.y - g * dt

    # 위치 업데이트
    ball.pos = ball.pos + ball.velocity * dt

    # 최고점 추적
    if ball.pos.y > max_height:
        max_height = ball.pos.y

    t = t + dt

# === 결과 출력 ===
print("=== 시뮬레이션 결과 ===")
print("최고점 높이:", round(max_height, 2), "m")
print("도달 거리:", round(ball.pos.x, 2), "m")
print("체공 시간:", round(t, 2), "초")

# === 이론값 (비교용) ===
H_theory = (v0 * sin(theta_rad))**2 / (2 * g)
R_theory = v0**2 * sin(2 * theta_rad) / g
T_theory = 2 * v0 * sin(theta_rad) / g
print("")
print("=== 이론값 ===")
print("최고점 높이:", round(H_theory, 2), "m")
print("도달 거리:", round(R_theory, 2), "m")
print("체공 시간:", round(T_theory, 2), "초")

단진자 시뮬레이션 (중간 시나리오 모범 코드)

GlowScript 3.2 VPython

# === 초기 조건 ===
L = 1.0           # 줄 길이 (m)
g = 9.8           # 중력 가속도 (m/s²)
theta0 = 10       # 초기 각도 (도) — 소각도!
dt = 0.01         # 시간 간격 (초)

theta0_rad = theta0 * pi / 180

# === 장면 설정 ===
scene.width = 600
scene.height = 600

pivot = vector(0, 0, 0)
support = sphere(pos=pivot, radius=0.05, color=color.white)

# 줄과 추
bob = sphere(pos=pivot + vector(L * sin(theta0_rad), -L * cos(theta0_rad), 0),
             radius=0.08, color=color.red, make_trail=True,
             trail_type="curve", trail_color=color.yellow)
string = cylinder(pos=pivot, axis=bob.pos - pivot, radius=0.01, color=color.white)

# === 초기 조건 ===
theta = theta0_rad
omega = 0          # 각속도

# === 주기 측정 ===
t = 0
crossings = []
prev_theta = theta

# === 시뮬레이션 루프 ===
while t < 10:
    rate(500)

    # 각가속도
    alpha = -(g / L) * sin(theta)

    # 각속도, 각도 업데이트
    omega = omega + alpha * dt
    theta = theta + omega * dt

    # 추 위치 업데이트
    bob.pos = pivot + vector(L * sin(theta), -L * cos(theta), 0)
    string.axis = bob.pos - pivot

    # 영점 통과 감지 (양→음)
    if prev_theta > 0 and theta <= 0:
        crossings.append(t)
    prev_theta = theta

    t = t + dt

# === 결과 출력 ===
print("=== 단진자 시뮬레이션 결과 ===")
if len(crossings) >= 3:
    measured_T = (crossings[2] - crossings[0])  # 반주기 2번 = 1주기
    print("측정된 주기:", round(measured_T, 4), "초")
else:
    print("주기를 측정하기에 진동 횟수가 부족합니다.")

# === 이론값 (비교용) ===
T_theory = 2 * pi * sqrt(L / g)
print("이론값 주기:", round(T_theory, 4), "초")
if len(crossings) >= 3:
    error = abs(measured_T - T_theory) / T_theory * 100
    print("오차율:", round(error, 2), "%")

탄성 충돌 시뮬레이션 (심화 시나리오 모범 코드)

GlowScript 3.2 VPython

# === 초기 조건 ===
m1 = 2.0          # 공 1 질량 (kg)
m2 = 1.0          # 공 2 질량 (kg)
v1 = 3.0           # 공 1 초기 속도 (m/s, 오른쪽)
v2 = -1.0          # 공 2 초기 속도 (m/s, 왼쪽)
dt = 0.01          # 시간 간격 (초)

# === 장면 설정 ===
scene.width = 800
scene.height = 400

# 바닥
box(pos=vector(0, -0.6, 0), size=vector(20, 0.2, 2), color=vector(0.3, 0.3, 0.3))

# 공 1 (빨간색, 왼쪽에서 출발)
ball1 = sphere(pos=vector(-5, 0, 0), radius=0.4,
               color=color.red, make_trail=True)
ball1.velocity = vector(v1, 0, 0)
ball1.mass = m1

# 공 2 (파란색, 오른쪽에서 출발)
ball2 = sphere(pos=vector(5, 0, 0), radius=0.3,
               color=color.blue, make_trail=True)
ball2.velocity = vector(v2, 0, 0)
ball2.mass = m2

# === 충돌 전 에너지 ===
KE_before = 0.5 * m1 * v1**2 + 0.5 * m2 * v2**2

# === 이론값 계산 ===
v1_after_theory = ((m1 - m2) * v1 + 2 * m2 * v2) / (m1 + m2)
v2_after_theory = (2 * m1 * v1 + (m2 - m1) * v2) / (m1 + m2)

# === 시뮬레이션 ===
t = 0
collided = False

while t < 6:
    rate(500)

    # 충돌 감지 (거리가 반지름 합 이하)
    dist = mag(ball2.pos - ball1.pos)
    if dist <= (ball1.radius + ball2.radius) and not collided:
        # 탄성 충돌 공식 적용
        ball1.velocity.x = ((m1 - m2) * ball1.velocity.x + 2 * m2 * ball2.velocity.x) / (m1 + m2)
        ball2.velocity.x = (2 * m1 * v1 + (m2 - m1) * ball2.velocity.x) / (m1 + m2)
        collided = True

    # 위치 업데이트
    ball1.pos = ball1.pos + ball1.velocity * dt
    ball2.pos = ball2.pos + ball2.velocity * dt

    t = t + dt

# === 결과 출력 ===
print("=== 탄성 충돌 시뮬레이션 결과 ===")
print("충돌 후 공 1 속도:", round(ball1.velocity.x, 4), "m/s")
print("충돌 후 공 2 속도:", round(ball2.velocity.x, 4), "m/s")

KE_after = 0.5 * m1 * ball1.velocity.x**2 + 0.5 * m2 * ball2.velocity.x**2
print("충돌 전 운동에너지:", round(KE_before, 4), "J")
print("충돌 후 운동에너지:", round(KE_after, 4), "J")
print("에너지 보존 오차:", round(abs(KE_after - KE_before) / KE_before * 100, 2), "%")

print("")
print("=== 이론값 ===")
print("공 1 충돌 후 속도:", round(v1_after_theory, 4), "m/s")
print("공 2 충돌 후 속도:", round(v2_after_theory, 4), "m/s")

부록

부록 1: 시나리오별 초기 조건 변형

학생이 한 세트를 완료한 후 초기 조건을 바꿔서 다시 시도할 때 사용합니다.

포물선 운동 변형:

변형	v₀ (m/s)	θ (도)	예상 H (m)	예상 R (m)
기본	20	45	10.2	40.8
높이 쏘기	20	70	18.0	26.2
빠르게	30	45	22.9	91.8
낮게 멀리	20	30	5.1	35.3

단진자 변형:

변형	L (m)	θ₀ (도)	예상 T (초)
기본	1.0	10	2.01
긴 줄	2.0	10	2.84
짧은 줄	0.5	10	1.42

부록 2: 흔한 AI 실수와 대응법

AI 실수	증상	대응
dt가 너무 큼	오차 10% 이상, 움직임이 끊김	”dt를 0.01초로 설정해줘”
중력 방향 오류	공이 위로 가속	”중력은 y 음의 방향 (g = -9.8)“
종료 조건 누락	공이 바닥을 뚫고 내려감	”y <= 0이면 루프 중단”
단위 혼용	숫자는 나오지만 의미 없음	”모든 값을 SI 단위(m, s, kg)로”
`from vpython import *`	GlowScript에서 에러	첫 줄 삭제
print 누락	결과 수치를 확인할 수 없음	”결과를 print로 출력해줘”

부록 3: 차시 5-6 평가 루브릭

목표	수준 0 (미달)	수준 2 (기대)	수준 3 (우수)
이론값 계산	계산 시도 안 함	치트시트를 보고 이론값 1개 이상 정확히 계산	복수 검증 포인트의 이론값을 모두 정확히 계산
수치 비교	비교 안 함	오차율을 계산하고 합격/불합격 판정	오차 원인(dt, 단위 등)을 구체적으로 분석
수용 기준	미작성	오차 허용 범위를 포함한 기준 2개 이상	오차 + dt + 단위 + 초기 조건 모두 포함
규칙 구축	미추가	수치 검증 규칙 2개 이상 (사건 포함)	규칙이 범주화되고 재사용 가능한 형태

다음 차시 예고

차시 7-8: “자유 프로젝트 + 트랙 A 규칙 정리” 조형/애니메이션/시뮬레이션 중 자기 수준에 맞는 프로젝트를 선택합니다. 트랙 A에서 축적한 규칙 파일(10~20개)을 분류하고, 교차 리뷰를 통해 규칙의 질을 점검합니다. 트랙 A의 대미를 장식하는 시간입니다.