python 汽车理论1.3加速度倒数求加速时间及numpy相关用法

最新推荐文章于 2024-08-12 09:07:37 发布

哈哈哈#

最新推荐文章于 2024-08-12 09:07:37 发布

阅读量394

点赞数 2

分类专栏： Python学习文章标签： python 汽车

本文链接：https://blog.csdn.net/qq_71710015/article/details/134203384

版权

Python学习专栏收录该内容

13 篇文章 1 订阅

订阅专栏

以汽车汽车理论1.3数据为例

一、无交点即最大转速换挡

通过驱动力-行驶阻力图以求得最大车速为：99.1，求解用2档起步至70km/h所需时间

由于2档起步， uimax[1]小标由1开始而不是0.

import numpy as np  # 加载数学库用于函数描述
import matplotlib.pyplot as plt

n1 = 600  # 最低转速
nmax = 4000  # 最高转速 r/min
mx = 2000  # 装载质量
my = 1800  # 整车整备质量
m = 3880  # 总质量
r = 0.367  # 车轮半径
nT = 0.85  # 传动系机械效率
f = 0.013  # 滚动阻力系数
CDA = 2.77  # 空气阻力系数
i0 = 5.83  # 主减速器传动比
If = 0.218  # 飞轮转动惯量
Iw1 = 1.798
Iw2 = 3.598
Ig = [5.56, 2.769, 1.644, 1.00, 0.793]  # 变速器传动比 0.793
L = 3.2  # 轴距
a = 1.947
hg = 0.9

uimax = []  # 第i档对应最大速度
p = np.zeros(len(Ig))  # 存储旋转质量换算系数
for j in Ig:  # 第i档对应最大速度
    u = 0.377 * r * nmax / (j * i0)
    uimax.append(u)
for i in range(len(Ig)):  # 对应的旋转质量换算系数
    p[i] = 1 + (Iw1 + abs(Iw2)) / (m * r ** 2) + (If * (Ig[i] ** 2) * i0 ** 2 * nT) / (m * r ** 2)

ua = np.arange(6, 99.1, 0.01)  # 通过已经求得的最大车速划分区间
N = len(ua)  # 区间的总个数 为计算做准备   N代表以下都为相同形状数组便于计算（初始为0）
n = np.zeros(N)  # 存储对应转速
Tq = np.zeros(N)  # 存储对应转矩
Ft = np.zeros(N)  # 存储对应驱动力
at = np.zeros(N)  # 存储对应加速度倒数
multiply = np.zeros(N)  # 速度与加速度倒数的乘积
t = np.zeros(N)       # 存储对应乘积的和（即求和）
t2 = np.zeros(N)      # 存储加速到某速度的对应时间
Ff = m * 9.8 * f
Fw = CDA * ua ** 2 / 21.15
for i in range(N):
    k = i   # 用作计算加速到某一速度时间
    if ua[i] <= uimax[1]:  # 2档起步
        n[i] = ua[i] * (Ig[1] * i0 / r) / 0.377
        Tq[i] = -19.313 + 295.27 * (n[i] / 1000) - 165.44 * (n[i] / 1000) ** 2 + 40.874 * (
                n[i] / 1000) ** 3 - 3.8445 * (n[i] / 1000) ** 4
        Ft[i] = Tq[i] * Ig[1] * i0 * nT / r
        at[i] = p[1] * m / (Ft[i] - Ff - Fw[i])
        multiply[i] = 0.01 * at[i] / 3.6
    elif ua[i] <= uimax[2]:
        n[i] = ua[i] * (Ig[2] * i0 / r) / 0.377
        Tq[i] = -19.313 + 295.27 * (n[i] / 1000) - 165.44 * (n[i] / 1000) ** 2 + 40.874 * (
                n[i] / 1000) ** 3 - 3.8445 * (n[i] / 1000) ** 4
        Ft[i] = Tq[i] * Ig[2] * i0 * nT / r
        at[i] = p[2] * m / (Ft[i] - Ff - Fw[i])
        multiply[i] = 0.01 * at[i] / 3.6
    elif ua[i] <= uimax[3]:
        n[i] = ua[i] * (Ig[3] * i0 / r) / 0.377
        Tq[i] = -19.313 + 295.27 * (n[i] / 1000) - 165.44 * (n[i] / 1000) ** 2 + 40.874 * (
                n[i] / 1000) ** 3 - 3.8445 * (n[i] / 1000) ** 4
        Ft[i] = Tq[i] * Ig[3] * i0 * nT / r
        at[i] = p[3] * m / (Ft[i] - Ff - Fw[i])
        multiply[i] = 0.01 * at[i] / 3.6
    elif ua[i] <= uimax[4]:
        n[i] = ua[i] * (Ig[4] * i0 / r) / 0.377
        Tq[i] = -19.313 + 295.27 * (n[i] / 1000) - 165.44 * (n[i] / 1000) ** 2 + 40.874 * (
                n[i] / 1000) ** 3 - 3.8445 * (n[i] / 1000) ** 4
        Ft[i] = Tq[i] * Ig[4] * i0 * nT / r
        at[i] = p[4] * m / (Ft[i] - Ff - Fw[i])
        multiply[i] = 0.01 * at[i] / 3.6
    else:
        n[i] = ua[i] * (Ig[4] * i0 / r) / 0.377
        Tq[i] = -19.313 + 295.27 * (n[i] / 1000) - 165.44 * (n[i] / 1000) ** 2 + 40.874 * (
                n[i] / 1000) ** 3 - 3.8445 * (n[i] / 1000) ** 4
        Ft[i] = Tq[i] * Ig[4] * i0 * nT / r
        at[i] = p[4] * m / (Ft[i] - Ff - Fw[i])
        multiply[i] = 0.01 * at[i] / 3.6
    b = multiply[1:k]
    t[i] = np.sum(b)
    if ua[i] <= 70.1:
        t2 = np.sum(multiply)

print(t2)
plt.title('t-ua')
plt.ylabel('U$_{a}$/(km/h)')
plt.xlabel('t/s')
plt.plot(t, ua)
plt.axis([0, 80, 0, 100])
plt.show()

二、numpy一些用法

1.创建矩阵：可以使用`numpy.array()`函数创建一个矩阵，或者使用`numpy.matrix()`函数创建一个矩阵对象。

import numpy as np

# 使用numpy.array()创建矩阵
matrix1 = np.array([[1, 2], [3, 4]])

# 使用numpy.matrix()创建矩阵对象
matrix2 = np.matrix([[1, 2], [3, 4]])

print(matrix1)
print(matrix2)

2. 矩阵运算：Numpy支持多种矩阵运算，如加法、减法、乘法等。

import numpy as np

# 创建两个矩阵
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 矩阵加法
C = np.add(A, B)
print("矩阵加法结果：", C)

# 矩阵减法
D = np.subtract(A, B)
print("矩阵减法结果：", D)

# 矩阵乘法
E = np.dot(A, B)
print("矩阵乘法结果：", E)

3. 矩阵转置：可以使用`numpy.transpose()`函数或`@`操作符对矩阵进行转置。

import numpy as np

# 创建矩阵
A = np.array([[1, 2], [3, 4]])

# 使用numpy.transpose()函数进行转置
B = np.transpose(A)
print("矩阵转置结果：", B)

# 使用@操作符进行转置
C = A @ np.transpose(A)
print("矩阵转置结果：", C)

4. 矩阵求逆：可以使用`numpy.linalg.inv()`函数求矩阵的逆。

import numpy as np

# 创建矩阵
A = np.array([[1, 2], [3, 4]])

# 求矩阵的逆
A_inv = np.linalg.inv(A)
print("矩阵求逆结果：", A_inv)

5. 矩阵特征值和特征向量：可以使用`numpy.linalg.eig()`函数求矩阵的特征值和特征向量。

import numpy as np

# 创建矩阵
A = np.array([[1, 2], [3, 4]])

# 求矩阵的特征值和特征向量
eigenvalues, eigenvectors = np.linalg.eig(A)
print("矩阵特征值：", eigenvalues)
print("矩阵特征向量：", eigenvectors)

三、有交点即交点处换挡

本题示例中加速度倒数曲线无交点如下：

当曲线存在交点时上述算法需要改善，即将umax 中的数据换为交点对应的车速。

以下本示例将区间转速调整由原来的 [600-4000] 变为 [600-4600]来举例说明。（仅作前两换挡点）

在运行代码前先计算交点对应的速度。

import numpy as np  # 加载数学库用于函数描述
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['Microsoft YaHei']
plt.rcParams['axes.unicode_minus'] = False  # 解决图像中的'-'负号的乱码问题
n = np.linspace(600, 4600, 5000)
n1 = 600  # 最低转速
n2 = 4000  # 最高转速 r/min
mx = 2000  # 装载质量
my = 1800  # 整车整备质量
m = 3880  # 总质量
r = 0.367  # 车轮半径
nt = 0.85  # 传动系机械效率
f = 0.013  # 滚动阻力系数
CDA = 2.77  # 空气阻力系数
i0 = 5.83  # 主减速器传动比
If = 0.218  # 飞轮转动惯量
Iw1 = 1.798
Iw2 = 3.598
Ig = [5.56, 2.769, 1.644, 1.00, 0.793]  # 变速器传动比 0.793
L = 3.2  # 轴距
a = 1.947
hg = 0.9
Tq = -19.313 + 295.27 * (n / 1000) - 165.44 * (n / 1000) ** 2 + 40.874 * (n / 1000) ** 3 - 3.8445 * (n / 1000) ** 4


Ft1 = (Tq * i0 * Ig[0] * nt) / r  # Ft 计算公式
Ft2 = (Tq * i0 * Ig[1] * nt) / r  # Ft 计算公式
Ft3 = (Tq * i0 * Ig[2] * nt) / r  # Ft 计算公式
Ft4 = (Tq * i0 * Ig[3] * nt) / r  # Ft 计算公式
Ft5 = (Tq * i0 * Ig[4] * nt) / r  # Ft 计算公式

ua1 = (0.377 * r * n) / (Ig[0] * i0)  # Ua 计算公式
ua2 = (0.377 * r * n) / (Ig[1] * i0)  # Ua 计算公式
ua3 = (0.377 * r * n) / (Ig[2] * i0)  # Ua 计算公式
ua4 = (0.377 * r * n) / (Ig[3] * i0)  # Ua 计算公式
ua5 = (0.377 * r * n) / (Ig[4] * i0)  # Ua 计算公式
p1 = 1 + ((2 * Iw1 + 2 * Iw2) / (m * r * r)) + (If * i0 * i0 * Ig[0] * Ig[0] * nt) / (m * r * r)
p2 = 1 + ((2 * Iw1 + 2 * Iw2) / (m * r * r)) + (If * i0 * i0 * Ig[1] * Ig[1] * nt) / (m * r * r)
p3 = 1 + ((2 * Iw1 + 2 * Iw2) / (m * r * r)) + (If * i0 * i0 * Ig[2] * Ig[2] * nt) / (m * r * r)
p4 = 1 + ((2 * Iw1 + 2 * Iw2) / (m * r * r)) + (If * i0 * i0 * Ig[3] * Ig[3] * nt) / (m * r * r)
p5 = 1 + ((2 * Iw1 + 2 * Iw2) / (m * r * r)) + (If * i0 * i0 * Ig[4] * Ig[4] * nt) / (m * r * r)
Fw1 = CDA * ua1 ** 2 / 21.15
Fw2 = CDA * ua2 ** 2 / 21.15
Fw3 = CDA * ua3 ** 2 / 21.15
Fw4 = CDA * ua4 ** 2 / 21.15
Fw5 = CDA * ua5 ** 2 / 21.15

Ff = m * 9.8 * f

at1 = (p1 * m)/(Ft1 - (Fw1+Ff))
at2 = (p2 * m)/(Ft2 - (Fw2+Ff))
at3 = (p3 * m)/(Ft3 - (Fw3+Ff))
at4 = (p4 * m)/(Ft4 - (Fw4+Ff))
at5 = (p5 * m)/(Ft5 - (Fw5+Ff))


k1 = np.where(abs(at2-at1) < 5)  # 可变化值理解其取值范围<5,<2
k2 = np.where(abs(at3-at2) < 2)
k3 = np.where((at4-at3) < 1.5)
k4 = np.where((at5-at4) < 1)
ua11 = ua1[k1]
ua22 = ua2[k2]
ua33 = ua3[k3]
ua44 = ua4[k4]

l1 = ua11.tolist()
l2 = ua22.tolist()
l3 = ua33.tolist()
l4 = ua44.tolist()
print(ua22)
print(ua11)

plt.plot(ua1,at1,ua2,at2,ua3,at3)
plt.show()

运行结果：

其中最大值即为换挡点对应的车速，将这些值赋到umax重新计算即可。转速区间精度不同结果可能有略微差异

在Python的NumPy库中，

numpy.where 是一个用于根据条件选择数组元素的函数。它的一些基本用法如下：

import numpy as np

# 创建一个numpy数组
arr = np.array([1, 2, 3, 4, 5])

# 定义一个条件，例如：选择大于3的元素
condition = arr > 3

# 使用numpy.where根据条件选择元素
result = np.where(condition, arr, -1)

print(result)

# [-1 -1 -1  4  5]

在这个例子中，我们首先创建了一个numpy数组 `arr`，然后定义了一个条件 `condition`，表示选择大于3的元素。接着，我们使用 `numpy.where` 函数根据条件选择元素，如果满足条件（即元素大于3），则保留原值，否则替换为-1。

也可以查找到条件值

import numpy as np

# 创建一个numpy数组
arr = np.array([1, 2, 3, 4, 5])

# 定义一个条件，例如：选择大于3的元素
condition = arr > 3

# 使用numpy.where根据条件选择元素
result = np.where(condition)
k = arr[result]  # 在arr中符合条件值

print(k)
# 输出  [4 5]