列车多质点纵向动力学方程数值求解（C#）

最新推荐文章于 2024-07-25 00:09:37 发布
最新推荐文章于 2024-07-25 00:09:37 发布
阅读量376 收藏 4
点赞数 10
文章标签： c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42552806/article/details/136235630
版权
本文介绍了一位作者使用C#编程语言，基于简单的动力学方程，对HXD单机和C70型货车54辆编组进行列车运行模拟的过程，主要展示了如何在WinForm中实现列车位置、速度和力的计算，旨在学习和验证列车纵向动力学模型。
摘要由CSDN通过智能技术生成 
  **

前言

铁路设计院行车专业时长借助牵引电算软件进行列车运行模拟，出于兴趣，本文对多质点列车纵向动力学模型求解过程进行了分析。知网上搜了好多文章，看的不太懂，大多数都是采用Newmark或其它高级方法进行仿真。此文采用简单的动力学方程，以HXD单机，C70型货车54辆编组进行验证学习，纯C#代码实现，没有Matlab或其它仿真软件辅助。内容简单，期待有该方面大佬深入指点一二。模型及仿真按钮图片如下：案例纵断面情况图纵向动力学模型

补充说明

以下代码在WinForm窗体运行，需要两个控件，Button与ListBox，代码较简单，先读懂再修改运行。

代码

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace TractionCalculation
{
    public partial class TrainDynamicsSolver : Form
    {
        public TrainDynamicsSolver()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            TrainDynamicsSolver solver = new TrainDynamicsSolver();
            solver.TimeStep = 0.0000008;
            solver.TotalTime = 0.08*2+0.03;
            solver.TrainLength = 55;
            solver.Mass = new double[(int)solver.TrainLength];
            solver.Position = new double[(int)solver.TrainLength];
            solver.Velocity = new double[(int)solver.TrainLength];
            solver.Force= new double[(int)solver.TrainLength];
            solver.couplingForce = new double[(int)solver.TrainLength];

            for (int i = 0; i < solver.TrainLength; i++)
            {
                if (i < solver.TrainLength - 1)
                {
                    solver.Mass[i] = 94;
                    solver.Position[i] = i * (14 + 14) / 2;
                }
                else
                {
                    solver.Mass[i] = 150;
                    solver.Position[i] = 1.0*(14 + 23) / 2 + (solver.TrainLength - 2) * (14 + 14) / 2.0;
                }
                solver.Velocity[i] = 0;
                if (i == solver.TrainLength - 1)
                {
                    solver.Force[i] = solver.GetTractionForce(solver.Velocity[i]);
                }
                else
                {
                    solver.Force[i] = 0;
                }
            }

            solver.Solve();

            // 输出结果
            listBox1.Items.Add("迭代完成！！！");
            //for (int i = solver.Mass.Length-1; i > -1; i--)
            //{
            //    listBox1.Items.Add("车辆：" + ((solver.Mass.Length - 1) - i)+"    "+"位置："+ solver.Position[i] + "    " +"速度："+ solver.Velocity[i]);
            //}
            //for (int i = solver.Mass.Length - 1; i >0; i--)
            //{
            //    listBox1.Items.Add("第"+ ((solver.Mass.Length - 1) - i) + "与"+ ((solver.Mass.Length - 1) - i+1) + "辆车"+"   位置差：" + (solver.Position[i]- solver.Position[i-1]) + "    " + "速度差：" + (solver.Velocity[i]- solver.Velocity[i-1]));
            //}
        }



        public double TimeStep { get; set; } // 时间步长
        public double TotalTime { get; set; } // 总时间
        public double TrainLength { get; set; } // 列车长度
        public double[] Mass { get; set; } // 各质点质量，以数组形式存储
        public double[] Position { get; set; } // 各质点位置，以数组形式存储
        public double[] Velocity { get; set; } // 各质点速度，以数组形式存储
        public double[] Force { get; set; }//各质点合力，以数组形式存储
        public double[] couplingForce { get; set; }//车钩力
        //public double a = 0.001;//位移限制数
        public double thetaValue=12;//坡度值
        public double lengthValue=2.6;//坡度长


        public void Solve()
        {
            int numParticles = Mass.Length; // 质点个数
            int numSteps = (int)(TotalTime / TimeStep); // 总步数
            StringBuilder[] str = new StringBuilder[Mass.Length];//输出结果
            for (int i = 0; i < str.Length; i++)
            {
                str[i] = new StringBuilder();
            }
            for (int i = 0; i < numSteps; i++)
            {
                double[] acceleration = CalculateAcceleration(Position, Velocity, Force,couplingForce); // 计算加速度
                for (int j = 0; j < numParticles; j++)
                {
                    Velocity[j] += acceleration[j] * TimeStep * 3600 * 3.6; // 更新速度
                    Position[j] += (1.0*Velocity[j] / 3.6) * (TimeStep*3600)+ acceleration[j] * (TimeStep*3600) * (TimeStep*3600) * 0.5; // 更新位置
                }

                // 存储结果
                if (i % 475 == 0)
                {
                    for (int j = Mass.Length - 1; j > -1; j--)
                    {
                        if (j > 0)
                        {
                            str[j].AppendLine("车辆：" + j + "    " + "位置：" + Position[j] + "    " + "速度：" + Velocity[j] + "    " + "车钩力：" + couplingForce[j] +
                              "    " + "位置差" + (Position[j] - Position[j - 1]) + "    " + "速度差：" + (Velocity[j] - Velocity[j - 1]));
                        }
                        else
                        {
                            str[j].AppendLine("车辆：" + j + "    " + "位置：" + Position[j] + "    " + "速度：" + Velocity[j] + "    " + "车钩力：" + couplingForce[j]);
                        }
                    }
                }
            }
            for (int i = 0; i < str.Length; i++)
            {
                //WritetoTxt(i.ToString(),str[i].ToString(), @"C:\Users\Administrator\Desktop\迭代结果\");
            }
        }

        /// <summary>
        /// 计算加速度
        /// </summary>
        /// <param name="position">位置数组</param>
        /// <param name="velocity">速度数组</param>
        /// <param name="force">合外力数组</param>
        /// <returns>加速度数组</returns>
        private double[] CalculateAcceleration(double[] position, double[] velocity, double[] netForce,double[] couplingForce)
        {
            int numParticles = position.Length;
            double[] acceleration = new double[numParticles];

            // 计算每个质点的加速度
            for (int i = 0; i < numParticles; i++)
            {
                double relativeVelocity, relativeDistance;
                if (i == 0) // 第一个质点
                {
                    relativeVelocity = (velocity[i + 1] - velocity[i])/3.6;
                    relativeDistance = position[i + 1] - position[i] - (14 + 14) / 2.0;
                    //if(relativeDistance>a)
                    //{
                    //    position[i]= position[i + 1] - a - (14 + 14) / 2;
                    //    relativeDistance = position[i + 1] - position[i] - (14 + 14) / 2;
                    //}
                    if (velocity[i] != 0)
                    {
                        if (position[i] > 2.5*1000 && position[i] < (2.5 + lengthValue)*1000)
                        {
                            couplingForce[i] = GetCouplingForce(relativeVelocity, relativeDistance);
                            netForce[i] = couplingForce[i] - GetBasicResistanceForce(i, velocity[i]) -
                            GetAdditionalResistanceForce(i, thetaValue, 0, double.MaxValue);
                        }
                        else
                        {
                            couplingForce[i] = GetCouplingForce(relativeVelocity, relativeDistance);
                            netForce[i] = couplingForce[i] - GetBasicResistanceForce(i, velocity[i]) -
                            GetAdditionalResistanceForce(i, 0, 0, double.MaxValue);
                        }
                    }
                    else
                    {
                        couplingForce[i] = GetCouplingForce(relativeVelocity, relativeDistance);
                        netForce[i] = couplingForce[i];
                    }
                        
                }
                else if (i == numParticles - 1) // 最后一个质点
                {
                    relativeVelocity = (velocity[i] - velocity[i - 1])/3.6;
                    relativeDistance = position[i] - position[i - 1] - (23 + 14) /2.0;
                    //if (relativeDistance > a)
                    //{
                    //    position[i] = position[i - 1] + a + (23 + 14) / 2;
                    //    relativeDistance = position[i] - position[i - 1] - (23 + 14) / 2;
                    //}
                    if (velocity[i] != 0)
                    {
                        if (position[i] > 2.5 * 1000 && position[i] < (2.5 + lengthValue) * 1000)
                        {
                            couplingForce[i] = GetCouplingForce(relativeVelocity, relativeDistance);
                            netForce[i] = GetTractionForce(velocity[i]) - couplingForce[i] - GetBasicResistanceForce(i, velocity[i]) -
                           GetAdditionalResistanceForce(i, thetaValue, 0, double.MaxValue);
                        }
                        else
                        {
                            couplingForce[i] = GetCouplingForce(relativeVelocity, relativeDistance);
                            netForce[i] = GetTractionForce(velocity[i]) - couplingForce[i] - GetBasicResistanceForce(i, velocity[i]) -
                          GetAdditionalResistanceForce(i, 0, 0, double.MaxValue);
                        }
                    }
                    else
                    {
                        couplingForce[i] = GetCouplingForce(relativeVelocity, relativeDistance);
                        netForce[i] = GetTractionForce(velocity[i]) - couplingForce[i];
                    }
                }
                else // 中间质点
                {
                    double relativeVelocity1;
                    double relativeDistance1;
                    relativeVelocity = (velocity[i] - velocity[i - 1])/3.6;
                    relativeVelocity1 = (velocity[i + 1] - velocity[i])/3.6;
                    relativeDistance = position[i] - position[i - 1] - (14 + 14) / 2;
                    //if (relativeDistance > a)
                    //{
                    //    position[i] = position[i - 1] + a + (14 + 14) / 2;
                    //    relativeDistance = position[i] - position[i - 1] - (14 + 14) / 2;
                    //}
                    if (i == numParticles - 2)
                    {
                        relativeDistance1 = position[i + 1] - position[i] - (23 + 14) / 2.0;
                        //if (relativeDistance1 > a)
                        //{
                        //    position[i] = position[i + 1] - a - (14 + 14) / 2;
                        //    relativeDistance1 = position[i + 1] - position[i] - (23 + 14) / 2;
                        //}
                    }
                    else
                    {
                        relativeDistance1 = position[i + 1] - position[i] - (14 + 14) / 2;
                        //if (relativeDistance1 > a)
                        //{
                        //    position[i] = position[i + 1] - a - (14 + 14) / 2;
                        //    relativeDistance1 = position[i + 1] - position[i] - (14 + 14) / 2;
                        //}
                    }
                    if (velocity[i] != 0)
                    {
                        if (position[i] > 2.5 * 1000 && position[i] < (2.5 + lengthValue) * 1000)
                        {
                            couplingForce[i+1] = GetCouplingForce(relativeVelocity1, relativeDistance1);
                            couplingForce[i] = GetCouplingForce(relativeVelocity, relativeDistance);
                            netForce[i] = couplingForce[i + 1] - couplingForce[i]
                            - GetBasicResistanceForce(i, velocity[i]) - GetAdditionalResistanceForce(i, thetaValue, 0, double.MaxValue);
                        }
                        else
                        {
                            couplingForce[i + 1] = GetCouplingForce(relativeVelocity1, relativeDistance1);
                            couplingForce[i] = GetCouplingForce(relativeVelocity, relativeDistance);
                            netForce[i] = couplingForce[i + 1] - couplingForce[i]
                           - GetBasicResistanceForce(i, velocity[i]) - GetAdditionalResistanceForce(i, 0, 0, double.MaxValue);
                        }
                    }
                    else
                    {
                        couplingForce[i + 1] = GetCouplingForce(relativeVelocity1, relativeDistance1);
                        couplingForce[i] = GetCouplingForce(relativeVelocity, relativeDistance);
                        netForce[i] = couplingForce[i + 1] - couplingForce[i];
                    }
                }
                acceleration[i] = netForce[i] / Mass[i];
            }
            return acceleration;
        }

        /// <summary>
        /// 获取车钩力
        /// </summary>
        /// <param name="relativeVelocity">相对速度</param>
        /// <param name="relativeDistance">相对位移</param>
        /// <returns>车钩力</returns>
        private double GetCouplingForce(double relativeVelocity, double relativeDistance)
        {
            double k = 20000;//单位：KN/m
            double d = 5000;//单位：KN/(m/s)
            return k * relativeDistance + d * relativeVelocity;
        }

        /// <summary>
        /// 获取机车牵引力
        /// </summary>
        /// <param name="speed">机车速度值</param>
        /// <returns>机车牵引力</returns>
        private double GetTractionForce(double speed)
        {
            if (speed < 10)
                speed = 10;
            return 288.2 + 99.29 * Math.Cos(0.02518 * speed) + 74.99 * Math.Sin(0.02518 * speed) +
                25.03 * Math.Cos(0.05036 * speed) - 12.82 * Math.Sin(0.05036 * speed) + 7.143 * Math.Cos(0.07554 * speed) -
                12.57 * Math.Sin(0.07554 * speed);
        }

        /// <summary>
        /// 获取基本阻力
        /// </summary>
        /// <param name="i">第i个质点</param>
        /// <param name="speed">速度</param>
        /// <returns>基本阻力</returns>
        private double GetBasicResistanceForce(int i, double speed)
        {
            if (i == Mass.Length - 1)//机车基本阻力
            {
                return (1.48 + 0.0018 * speed - 0.0003 * speed * speed) * Mass[i] * 9.8 / 1000;
            }
            else//车辆机车阻力
            {
                return (1.48 + 0.0018 * speed - 0.0003 * speed * speed) * Mass[i] * 9.8 / 1000;
            }
        }

        /// <summary>
        /// 获取附加阻力
        /// </summary>
        /// <param name="i">第i个质点</param>
        /// <param name="theta">坡道附加单位阻力</param>
        /// <param name="ls">隧道附加单位阻力</param>
        /// <param name="r">曲线附加单位阻力</param>
        /// <returns>附加阻力</returns>
        private double GetAdditionalResistanceForce(int i, double theta, double ls, double r)
        {
            return (theta + 0.00013 * ls + 600.0 / r) * Mass[i] * 9.8 / 1000;
        }

        /// <summary>
        /// 获取空气制动力
        /// </summary>
        /// <returns></returns>
        private double GetAirBrakeForce()
        {
            return 0;
        }

        /// <summary>
        /// 获取动力制动力
        /// </summary>
        /// <returns></returns>
        private double GetDynamicBrakeForce()
        {
            return 0;
        }

        /// <summary>
        /// 写入文本
        /// </summary>
        /// <param name="i">车辆序号</param>
        /// <param name="strContext">文本内容</param>
        /// <param name="strPath">文本路径</param>
        private void WritetoTxt(string i,string strContext,string strPath)
        {
            DirectoryInfo theFolder = new DirectoryInfo(strPath);
            if (theFolder.Exists)
            {
            }
            else
            {
                Directory.CreateDirectory(strPath);
            }
            using (FileStream fs = new FileStream(strPath +i.ToString()+ ".txt", FileMode.Append, FileAccess.Write, FileShare.Delete | FileShare.ReadWrite))
            {
                byte[] data = Encoding.UTF8.GetBytes(strContext);
                fs.Write(data, 0, data.Length);
                fs.Flush();
                fs.Close();
            }
        }
    }
}
CsharpZYH
关注
  • 10
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
列车控制matlab仿真,基于matlab的列车纵向碰撞建模仿真研究
weixin_39536806的博客
03-18 1269
与碰撞试验比较,碰撞仿真能够大量地减少成本,如时间、经济等。列车纵向碰撞动力学主要分析列车在纵向冲击力作用下的各种动态响应,既需要保证仿真模拟的准确性,又能快速建立列车动力学模型。Pugi[1]等建立了某货运列车纵向动力学模型,实现快速分析列车的编组、制动系统等因素对列车纵向冲击的的影响;Ansari[2]等对纵向动力学模型中的非线性模型的参数进行了研究,分析了空车位置对整列车纵向碰撞的影响,并着...
多质点高速列车运行动力学模型
wq6qeg88的博客
06-14 658
高速列车的速度控制是一类需要同时满足安全、准点、节能与舒适度的多目标优化问题，其控制实现过程是以运行速度曲线规划为基础的. 论文：面向节能的高速列车速度自动控制优化方法研究...
高速列车纵向动力学模型时变参数在线辨识方法
08-07
针对高速列车纵向动力学特性,分析了牵引力、制动力、阻力与速度和加速度的关系;考虑了天气和线路对高速列车运行状态造成的随机干扰,以及机械磨损和运行环境对列车模型结构参数造成的随机影响,建立了噪声干扰下的高速列车纵向动力学参数化状态空间模型,利用期望极大化准则,计算了列车模型参数的条件数学期望,并结合粒子滤波理论估计了参数粒子下的列车状态;基于贝叶斯后验概率理论,建立了高速列车非线性动力学模型的时变参数辨识方法,估计了列车的实时状态,并在噪声与参数分布均属于高斯分布、噪声属于高斯分布与参数属于指数分布、噪声属于伽玛分布与参数属于高斯分布的3种工况下,进行了蒙特卡洛仿真试验。仿真结果表明:在3种工况下,高速列车位移和速度的估计值与真实值的相对误差小于5%,列车模型参数估计值与真实值的相对误差小于10%,满足实际系统需求,因此,在高斯或伽玛噪声的干扰下,针对给定概率分布的时变参数,本方法均能实现系统状态的估计和模型参数的辨识。
多质点列车动力学模型
qq_36744350的博客
04-26 3155
铁路运输是我国最重要的交通运输方式之一，担负着国民经济和社会发展的重要任务。货物运输作为铁路运输的主要组成部分，在运输过程中既要保证行车安全，又要准点和低能耗运行。
质点动力学的基本方程
Debug的魔法小马的Debug博客
08-18 964
动力学基本定律 其实就是牛顿三定律： 惯性定律：保持原有状态的性质 力与加速度定律：力是动量的微分（力，质量，加速度三者关系） 作用力与反作用力：等大反向，对于任何参考系都成立 补充： 1N（牛顿） = 105dyn（达因） 三定律只在惯性参考系中完全成立。一般问题，选取地面或与地面相对做匀速直线运动的物体为惯性参考系。 运动微分方程 三种形式： 根本：md2rdt2=∑Fim\frac{\mathrm{d^2}\textbf{r}}{\mathrm{d}t^2}=\sum{\textbf{Fi}}m
质点系的牛顿-欧拉动力学方程
roogong的博客
10-10 670
经典力学是充分利用了欧式几何的公理化方法来构建我们的知识体系。了解什么是公理化方法。知识的公理化可以帮助我们记住和理解繁多的知识。思考：这些概念中，哪些是最基本的，也就是不能用其他概念来定义的？哪些又是用基本概念和法则定义出的扩展的概念？
刚体动力学-牛顿欧拉方程（刚体旋转）
subtitle_的博客
10-14 4644
刚体动力学-牛顿欧拉方程（刚体旋转）
matlab求解动力学,用MATLAB求解机械动力学问题，急！！！
weixin_35382961的博客
03-20 1209
由于要急交作业，所以到网上来求救，题目如下：某一机械的等效主动力矩为Md=5500-1000w (N•m)，等效阻力矩Mr (N•m)和等效转动惯量J (kg•m2)均为位置t 的函数，其数值列于下表中，试研究系统的动力学方程，并作如下过程的详细计算及分析(2)用计算程序计算启动过程(初始条件为t=0，x=0 )到稳态过程的运动规律。要求：1)列出所用计算机语言(如Matlab)的源程序；2)画出...
matlab仿真动力学方程的几种方法，总结，以范德波振子为例
Kp0fS的草稿纸
05-12 3813
1、 直接写方程 diff(y, 2) == k*(1 - y^2)*diff(y) - y，借助 odeToVectorField 和matlabFunction 和ode45函数求解。优点是，构造的方程非常直接； syms y(t); [V] = odeToVectorField(diff(y, 2) == k*(1 - y^2)*diff(y) - y);%把高阶变成一阶； M = matlabFunction(V,'vars', {'t','Y'}); [t, y] = ode45(M,[0 3
Matlab在求解质点动力学问题中的应用.pdf
10-31
Matlab是进行数值计算和数据分析的强大工具，能够对质点动力学问题进行求解和分析。论文首先介绍了质点动力学问题中的两类典型问题，即力是位置的函数和力是速度的函数的质点微分方程。然后，论文使用Matlab对这两类...
机器人动力学方程（一）：牛顿-欧拉法
05-17
一旦得到了所有关节的动力学方程，就可以组合成一个大的代数方程组，通常用数值求解方法（如雅可比迭代法、牛顿-拉弗森法）求解，以获得关节的加速度，进而计算出速度和位置。 5. 实际应用： 牛顿-欧拉法在机器人...
经典质点动力学方程的形式探讨
02-02
经典质点动力学方程的形式探讨，陈驰一，，本文根据因果一致原理的要求，重新构建了质点动力学的形式体系，得到了新的质点动力学方程。在其导出过程中引入的一个最自然最简
质点动力学的基本方程.ppt
01-05
总的来说，质点动力学的基本方程是描述物理系统动态行为的关键工具，它们不仅包含了牛顿的三大定律，还涉及到微分方程的求解技巧，以及对物理现象的深刻理解。通过这些方程，我们可以分析和预测各种物理系统的行为，...
质点动力学的基本方程.zip
11-05
在"质点动力学的基本方程.zip"压缩包中，包含了一个名为"质点动力学的基本方程.ppt"的文件，我们可以期待它详细阐述了质点动力学的基本概念和方程。 牛顿的第一定律，也被称为惯性定律，指出如果没有外力作用，一个...
leetcode位运算(1684. 统计一致字符串的数目)
磐门的博客
07-21 568
经过前期的基础训练以及部分实战练习，粗略掌握了各种题型的解题思路。后续开始专项练习。
C# 基础语法（一篇包学会的）
liyankang的博客
07-21 1169
史上最全C#基础，包会的，3.5W字，贯穿整个C#的基础语法。并且每个知识点都包含有例子来解读哦。
C# 设计模式分类
語衣的个人博客
07-23 799
创建型模式主要关注对象的创建过程，包括如何实例化对象，并隐藏实例化的细节。结构型模式主要关注类和对象的组合，以形成更大的结构。行为型模式主要关注对象之间的通信和职责分配。
c# 使用DiffPlex 1.7.2进行内容对比实例
最新发布
badaaasss的专栏
07-25 268
c# 使用DiffPlex 1.7.2进行内容对比实例
根据质点弹道模型运动方程，动力学方程以及欧拉动力学方程建立质点弹道
05-29
质点弹道是指质点在空气中运动的轨迹，其受到空气阻力和重力的影响。根据运动学和动力学的基本原理，可以建立质点在空气中的运动方程，以描述其运动轨迹。假设质点的初始位置为 $(x_0,y_0,z_0)$，初始速度为 $(v_{x0},v_{y0},v_{z0})$，则质点在空气中的运动方程可以表示为： $$ \begin{aligned} x(t) &= x_0 + v_{x0}t \\ y(t) &= y_0 + v_{y0}t \\ z(t) &= z_0 + v_{z0}t - \frac{1}{2}gt^2 \\ \end{aligned} $$ 其中 $g$ 是重力加速度，$t$ 是时间。这个模型假设空气阻力对质点运动的影响可以忽略。在实际情况中，空气阻力是不可忽略的，因此需要考虑空气阻力对质点的影响。 考虑空气阻力对质点运动的影响，可以将动力学方程和欧拉动力学方程应用于质点的运动。动力学方程描述了质点运动时所受的力以及加速度之间的关系，欧拉动力学方程则描述了质点的运动状态以及其变化过程。根据动力学方程和欧拉动力学方程，可以得到质点在空气中的运动方程： $$ \begin{aligned} \frac{dx}{dt} &= v_x \\ \frac{dy}{dt} &= v_y \\ \frac{dv_x}{dt} &= -\frac{1}{2} \rho C_d A v_x^2 \frac{1}{m} \\ \frac{dv_y}{dt} &= -\frac{1}{2} \rho C_d A v_y^2 \frac{1}{m} \\ \frac{dz}{dt} &= v_z \\ \frac{dv_z}{dt} &= -g - \frac{1}{2} \rho C_d A v_z^2 \frac{1}{m} \\ \end{aligned} $$ 其中，$\rho$ 是空气密度，$C_d$ 是阻力系数，$A$ 是物体的参考面积，$m$ 是物体的质量。这个模型中，假设空气阻力的大小与速度的平方成正比，与速度的方向相反。 通过求解上述运动方程，可以得到质点在空气中的运动轨迹。需要注意的是，这个模型中假设空气阻力对质点运动的影响是恒定的，而实际情况中空气阻力也受到其他因素的影响，因此模型的精度可能会受到一定的影响。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值