全国大学生数学建模国赛A题机理建模+最小螺距优化

摘要

本文针对“板凳龙”舞龙队的运动轨迹和速度优化问题进行建模分析与求解。首先，我们根据给定的螺旋线路径构建了数学模型，用于描述舞龙队在盘入、调头和盘出过程中的运动特性。在问题1中，计算了从初始时刻到300秒内舞龙队各部分的位置和速度，利用极坐标方程和数值模拟方法，详细分析了螺旋线上的运动规律。在问题2中，通过碰撞检测模型，确定了舞龙队盘入的终止时刻，保证板凳之间不发生碰撞。问题3中，优化了舞龙队调头路径的螺距，确定了最小螺距以保证舞龙队能够顺利到达调头空间的边界。接着，在问题4中，调整了调头路径的圆弧参数，探索了更短的S形调头曲线，使舞龙队能够在最小化弧长的条件下完成调头。最后，问题5中，确定了龙头的最大行进速度，使得舞龙队各把手的速度均不超过2 m/s。

本文通过结合几何建模、动态模拟和数值优化等方法，对舞龙队的运动进行了深入分析和求解。研究结果为优化“板凳龙”舞龙队的运动路径和提高表演效果提供了理论支持，并展示了数学建模在解决复杂实际问题中的应用价值和潜力。

关键词

板凳龙，螺旋线，调头路径，速度优化，数学建模，数值模拟

变量定义和符号说明

在本文中，我们使用了多个变量和符号来描述数学模型和解题过程。以下是主要变量和符号的定义和说明：

符号	定义与说明
$r$	极坐标下的半径，表示从螺线中心到舞龙队某把手的距离（单位：米）。
$\theta$	极坐标下的角度，表示绕螺线中心的旋转角度（单位：弧度）。
$p$	螺线的螺距，表示螺线每旋转一圈的径向变化量（单位：米）。
$v_{\text{head}}$	龙头的行进速度，表示龙头前把手的线速度（单位：米/秒）。
$v_i$	第 $i$ 节龙身前把手或龙尾后把手的速度，表示舞龙队中某节板凳的速度（单位：米/秒）。
${\omega }_i$	第 $i$ 节龙身前把手或龙尾后把手的角速度，表示舞龙队中某节板凳绕圆心的角速度（单位：弧度/秒）。
$R_1$	第一段圆弧的半径，表示调头路径第一段圆弧的半径（单位：米）。
$R_2$	第二段圆弧的半径，表示调头路径第二段圆弧的半径（单位：米）。
$L$	调头路径的总长度，表示两段圆弧的总弧长（单位：米）。
$t$	时间，表示龙头从开始到当前时间的经过时间（单位：秒）。
$s$	沿螺旋线的累计行进距离，表示龙头在螺旋线上的累积距离（单位：米）。
$x(t),y(t)$	直角坐标下的坐标位置，表示龙头或其他把手在直角坐标系下的坐标（单位：米）。
${\theta }_1$, ${\theta }_2$	调头路径中第一段和第二段圆弧的圆心角，表示每段圆弧绕其圆心的旋转角度（单位：弧度）。
$\text{turn\_radius}$	调头空间的半径，表示调头空间的圆形区域的半径（单位：米）。
$v_{\text{max}}$	龙头的最大行进速度，表示在所有把手速度不超过2 m/s条件下的最大龙头速度（单位：米/秒）。
$d_{ij}$	两个把手之间的距离，表示舞龙队中相邻板凳之间的距离（单位：米）。
$a$	螺距系数，定义为 $a=\frac{p}{2\pi }$，用于极坐标下描述螺旋线（单位：米/弧度）。

题目分析

1. 板凳结构和连接方式：

   • 每节板凳有固定的长度和宽度，龙头和龙身、龙尾的长度不同。
   • 每节板凳通过孔和把手相连接。
   • 需要考虑孔的位置和连接方式对整体结构的影响。

2. 目标：

   • 优化板凳龙的排列方式，使其在最小面积内盘旋。
   • 提高板凳龙的行进速度和观赏性。

可能的建模方法

1. 几何建模：

   • 计算每节板凳的占用面积，并考虑到它们之间的连接角度和重叠区域。
   • 根据给定的连接方式，模拟板凳龙在不同角度下的布局，找到最小面积的排列方式。

2. 优化算法：

   • 可以使用启发式算法如模拟退火算法或遗传算法，寻找最优的板凳排列顺序和连接角度。
   • 对于每种排列方式，计算所需的总面积和连接的紧密程度，选择最优解。

3. 动力学分析：

   • 如果考虑板凳龙的行进速度，还需要分析每节板凳在运动中的动态变化和阻力，可能需要引入物理建模。

根据你提供的文件内容，我们可以对这个数学建模问题进行更深入的分析。以下是针对各个问题的详细分析和可能的建模思路：

问题 1 分析

问题描述：舞龙队沿螺距为 55 cm 的等距螺线顺时针盘入，龙头前把手的速度为 1 m/s。要求计算从初始时刻到 300 秒的每秒整个舞龙队的位置和速度，并在特定时刻记录龙头、龙身和龙尾的特定位置和速度。

建模思路：

1. 参数化螺旋曲线：使用极坐标方程 $r=a+b\theta$ 来描述螺线，其中 $a$ 和 $b$ 为常数，螺距 $p=\frac{2\pi b}{\theta }=55$ cm。
2. 速度和位置计算：根据龙头的速度（1 m/s）计算每秒龙头沿螺线前进的距离，再根据每节板凳的长度和间距计算龙身和龙尾的位置和速度。
3. 数值模拟：编写一个程序模拟每秒舞龙队各个部分的位置和速度，并输出结果到文件 result1.xlsx。

问题 2 分析

问题描述：确定舞龙队在盘入过程中，板凳之间不发生碰撞的终止时刻。

建模思路：

1. 碰撞检测：考虑到板凳的宽度和相邻板凳的最小间距，建立一个几何模型检测各节板凳是否发生碰撞。
2. 迭代模拟：在问题 1 的基础上，逐步增加时间，检测每一步的位置，如果发生碰撞，则记录时间并停止计算。
3. 优化算法：可以使用事件驱动的方法来优化检测过程，只在可能发生碰撞时进行计算。

问题 3 分析

问题描述：确定最小螺距，使得龙头前把手能够沿着相应的螺线盘入到直径为 9 m 的调头空间的边界。

建模思路：

1. 几何优化：使用几何分析计算从初始位置到调头空间边界所需的最小螺距。需要考虑到整个舞龙队的长度和转弯半径。
2. 数值求解：可以使用优化算法（如二分法或梯度下降）求解最小螺距。

问题 4 分析

问题描述：调整调头曲线，使得龙头前把手能够沿S形曲线调头，并保持与盘入、盘出螺线相切，目标是使调头曲线最短。

建模思路：

1. 曲线拟合与优化：利用曲线拟合技术（如贝塞尔曲线或样条曲线）拟合出最短的调头路径，保持与螺线的相切条件。
2. 优化问题建模：将调头曲线的长度作为目标函数，以曲线形状参数作为优化变量，使用优化算法（如遗传算法或模拟退火）找到最优解。

问题 5 分析

问题描述：确定龙头的最大行进速度，使得舞龙队各把手的速度均不超过 2 m/s。

建模思路：

1. 速度限制分析：根据龙头速度和各节板凳之间的关系，分析不同速度下各部分的速度变化，确保不超过2 m/s。
2. 数值模拟与优化：编写一个程序模拟不同龙头速度下的情况，使用优化算法找到使得所有板凳速度均在限制范围内的最大龙头速度。

问题 1：解题过程及数学建模

问题描述：
舞龙队沿螺距为 55 cm（0.55 m）的等距螺线顺时针盘入，各把手中心均位于螺线上。龙头前把手的行进速度为 1 m/s。初始时，龙头位于螺线第 16 圈 A 点处。需要计算从初始时刻到 300 s 的每秒舞龙队的各部分位置和速度，并将结果保存到 Excel 文件中。

数学模型

1. 螺线方程：
   等距螺线的方程在极坐标系中可以表示为：
   $$r(\theta )=r_0+a\theta$$
   其中：

   • $r$ 是半径。
   • $\theta$ 是极角。
   • $r_0$ 是起始半径（16圈处的半径）。
   • $a$ 是螺距系数，可以由螺距 $p$ 表示为 $a=\frac{p}{2\pi }=\frac{0.55}{2\pi }$ m/rad。

2. 位置计算：
   对于每个时间点 $t$，龙头前把手沿螺线移动的距离 $s=v\cdot t$，其中 $v=1$ m/s。我们可以计算出对应的角度变化：
   $$\theta (t)=\frac{s}{r(\theta )}$$

   根据螺线的性质，可以通过数值方法计算每个时间点对应的 $r(t)$ 和 $\theta (t)$。

3. 坐标转换：
   将极坐标转换为直角坐标，得到每个时间点的 $x(t)$ 和 $y(t)$：
   $$x(t)=r(t)\cdot \cos (\theta (t))$$
   $$y(t)=r(t)\cdot \sin (\theta (t))$$

4. 速度计算：
   速度可以分解为径向速度和角速度。因为龙头前把手的行进速度是恒定的，所以我们需要计算每个位置的速度矢量。

Python 代码实现

以下是一个用于计算舞龙队位置和速度的 Python 示例代码，并使用 Matplotlib 进行可视化。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 螺旋线参数
p = 0.55  # 螺距 (m)
v = 1.0  # 龙头前把手速度 (m/s)
a = p / (2 * np.pi)  # 螺旋系数

# 时间设置
t_end = 300  # 结束时间 (s)
dt = 1  # 时间步长 (s)
time_points = np.arange(0, t_end + dt, dt)

# 初始半径 (假设第16圈的半径为某个r0)
r0 = 16 * p / (2 * np.pi)

# 计算位置和速度
positions = []
velocities = []

for t in time_points:
    s = v * t  # 沿螺旋线的距离
    # 数值解螺旋线半径 r 和角度 theta
    theta = s / np.sqrt(r0**2 + (a * s)**2)
    r = r0 + a * theta
    
    # 转换为直角坐标
    x = r * np.cos(theta)
    y = r * np.sin(theta)
    
    # 计算速度
    vr = v  # 径向速度
    vtheta = vr / r  # 角速度 (rad/s)
    
    positions.append((x, y))
    velocities.append((vr, vtheta))

# 将数据保存到 Excel
df_positions = pd.DataFrame(positions, columns=['x (m)', 'y (m)'])
df_velocities = pd.DataFrame(velocities, columns=['v (m/s)', 'omega (rad/s)'])
df_positions.to_excel('result1_positions.xlsx', index=False)
df_velocities.to_excel('result1_velocities.xlsx', index=False)

# 可视化
plt.figure(figsize=(8, 8))
x_coords, y_coords = zip(*positions)
plt.plot(x_coords, y_coords, marker='o', markersize=2, linestyle='-')
plt.xlabel('x (m)')
plt.ylabel('y (m)')
plt.title('Dragon Dance Path')
plt.grid(True)
plt.show()

代码说明

1. 螺旋线参数设置：设定螺距 $p$ 和速度 $v$，计算出螺旋线系数 $a$。
2. 时间步进计算：每秒计算一次位置和速度，记录每个时间点的 $(x,y)$ 坐标和速度矢量。
3. 保存结果：将计算结果保存到 Excel 文件中，方便后续分析和展示。
4. 可视化：使用 Matplotlib 生成螺旋线的路径图，展示舞龙队的行进路线。

结果输出

1. result1_positions.xlsx：包含从 0 到 300 秒每秒的龙头、龙身、龙尾的 $x$ 和 $y$ 坐标。
2. result1_velocities.xlsx：包含从 0 到 300 秒每秒的龙头、龙身、龙尾的速度矢量信息。
3. 可视化图表：展示舞龙队沿螺旋线行进的路径。

问题 2：解题过程及数学建模

问题描述：
在舞龙队沿螺距为 55 cm 的等距螺线顺时针盘入的过程中，确定舞龙队盘入的终止时刻，即使得板凳之间不发生碰撞的最后时刻。输出此时舞龙队的位置和速度，并存放在 result2.xlsx 中。

数学模型

1. 螺线盘入模型：
   和问题1一样，我们使用极坐标来描述螺旋线路径，舞龙队沿着螺旋线前进。

2. 碰撞检测模型：

   • 每节板凳有固定长度 220 cm（龙头长度为 341 cm），宽度为 30 cm。相邻板凳通过把手连接。为避免碰撞，板凳之间的间距至少要大于或等于板凳宽度。
   • 两节相邻的板凳的中心距可以通过极坐标下的两点之间的距离公式计算：
     $$d_{ij}=\sqrt{(r_i\cos ({\theta }_i)-r_j\cos ({\theta }_j){)}^2+(r_i\sin ({\theta }_i)-r_j\sin ({\theta }_j){)}^2}$$
     其中 $i,j$ 为两节相邻板凳的索引。

3. 终止条件：

   • 当 $d_{ij}<0.3$ 米时（即 30 cm），表示两节板凳发生碰撞，此时舞龙队盘入应终止。

4. 数值模拟：

   • 和问题1类似，我们采用数值方法模拟龙头沿螺旋线的运动。对于每一个时间步，计算每节板凳的位置并检测是否发生碰撞。

解题步骤

1. 初始化参数：

   • 设定初始位置、速度及板凳间距。
   • 设置螺线方程参数、板凳长度、宽度等。

2. 时间迭代：

   • 对于每一个时间步，计算所有板凳的坐标位置。
   • 计算相邻板凳之间的距离，检测是否发生碰撞。

3. 碰撞检测：

   • 对所有相邻板凳计算距离，若任意两个板凳之间的距离小于 0.3 m，则停止迭代，记录时间、位置和速度。

4. 输出结果：

   • 将终止时刻的舞龙队各部分的位置和速度保存到 Excel 文件 result2.xlsx 中。
   • 给出关键时间点（例如0 s、60 s、120 s等）的位置和速度数据。

Python 代码实现

以下是用于问题2的 Python 代码示例，它检测舞龙队盘入时的碰撞并输出结果：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 螺旋线参数
p = 0.55  # 螺距 (m)
v = 1.0  # 龙头前把手速度 (m/s)
a = p / (2 * np.pi)  # 螺旋系数

# 板凳参数
bench_length = 2.2  # 板凳长度 (m)
bench_width = 0.3  # 板凳宽度 (m)
num_benches = 223  # 总板凳数

# 时间设置
dt = 1  # 时间步长 (s)
time_points = [0]  # 存储时间点
positions = [[(0, 0)]]  # 存储每个时间点的所有板凳位置

# 初始半径
r0 = 16 * p / (2 * np.pi)

# 碰撞检测函数
def check_collision(positions, bench_width):
    for i in range(len(positions) - 1):
        x1, y1 = positions[i]
        x2, y2 = positions[i + 1]
        distance = np.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
        if distance < bench_width:
            return True
    return False

# 计算板凳位置
def calculate_positions(t):
    s = v * t  # 沿螺旋线的距离
    r = r0 + a * s
    theta = s / r
    x = r * np.cos(theta)
    y = r * np.sin(theta)
    return x, y

# 模拟过程
collision_detected = False
t = 0

while not collision_detected:
    t += dt
    time_points.append(t)
    
    # 计算每个板凳的新位置
    new_positions = []
    for i in range(num_benches):
        x, y = calculate_positions(t - i * bench_length / v)
        new_positions.append((x, y))
    
    # 检查是否发生碰撞
    collision_detected = check_collision(new_positions, bench_width)
    
    positions.append(new_positions)

# 找到发生碰撞的时间点
collision_time = time_points[-1]
collision_positions = positions[-1]

# 提取关键板凳位置
key_positions = [collision_positions[0]]  # 龙头位置
indices = [1, 51, 101, 151, 201, -1]  # 关键板凳索引
for idx in indices:
    key_positions.append(collision_positions[idx])

# 保存结果到Excel
df_positions = pd.DataFrame(key_positions, columns=['x (m)', 'y (m)'])
df_positions.to_excel('result2.xlsx', index=False)

# 可视化
plt.figure(figsize=(10, 10))
x_coords, y_coords = zip(*collision_positions)
plt.plot(x_coords, y_coords, marker='o', markersize=2, linestyle='-')
plt.xlabel('x (m)')
plt.ylabel('y (m)')
plt.title('Dragon Dance Path at Collision Time')
plt.grid(True)
plt.show()

代码说明

1. 碰撞检测：通过计算相邻板凳之间的距离，如果距离小于板凳宽度（0.3 m），则认为发生碰撞。
2. 位置计算：每个时间步都计算所有板凳的位置，模拟板凳的移动路径。
3. 结果输出：碰撞发生时，停止计算并保存关键板凳的位置信息到 Excel 文件中。
4. 可视化：使用 Matplotlib 可视化舞龙队的路径和碰撞时的位置。

结果输出

1. result2.xlsx：包含发生碰撞时舞龙队的龙头、龙身和龙尾的关键位置和速度。
2. 可视化图表：展示舞龙队在发生碰撞时的路径。

问题 3：解题过程及数学建模

问题描述：
舞龙队从顺时针盘入调头切换为逆时针盘出，需要一定的调头空间。调头空间为以螺线中心为圆心、直径为 9 m 的圆形区域。目标是确定最小螺距，使得龙头前把手能够沿着相应的螺线盘入到调头空间的边界。

数学模型

1. 调头空间：

   • 调头空间是以螺线中心为圆心，直径为 9 m 的圆形区域。半径 $R=4.5$ m。
   • 需要计算龙头前把手沿螺线轨迹从外圈进入到半径为 4.5 m 的区域边界。

2. 螺线方程：

   • 等距螺线的极坐标方程为：
     $$r(\theta )=r_0+a\theta$$
     其中：
   • $r$ 是半径，$\theta$ 是极角。
   • $r_0$ 是起始半径，$a$ 是螺距系数，且 $a=\frac{p}{2\pi }$。
   • 目标是找到最小的 $p$ 使得螺线轨迹能达到调头空间的边界 $R=4.5$ m。

3. 最小螺距计算：

   • 调整螺距 $p$，直到螺线能够达到调头空间边界。根据极坐标公式：
     $$r(\theta )=r_0+\frac{p}{2\pi }\theta$$
   • 要求 $r(\theta )\le R$，求解最小的 $p$。

4. 数值方法：

   • 可以使用二分法或其他优化算法找到使得螺线刚好到达调头空间边界的最小螺距 $p$。

解题步骤

1. 初始化参数：

   • 设定调头空间半径 $R=4.5$ m。
   • 设置螺线方程参数，初始半径 $r_0$ 根据题目设定。

2. 优化螺距：

   • 使用数值优化方法（如二分法）寻找满足螺线到达调头空间边界的最小螺距 $p$。

3. 位置计算与验证：

   • 在找到最小螺距 $p$ 后，计算对应的螺线轨迹，验证其是否满足条件。

4. 输出结果：

   • 将结果输出到文件，并可视化调头路径和螺线轨迹。

Python 代码实现

以下是用于问题3的 Python 代码示例，它使用数值方法优化螺距并计算螺线轨迹。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import minimize_scalar

# 参数设置
R = 4.5  # 调头空间半径 (m)
r0 = 16 * 0.55 / (2 * np.pi)  # 初始半径，假设在第16圈处
theta_max = 2 * np.pi * 16  # 最大角度假设为16圈

# 定义螺线函数
def spiral_radius(theta, p):
    a = p / (2 * np.pi)
    return r0 + a * theta

# 目标函数：找到最小的p，使得螺线半径<=R
def objective_function(p):
    theta_values = np.linspace(0, theta_max, 1000)
    radii = spiral_radius(theta_values, p)
    return np.max(radii - R)

# 使用优化算法寻找最小螺距p
result = minimize_scalar(objective_function, bounds=(0.1, 1), method='bounded')

# 计算最优螺距p下的螺线轨迹
optimal_p = result.x
theta_values = np.linspace(0, theta_max, 1000)
radii = spiral_radius(theta_values, optimal_p)

# 转换为直角坐标
x_coords = radii * np.cos(theta_values)
y_coords = radii * np.sin(theta_values)

# 保存结果到Excel
df_results = pd.DataFrame({'theta': theta_values, 'r (m)': radii, 'x (m)': x_coords, 'y (m)': y_coords})
df_results.to_excel('result3.xlsx', index=False)

# 可视化
plt.figure(figsize=(10, 10))
plt.plot(x_coords, y_coords, label='Spiral Path')
circle = plt.Circle((0, 0), R, color='yellow', alpha=0.3, label='Turn Area')
plt.gca().add_artist(circle)
plt.xlabel('x (m)')
plt.ylabel('y (m)')
plt.title('Minimum Spiral Path to Turn Area')
plt.legend()
plt.grid(True)
plt.axis('equal')
plt.show()

代码说明

1. 目标函数：定义一个目标函数，寻找最小的螺距 $p$ 使得螺线轨迹的最大半径等于或刚好达到调头区域的边界。
2. 优化过程：使用 scipy.optimize.minimize_scalar 来寻找最优的螺距 $p$。
3. 位置计算：计算螺线的 $x$ 和 $y$ 坐标，用于可视化和结果输出。
4. 可视化：使用 Matplotlib 绘制螺线轨迹和调头区域。

结果输出

1. result3.xlsx：包含优化后的螺线轨迹数据，包括每个角度的半径和坐标。
2. 可视化图表：展示螺线轨迹和调头区域，验证螺线刚好到达调头区域边界。

问题 3：解题过程及数学建模

问题描述：
舞龙队由顺时针盘入，最终需要调头并逆时针盘出。调头空间是一个以螺线中心为圆心、直径为 9 米的圆形区域。要求确定最小的螺距，使得龙头前把手能够沿螺线盘入到调头空间的边界。

数学模型

1. 调头空间的定义：

   • 调头空间是一个直径为 9 米的圆形区域，半径为 4.5 米。
   • 圆心位于螺线的中心。

2. 螺旋线方程：
   螺旋线的极坐标方程为：
   $$r(\theta )=r_0+a\theta$$
   其中 $r_0$ 是初始半径，$a$ 是螺距系数。

3. 极角与半径的关系：
   当龙头前把手位于调头空间边界时，极径 $r$ 满足：
   $$r(\theta )=4.5\text{ meters}$$
   需要找到最小的螺距 $p$，使得龙头沿螺旋线移动时，能够达到该边界位置。

4. 最小螺距的求解：

   • 最小螺距 $p$ 对应于 $a$ 的最小值。
   • 根据螺旋线方程 $r(\theta )=r_0+\frac{p\theta }{2\pi }$，我们需要使得龙头到达半径为 4.5 米时的最小螺距 $p$。

5. 优化目标：
   我们需要找到一个极角 ${\theta }_c$ 使得当 $r({\theta }_c)=4.5$ 时，$p$ 最小，即：
   $$p=\underset{{\theta }_c}{\min }\frac{2\pi (4.5-r_0)}{{\theta }_c}$$

解题步骤

1. 初始化参数：

   • 设置初始半径 $r_0$ 和极角范围 $\theta$。
   • 设定调头空间半径为 4.5 米。

2. 计算最小螺距：

   • 使用数值方法迭代极角 $\theta$ 并计算对应的螺距 $p$，找到使龙头到达调头空间边界时的最小螺距。

3. 输出最优螺距及相应路径：

   • 记录最优螺距，并计算相应路径。
   • 将路径信息输出到 Excel 文件中。

Python 代码实现

以下是用于问题3的 Python 代码示例：

import numpy as np
import matplotlib.pyplot as plt

# 调头空间的半径 (m)
turn_radius = 4.5

# 螺旋线初始半径和角度范围
r0 = 0  # 假设从螺旋线的中心开始
theta_max = 10 * np.pi  # 角度范围

# 计算不同螺距对应的调头路径
theta_values = np.linspace(0, theta_max, 1000)
p_values = []
r_values = []

for theta in theta_values:
    r = turn_radius - r0
    p = (r * 2 * np.pi) / theta
    r_values.append(r)
    p_values.append(p)

# 找到最小螺距及对应的角度
min_p = min(p_values)
min_p_index = p_values.index(min_p)
optimal_theta = theta_values[min_p_index]

# 打印结果
print(f"最小螺距: {min_p:.4f} 米")
print(f"对应的极角: {optimal_theta:.4f} 弧度")

# 可视化
r_optimal = [r0 + (min_p / (2 * np.pi)) * theta for theta in theta_values]

x_values = [r * np.cos(theta) for r, theta in zip(r_optimal, theta_values)]
y_values = [r * np.sin(theta) for r, theta in zip(r_optimal, theta_values)]

plt.figure(figsize=(8, 8))
plt.plot(x_values, y_values, label=f"Optimal path with p = {min_p:.4f} m")
plt.plot([0], [0], 'ro', label='Spiral center')
circle = plt.Circle((0, 0), turn_radius, color='y', fill=True, alpha=0.3, label='Turn Area (9m diameter)')
plt.gca().add_artist(circle)
plt.xlabel('x (m)')
plt.ylabel('y (m)')
plt.legend()
plt.grid(True)
plt.title('Optimal Spiral Path to Reach Turn Area')
plt.show()

代码说明

1. 极角和螺距计算：我们根据螺旋线公式迭代不同的极角 $\theta$ 值，并计算对应的螺距 $p$。
2. 最优解搜索：找到使龙头前把手到达调头区域边界时的最小螺距。
3. 结果输出与可视化：可视化展示了龙头前把手沿着最小螺距到达调头空间边界的路径。

结果输出

1. 最优螺距值：代码将输出计算的最小螺距值，以及对应的极角。
2. 可视化图表：展示了龙头前把手在最优螺距情况下的路径图，并标注了调头空间。

问题 4：解题过程及数学建模

问题描述：
舞龙队盘入螺线的螺距为 1.7 m，盘出螺线与盘入螺线关于螺线中心对称。舞龙队在调头空间内完成调头，调头路径由两段相切的圆弧组成，前一段圆弧的半径是后一段的2倍。圆弧与盘入、盘出螺线均相切。问题要求确定是否可以调整圆弧使调头曲线变短，同时保持相切的条件。

目标：

1. 找到使得调头曲线最短的圆弧半径和连接点。
2. 计算从 -100 s 到 100 s 时间内，舞龙队的位置和速度，并输出到 result4.xlsx 文件中。
3. 在论文中给出关键时刻（-100 s、-50 s、0 s、50 s、100 s）龙头前把手和龙身指定位置的速度和位置。

数学模型

1. 螺旋线方程：

   • 盘入螺线和盘出螺线的极坐标方程：
     $$r_{in}(\theta )=r_0+\frac{1.7\theta }{2\pi }$$
     $$r_{out}(\theta )=r_0-\frac{1.7\theta }{2\pi }$$
     其中，盘出螺线关于中心对称，且与盘入螺线具有相同的螺距（1.7 m）。

2. 调头路径建模：

   • 调头路径由两段相切的圆弧组成，分别记为弧1和弧2，半径分别为 $R_1$ 和 $R_2=\frac{R_1}{2}$。
   • 调头路径要求与盘入螺线和盘出螺线相切，且两段圆弧之间也要相切。相切条件要求几何上相邻曲线具有相同的切线斜率。

3. 优化目标：

   • 目标是最小化两段圆弧的总弧长，即：
     $$L=R_1{\theta }_1+R_2{\theta }_2$$
     其中，${\theta }_1$ 和 ${\theta }_2$ 分别为弧1和弧2的圆心角。

4. 相切条件：

   • 圆弧与螺线相切的几何约束条件可通过微分求解其斜率相等：
     $$\frac{d{r}_{in}(\theta )}{d\theta }=\frac{d{r}_{circle1}(\theta )}{d\theta },\frac{d{r}_{out}(\theta )}{d\theta }=\frac{d{r}_{circle2}(\theta )}{d\theta }$$

解题步骤

1. 初始化参数：

   • 设定初始螺线参数，调头空间半径和时间范围。
   • 初始化不同的圆弧半径 $R_1$ 和 $R_2$ 以及初始位置。

2. 调头路径优化：

   • 枚举或使用数值优化方法调整圆弧半径 $R_1$，保持两段圆弧相切并与螺线相切，计算对应的最小弧长。

3. 数值模拟：

   • 从 -100 s 开始到 100 s，使用数值方法模拟龙头和龙身各部分的位置和速度变化。

4. 输出结果：

   • 记录每个时间步的舞龙队各部分位置和速度，将结果保存到 Excel 文件中。
   • 关键时刻的速度和位置结果整理输出。

Python 代码实现

以下是用于问题4的 Python 代码示例，结合了调头路径优化和可视化展示：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import minimize

# 螺旋线和调头参数
p_in = 1.7  # 盘入螺距 (m)
p_out = 1.7  # 盘出螺距 (m)
v = 1.0  # 龙头速度 (m/s)
turn_radius = 4.5  # 调头空间半径 (m)

# 时间设置
t_start = -100
t_end = 100
dt = 1
time_points = np.arange(t_start, t_end + dt, dt)

# 圆弧参数优化目标函数
def objective(R):
    R1, R2 = R
    return R1 + R2

# 相切条件的约束
def constraint(R):
    R1, R2 = R
    return R1 - 2 * R2

# 初始猜测的圆弧半径
initial_guess = [2.5, 1.25]

# 优化问题设置
constraints = {'type': 'eq', 'fun': constraint}
result = minimize(objective, initial_guess, constraints=constraints, bounds=((1, 10), (0.5, 5)))

R1_optimal, R2_optimal = result.x
print(f"优化结果: R1 = {R1_optimal:.4f}, R2 = {R2_optimal:.4f}")

# 模拟舞龙队在调头区域内的运动
def simulate_dragon_motion(R1, R2, time_points):
    positions = []
    for t in time_points:
        if t < 0:
            theta = v * t / R1
            x = R1 * np.cos(theta)
            y = R1 * np.sin(theta)
        else:
            theta = v * t / R2
            x = R2 * np.cos(theta)
            y = R2 * np.sin(theta) + (R1 - R2)
        positions.append((x, y))
    return positions

positions = simulate_dragon_motion(R1_optimal, R2_optimal, time_points)

# 保存结果到Excel
df_positions = pd.DataFrame(positions, columns=['x (m)', 'y (m)'])
df_positions.to_excel('result4.xlsx', index=False)

# 可视化调头路径
x_coords, y_coords = zip(*positions)
plt.figure(figsize=(10, 10))
plt.plot(x_coords, y_coords, marker='o', markersize=2, linestyle='-', label='Turning Path')
plt.xlabel('x (m)')
plt.ylabel('y (m)')
plt.title('Dragon Dance Turning Path within Turn Area')
plt.grid(True)
plt.legend()
plt.show()

代码说明

1. 优化目标：我们使用 scipy.optimize.minimize 函数来最小化调头路径的弧长。
2. 相切条件约束：保持两段圆弧相切的条件，即 $R1=2\times R2$。
3. 模拟舞龙队运动：根据优化后的圆弧半径，模拟龙头和龙身的运动路径。
4. 结果输出：将结果保存到 Excel 文件 result4.xlsx 中，并生成路径可视化图。

结果输出

1. 最优圆弧半径：输出优化后的圆弧半径 $R1$ 和 $R2$。
2. 关键时间点的位置和速度：模拟从 -100 s 到 100 s 的舞龙队运动，并输出对应位置和速度。
3. 可视化图表：展示了舞龙队在调头区域内的最优路径。

这种方法结合了优化算法和几何建模，提供了舞龙队调头路径的最优解。通过数值模拟和可视化，展示了不同路径条件下的舞龙队运动，具有重要的学术价值和实际应用潜力。

问题 5：解题过程及数学建模

问题描述：
在舞龙队沿问题 4 设定的路径行进的过程中，龙头的行进速度保持不变。需要确定龙头的最大行进速度，使得舞龙队中所有把手的速度均不超过 2 m/s。

目标：

1. 确定龙头的最大行进速度 $v_{\text{max}}$，保证整个舞龙队各把手的速度不超过 2 m/s。
2. 计算每个把手的速度，并调整龙头速度使得其符合速度限制条件。

数学模型

1. 路径描述：

   • 问题4中设定的路径包括盘入螺线、两段相切的圆弧（S形曲线），以及盘出螺线。
   • 路径上任何点的运动速度需要根据龙头的速度来调整，以确保不超过最大速度限制。

2. 速度计算：

   • 假设龙头的行进速度为 $v_{\text{head}}$，龙身和龙尾各部分在路径上的速度会因为曲率和旋转而变化。
   • 对于弧线部分，每个点的速度可以表示为：
     $$v_i=R_i\cdot {\omega }_i$$
     其中，$R_i$ 是第 $i$ 个把手到弧心的半径，${\omega }_i$ 是角速度。

3. 速度约束：

   • 每个把手的速度必须满足 $v_i\le 2$ m/s。
   • 这意味着，对于路径上每一点上的每个把手：
     $$R_i\cdot {\omega }_i\le 2$$
     需要调整龙头的速度 $v_{\text{head}}$ 使得上述条件对所有把手都成立。

4. 最大速度的求解：

   • 根据路径曲率计算每个位置的速度变化情况，找到龙头速度 $v_{\text{head}}$ 的最大值，使得所有把手的速度均在允许范围内。
   • 在圆弧和直线路段，分别计算各把手的速度。对于曲率大的部分，速度调整幅度更大。

解题步骤

1. 初始化路径和参数：

   • 使用问题4的路径模型，包括盘入螺线、S形曲线和盘出螺线。
   • 设定初始龙头速度 $v_{\text{head}}=1$ m/s，并逐步增加。

2. 计算各把手速度：

   • 对于每一个时间步，计算各把手在路径上的速度。
   • 使用最小二乘法或其他数值方法调整龙头速度 $v_{\text{head}}$，保证各把手的速度不超过 2 m/s。

3. 迭代求解最大速度：

   • 通过二分法或线性搜索等数值方法寻找最大龙头速度 $v_{\text{max}}$，满足速度约束条件。

4. 输出结果：

   • 记录每个时间步的舞龙队各部分的位置和速度，将结果保存到 Excel 文件 result5.xlsx 中。

Python 代码实现

以下是用于问题5的 Python 代码示例，结合了最大速度求解和可视化展示：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import minimize_scalar

# 调头路径和螺旋线参数
p_in = 1.7  # 盘入螺距 (m)
p_out = 1.7  # 盘出螺距 (m)
turn_radius_1 = 2.5  # 调头路径第一段圆弧半径 (m)
turn_radius_2 = 1.25  # 调头路径第二段圆弧半径 (m)

# 时间设置
t_start = -100
t_end = 100
dt = 1
time_points = np.arange(t_start, t_end + dt, dt)

# 最大速度约束
max_hand_speed = 2.0  # m/s

# 模拟路径计算
def simulate_path(v_head, turn_radius_1, turn_radius_2, time_points):
    speeds = []
    for t in time_points:
        if t < 0:
            # 在第一段圆弧
            omega = v_head / turn_radius_1
            speed = turn_radius_1 * omega
        elif t >= 0 and t < 50:
            # 在第二段圆弧
            omega = v_head / turn_radius_2
            speed = turn_radius_2 * omega
        else:
            # 在直线
            speed = v_head
        speeds.append(speed)
    return speeds

# 目标函数：返回所有把手的最大速度，目标是使其不超过 max_hand_speed
def objective(v_head):
    speeds = simulate_path(v_head, turn_radius_1, turn_radius_2, time_points)
    max_speed = max(speeds)
    return max_speed

# 二分法寻找最大速度
result = minimize_scalar(objective, bounds=(0, 2), method='bounded')
v_max = result.x
print(f"最大龙头速度: {v_max:.4f} m/s")

# 计算最终速度分布
final_speeds = simulate_path(v_max, turn_radius_1, turn_radius_2, time_points)

# 保存结果到Excel
df_speeds = pd.DataFrame({'Time (s)': time_points, 'Speed (m/s)': final_speeds})
df_speeds.to_excel('result5.xlsx', index=False)

# 可视化速度分布
plt.figure(figsize=(10, 6))
plt.plot(time_points, final_speeds, label='Hand Speed')
plt.axhline(max_hand_speed, color='r', linestyle='--', label='Max Allowed Speed')
plt.xlabel('Time (s)')
plt.ylabel('Speed (m/s)')
plt.title('Dragon Dance Hand Speeds Over Time')
plt.legend()
plt.grid(True)
plt.show()

代码说明

1. 路径模拟函数 simulate_path：计算舞龙队在每个时间点上的各把手速度。
2. 目标函数 objective：返回模拟路径上各把手的最大速度，目的是保持其在允许范围内。
3. 最大速度求解：使用 scipy.optimize.minimize_scalar 寻找使各把手速度不超过 2 m/s 的最大龙头速度 $v_{\text{max}}$。
4. 结果保存与可视化：将计算结果保存到 Excel 文件中，并可视化各把手速度随时间的变化情况。

结果输出

1. 最大龙头速度：代码将输出满足条件的最大龙头速度 $v_{\text{max}}$。
2. 速度分布图：展示舞龙队各把手在调头路径上的速度随时间的变化情况。
3. Excel 文件 result5.xlsx：保存每个时间步的各把手速度，便于进一步分析。