在日常的开发和物理模拟中，你是否思考过这样一个问题：为什么在真实的物理引擎中，物体碰撞后速度会发生变化？为什么两个物体相撞后往往会“粘”在一起，或者虽然分离但速度却慢了下来？这就涉及到了我们今天要深入探讨的核心主题——非弹性碰撞。
在这篇文章中，我们将不仅仅是背诵定义，而是作为开发者，从物理原理、数学推导以及代码模拟三个维度，深入剖析非弹性碰撞的每一个细节。我们将探讨什么是非弹性碰撞，它有哪些类型，如何通过公式计算最终状态，最重要的是，我们将通过 Python 代码亲手构建一个物理模拟器来验证这些理论。无论你是正在编写游戏引擎，还是对物理模拟感兴趣，这篇文章都将为你提供从理论到实践的全面指引。
什么是非弹性碰撞？
首先，我们需要明确一点：能量守恒定律是物理学的基本法则，但在碰撞问题中，我们需要精确地定义我们在讨论哪种能量。
非弹性碰撞（Inelastic Collision）是一种特殊的物理碰撞过程。在这个过程中，系统的动量是守恒的，但动能却不守恒。你可能会问：“能量去哪儿了？”这是一个非常好的问题。在非弹性碰撞中，系统的一部分动能转化为了其他形式的能量，最常见的是热能（因为摩擦生热）、声能（碰撞发出的巨响）或者导致物体永久形变的内能。
想象一下，当你扔出一团软泥撞向墙壁时，它不会像橡胶球一样弹回来，而是“啪”的一声粘在上面。在这个过程中，宏观的动能消失了，转化为了微观分子运动的热能和形变势能。
两大类型：完全非弹性与部分非弹性
为了更精确地建模，我们将非弹性碰撞分为两大类。这种分类对于我们在代码中设置碰撞参数至关重要。
#### 1. 完全非弹性碰撞
这是“最彻底”的碰撞。在完全非弹性碰撞中，两个物体在碰撞后会粘在一起，并作为一个整体以相同的速度继续运动。
- 关键特征：碰撞后两者速度相同 ($v‘1 = v‘2$)。
- 能量损失：在所有非弹性碰撞中，这种碰撞的动能损失是最大的（在初始条件相同的情况下）。
- 现实场景：两辆汽车发生严重车祸撞在一起，或者一颗子弹射入一块木头并停留在其中。
> 注意：即便物体粘在一起，动量依然是守恒的。这是解决此类问题的关键钥匙。
#### 2. 部分非弹性碰撞
这是现实生活中最常见的情况。物体在碰撞后彼此分离，但它们的相对速度变小了。
- 关键特征：物体分开，但系统总动能减少。
- 能量损失：只有部分动能转化为热能或形变势能。
- 现实场景：一个篮球从高处落下。它会反弹，但永远无法回到初始的高度。每次反弹，它都损失了一部分能量。
核心公式与数学推导
作为开发者，我们需要将这些物理概念转化为数学公式，进而转化为代码。让我们来推导一下这些公式。
#### 动量守恒定律
无论发生何种类型的碰撞（只要不受外力），系统的总动量始终保持不变。这是我们所有计算的基石。
公式表达为：
$$ m1v1 + m2v2 = m1v‘1 + m2v‘2 $$
其中：
- $m1, m2$ 是两个物体的质量
- $v1, v2$ 是碰撞前的速度
- $v‘1, v‘2$ 是碰撞后的速度
#### 完全非弹性碰撞的速度计算
在完全非弹性碰撞中，由于物体粘在一起，它们具有共同的末速度 $v‘$。这极大地简化了我们的计算。我们可以将公式修改为：
$$ m1v1 + m2v2 = (m1 + m2)v‘ $$
解出末速度 $v‘$：
$$ v‘ = \frac{m1v1 + m2v2}{m1 + m2} $$
这个公式告诉我们：最终速度只取决于总动量和总质量。
#### 动能的分析
对于动能 $K.E. = \frac{1}{2}mv^2$，我们可以直观地看到能量的损失：
$$ \text{初始总动能} = \frac{1}{2}(m1v1^2 + m2v2^2) $$
$$ \text{末态总动能} = \frac{1}{2}(m1 + m2)v‘^2 $$
$$ \frac{1}{2}(m1v1^2 + m2v2^2) > \frac{1}{2}(m1 + m2)v‘^2 $$
这个不等式永远是成立的，直到能量完全耗尽。
Python 模拟实战：从基础到进阶
理论讲完了，现在让我们动手写代码。我们将使用 Python 来模拟这两种碰撞。为了确保代码的清晰度和可扩展性，我们将创建几个实用的类和函数。
#### 示例 1：完全非弹性碰撞计算器
这是一个纯计算的示例，模拟两个物体相撞并合并的过程。我们将定义一个函数，接收质量和初速度，返回碰撞后的状态。
class PhysicsObject:
"""定义一个简单的物理对象类"""
def __init__(self, mass, velocity, name):
self.mass = mass
self.velocity = velocity
self.name = name
def get_momentum(self):
return self.mass * self.velocity
def get_ke(self):
"""计算动能 K.E. = 0.5 * m * v^2"""
return 0.5 * self.mass * (self.velocity ** 2)
def simulate_perfectly_inelastic_collision(obj1, obj2):
"""
模拟完全非弹性碰撞。
原理：动量守恒，物体合并，速度相同。
"""
print(f"--- 模拟对象: {obj1.name} vs {obj2.name} ---")
print(f"初始状态:")
print(f"{obj1.name}: 质量={obj1.mass}kg, 速度={obj1.velocity}m/s")
print(f"{obj2.name}: 质量={obj2.mass}kg, 速度={obj2.velocity}m/s")
# 计算初始总动量和动能
total_initial_momentum = obj1.get_momentum() + obj2.get_momentum()
total_initial_ke = obj1.get_ke() + obj2.get_ke()
print(f"系统初始总动量: {total_initial_momentum:.2f} kg·m/s")
print(f"系统初始总动能: {total_initial_ke:.2f} J")
# 应用公式: v‘ = (m1*v1 + m2*v2) / (m1 + m2)
final_velocity = (obj1.mass * obj1.velocity + obj2.mass * obj2.velocity) / (obj1.mass + obj2.mass)
# 计算碰撞后的数据
final_mass = obj1.mass + obj2.mass
final_momentum = final_mass * final_velocity
final_ke = 0.5 * final_mass * (final_velocity ** 2)
energy_loss = total_initial_ke - final_ke
print(f"
碰撞结果 (完全非弹性):")
print(f"合并后质量: {final_mass}kg")
print(f"共同末速度: {final_velocity:.2f}m/s")
print(f"系统末态动量: {final_momentum:.2f} kg·m/s (验证守恒)")
print(f"系统末态动能: {final_ke:.2f} J")
print(f"动能损失: {energy_loss:.2f} J (转化为热能/形变)")
return final_velocity
# 实际案例：两车相撞
# 假设车1 (1000kg) 以 20m/s 撞向 静止的车2 (1500kg)
car_a = PhysicsObject(1000, 20, "Car A")
car_b = PhysicsObject(1500, 0, "Car B")
simulate_perfectly_inelastic_collision(car_a, car_b)
代码解读：在这个例子中，我们首先初始化了两个物理对象。我们计算了系统的初始动量和能量作为基准。然后，应用完全非弹性碰撞的公式，你会发现虽然动能大幅减少，但最终的动量与初始动量完全一致。这就是动量守恒定律的威力。
#### 示例 2：部分非弹性碰撞与恢复系数
在处理部分非弹性碰撞时，我们需要引入一个新的概念：恢复系数，通常用 $e$ 表示。
- $e = 1$: 完全弹性碰撞（不损失动能）。
- $0 < e < 1$: 部分非弹性碰撞（损失部分动能）。
- $e = 0$: 完全非弹性碰撞（粘在一起）。
利用恢复系数，我们可以使用以下方程组求解末速度：
- $m1v1 + m2v2 = m1v‘1 + m2v‘2$
- $v‘2 – v‘1 = e(v1 – v2)$
让我们用 Python 来实现这个更复杂的模型。
def solve_partial_inelastic_collision(obj1, obj2, restitution):
"""
根据牛顿恢复定律求解部分非弹性碰撞。
参数:
obj1, obj2: 物理对象
restitution (e): 恢复系数 (0 <= e <= 1)
"""
if not (0 <= restitution <= 1):
raise ValueError("恢复系数必须在 0 到 1 之间")
m1, m2 = obj1.mass, obj2.mass
v1, v2 = obj1.velocity, obj2.velocity
print(f"
--- 部分非弹性碰撞模拟 (e={restitution}) ---")
# 基于动量守恒和恢复系数公式联立求解
# v1_final = (m1*v1 + m2*v2 - m2*e*(v1-v2)) / (m1+m2)
# v2_final = (m1*v1 + m2*v2 + m1*e*(v1-v2)) / (m1+m2)
v1_final = (m1*v1 + m2*v2 + m2*restitution*(v2 - v1)) / (m1 + m2)
v2_final = (m1*v1 + m2*v2 + m1*restitution*(v1 - v2)) / (m1 + m2)
# 更新对象状态
obj1.velocity = v1_final
obj2.velocity = v2_final
# 验证结果
final_ke = obj1.get_ke() + obj2.get_ke()
print(f"{obj1.name} 新速度: {v1_final:.2f} m/s")
print(f"{obj2.name} 新速度: {v2_final:.2f} m/s")
print(f"碰撞后系统总动能: {final_ke:.2f} J")
return obj1, obj2
# 场景：篮球反弹 (近似模拟)
# 地板可以看作质量无穷大且速度为0的物体，公式简化为 v_final = -e * v_initial
# 这里我们演示两个物体互相撞击
ball = PhysicsObject(2, 10, "Tennis Ball")
other_ball = PhysicsObject(2, -5, "Baseball")
# 设置恢复系数为 0.8 (典型的球类碰撞数值)
ball, other_ball = solve_partial_inelastic_collision(ball, other_ball, 0.8)
#### 示例 3：处理一维非弹性碰撞的边界情况
在实际开发中，我们必须考虑异常情况。例如，当其中一个物体质量极其巨大（如墙壁）时，或者动量极小的情况。以下是一个健壮的类设计，包含了错误处理和能量损耗统计。
class CollisionSimulation:
def __init__(self):
self.history = []
def log_event(self, message):
self.history.append(message)
def calculate_energy_loss_percent(self, initial_ke, final_ke):
if initial_ke == 0: return 0.0
return ((initial_ke - final_ke) / initial_ke) * 100
def robust_collision_solver(self, m1, v1, m2, v2, coeff_restitution=0.0):
"""
一个通用的求解器，既可以处理完全非弹性，也可以处理部分非弹性。
默认 coeff_restitution=0.0 即为完全非弹性。
"""
try:
# 输入验证
if m1 < 0 or m2 < 0:
raise ValueError("质量不能为负数")
total_mass = m1 + m2
initial_momentum = m1*v1 + m2*v2
initial_ke = 0.5*m1*v1**2 + 0.5*m2*v2**2
# 使用通用公式
# v1_f = (m1*v1 + m2*v2 + m2*C*(v2-v1)) / total_mass
v1_final = (initial_momentum + m2 * coeff_restitution * (v2 - v1)) / total_mass
v2_final = (initial_momentum + m1 * coeff_restitution * (v1 - v2)) / total_mass
final_ke = 0.5*m1*v1_final**2 + 0.5*m2*v2_final**2
loss_percent = self.calculate_energy_loss_percent(initial_ke, final_ke)
return {
"v1_final": v1_final,
"v2_final": v2_final,
"energy_loss_percent": loss_percent,
"status": "success"
}
except ZeroDivisionError:
return {"status": "error", "message": "总质量不能为零"}
except Exception as e:
return {"status": "error", "message": str(e)}
# 使用示例
sim = CollisionSimulation()
result = sim.robust_collision_solver(m1=10, v1=5, m2=10, v2=-5, coeff_restitution=0.5) # 50% 弹性
print(f"模拟结果: {result}")
常见陷阱与最佳实践
在处理物理模拟代码时，我们经常遇到一些“坑”。以下是基于实战经验的总结：
- 浮点数精度问题：在比较动能是否守恒或速度是否相同时，永远不要使用 INLINECODEd238bfea。请始终使用容差比较，例如 INLINECODE50de8926。由于浮点数误差，完全非弹性碰撞中计算出的两个末速度可能会有极微小的差异，这在数学上是错误的，但在计算机中是常态。
- 负恢复系数：如果你在计算中发现物体不仅没有减速，反而像加速了一样“弹开”，请检查恢复系数的符号。负的恢复系数在物理世界中没有意义（在简单模型中），通常会导致系统获得能量，这不符合热力学定律。
- 大质量差异：当模拟一个球撞墙时，墙的质量 $m2$ 设为无穷大是不可能的。在代码中，通常通过将 $m2$ 设为一个非常大的数，或者直接使用简化公式 $v‘1 = -ev1$ 来处理固定障碍物。
- 单位一致性：这是最常见的错误。确保所有输入质量都是千克，速度都是米/秒。混合使用克和千米/小时会导致灾难性的计算错误。
总结与下一步
今天，我们从零开始，构建了关于非弹性碰撞的完整知识体系。
- 我们了解到，非弹性碰撞的核心在于动量守恒而动能不守恒，能量主要转化为了热能和形变势能。
- 我们区分了完全非弹性碰撞（粘在一起，能量损失最大）和部分非弹性碰撞（分开但有能量损失）。
- 最重要的是，我们不仅写了公式，还写了代码。通过 Python，我们验证了物理定律，并学会了如何计算最终的系统状态。
作为开发者，掌握这些基础物理原理对于游戏开发、仿真软件甚至简单的动画制作都至关重要。
下一步建议：你可以尝试将上述的一维碰撞代码扩展到二维空间。在二维碰撞中，你需要将速度分解为法向分量和切向分量。法向分量使用我们今天讨论的动量守恒公式处理，而切向分量通常假设不受摩擦力影响而保持不变。这将是你构建更复杂 2D 物理引擎的绝佳起点。
希望这篇文章对你有所帮助，祝你在物理编程的探索中玩得开心！