GAMES 图形学系列笔记（四十九）

GAMES401-泛动引擎(PeriDyno)物理仿真编程与实践 - P1：1. 物理仿真及PeriDyno开源引擎架构简介 - GAMES-Webinar - BV15M4y1U76M

行那这样吧。

我们开始吧，今天晚上那个呃晚了几分钟啊，那个不好意思，这样因为那个这个系列是这样的，应该是四开头的，然后主要还是注重就是开发为主，说这样的话就是我们会设计设计一些，就是说编程实践啊。

然后呢可能跟前面几个系列可能稍微的差别，就是主要还是注重实践，就是当理论会穿插在里边，我们会去讲，就是因为这401的话主要还是讲物理仿真，然后因为前班的话，实际上包括那个啊黄梅老师啊，以及那个胡阳明。

也就应该都讲了一些基础理论了，所以这样的话就这期课的话，我们不会嗯展开讲那么多的，那个就是仿真相关的技术理论知识，然后呢实际上就是还是以实践为主，将的话就在实践里边穿插着。

就是我们需要掌握的一些相关的一些知识，然后会会呃融到里头了，所以这样的话实际上就是理论跟实践，实际上是一个相互交叉的这么一个一个过程啊，所以这里边因为现在之前，我们相当于也是有一个自研的这么一个系统。

所以整个那是呃，会以我们自研的一个系统为基础，然后去讲就怎么就是说去啊，当然就是说你如果没完成以前，完全不这个没有怎么接触过，其实也没有关系啊，就是这样的话，就是从第一课开始，我们可以逐步的去看。

就是说怎么去把这个系统搭起来，然后后面逐步去研发一个，比如说具体的一个访问算法，然后整个大纲都是这样的，就是呃诶这是第一次是吧，哦这个我可能那个啥了，这个位置调错了，就是呃整个安排的是这样的。

就是一共是有13讲，然后呢是这样，就是前八讲是我来讲，然后后面呢有五讲，是那个湖南大学的那个蔡文老师，然后这个课程是这样，我说一下为什么这么设计啊，就是因为其实我们知道就是仿真这个东西啊。

虽然我们现在做的就是，咱们是就相当于这个方向的图形这个方向，但是呢实际上仿真这个就是，从常就是从大的范畴来讲的话，实际上在工程领域应该是用的非常的多，然后呢其实这个发展历史也很悠久啊。

其实其实如果从理论上来讲，你可能几百年前就已经就各种流体力学啊等等，这些力学理论都已经逐步的成熟，然后呢相当于当然后面是计算机出现之后呢，逐渐出现了数字模拟，所以这样的话就是呃这个课程整个会结合。

就图形这边的物理仿真跟工程领域的物理仿真，然后呢，因为其实我们发现就是很多东西呢，就工程的仿真跟物理就是图形里边做的仿真啊，就是当然图形里边，主要还是以视觉摄效果为主啊。

然后当然跟工程里面可能有一定的差别，但这个主要也是因为体现在，就是说你整个计算资源不足的情况下，像我们这样，往每一头可能会有稍微有一点的一个偏倾斜，但是最终的话实际上我们实际上呃。

一个理想的情况肯定是这样，就是工程仿真，跟这个我们所谓的一个同学学里做的，一个视觉仿真，这样的话应该是能最终能融合到一起，就是说我们既希望是，既能达到工程网的那个精度。

同时呢又能达达到这个呃图形里的视觉，仿真的一个一个效果，所以这样的话就是最理想的一个状态，所以这里边整个就是图形仿真，就是图形领域的仿真，我来讲的呢主要是八节课，然后第一个呢主要是讲可用物理仿真。

就咱们这个开源的那个引擎的一个一个，引擎架构的一个简介，然后呢另外主要就是呃因为我们知道，反正那个计算整个他的那个计算量非常的大，所以呢这样的话整个会议呃，gpu以及扩大编程为基础。

然后呢讲如何就是利用一些并行的一个计算，然后来加速整个呃法律计算的过程，然后当然这个估计就是整个呃，这里边会包含涉及到，就是说一些建图形学里面常用的，就是这几何工具啊，包括数学原理啊等等，就这些。

然后当然后面三次，主要是针对具体的一个防御算法，就是第四讲，主要是这样刚体动力学相关的，就包括并行编程啊，以及一些实践的一些呃算法，然后当第五讲主要是讲s p h，就是呃光滑粒子动力学就这一块。

然后这一块的话，因为其实相对来说，就是其实sp相对来说比较简单的，如果一个简单算法，对于就是咱们新入门的那个同学的话，还是比较友好的，然后第六讲的话主要是结合，因为那个呃像我们自己一些研究的内容的话。

会讲金像动力学相关的一些内容，然后当然第七哦这个有个错别字啊，第七跟第八的话主要就是一些扩展的内容啊，然后呢因为这个系统呢其实除了算法之外呢，其实也相当于也最终的话是希望能把，就是说我们自研的算法。

然后最终将它组合起来，然后来做一些有意思的小的app，说这样的话主要会涉及一些插件啊，以及扩展功能，然后呢最后因为是这样，就是呃其实gpu编程的话不单纯枯打啊，就是他其实能用的呃，后端的语言其实非常多。

就是包括比如welcome open cl，或者是那个呃比如说h l s l等等啊，就这些实际上都有，所以呢这里边就第八讲，主要会稍微做一定的那个拓展，然后去讲啊瓦肯的那个编程。

以及其实这两个跟扩大挖坑不大，其实呃大的那个逻辑上其实会发现非常的像，但是呢实际上你具体做的时候啊，主要因为他们语言上的差异，会导致就是说你实际编程的时候，感觉这两个东西呃还是不太一样的。

然后后面几个主要是那个蔡文老师就讲的，就是呃从有限就是说通过讲有限元，然后来呃讲讲就是说基于这个开源的系统，怎么去做后面的一些应用啊，啊这个是整个整个课程的一个安排啊，然后呢就这一次的话，实际上就是呃。

因为主要是讲就大的一个一个呃大纲啦，然后这样的话主要是也可能安排，然后呢还有物理仿真的概述，然后以及物理仿真引擎的概述，然后当然因为是这样，就是咱们还是希望就是对于就是说。

不论是你现在已经掌握到什么程度了，所以就是比如说你现在完全不，这可能是一个小白的一个程度，这样的话其实也希望能这个课程能入门的，所以这样的话，有些东西我们讲的可能会，一开始就是讲的会比较细一些。

尤其比如一些工具的运用啊，也是也会设计一下，这样的话，因为我觉得，就主要对于这个新入门的同学来讲的话，可能大环境还是比较困难的，这样的话就是我把整个过程可以呃，在这次课里面会演示一下。

然后最后的话可能会讲，就我们这个系统的一个架构，然后当然还有一些仿张力的一个展示，然后呢这里有一个那个课程的一个呃，咱们的一个qq群，然后当然里边如果涉及到有一些具体的编程上，或者是其他的一些问题的话。

然后呢也也可以加入这个群，然后里边有几位我们的一个助教啊，然后有什么问题的话，也可以请助教，到时候那个请他帮忙，然后呢在嗯另外我说一下，就这个课，就是因为主要还是相当于基于一个开源的系统，来来讲，说。

这样的话就是里边可能会涉及到一些，就是说呃方方面面可循，需要的一些背景知识，所以我讲一下这个课呃适合的呃那个对象，然后首先是这样，就是因为我们这里边啊做仿真，大家如果以前如果有些了解过的。

可能会知道这个东西它涉及的东西非常的多，所以呢就是呃相当于这里边，就比如适合那种哪种同学来来做，就是说比如说他希望有一个能快速上手，这么一个科研平台，然后这样的话就是他比如说也不需要去搭建，太多的。

就是说跟法律没有相关不太相关的一些内容啊，然后第二个呢，就是因为本整个我们还是基于开源的，这么一个平台，所以里边有可能会有一些不太完善的东西，就是比如可能有很多bug呀或者啥的，那对于这种就是需要。

就是说可能对这个有问题的，有一个有一定的容忍度啊，就是就允许就比如你出现问题之后呢，你呃会有就是呃希望去怎么去解决啊，然后当然还有就是呃因为整个做仿真的领域啊，就是其实这个方向总的来说做的人其实不太多。

就做图形里边你相比人工智能的话，其实相对来说人还是比较少的，所以呢其实通过这些课程呢，也是希望比如有些同学可以找到，就是说跟我做的这个方向比较契合的，一些小伙伴，这样的话大家可以一起来做。

所以呢比较适合这样的一个一些同学来来学习，然后当然最后呃我想说一点，就是因为整个仿真的话，他对数学跟物理的这个基础的要求，还是比较比较高的，所以这样的话比较适合，就是说呃呃学术语基础比较好的。

然后同时呢因为整个还是因为是偏向图形呢，这样的话对于几何直观比较强的这个同学，来来学习这些课，然后那个我说一下，就是说啊，当然这个其实反之就是对那些不太适合的，就是呃实际上因为现在尤其搞深度学习的话。

很多人学的可能不是c或者c加加，然后对python的话可能比较了解，但是因为c和c加加整个它实际上是一边语言，所以他其实对于编程的一个那个能力，要求相对来说会高一些，所以呢就是说如果c跟c加加。

你以前没怎么学过的话，可能会呃觉得这个上节课或者包括后面的，如果有一些作业的话，你做起来的话非常的痛苦，所以这样的话其实可能会嗯对这个课程，可能不太适应，然后当第二个就是我刚才也讲了。

就是对于整个数学公式啊，就包括那个呃因为数数学要求还是蛮多的，所以这样的话你如果对于整个数学，比如你看就头疼的话，这样的话就是可能会比较难受，然后最后还有一个就是，因为整个我们还是一个开源平台。

这样的话里边还是说，就是有很多不太完美的地方，就是啊就是这里边如果想是去找一个成熟的，一个反对的解决方案的话，就是这个课其实也也不太适合，然后呢接下来我们就开始讲一下，就是呃整个呃我们开始我们这次课。

然后我先讲讲背景，就是物理仿真到底是一个什么东西啊，这是当然通过其实前面102，103以及201的话，如果学过的话，应该有一个初步的一个概念了，当然这里边我如果我们把这个东西，层次放的更大一点啊。

其实可以理解为，就是，因为比如说我们我们就看我们身边的这么一个，就比如我们这个地球啊，你其实可以看到，就是比如从这个图上可以看的话，它其实从最远古的，比如说那个早期的，比如说呃相当于那会儿。

因为早期的话实际上也不适合那些猪猪啊，所以最多的好像都有一些微生物或者啥的，其他一些低等的一个生物，然后你发现，就是随着这个整个地球的不断演变的话，其实上就是有一些逐渐就发展出了，一些高级的一个智能。

然后从比如说那个后来的恐龙时代，然后到现在我们就说这个呃，呃相当于这个人类的一个诞生，所以这里边实际上蕴含的应该是有两条的，一个主线，就是一个你会发现就是呃整个地球的环境，实际上是在不断的一个变迁。

所以这个呢实际上就是从哲学角度来讲，就是实际上可以理解为，相当于是我们的一个物质世界，相当于是在不断的一个变化，然后第二个呢，实际上在物质基那个世界基础之上呢，你可以发现就是啊这个就是智能的一个形成。

自动的形成的话，实际上是是物质世界基础之上，然后呢在受环境影响之后，然后逐步形成形成的一些智能，然后这里边当然就你发现不同的环境啊，这个孕育的那个智能形态实际上是不太一样的，比如这个水铝的。

你发现可能是这种鱼啊，或者这种这种生物，然后当然陆地的话是各种的多种的哺乳动物，然后包括人类啊等等，就这种，所以你发现这个呃如果从这个角度来讲，实际上就是我们的世界呢，就分为就是说物质世界以及精神世界。

这么这么两个就笼统讲啊，其实分为这么两个概念，所以呢就是这两个，就是说当我们从研究角度来讲呢，其实就分别针对的，我们就说是物理仿真以及人工智能，当人工智能前几年其实研究的非常的多啊。

所以然后实际上就是呃，但是整个人工智能赖以生存的一个基础，实际上是我们的一个呃物理仿真的一个，研究的一个对象，实际上就是我们周围的一个物质的一个环境，然后呢我们具体的我们再来看一下。

就是呃整个就是首先我们看看那个人工智能啊，到底在解决哪些问题，就是实际上是我们的精神世界里边的，一些一些内容，就比如说包括那个像运动啊啊痛觉，然后呢比如感啊感觉，然后语言理解听觉等等，视觉啊这些等等。

都是人工智能理解的这么一个，就研究的一个范畴，所以它整个解决的是我们精神世界里边，我们所考虑的一些东西，然后但是呢，实际上物理仿真更多的是研究什么呢，是实际上是研究的，我们赖以生存的这个一个。

客观的一个世界里边的一个一些内容，然后比如说像呃，比如说我们这个海洋和火焰汽车等等，这个实际上都是符合物理规律的，一些客观的一些存在，然后呢我们需要去研究它的那个物理规律，然后以及他的那个行为特征等等。

当然龙头讲这里边可以分为，比如是有流体，然后有钢铁，当然有柔性体啊，就大类的话，就在这个当然是图形那里边比较长的一个呃，常见的一个分类，当然如果工程里的话，这个非常分的会非常的一个细。

然后所以整个这个实际上都是一个物理仿真，要研究的一个范畴，相当于就是说我们用计算机去模拟，这个整个这种物理介质的一个一个力学行为，然后呢这里边我们再看看这个物理，法律到底是能干什么。

然后当然这里边呃我们这就是其实学图形的，很多，很多同学呢是这样的，最初因为很多其实喜欢玩游戏啊，所以呢通过玩游戏呢，反正觉得诶这个挺有意思，所以呢很多其实是从呃开始玩游戏，然后逐步的对图形有了一些概念。

然后呢当然最后再细分的话，就要图形里面可能有渲染，有仿真啊，或者有几何等等各个方向，那那我们这里边就来看看这个图形里边，这个物理仿真到底是能做什么呢，我们想象一下。

就这对于这个比如这个命运二这么一个游戏，里边，如果没有物理仿真的话，会出现一个什么样的一个场景啊，就是这里边实际上很简单，就是呃比如说玩过射击游戏，你呃你比如往前走的话，比如这里有堵墙。

那如果这里边你不用仿真对它做约束的话，这样的话你会发现，当然有很多职业就穿墙穿进去了，那这个就是对于很多玩家来说，哎呀就觉得这个游戏就可能太假了，那所以这样的话实际上物理仿真去模拟的。

应该是就是说把真实的一个力学行为，实际上赋予到了一个呃，虚拟的这么一个一个世界里边，所以比如这里边你在虚拟的世界里边，你这样跳一下之后呢，也不会说你一下就飞出，飞到了天上啊。

当然这个跟你的游戏设定其实是有关系的，然后实际上就相当于是把真实的物理的一些呃，属性，就赋予到了一个呃就是虚拟的一个世界里边，所以物理反正整个干的实际上就是就是他做的。

实际上就相当于是这么做这么一些内容，然后当然这里边游戏的话，实际上你是从一个呃上帝视角去看，就是说这个整个游戏，但反过来其实你可以想一下，如果打个比方啊，有一天呃你醒来之后呢，你发现如果是有人告诉你。

就是说你这个呃世界实际上可能并不是真实的，然后他也有可能你可以想想，有没有可能说咱们这个世界，实际上也是一种模拟出来的一个结果，因为这个呢实际上在中西方的科幻世界里边，其实科幻的包括电影啊。

里边其实出现的也非常多，然后包括今年那个三体的这个呃，那个呃电视剧啊，里边其实也反映了这么一种呃思维，就是说呃如果打个比方，就是说咱们可能是呃，有没有可能出现一种更高级的一个外星的生物，然后呢。

实际上整个地球那有可能是呃，外星更高级生物里的一个一个，测试的一个一个训练场，比如说我们可能就是里边的一个火机，那对于这样的一个情况，如果存在的话，那我们这里边需要解决的到底是哪些内容，那也就是说。

实际上相当于我们整个所所周围所处的环境，实际上可能就是一个模拟的一个结果，它呃它可能符合某种的物理规律，但是呢它实际上这个规律呢可能是在呃，相当于外就是外，就是外面的更高级生物里边的一个实验场里边。

模拟出来的一个结果，然后当然这里边你可你可以看一下，就是以前如果看过这个啊，黑客帝国的这个电影的话，它其实就是反映的这样的一种哲学思想，就是啊当然这个故事的一个背景。

其实发生在比如几百年之后或者几十年之后，我们的这个地球可能是出现各种各样的，就是呃原因啊，导致这个整个地球不适宜人类生存之后，然后呢整个机器他统治了这个世界，然后机器统治世界之后呢，相当于那这样的话。

整个人类它实际上就已经没有，它赖以生存的空间了，然后呢他在一个虚拟的世界里边，就是重新创造了一个人类，人类赖以生存的这么一个数据，就是虚拟世界，然后当然这样的话就是怎么能骗我。

就是说你呃对于这个里边生存的人来说，他让他相信，就是说你活在的，实际上是一个真实的一个世界里头，那这样的话就需要把整个就是除了，就是说你整个人人类的一些精神世界里边的，那个ai的这个东西模拟完了之后。

他实际上要再造一个，就是说跟真实世界一模一样的，这么一个物理的一个世界，所以这里边思想完全就需要通过物理，仿真的一些技术，需要把我们周围赖以生存的，比如说刚刚前面看到的山川河流啊，空气啊等等。

就这些行为，然后相当于需要在计算机里边去模拟出来，所以呢这里边实际上就是这么一个场景呢，就是当然这个是这部电影里边最后那个救世主，然后到到达，说白了就更外层的一个世界，里边看到的一个场景啊。

它实际上就是机器统治人类之后，就这么一个场景，然后它相当于你如果从用我们现代的一个技术，来去理解的话，其实你发现相当于他需要哪些东西呢，需要比如说可能需要大量的超级计算机。

然后呢以及就是说我们整个各种的算力，然后来把就是呃我们这个世界里面，涉及到的各种物理介质，然后相当于给它模拟出来，所以这样的话就实际上就是涉及到，当然这里可能扯的就比较有点比较远。

然后也就是说实际上就是，然后相当于就是说这样的话，就是如果我们需要再造，就是说的近一点，我们再造一个，比如说我们一个小的试验场景，实际上就需要各种各样的软件算法，以及呢硬件的一个设备。

然后呢去把这个场景给它整个搭起来，那我们再来我们看的细一点的话，实际上那整个这个过程的话，实际上就需要啊，因为前面讲的可能就是你各种各样的那个呃，力学的一个材质呢，实际上需要不同的算法去做。

那把这些所有的算法综合起来，然后呢在一个系统里边去给搭建起来，那就需要依赖什么东西呢，实际上就是需要依赖，依赖整个物理仿真引擎这么一个一个概念，那物理仿真引擎如果对于我们来说，就是离得比较近的啊。

它到底能来能用来做什么，就是首先第一个实际上就是呃打个比方，我们以前可能呃是可能是一个初学者，那这样的话实际上以前我可能啥技术都没有，那这样我可以呃如果想实践一个算法的话。

就是我实际上可能就不知道从哪入手，那这个时候如果有物理网络引擎的，可以为我们提供一个基础的一个交流，加的一个功能，那第二个呢，就是如果我比如说对于做仿真算法的一个同学。

然后他的研究的主方向可能是一个访问算法，那这样的话他如果不想去写，比如说跟渲染啊，ui或者导入导出等等相关的一些，就是说跟法律无关的一些事情啊，他如果不想做的话，那个物理仿真引擎的能干的事情。

就是可以为就是这样的一类群体可以帮他解决，比如说这个跟法律无关的一些基础的一些算法，然后当然还有一个就是，这个应该是大家深有感触的，就是如果后面做的比较多的话，打个比方，如果是审稿人的意见回来了。

就是很有可能会出现，就是说这个审稿人让你跟呃，其他的论文做一下对比，然后这个时候呢呃当然对于做研究人啊，这个东西非常的头疼啊，就是很多时候就会就会出现，就是说那这个我肯定大部分同学是不愿意做的。

那这个时候如果我这个仿真引擎里边，可能如果是已经集成了大量的，其他的那个算法的话，那这个时候就这个事情就很容易实现了，就是可以相当于你可以直接调用啊，其他的那个算法，然后呢做进行对比。

所以就是说仿真引擎这个能做什么事情呢，一个就是提供一个技术的一个，脚手架的一个功能，第二个呢就是实际上跟仿真无关的，这个功能模块，因为这样的话就是包括渲染ui以及导入等等，这些算法的话。

实际上就直接可以调用现成的模块去去完成，然后呢，最后的话当然最主要的也是因为法律算法，它会集成大量的，就是呃就是各种各样的一个算法，然后呢也就是说可以用，比如说我们需要应用的时候，或者做横向对比的时候。

不同功能的，包括它的效率啊，包括它的精度等等，需要做对比的时候呢，实际上可以调用不同的算法模块，然后去啊，辅助我们去做各种各样的一个对比实验，那通常也就这样，就是一个，那我们来看一下。

就是呃通常一个仿真引擎啊，它包含会包含哪些东西，就是呃当然这个图大家其实也不一定要，这会儿就需要去了解了，就是当时我主要简单过一下，然后呢有个大概的一个意识就行，因为这个架构图的话。

其实主要是为了相当于给里边的一些技术，模块和技术内容进行分类，然后呢使得它条理更清晰，所以这样的话通常来讲就是呃这个一个仿真图，可以，它比如像我以我们现在的那个啊，piano这个系统为例的话。

它会包含几个层次，就是首先最底层的话实际上是有一个硬件层，那这个实际上主要是跟比如cpu跟gpu，或者是跟那个数据存储啊，比如说我们的硬盘和内存打交道，这么这么一些api，然后在这个基础之上呢。

就会有各种各样的一个数据结构，比如说有包含数据库啊，然后包含图形接口以及碰撞检测算法，这些通用的啊这些算法，然后去用来支撑，就是说比如用上层的一些啊，比如仿真算法也好啊，或者是交互交互的一些算法。

或者是渲染的一些算法，当然这里面最核心的实际上就是，因为作为一个仿真物理物理仿真的引擎的话，最核心的实际上主要是不会包含各式各样的，这个呃仿真的一些核心算法，比如说像会有有有有限元的。

就是或者s p h的钢铁动力学的这样，动力等等啊，然后当然除此之外的话，就是为了因为我们这个整个研发的话，我们也不太可能说我们所有的都是呃，从基础开始学习，说这样的话，就是我们上层的话。

需要对这个所有的算法进行管理，然后这样的话就是在上层会包含比如场景管理，模块管理等等这些东西，然后以及一些ui，因为比如我们需要把这个研发的算法，然后通过一些可视化的手段，然后把它给啊展示出来。

所以整整体来说就那个架构图的话，包含不同的一个层次，但是这个跟游戏性情警情里边会包含内容，可能会稍微有一定的偏差，然后这里也是，因为就是说整个游戏引擎跟仿真引擎，它所面向的那个呃对象。

或者他整个研究的一个问题呃，有一定的差异，所带来的那个架架构上的一些不一样的地方，然后接下来就是我们来看一下，就是说嗯以这个系统为例的话，我们怎么就把从相当于从一开始，相当于就是从搭建场景。

然后呢到最后，然后把这个程序整个运行来到最后，比如我们怎么基于这个平台之后，相当于呃进一步的去研发一个新的算法，然后这个整个流程我们可以看一下怎么来做，所以这里边我把整个过程分为了三部。

就是因为当然这里边我们现在这个系统呢，实际上主要是啊windows和linux两个平台为主，然后当然是啊，有时候可能用的是mac系统的话，可能这样的话就有可能目前不太支持。

所以呢这里边我主要是以windows为例，来讲一下整个开源系统就怎么去搭建这个场景，然后呢每一部里边呢会依赖不同的一些工具，就是比如像构建阶段，主要是需要依赖这个d这个一个工具。

然后呢在配置阶段呢会依赖，比如c make以及呃view studio code，当然这个东西其实跟每个人，个人的偏好有关系啊，就是有些同学可能会用其他的一些一些工具，也完全也可以。

然后这里我只是以这个为例呢，就是把这个整个场景相当于去啊，整个可以串一下，所以这样的话就是嗯，至少就是说这个流程应该是以前，就是说我们应该是比较成熟的，就中间可能相对来说问题会比较少。

因为开源的系统通常来说还是稳定性方面，有些可能会没有那么稳定，这样的话就如果用一些新的工具的话，中间有可能会出现一些意想不到的一些问题，然后到最后整个开发的话。

我们目前推荐实际上是以比如studio为主啊，当然比如说用g4 z啊什么，其实应该也问题也不大，然后呢接下来我们看一下，就是说这个整个一个配置啊，因为这个我们现在整个所有的仿真的话，是需要依赖gpu。

当然整个房子算法实际上这样，就如果对于性能没有要求的话，其实完全用cpu，比如说我就用c加加写一些，那那个串行的代码其实也可以，但这里推荐的话，实际上是有一个显卡的这么一个电脑。

然后当然那个系统的话就是如果windows平台的话，是啊windows 10啊，我的windows 11，这应该都没问题，然后另外就是显卡的话，呃我讲一下这个东西，就是呃当然目前主流的。

比如说像最新的可能四零系列，但这个系列可能会比较贵啊，所以呢就是对于如果想买这个显卡的同学，可以找个几个系列，然后呢这样的话其它的性能力方面可以保障，同时呢，就是呃价格方面又相对于来说是可以接受的。

然后呢另外就是整个扩大，因为这个如果是有呃，英伟达的显卡为基础去开发的话，这里就需要一个依赖一个kda的这么一个sdk，啊clean的话呃，现在mn这是哪个clean c l i o n。

这是哪个平台吗，还是什么意思啊，因为目前的话我们这边实际上主要还是呃，就是我现在ppt列里列的那个，就包括我们当然有文档啊，上面会推荐的一些配置，然后呢呃以那个为主，然后当然其他的平台大家可以去试。

然后有问题的话，其实也可以反馈回来，然后我们可以到时候到我们住那边住假啊啥的，可以帮助你们可以去试一下，就是因为其他的这个平台，我们确实没有那么多精力啊，把所有的平台都去测一遍。

然后呢接下来我整个演示一下那个呃，就一步一步看看，就把这个系统啊怎么去搭起来，然后首先呢是这样，第一个就是需要用到的就是一个git，然后这个git主要是用来做一个版本的一个控制。

然后呢如果以前对这个大家对这个不了解的话，其实可能就没有一个概念，就是他其实主要能用来干哪些事情呢，就是实际上一个呢，就是相当于就因为你写代码的话，其实相当于包含不断的会去修改，比如说其中的某些代码。

所以这里边就需要有一个呃，你的修改记录的这么一个呃文件，所以呢实际上就是这个git，主要是会把你每次的修改，然后都给他记下来，然后呢万一比如打个比方，你在中间某一次出现错误的话，这样你可以去回退到。

比如说某就是以前的一个正确的一个版本，所以这个是他其实非常有用的一个地方，这样的话可以保证就是说呃，你实际上是不断的去迭代的，去把你的代码去向他最后去完善啊，然后还有一个就是主要是分支跟合并的。

这么一个功能，然后这个东西主要用来干嘛呢，就是啊这个如果是一个，你只有一个人开发一个系统，这个东西可能其实意义不大，但这个问题大概就是，我们现在面对的是一个大型的这个一个系统。

比如说是一个几十个人参与的，这么一个大型的一个呃软件，那这样的话，其实每个人可能他开发的，实际上就是里边的一个模块，然后这样的话就需要不同的人开发的一个扣的，就是去合并，然后去管理。

然后这样的话就需要用到git里边的分支，以及合并的一个功能，但是后面我会去可以具体去演示啊，到底怎么去操作这些内容啊，然后还有当然就是主要会是为了可追踪，就是你这样的话。

就是说也就是说你多人去开发的每一个节点，实际上都可以被记录下来，也就是中间比如如果某一个研发人员，他写了一个bug进来之后呢，那这样的话你就可以定位的啊，这里可能是谁写的bug。

然后呢去逐步的去把这个东西去定位出来，之后去修复，然后这里呢就给出了一个直观的一个示意图啊，就是d它到底是做一个什么样的一个事情，然后这里边上面那个黑色的条线啊，实际上是代表的一个主线。

就是相当于你一个系统研发的一个呃主版本，然后这个主版本呢你可以看到，就是说它有一些可以报一次，它其实会有一些黑色的那个那些点，那些点是什么意思呢，就代表了实际上就是你每一次的就提交。

比如说你当前做了一个备份，然后这个点就会记录下来，然后相当于代表了你当前的一个状态，就是你整个研发的一个状态啊，然后这个状态呢就是你每提交一次，它会记录一个节点，然后这个节点呢就会永久的记录下来。

如果打个比方，你出现到后面，你发现后面出现错误了，然后这样的话你可以直接回退到中间任意一个，就是你有记录的这么一个点，那这样的话就是你如果后面出现了问题的话，你回退到前面正确的一个呃节点之后。

然后可以把这个呃，相当于把那个节点的一个代码恢复出来，然后呢再逐步的去修复，就是后面出现的一些错误，然后当然这个过程中，如果比如说新的那个研发链参与进来之后呢，他就可以干什么呢。

就是可以从你的某个节点里边呃做一个分支，然后这个分支出来之后呢，你会发现它实际上整个研发过程是并行进行的，就是说你像这样的话，就是新的功能的研发，它实际上是并不会影响啊，主分支的这么一个研发的一个进度。

然后当然当然等它，比如说新的一个到某个节点之后，这个新的功能研发完了之后呢，那比如到这个五这个节点的话，那它相当于又可以和就是说主分支，然后合并到一起，然后呢就是这样的话。

这个新的研发的功能呢也会进入到主分支，然后逐步去往后进，再进一步的去迭代，所以你发现整个g的其实主要就是为了方便，就是说这个多人研发，然后协同管理的这么一个一个工具，然后它里面会包含很多的这个呃。

不同的这个命令，就是他其实主要是，但这个大家如果对这个有兴趣的，可以详细的，其实看下面有个链接啊，然后这里边会包含非常详细的一个讲解，然后这里边我主要讲一下，就是跟咱们这个系统相关的。

就是说怎么去构建这个系统相关的一些指令，就是首先最重要的是一个去打点，去搭建这个系统的时候，用到的就是这配置环境的时候，就初始化一个的一个，环境的时候用到的一个指令，就是呃当然这里包含两个。

一个是初始化，第二个是克隆，那初始化代表什么意思呢，就是你如果现在是，你相当于是第一次创建这个工程，那这样的话，你需要用到的实际上是一个初始化的一个指令，但是你大部分时候我们那我们也做研发的话。

一般可能会基于人家的一个开源代码，那这样的话实际上我们需要做的，实际上是把人家的这个仓克隆到本地，然后来来去进行进一步开发，所以这里边主要就是用克隆，比如说这个克隆，然后呢去把比如说我们这个现有的两个。

当然这里边我们包含了两个层啊，一个是github上，但是考虑到因为是这样，就是给他汉堡，好多同学可能就连不太上，就是他因为需要代理去啊去连，就是，所以这里边我们就额外的会有一个，马云上建了一个仓。

然后马云的仓的话效率还可以，然后另外这里边有个指令可能需要注意一下，就是如果直接用命令行的话，需要必须把这个recursive，这个指令必须得加进去，因为这里边会包含到里边会设计很多的子模块。

然后如果没有这个模块，那就这个recursive这个指令如果不加进的话，它里边儿子模块是没法克隆克隆下来的，说这样的话，就整个生成的时候会因为缺少子模块，然后导致他整个编译不过。

所以这里边可能有一个需要注意的，其实就这个地方，然后呢这个下来了之后呢，剩下的实际上就是在我们开发的过程中，可能就需要用到，就是说呃比如说像give them remote，就是添加远程仓。

然后呢包括fetch上呢是实际上是获取远程仓，然后呢以及poor push，就是拉从相当于从远程仓里边同步，把那个内容同步下来，拉到本地，然后呢以及push呢是把本地的一些更改。

然后呢是推送到一个远程的这么一个长的，这样的一些一系列的一个指令，然后另外就是还有很多的分支的，管理的一些功能，确实比如说哎现在有一个主仓，然后这样的话如果是想研发刚才讲的，想研发一些新的功能。

在这里边就需要去呃创建一个新的brunch，然后当然包也包括就是不同分支的一个切换，然后呢合并等等啊，这样一系列的一个功能，当然这个指令因为是这样，就是实际上他ga的指令非常多。

然后呢一般像我其实也不太记得住，所以呢就是呃实际上做的时候一般会推荐，就是说用g u i去做这些东西，然后但是后面我演示的时候，也主要就是简单演示一下，就这这几个指令。

但是大部分的那个也是我直接用g v i去演示，到底怎么去去做各种的那个get的一个管理，然后所以这里边可以看一下，就是这样，我说一下，就是当我这里边主要是呃我事先拉了一下，就已经拉好了一个仓。

然后呢比如这里把如果你装了git之后呢，这里边有一个命令行的这么一个一个ui，然后呢接下来要怎么做呢，实际上就也很简单，就是也是就这里边就敲入get clone，然后就刚才的那个recursive。

然后然后刚刚就这里了，当然这里边有个后面有个呃有个地址啊，然后这个地址的话实际上就是在哪呢，就是你如果比如说跑道就这个我们这个层，然后它这里边有克隆下载，里边你点一下之后呢，它里边会有一个呃。

这个这个类似于网址这样的一个东西，然后把这个网址然后贴到这里边，然后这样的话整个这个克隆的这个过程，实际上就就已经完成了，然后当然因为我已经克隆过了，我这里就不演示后面怎么去做了，然后克隆完了之后呢。

在后面会有什么东西呢，就是，就是正常应该这样有一个这样的一个目录，就是他叫paradio，然后呢里边进去之后呢，实际上会有这么一个目录结构，然后这样我对照着这个ppt讲一下。

这个里边每一个到底是哪个目录，里面包含什么东西啊，当然这个吊地的这个轮管，它这个实际上是那个d的这个工具，然后它用来记录一些就是临时文件，是用的一些一些内容，然后呢当然这个c mac这里边其实是会包含。

就是说它的一些就是我们提供的一些，比较用来方便的创建样例啊，然后创建那个library的一些脚本，然后呢另外就是第二个呢实际上主要是这个data，然后data主要里面会包含各种各样的数据。

比如说o b j文件啊，或者是那个各种模型文件等等，都会放在都会放在这里头，那还有就是第三个一个example的话，实际上会包含各种各样的一个样例，比如说当然这里有三个目录。

现在啊就一个主要是不同的目录，就是针对的实际上不同的gpu的一个后端，然后包括像扩大的挖坑的，然后当general的是各个平台通用的，然后在后面的话就是有一个external。

然后这个external的话刚才也讲了，就是就是杠杠recursive那个指令，如果不用的话，就这里边的所有的子模块有可能就拉不下来，然后就会导致你这个编译的时候，就因为确定模块编译通过，然后呢。

再往后的实际上就是这个python，是因为呃跟c加加的做一些绑定用的，然后后面的source里面就包含这里面仿真的，所以就整个引擎相关的所有的一些核心库啊，就是比如说这个最底层的是有个call。

就是最核心的一个库，然后当然还有动力学的啊，仿真算法库，然后还有访问框架，这个费沃克是一个访问框架，然后但是后面就包含交互的建模的，插件的跟渲染等等的，就这一系列的这个啊这些不同的一些库啊。

然后都在各个各自的文件夹里头，然后当然这里面还有一个就是测试的，就是因为其实测试主要的作用就是用来，就是说，因为我们知道就是大型系统列表，会包含非常多的一个代码，然后呢也有很多的算法模块。

所以这样的话就是呃需要保证每一个，就是你比如说你一个算法，其实里边好可能包含了很多部啊，然后但是这样的话，你实际上很多时候，我们需要对每一步需要去做单独的一个测试，所以这里边会包含各种各样的模块测试。

然后呢或者是某个一些某一个，比如某个具体的一个步骤等等，就这些啊去独立的去测试，这些一个一个礼拜的一些模块，所以呢这个东西实际上测试，对大于系统来讲的话，实际上是非常重要的，就是因为这样的话可以保证。

就是说你比如说中间的某一部分代码，被别人改了之后呢，实际上因为你尤其代码多了，你比如说几10万代码之后呢，其实你不太可能说每一行代码你都记着，然后呢你你去相当于把里边去修复过来。

所以呢一般来说都是通过这个测试样例，然后呢我们整个跑一下，然后看看这个结果是不是对来反推，就是说呃比如当前这个版本，是不是所有的那个呃上网模块，是不是都是正确的，说这样的话。

整个实际上就是你克隆下来之后呢，实际上啊，这个系统会包含所有这样的一些文件夹啊，然后呢后面我们就开始讲一下，就是啊这个gt就怎么去用啊，然后当然这里边有一些我常用的一些g u i。

就是啊比如像那github的那个desktop，然后搜索three啊，那这里边因为我们这边用的是一个smart git，所以呢我一会儿会以这个为例来讲讲，就是说怎么用这个呃git来。

比如说进行这个呃版本管理，然后这里边我们先看一下它整个呃smart gt，它包含就是会包含哪些东西啊，就是一个最左边的那个，实际上就是这里是包含了所有舱，就是比如说你克隆下来一个仓之后呢。

它实际上它会出现在这个地方，然后这样的话你双击一下，比如点双击一下之后呢，同时它在下面呢会出现，就是说你所有的一个分支，然后呢这里边在呃右下角的话会实际上会包含，就是说你比这里的点m的文件。

因为这里每个分支里吧，它其实都是各种各样的记录，就比如那个时间点改了哪些文件，比如这里边就像这个地方，就可能有很多的这个文件的更改，然后你点那个文件的更改之后呢，它其实在下面那个地方会显示。

就是说你左边跟右边的那个修改前和修改后，这样的一个一个视图，所以这样的话就是这里边可以比较方便的，就是可以查看，就是说你这个文件到底改了哪些内容，然后呢就是说这个时候你如果出现。

比如说中间改了哪个地方有问题的话，你也可以定位到这里边，然后去给他做回退，然后当然中间那个是一个呃，就是其实前面看到有个类似于分支啊，这种结构，就是你看这里黑色那条线，实际上是一个主的一个分支。

然后呢其他的那个就是其其他颜色的，实际上是一那就是说你fork出去啊，不是不是你现在新建了一些新的一个分支上，包括一些合并的这些呃结果，然后这样的话就可以在这里边，其实可以看到整个就是说呃一些合并啊。

分叉的一些一些结果，然后比较直观啊，然后呢这样的话我用一个呃新建的一个苍老，我演示一下这个东西到底怎么怎么来用这个，然后这个是我新建的一个，当然里边现在什么东西都没有啊。

它实际上就只有两个read me的这么一个文件，然后呢同时它这里边包含一个主的一个master分支，然后这个master分支呢相当于就是你的一个主版本，然后这个时候如果打个比方。

我现在是呃有个新的一个功能模块需要去开发，然后同时呢刚才讲的我现在也不希望，就是说我去影响原来的那个主分支的话，这里边你就需要去创建一个新的分支，所以这里边就是你可以爱的一个新的一个分支。

搁这里边你随便取个名字，这些都可以啊，然后那个爱了，这样的话就是新创建了一个分支，然后你可以看到就是他新创建的分支啊，其实从因为如果你从mata算出来，这样的话，他这个分支的内容跟你这个原来的那个分支。

实际上是一样的，然后它实际上只是说在两个不同的一个，分叉里头，然后这个时候呢你可以因为你可以在里面看到，就是说他如果啊这里边没有加粗的话，它的active分支这里其实还有个概念。

就是它的active分支是就是你啊就是粗体显示的，实际上是你当前的一个工作分支。

所以这样的话你所有的更改啊，就比如你这里边这样，这里边进去，你所有的对里边的文件的一个更改的话。

它其实都会在你的active的那个分支里吧，去呃去调整，所以这样的话就如果你现在需要做的，实际上我不想去改这个主分支啊，所以我需要给它切出来，所以这里边会有一个check out这么一个一个命令。

然后它对应的当然就是get out，get的那里边的一个check out指令，然后这里边切出来之后呢，这样的话实际上就是你呃所有的改动呢，实际上就不会影响到原来的那个master分支啊。

所以这里边就是如果我对他，比如我新加一个文件，就这个我随便加了，然后这里不要不要再加一个test。txt，这个加了之后呢，你会发现就这里边会提示你就是有一个更改，然后这个更改呢。

就相当于实际上你是新增了一个文件，然后这个时候如果我们改完之后呢，怎么做呢，就是这里边我需要点一下这个右键，然后呃点提交，提交完了，然后这个呢，当然就是你提交的时候需要有个注意的地方。

就是这里边需要输入一个信息啊，就是比如说这里是个first commit，就第一次提交，那这样的话你提交完了之后，也就是说你这个就完成了一次更改，然后呢并对这个结果做了一个一个记录。

然后但是这个时候记录完了之后，他其实还依然还留在这个原来那个分支，所以这个时候比如你现在就看这个呃文件的话，其实你是可以看到这个文件，但是呢你这个比如说你给它切回来，你再给它切回来之后呢。

你会发现实际上这个文件就就没有了，那因为实际上你所有的更改，它实际上是不会对它的主主分支，对他有任何的一个影响，所以这个时候你如果是相当于，比如说刚才那个新建的分支，你已经把所有的更改做完之后呢。

你想合到这个主分支呢，接下来怎么做呢，实际上就这里边你需要去点中，就是说新建的那个分支，然后呢你点这个你相当于再用一个命令，就是merge，然后呢这个当然就是根据提示啊，你当然可以创建不同的一个方式。

然后这里我们点fast forward之后呢，实际上这样的话就把这个新的那个分支的内容，然后就已经合到了一个主分支，也就是说别这里边如果你新的分支里边，你新增加了一些模块的话，这个新的模块的话。

实际上就可以给你引入到这个呃主分支里头，然后这个时候你再回去看那个目录的话，其实这个这个文件就已经进来了，当然这里边其实还有一些其他的功能，就是可以说一下，就是呃因为这里边你可以看到这里边有两部分。

一个呢就是呃上面叫logo brunch，然后这个logo brunch实际上就是你本地的一个仓，然后他其实对应到有个远程仓，就是这个远程的，实际上就应到就是说你比如说网页上的。

或者是就是说github或者码云上的一个仓，然后这个时候呢其实还有一个功能啊，就还不是还有一个需求，就是很多时候会也很常见的，就是说你哪个地方，你需要和跟多个远程仓需要去同步的话。

那这里边还有一个需要做的，就是呃你这里边需要增加一个远程仓，就是比如说你现在虽然是本地是一个，但是你我现在打个比方，远程有两个，我需要推送到另外一个厂里面呢，就需要在这里边增加，再增加一个远程仓。

然后这样的话就把啊gt那个，比如类似这样的一个地址放在这里边，然后当然这里边我随便演示下，其实也可以，比如把这个copy过来，然后这里边相当于可以再新建一个啊，当然这里边因为婚礼有可能有自己的一些。

密码的一些设置啊，所以这样的话就是你输入密码之后，然后你可以看到第二个，因为这当然这里边两个我设的是一样的，所以其实你发现没什么差别，然后这里边你添加了远程仓之后呢，你这里一定要点一下。

就是你重新拉一下，拉完之后呢，你就可以看到就是它里边的所有的分支，实际上从会被同步到你另外一个啊，就是这个仓里吧，所以这样的话实际上依然会有一个master，所以呢就这到时候这里边你如果现在因为这样。

你现在这个master那个分支，然后因为他现在是跟这个是保持同步的，然后这个时候如果打个比方，你需要去切换啊，然后这样的话，你就需要把那个他的那个track的那个分支，你需要去在这个地方点一下。

点一下之后呢，然后你这里边它会出现，就是呃你看可以看到它有两个远程仓，一个是origin，第二个呢是英语二呢是我们后来新加的远程，那这样的话在两个来回之间就可以切，贴完之后呢。

你可以在不同的舱里边进行相当于同步，所以就有一个这样的一个一个功能，然后当然完了之后呢，其他的就是主要的其他的一些呃修改的，实际上都会在这个地方去去处理啊，然后这样的话就是整个我这部分的话。

差不多演示到这儿，然后后面的话就是再看看别的，然后呢这样的话就是整个这个get啊，这部分就整个代码已经拉下来了之后呢，后面我们要做的是什么呢，就是呃实际上就需要利用这货还往后呃。

接下来的话实际上就需要利用，就是说这个semi这个工具，然后把啊整个系统给它给生成出来，然后因为现在你刚才拉下来完了之后呢，其实只看到一堆源码，它里面没有任何的一个工程文件。

所以这里边就需要利用这个工具，然后它它其实整个过程也很简单，就是你需要做的，实际上就把这里边的那个源码的目录，然后呢同时你这里边设置一个，就是说你想把这个生成的一个工程文件，放在哪个目录需要设置啊。

然后呢最后单点几个，下面就是你configure一下生成一下，然后最后整个工程打开，然后这个过程其实就做完了，然后这样对应的我其实也可以演示一下，就到底应该怎么做的，然后因为这个刚才我已经拉过了。

就是所以我以这个仓为例来讲一下，应该怎么来做的，就是首先就需要把它的源码的目录，因为首先要确认一下，就是他那个目录到底在哪，实际上主要是去找到它，这里边会有一个c make。txt，然后你点进去之后呢。

其实看到就是说一般它的呃根目录的那个c mac，它会里边有这样的一些设置，就是比如他对啊c mac的那个版本啊，比如就这样的一个设置，然后这个呢确定它是一个根目录，然后这个根目录是找到之后呢。

实际上你就要把这里边就是啊复制到这里边，然后呢，同时第二个呢就需要把那个你编译的，就是就生成这个路径，你给他设置一下，然后一般来说就是当然很多时候，可能你你可能把它放到同一个目录。

但是一般来说我们推荐呢，给他放到一个新的一个目录里头，这样的话就是整个会比较清晰，比如比如这里边新建了一个新的一个目录，然后这个设置完了之后呢，你这个时候再去点这个configure的时候。

它会弹出这么一个ui，然后这个ui里边主要是有几个事情要做，一个呢就是你要选择编译器，就是啊这里边当然你跟你本地安装有关系啊，就你这里边装了哪几个，它实际上就会提示有哪几个相当于理解编译器。

然后这里边我们就选那个2019，打个比方，然后2019选完之后呢，实际上另外第二个呢要注意，就是你要选择一个平台，就是啊，因为现在我们的电脑其实都是64位结构，所以一般来说这里边直接就选啊x64 。

然后选完之后呢，就这里边就可以了，然后他可能需要配置一呃，花点时间，然后他那个会根据c mac里的那个脚本，然后呢相当于把整个工程配置一遍，然后当整个配置过程中，如它中间有可能会呃出现一些bug。

就是当然如果出现错的话，你就按照那个提示，然后去把它修复过来就行，但现在我们这个应该是基本都调过的，所以正常情况直接就一次应该应该能过，行，这个这样的话应该呃。

你可以看到这个就是如果configuration那个down的话，这样说明就整个是没有任何问题的，然后也就是说整个是顺利config成功了，然后这样的话，当一当然一般来说你需要就说点啊，多点几次。

点到他这个红色的消失，那就说明彻底的没有任何问题了，那这样的话就可以，然后你可以直接生成，当然这里边就是有几个有几个地方需要注意的，就就我们这个系统里边会包含就是很多选项。

就是然后这个选项其中有一个需要注意的是，这样后面因为我们讲的时候也会提到，就是这里的qt，因为我们需要依赖一个，然后这个qt的配置的话可能就没有那么顺利啊，就是不像那个啊一开始那个可能点一下就行了。

然后这里边如果你把这个选上的话啊，这个时候其实会报错，然后那我接下来讲一下怎么去解决这个问题啊，它实际上主要原因就是因为呃，它里边有个c qt的那个这么个文件，他其实没找着，所以你点开这个的话。

你会发现他qt的目录没找着，所以这里边就是需要去找一下，你qt的那个安装目录，当然这里边qt呃怎么安装呢，我就不讲了，就是网上其实有很多的一个教程，我就直接去找一下那个qt。

然后因为我这个是装在c盘里边，然后qt然后当然这里有很多版本啊，其实啊我们推荐就现在我们用的是呃，13。2跟一四点，这都是可以的，所以这样的话我就以这个为例，然后这里边点进去5。13。2。

然后open这个那是，哦无限啊，对这里边，然后呃，他需要找到m s m s v c的那个对应的库，然后在这里有个lib，有个lib的那个文件夹，然后，然后再点再点这里边的那个qt 5啊。

然后这样的话实际上就可以看到就这个，就这里边有一个qt 5 config，点c make的这样一个一个文件，然后这个文件有了之后呢，你把这个文件拷到就是这个地方，诶这样直接考就行，然后考完之后呢。

重新生成一下，那这个时候应该他整个所有的那个需要的，依赖的那个目录应该都都找到了，找到之后你再点一下，直到他没有那个红色那个出现啊，然后这样的话其实就是呃直接就可以生成了。

生成之后的话其实就是整个在刚才那个目录里，你可以看到就是有一个掉sl啊，sl n的结尾的这么一个工程文件，然后这个工程文件呢，实际上就可以用vc dio打开，当然因为我之前已经呃。

就是在另外一个文件夹里吧，因为已经生成过一份了，所以这里就直接可以打开，然后打开之后呢，就可以看到就是正常情况，应该就可以看到有有这么几个目录结构，就是首先最顶层的实际上就是一个engine。

然后engine里面就会包含各种各样的，这个就是底层，就是这个引擎里边相当于现有的一些库，然后下面是一个example，然后这example主要是一些示例代码，然后再往后的话就是有些渲染。

然后第三方库等等一系列的在，相当于就都放在不同的一个目录结构里头。

然后呢这个有了这个之后呢，实际上接下来其实我们要做的就是什么呢，就是啊，因为其实我们是实际上需要依赖这个系统。

去做开发嘛，所以这样我们来看一下，就是怎么就是呃用这个系统去搭建一个，呃一个基础的一个，一个脚手架的这么一个东西啊，就是所以将当前期我们可以先不设计，仿真的一些内容。

所以这里边就是当然这个c mac的那些。

脚本文件啊，然后包括还有一些就是v vs studio code这些，当然一会会讲的，就是当然包括这个呃，整个用这个系统怎么去调试啊。

我直接就演示一下吧，就是呃所以现在最简单的一个方式。

这样的就是，因为你可以看到就是，就这个目录里的，你点进去之后呢，实际上你可以看到很多的一个样例，然后这里的样例呢就是你比较快的一个办法呢，实际上你去找一个，比如说我我现在打个比方。

我现在先去想新建一个叫类似hello hello这么一个呃，一个新的一个目录啊，然后呢，里边呢就是把一个比如写一些基本的一个，c mc的脚本，比如然后当时写了一个main main的函数啊。

然后这样的话就把这个整个系统给它跑起来，然后呢就我们看看怎么做，就是这里边就可以进进一个这样的一个目录，然后呢我们随便创建一个文件夹，然后，这样的话就一个文件创建出来之后呢。

然后我们可以直接去别的那个呃，去这里边我们可以去复制一个工程过来，就是，比如这里吧，因为它这里边他的所有的那个脚本，它很多脚本其实是相通的，那这样的话它主要包含两个东西啊。

一个是呢实际上是c max脚本，然后呢打开之后呢，其实看可以看到，就是说它里边有包含那个整个工程的一个名称，然后呢，当然它里边有这个这个源代码的那个名称，然后呢当然后面也是一些其他的一个配置。

然后当这里边你拷过来之后呢，需要有一些改动，就是所以呢就是我这里边把这个打开。

然后呢用这个东西看看怎么去改。

哦刚才应该考到这个地方了，对，然后这里边就相当于有一个，就这个是一个visual studio code的这么一个app啊，然后当然这里边就是如果有一些你高亮啊，这个颜色可能不对的话。

这里边有需要装一些插件，就是你比如这里的像一个c加加的，或者是以及c mac的一些插件，你需要去安装一下，装完之后呢，其实就相当于你可以看到它里边的一些呃，根据不同的那个数据结构。

然后它会显示不同的一个颜色，然后呢这个有了之后，因为它其实是从别的考过来的，所以它会跟以前的工程实际上是会会重名，然后这所以这里唯一要做的是什么事情呢，就实际上就是相当于需要把这个名称改一下。

这里我们就改成一个hello的这么一个名字，然后呢其他的实际上就不需要改了。

然后这样的话有了之后呢，我们实际上就可以对这个工程，当然这个是原来那个工程，然后我们重新的点配置一下，因为所有的c mc改了之后，你必须得重新的去生成这个工程。

然后这样的话他才会生效，不然的话在整个view studio里边他其实看不到了，所以那个你相当于重新设置之后呢，它会让你重新载入这个整个工程，然后呢你再去看，就是说，呃你看看example里边它会在。

让我看一下它这个脚本在哪儿，哦在球球里有目录下的。

好像没生效是吧，什么表。

哦这里边可能还有一个要调一下，就是，这样我索性用直接用快捷键吧，就是因为还有一个办法是这样的，就直接因为我们这里边加了一个呃，叫a的example的这么一个宏，然后这个红呢可以。

相当于实际上跟这个是等效的，但是呢它会更方便一些，就是呃我们就不需要写那么多代码了，然后直接就是这里边改成这个之后，然后当然这里边还有一个参数需要去加，就是你需要把就把这个东西放到。

到底是对应到v studio code里面的哪一个呃，文件夹底下，需要去给他调一下，所以这样的话就是当然这里的这个是他们嗯，相当于你需要link进来的一个一个库啊，所以这里我重新生成一下的话。

就应该是在。

哎我看一下我是不是那个。

我关一下重新生。

重新打开看一下。

哦这里看到了对，刚才可能是因为那个vs他没更新，那所以这样的话其实你就可以看到，就他会新创建这么一个工程，然后呢呃里边就会包含一个简单的这么一个呃，就这个讲代码，其实这个讲代码。

其实主要就是创建一个windows的一个界面，然后其他的当然啥也没有干啊，然后这个东西当然编译一下之后呃，这里边很多很多同学，就是如果这个以前没怎么用过的话，他可能直接去点运行的话会报错。

然后因为这个必须得设置一下，把这个东西设成一个作为一个启动项目，然后点这个之后呢，它实际上就会对这个项目进行编译编译，然后相当于最后会弹出一个，g u i的这么一个框，别人可能稍微得等一下啊。

像我们先往后讲吧，后面按理说这个应该是比较快的，但是我不知道是不是因为敢打了，可能需要嗯稍微等个两分钟。

所以这样的话就是整个这边如果跑通的话。

他其实可以看到类似这样的一个一个界面，然后但这个界面里边其实现在几乎是啥也没有，就是因为它主要其实就是一个界面，然后里边现在没有加任何。

跟仿真相关的一个内容，然后呢接下来我们看一下，如果打个比方，要给它加上啊仿真相关的内容啊，其实要怎么做呢，实际上这里边就是呃整个a p p在层面里边，会有一个接口，就相当于需要给它设置一个场景。

然后这个场景呢设定之后呢，它实际上是跟呃，我们现在整个框架，你可以看它其实包含这么几部分，就是首先最外层是一个界面，然后界面里头会包含两部分，一个就是它的一个呃渲染渲染相关的一个窗口。

然后呢另外一部分其实就是一个场景，然后这个场景其实就是，比如说我可能有钢体仿真的场景啊，或者是一个流体仿真场景，然后呢需要在外头需要把这个场景给他射进去，然后这样的话实际上就是在渲染窗口里边。

它实际上利用它的渲染引擎，它的那个视口，这样就可以识别它的它的那个场景，然后最终把它里边的内容啊。

显示到就整个界面里头。

还没出来是吧，所以这样我们先往后再讲一下吧。

就是然后这里边就是整个我讲一下，那个场景将来是怎么回事，就是因为它里边实际上，我们现在用的是一个四层的一个结构，然后什么意思呢，就是它里面包含主要包含四部分内容，一个就是它首先场景它实际上是由。

就是你可以看这个图，它实际上就是由不同的一个节点，然后他去组起来的，然后呢，节点间当然可以通过这个一些数据的传递啊，来传输数据，然后呢同时节点里边，那你可以看到它里边会包含呃，就是各种各样的算法模块。

然后所以里边是一个各种有模块组合起来之后，的这么一个呃一个节点，然后另外就同时节点呢跟模块，它其实都会依赖于就整个呃我们叫那个field的，这里边就是它实际上就相当于需要依赖，比如数据的一个输入。

然后当然也可以有一些数据的一个输出，然后这里边就可以看到，就他有啊这个数据的一个流向，它其实我们现在主要有设计的呃四种流向，一个呢就是节点是跟节点之间的一个传递，就是你比如说一个节点。

你的数据可以输入到下一个节点，然后呢下一个节点呢，其实就可以以以这个数据作为输入，然后呢进行计算，然后还有一部分呢实际上模块内部，模块内部其实也是存在一个数据的传递。

就是可以从上一个模块传递到下一个模块，同时这里边还包含两个比较特殊的呢，实际上就是就是比如说我模块里边算完，那些数据呢，可以通过这个导出。

然后导出到外道啊，刚才那个长期跑友对，所以这个呢实际上就是呃，就是刚才我们搭建的那个hello hello的那么一个空的，有工厂啊，然后当里边就是现在啥也没有，只有就是包含一个空的场景。

然后呢有些ui的一个操作，所以这里边如果你要想对它进行缩放旋转啊，这样的话需要按住那个control，然后呢包括鼠标的左键，中键和右键的时间都可以缩放，当然这里边还有一些呃其他的一些呃功能。

就是比如说像摄像机的呃，这个主要是为了方便，就是说以后比如在调试的过程中，比如说我想通过不同的视角，然后呢去看它里边的一些变化的话，比如这样我们可以就可以切换不同的呃，一个视角。

然后当然就这个主要是camera的一些功能，那还有一些呢就是那跟呃光照有关系的，跟光照有关的，比如说像调它的光影啊，然后呢当然还有一些背景的，然后一些辅助的一些功能，然后这里的主要像相机的相关的。

以及就是说这里去打印一些统计信息等等的，就这些功能。

那剩下的实际上就刚才说的，就是让这个东西就需要去给里边设置一些场景，然后也就是这样的一个场景，你创建完了之后呢，需要给它传进去，然后这个场景呃我简单介绍一下，就是怎么怎么去创建这个场景。

然后它里面包含了哪几哪个部分，到底是用来做什么，首先上数据层呢是这样，就是就刚才看到，就是说，因为它数据主要是用来做输入输出的一个功能，所以呢这里边会包含不同的一些类型。

然后呢主要包含的是包括像呃基本类型，基本类型主要是一些，比如说像布尔型啊，int flow的double等等啊，就这些，但还有比如像呃三维，就是说像一些向量，比如vector 3。

vector 3 b3 f等等，就这些，然后还有矩阵，然后这些呢因为它一个特点呢，是它的数据的规模实际上是呃比较小的，所以呢也就是说他直接可以用来在cpu和gpu之间，时间直接可以传递。

所以呢就是可以用啊，就这里边有两个红，就是一个呢是定义它的一个数据，就是用的fy的这么一个宏定义，然后呢这样的话就是定义完了之后呢，他直接可以在界面里边就可以识别出这个数据，然后呢。

当然通过可以在界面里面去调节它的那个数呃，他的那个值，然后来更改的这个场景里的那个一个值，然后当时还有一个宏定义啊，就是枚举的，后面那个是一个枚举的变量的一个类型，然后第二种呢实际上对于比如说呃。

因为像达比流体里边，它包含大量的那个数据的话，这样的话实际上需要有一个连续的一个存储空，间，有一个buffer，所以这里边就包会包含这个一维数组，二维数组，然后呢比如三维数组等等啊。

它主要是通过类似于这样的一个宏，就define array，然后当然后面如果是二维的话，就带一个2d，三维的话带一个3d这样的一个红来定义，然后此外呢还有一些动态的数组。

然后这个其实就跟嗯c加里边那个str，其实比较像的，然后但是这里的好处呢是，这个s d l可以就是在cpu和gpu之间是通用的，也就是这样的话，你可以cpu里面把这个数据创建完了之后。

直接可以传到gpu，然后呢，就是也用类似于这s t r的这个一个结构，然后当然最后还有一个就是啊，对于太复杂那个类型，就是我们这里边定义了一个，就是说叫实力的一个类型，然后这个类型的就是你可以理解为。

其实就是一个指针，但是呢它跟g u i实际上是联动的，就是它可以从g u r里面去识别这个类型啊，应该就是从那个用途上来讲的话呢，其实包含几类，就是主要是有包含那个呃变量，然后呢输入输出。

然后当然还有状态变量，这个状态变量是节点特有的，是比较特殊的，就是主要用来描述，比如说一个呃物理现象，当前的一些状态用的这么一个一些量。

然后呢这个对应到一个ui里边，其实我们可以看到就是这里边有个场景，就是有个q t field的一个场景啊，这个搭着搭着可以跑一下，跑完之后呢，其实可以看到，就是说它左边对应的是是实际上是代码。

然后右边呢实际上就会有一个创建出来的，这么一个节点，然后这个节点就包含了几个东西，就是下面那部分展示的，实际上是他的那个基本的一个控制变量，然后比如包含布尔型的，int型的，float型的。

以及vector 3的，比如对应的其实就是这最左边的那个四个变量，然后当然它还有就是呃输入输出输入的话，这里边它定义了一个float v，就是一个浮点数的一个数组作为一个输入。

然后当然你可以给定一个输出，然后这样的话，这里边会有一个浮点数数的那个数组，相当于它有一个输出，然后此外呢它这里边定义了一个状态变，但转变因为在下面的截断了，所以这样的话也可以在ui里边其实可以看到。

所以呢也就是说，现在这里边所有的那个数据类型，就是跟ui其实理论上是一一对应的，所以就是可以直接从ui里边，相当于是就是你实际上你定义的数据类型，直接在ui里边，其实就可以去调节所有的那个数据类型。

所以这个是实际上我们目前就是这么去设计的，比较方便的一个地方，也就是说你有些场景因为仿真的是这样的，就是很多复杂场景，就是它有可能你在访的过程中，你比如说我想动态的调一下某个参数，然后呢去看一下。

就调完之后它后续的一些变化，就这样的话就可以不需要我，比如说我去不断的去改代码，然后选完成，也就是我们可以在ui里边去完成这么一个。

一个工作，然后当然模块的话实际上就是类似的，就是有了这些数据之后呢，其实我们只需要做的就是呃，定义一个模块到底需要哪些啊。

控制变量，哪些输入，哪些输出，然后呢对应的就是也有一些样例啊，就是如果你可以把ui打kt那个界面打开的话，实际上就是比如像这里边有一个s p r h b表，用的比较多的就是呃密度计算。

然后它包含比如说啊它的标准密度，然后呢他输入的话，因为还是像粒子法里的，你需要去上密度的话，你需要知道就是说你的领域有哪些例子，然后你本身比如说啊自己有些例子，然后他需要根据领域的那个id。

然后去计算它的那个每个例子上那个密度，所以这里边它会就会有输入，就比如说这里会有一个位置，然后当然还有一些还有一个其他的位置，然后当然还有领域的i d，然后到上面那两个定位是它的父类的定义的。

所以这样的话，它其实所有的那个输入其实就含在这个地方，然后最后呢它会有一个输出，然后这个输出呢实际上就是会价格，根据输入算完之后呢，他会把这个值写入到这个密度的那个数组。

然后作为一个输出，然后节点的话其实也是类似的一个结构，就是在这里啊，唯一不太一样的地方，就是节点里边会有一些新的一些量，就一个就是呃有一个输入，就是你可以整个节点作为一个输入，然后输入到后续的一个节点。

然后这个主要是考虑到有些数据的话，它实际上啊比较复杂，因为你这样的如果太复杂数类型传递的话，这个他的数据太多，就导致他整个呃计算相当于是啊就整个显示啊，它就太冗长，所以呢就这部分。

你可以直接用一个整个节点传进去，这样可以降低这个整个输入的那个连线啊，然后当然除除了这些之外呢，就是节点里边会有呃状态变量以及管线，然后这个管线其实后面我们还会详细的讲，然后这里边有一个样例啊。

我简单的说一下，就是呃这样的话可以加深一下理解，就是这里q t里边打开之后呢，其实可以看到，就这里有个qt connection的这么一个一个样例，然后这个样例，然后这个跑起来的话。

实际上可以看到一个界面，然后呢另外这里边就定了几个节点，就是呃当然这个数据啊，这个数据其实可以用来传递的，然后这里面主要有几个类型，就一个source a那都是从节点里面继承下来的。

然后呢它会输出一个呃这个data的那个数据，然后呢还有一个类型的就是source b，然后呢他也会输出一个贝塔的一个类型，然后当然最终呢会有嗯，还有一个那个定义了一个，第三个就是target的。

然后相当于前两个作为一个source呢，可以连到这个后面那个ta的这么一个节点，所以这里边实际上主要是为了测试，就是各个节点之间的这个两性关系，搭的这么一个测试一个场景。

然后一会儿跑起来的话也可以演示一下，看看就是说讲的是怎么一个效果。

这样可能那个稍微等一下，然后这样我们索性看后面那个样例吧，就是嗯因为比较直观。

然后这个是因为那个是早期的一个版本，搭的一个样例啊，所以现在ui实际上跟现在的那个可能不太一样，诶，我先把这个停一下，但那个应该起来。

对，所以这里边其实可以看到，就是刚才main函数里边创建出来的几个样例，就是可以看到有一个source a，然后呢还有一个类型的source b，然后呢，他他们输出的其实就一个就包含他们自己本身。

然后呢还有就是定义自己定义的一个数据类型，叫data的这么一个数据类型啊，就是当你把这个光标移上去的话，其实可以看到它的类型其实就是一个instance，然后呢后面那个节点呢实际上主要用来接收。

就是说前面那个节点输入的那个数据类型，然后这里边就可以把这里复格，有login的那个选项可以打开，打开之后呢，就是这里边就是可以看到，就是说它整个连接信息啊，就是呃比如说这个给它断开之后呢。

其实可以看到这里有个提示，就是source a里边的这个呃，他的那个那个输出，实际上就从他给的就这样就给它断开了，然后类似的就是你可以看到，就这样的一个提示信息。

就是啊这个这里边主要是为了呃帮助加深理解，就是说它它到底是怎么一个工作机理啊，就当然这里边是这样的，就是因为它这里边定义了一个，source a的数据类型的话，他也就是说对的。

如果你现在输入的是不兼容的那个数类型，我现在给它都断开，然后我们现在如果对，硕士b如果想连到这里的话，它实际上是不行的，所以这样的话就它其实会有一个，你都会有一个类型的一个判断。

就是你必须是同一种类型的，他其实才允许它输入，比如这个数据，但连这个都是可以的，但是连上面的实际上连不过去的，所以这个东西其实也是类似的，说这样的话就是在后面，比如说我们在研发模块的时候。

就是我们需要清楚，就是我们需要啊输入和输出的类型，定义清楚之后呢，这样的话就是呃可以辅助的就是来创建，就是包括后面的场景啊，就是啊对比如说一些不兼容的一些常情况的话，我们实际上就可以事先给它规避掉。

就不至于出现。

比如说你连入一个啊不太对的一个数，就导致了整个程序可能就直接就崩了。

然后呢，所以这里边这个整个这个过程有什么用呢，就是这里的场景其实就有个展示，就是呃比如说我们现在有个流体房的那个场景，他整个实际上就是从呃建模开始，然后到后面的一个仿真，然后前面因为建模的话。

就需要相当于创建一个几何的cube，然后呢生成粒子，然后呢，当然这里边还有后面的话，还有一些呃属性需要去设置，就比如我设置它的初始速度啊，然后包括这个再往后的话，实际上就是呃有一些节点。

就是呃仿真计算的一些节点，然后这个完了之后呢，实际上就可以看到它其实可以动起来，但是呢这里吧当然也呃没有几何边界啊，所以呢另外的话其实我们也可以呃加入一些呃，几何边界的一些东西。

然后呢就让流体跟这个边界发生作用，所以这里边也就这个好处，就相当于整个我们的所有的这个场景，就是说我们的基础模块我们都搭，构建完了之后呢，实际上就可以就利用这种ui的那个形式啊，把就是说更多的场景。

就直接在ui里面就构建出来，就不需要每次就需要去呃，不断的去重复的写代码，所以这样的话，就可以降低整个代码的一个工作量。

所以这里边其实就是很重要的一个东西，就是需要讲一下，就是这个管线到底什么概念，其实就是呃如果以前大家学过图形学的话，可能对这个有一定的了解，他实际上你可以就可以理解为，就一系列功能的这么一个呃。

顺序排布的这么一个执行的一个队列，然后当然这里边我们现在这个管线，它其实不是不是一个简单的一个，线性的一个队列啊，然后它实际上是一个图的一个结构，所以这里边就包含就是呃，包括因为它主要包含两个。

就是仿真的管型和渲染管线，然后这样的话每条网线里边，它其实都会有个入口，这个入口呢实际上对应的就是呃节点里边，它所需要的一个状态变量，就是比如说像如果是一个流体，那它可能会包含比如说它的速度信息啊。

它的位置信息，它的那个其他等等的一些一些厂的一个信息，然后呢，后面呢就是会接一些各种各样的一些模块，然后当然这里模块有可能会是呃，访问计算的模块，也有可能是交互的一个模块。

然后呢这些模块呢它计算完了之后，它实际上会去跟更新它的所有的一个状态变量，所以这样的话就是呃这里有一个机制需要去保，证，就是说你这个数据什么时候更新，所以这里边呃就是所有的数据。

实际上会有一个叫我们叫这个tag的，这么一个机制，就是说你这个数据什么时候更新了之后，我会记录一下，这样的话他会告诉后面的模块，就说我这个数据已经更新了，然后他在后面计算的时候。

如果发现就前面的数据更新的话，它才会重新去计算他理赔的所有的量，但是如果发现就是以以前的量啊，他完全没有动，也就这个时候他实际上不需要去啊重新计算，所以这个呢可以有效的降低整个容易计算，因为不然的话。

你相当于你所有的那个呃计算，一遍一遍都在重复算的话，其实会造成大量的一个计算的一个浪费。

然后这里边就是我以这个缸体的场景啊讲一下，就是这个到底什么概念，就是呃大家如果打开这个qt breaks，这么有一个example的话，其实你可以看到一个有一个钢铁的节点。

然后这个节点呢点进去之后呢，它其实会有两个啊，两个啊就是嗯就是其实可以看到有两个视图，一个是这样的，左边那个就是你点的animation的话，实际上看到的是一个仿真惯性的一个视图，然后点右边那个呢。

实际上是一个渲染管线的一个视图，然后这两个视图有什么差别呢，其实主要体现在呃他的一些算法模块上的差别，就是左边那个主要是因为针对访问计算的，所以呢它实际上这里边比如最后一个。

他会接一个钢铁动力学的一个算法，然后当然前面的也是一些相关的一些也算吧，做完，然后当然后面右边的呢，实际上因为主要是渲染为主的，所以这样的话，它主要其实主要是接的渲染的算法。

然后呢去为了辅助显示，所以这个呢实际上就是你打开的话就是。

然后把之前那个关一下。

这样我直接找一下那个里边那个。

哦这个跑起来，然后这里边儿跑起来之后呢，实际上可以点双击点进这个，这样的话实际上就是可以看到，就是说这里呃，这个左边那个这个，实际上就是一个仿真算法的一个pine，然后右边那个是渲染算法的，跑到那。

然后当然这里边啊之所以是papa呢，它的一个好处呢，实际上，就是因为它里边的模块是可以动态删减的，就比如这里我们可以看一下，就是呃就以渲染这个来看的话。

其实显示几个东西啊，就是一个呢是它的那个整个boss，比如它的表面网格下显出来，第二个呢其实你可以看到它里边有一些触点，然后他以及一些法向。

所以这样的话点点击里边的话，实际上你可以看到它里边有三个东西，分别去显示这些东西，就一个是呃它的那个触点的法向，实际上是用这个模块去显示的，然后还有一个就是呃触点，然后这个是用一个点的一个渲染模块。

然后当然还有表面网格，所以这些呢就是当然可以动态的调，就是因为所有的管线啊，就为什么之所以较为管线的话，其他其实因为它其实都是可以动态的去配置，里边的一些模块，比如说这样的话。

我可以把里边的一些东西给它删掉，删掉之后。

当然我可以加一些其他的新的算法模块，然后这样的话就可以啊，自定义的去把这个呃显示啊，或者仿真的一些需求，然后给他给搭建起来啊。

然后呢整个这个算法模块就是它这么多的模块。

它怎么执行呢，我们这里有一个图，就是首先它整个仿真管线它的运行，这是一个时序图，所以它实际上主要是包含呃，四个部分的逻辑关系，最左边当整个是整个场景啊，然后整个场景呢实际上包含两部，一个是是重置。

重置的话，它实际上会调用后面所有的那个包括节点，然后以及模块里边的模块，相当于把它恢复到它的一个初始状态，然后当然在运行过程中呢，它会不断的去调这个，比如呃相当于take one frame。

然后相当于因为仿真的话，他整个实际上是一步一步的去执行的，所以呢它会循环的去掉这个呃这个函数，然后呢里边具体的话实际上就是它会去调用，就每个node里边它对应的这个呃访量管线，然后但是法定管线里边。

就会包含各种各样的模块啊，然后呢他会不断的去更新这个模块，然后这样的话，实际上就是去完成整个场景的这么一个更新，然后这里呢对应到这个渲染管线的话，实际上是类似的，也是整个场景，然后到节点。

然后最后到渲染管线，然后渲染管线之后会去更新它的那个。

所有的一个一个模块，然后整个渲染它这个流程呢，实际上是这么一个流程，就是说因为这里边我们实际上集成了很多，比如说点线面啊，然后包括实例的一些渲染啊，这些功能模块，所以这样的话就是。

所以相当于就是说它里边儿一开始的话，他会整个渲染的流程，它是相当于会把所有的就是场景里边搭建的，这个渲染的一些模块给他都取出来之后，然后呢对它做渲染的一个操作，然后完了之后当然这里边会有阴影的渲染。

当然呃印完了之后就实例的一些渲染，然后最后当然是就界面相关的，就是整个ui的一渲染，都最终把它都渲染到这个render target，就相当于我们的那个帧缓存，就我们看到那个屏幕上头。

所以这是整个渲染的这么一个流程，然后这里边就是可能很多人不太理解啊，就是这个东西为什么要搞那么复杂，就是为什么就是要搞四层的这么一个结构啊，所以这里边主要问主要目的，实际上就是为了解耦。

所以这里边主要包含三个概念，就是一个是法律计算需要跟数据给他分离出来，第二个呢就是需要更渲染给分离出来，当然最后一个是分交互呢，实际上也需要分离，所以后面我逐步讲逐个讲一下，就是这个到底什么概念。

就是首先就是访问，基本上跟数据这个结构到底什么意思，就是呃我们首先看一下左边那个，它实际上是一个有限元的这么一个仿真场景，就是它里面包含哪些东西呢，就是我们可以看一下，首先它实际上是有一个呃拓扑结构。

然后它实际上就对应到有限元这个场景的话，它其实就是一个四面体的网格，然后呢定义了这么一个网格之后呢，它实际上还有一些其他的一些厂，比如他的有他的那个啊位于场，他的那个呃应变场。

以及它的那个应力应力应变啊等等这些这些厂，然后这一场的信息有了之后呢，接下来就实际上就需要去计算，就是呃更新，比如它里边的场景，比如它的位，它的运动过程中，它的位移实际上是要更新。

然后包音那面实际上是更新，所以呢会相当于有不同的一些算法，然后呢相当于需要把呃拓扑结构以及它的field，他的那个一些厂，然后呢结果他的那个相当于在动态的去，相当于把它给呃运行起来。

然后当然这里对应到一个粒子的一个场景的话，实际上有些东西类似的，比如他的那个场，它其实也会包含可能性应力啊，包括位置啊速度，但是呢它的拓扑结构你会发现其实不太一样，就是如果是s p h的话。

可能其实整个都是particle的基本的一些结构，然后当然对应的算法有些实际上也是相通的，它主要包含，比如可能有像杰克比亚和塞德尔牛顿等等啊，这个算法，那从这两个里边我们其实可以看到啊。

就是呃对于很多各种各样的一个算法，但是算法其实非常的多啊，就是比如说有s p h啊，p p t啊，m p m f e m等等，就这些，但是呢这些算法其实有一些相通的地方，在于，就是说呃很多算法。

它其实可以用相同的数据结构来进行模拟，比如说s p h跟p p t或者s p h跟m p m的，实际上都会依赖于po，当然呢同时反过来呢，实际上就是就是同一呃，也就是说那相当于是比如说你反过来。

你相当于不同的这个拓扑结构呢，其实也可以用同一种方法去模拟，比如说你都是particle，或者是这个表面网格以及提网格，实际上都可以用，比如说f e m去去做啊，然后这个实际上都是可以的。

所以你会发现这里边就存在一个一对多，对多的这么一个关系，那这样的话就也就是说，导致我们如果实际上在真正去写算法的时候，我们不可能不太可能去群举，比如说我们把两两之间我们都去写一个算法。

那这个实际上就会导致大量的冗余，所以这里边我们要做的一个呢，实际上就是把它的表示需要给它单独抽象出来，所以这样的话整个我们现在的系统呢，实际上就引入了一个层次化的这么一个表格结，构。

就是从最顶层的这个点云到编，然后到三角网格，然后到比如说呃四边形网格，四面体网格等等啊，所以这样的话就是可以有效的，就是说把啊各种各样的不同算法，它所依赖的这个拓扑结构，然后给它有机的给整理起来。

然后这样的话一个好处呢也是比较方便，就是说比如不同算法之前他要进行数据共享，那这样的话就可以依赖于这个统一表示，这个数据结构，然后呢做相当于做一个映射，然后呢来进行数据的一个传递。

那有了这个统一的一个表示之后呢，那也就是整个流程啊，就是整个比如说我现在想想写一个访问算法，那这个流程就其实就包含三个步骤了，就是啊，首先第一个我们实际上要做的，就是创建一个top结构。

然后这个结构呢就是就是我们系统里定义的，就是你可以也可以一个电源，也可以是一个四面体网格，然后当然有了这个拓扑结构之后呢，我们在需要在上面定义各种各样的场，然后呢呃比如说这个位置速度体体积等等啊。

然后当然这个厂的定义呢，会跟他的那个拓扑结构实际上是相关联的，就是比如说你如果原先是一个电源，那这样的话，你的所有的那个厂的，那实际上都是定义在电源上，当然你如果原先四面体网格的话。

你有些信息可能会定义在四面体的那个单元上，而有些性呢会定义在那个点上，所以这样的话整个厂的那个定义，实际上是依赖于这个拓扑结构的，这么一个结定义，然后再往后的话。

实际上就依赖这个拓扑结构以及它的一个呃厂，然后呢再做一些就是说运算，然后当然就包括比如说呃从数学上来讲，就可能是比如说梯度散度拉普拉斯算子，然后当然这个也是因为跟你的那个决定的呃，差异性有关系。

所以整个运算呢也会有一些不一样的地方。

然后呢具体体现到刚才的那个管线里边，其实就可以看到，就这里边就包含两部分，就左边那个实际上就对应的是数据层面，就是包含主要两个，一个是他的那个拓扑结构，然后呢除了这个之外呢，其实可以看到。

就比如这钢铁这个场景，他会有质量，它有位置，他得有它的速度，然后角速度等等，就这些一些状态变量，然后除此之外呢，后面的话实际上是接各种各样的这个算法模块，就是也就是整个计算的话，你会发现。

就实际上就是跟呃这个数据实际上就分离开了，这样的话就是我们如果要更新算法，或者是要做别别的一些，就是说呃做替换，比如这样的或者增加新的模块，这样的话就不首先就不影响它整个呃，拓扑结构的一个定义。

就是整个状态变量的一个定义，也就可以直接在后面就调整它的算法模块，然后来呃，同用同一个拓扑结构来模拟不同各种各样的不，同，就各种不同的一个现象，那这里边其实可能就会有一个问题，就是因为我们知道有可能。

这里边接的算法模块可能会非常多啊，然后那这样的话就是呃，其实仿真的算法其实最困难的地方，其实它主要是调试非常的麻烦，那这里边我们需要怎么去做呢。

这里边实际上就需要依赖，就是呃一些渲染的一些办法，那这里边所以涉及到就是整个访问计算，怎么个渲染呢，相当于拆分开来，因为这里边就需要就是结合不同的场景，我们自己去设计一些不同的一个呃，渲染的一个方式啊。

比如像这个场景左边那个，如果我们发现比如说啊他有穿模的那个现象，那这个时候我们可以怀疑，比如他是不是比如触点啊，或者没有算对，那这样的话我们可以针对这个想法的话，我们可以把它那个触点或者他的一个法向。

实际上给它给显示出来，所以呢就是呃这样的话就可以帮助我们去调试，就比如里边有没有可能哪个触点呢。

就没有能找出来，然后导致他这个程序出现bug，所以这个好处呢，实际上就是呃也就相当于我们整个渲染管线呢，其实就可以引入不同，各种各样的不同的渲染模块，然后呢去辅助我们去相当于去那讲的。

就是比如说仿真过程中的一些问题的一个调试，然后当然也也可以包含一些，比如中间过程的一个展示啊，就是逐步的去相当于发现问题，然后最终呢就相当于呃。

设计出一个稳定的一个算法，所以这里面就会包含，就是说这个仿真的就渲染这一块，实际上其实就会包含各种各样的一个啊，用来就做辅助研发的一些功能，就比如说这个啊点线面的这个渲染啊。

然后当然包括一些实例的一个渲染，然后呢以及后面的比如说像半透明啊，或者是颜色映射等等啊，就这些，然后这些东西呢，实际上都是以模块的形式，集成到整个渲染的pnine里头，也就是说可以根据我们的需要。

然后呢去呃调解，就是到底需要去组合，到底需要哪些的那个模块，来支撑我们的仿真算法的一个延长。

然后当然最后还有一部分，就是这里边就主要是那个反正就算跟交互，然后这个东西呃最直观的理解呢是这样的，就是因为我们打游戏的话，你可以看看，就是一般比如说我们需要跟鼠标啊，键盘实际上进行需要有一个交互。

然后当然对于仿真里边，这里最大的一个差异的一个地方，就是比如说打个比方，同样是一个鼠标的一个点击事件，那在仿真场景里边，你有可能你只是想拾取某一个物体，或者另外一种场景，有可能是需要把那个物体的拽住了。

然后呢去点住之后进行拖拽，所以呢实际上就是说每一个呃对每个开发人员，他其实对交互的一个需求实际上是不一样的，所以这一部分实际上就需要对交互的一个行为，进行定制，这样的话就是这里边。

实际上我们也是把这个整个交互的模块，就实际上也是把它模块化了，然后呢跟仿真的模块以及跟渲染的模块，实际上就整合到了一起，然后这样的话就是无论在渲染还是仿真里头啊，实际上都可以用这个交互的模块。

然后来实现一些交互的一些功能，然后呢这里边具体怎么做的，因为这个东西跟以前的那个图形的那个，还是稍微有点差别，就是因为这里边我们需要保证，就是整个交互跟呃跟仿真渲染的一致性。

所以这样的话我们这里边做的呢，实际上就是呃就比如以鼠标这个为例啊，我们像笼统的就把它，从交互空间，比如说我们现在一个鼠标的一个事件，它实际上它的点击事件，实际上在一个二维的屏幕空间里面发生的。

那这样的话我们需要把他这个事件相当于通过，就是因为这个后面那个实际上是一个视锥啊，就是比如说我们在虚拟世界里面看到一个视锥，然后呢，就这个口对应的实际上是交互空间的一个平面。

然后比如它上边那会产生一个点击的一个响应，然后呢我们需要把这个响应呢，就是利用这个结账，当然结合这个相机啊，这个相机我们是知道的，然后这样的话需要把它变换到，就是说它的一个世界空间里边。

就是相当于我们的那个场虚拟场景里边，的一个世界坐标系，也就这样的话就可以把所有的那个计算，然后呢跟呃渲染的那个模块，以及跟那个法律计算模块，实际上就综合起来，然后这样的话就可以实现一个。

整个模块上的一个统一，然后这里就会有一个样例啊，这里嗯在canyon那个代码里边，其实我就不演不演示，然后实际上就是相当于，比如说因为这里实现的，实际上就是一个点鼠标点击，比如说选中了某boss之后。

然后呢给他一个冲击，然后相当于给他呃推远了这么一个过程，然后当然如果有些有其他的一个需求的话，这样的话就是比如我需要现在拽住，然后给他拖拽的话，那这样的话需要重载一下，就是交互的鼠标响应的一个模块。

然后把这个模块给他踢进去。

然后就可以实现其他的一些一些功能，然后这里边最最温暖，最后的话可能还得讲一下，就是因为前面主要讲到三个，就是法律渲染和交互，然后他们之间实际上会有一个呃呃协作的，这么有关系。

当然这里边其实主要是呃复杂的地方，就在单单线程的话，其实呃问题一般不大，因为一般来说单线程的话，你所有的你不论仿真也好，渲染也好，好交互也好，但实际上都是一个顺序执行的。

所以这里边实际上因为我现在这里边，虽然画的是，比如说我先做仿真渲染交互，然后再做渲染，再做仿真，但实际上这个过程没有那么绝对啊，就是因为在单线成立的话，你完全可以比如说你可以先渲染，然后呢啊在交互。

然后再仿真，其实也没有关系，然后它整个呢实际上就会依次的去调用，相应的一个模块，但是这里边实际上复杂的地方在哪呢。

就是实际上在多线程的环境下边会涉及到，就是说三个loop，就是首先是首先是这样的，这个整个g u i它实际上会有一个loop，然后这个loop在做什么事情呢，它实际上会呃去收集。

相当于从界面或者是从一些外设里边去收集，所有的那个交互响应的一个事件，然后这些事件呢实际上它会分发到，比如说这里边我们还有两个呃loop，就一个是仿真的路牌，一个是渲染的一个loop。

然后他需要把那个仿呃，就是ui里边搜集到的一些事件，然后需要分发到那个仿真的一个管线，以及一个渲染的一个管线，但这里边的一个问题在于，就是实际上仿真的管线也好，炫耀的管线。

如果它执行在是不同的这个呃线程下的话，它会导致整个它实际上，有可能会出现一些不同步，然后同时仿真和渲染，就这整个物理引擎它会还会有一个特点，就是它包含就是说这首先是仿真这个部分。

它其实不会包含大量的那个动态数据，比如说可能是几10g甚至几百g的那个数据，然后这些数据呢，同时还它还需要发送给渲染去去进行渲染，渲染引擎渲染，那这个过程呢，其实你会发现就包含大量的那个读写冲突。

所以这里边怎么去解决，就是说因为如果这个里边你不解决的话，就可能会导致就是说你怎么仿真这个路口，你在呃那个计算的时候呃，你可能只计算了一部分，然后这个时候渲染可能就直接就呃进行渲染。

这样会导致整个计算结果啊，轻一点可能就是显示不太对，但是如果是严重一点的，可能整个会导致他的那个程序会导致什么crash，所以这里的我们现在解决一个策略呢，实际上就是首先这里边肯定不能把。

因为肯定是需要引入一个互斥的，这么一个互斥锁的这么一个概念，就是需要打个比方，就是你在写仿真的时候，也就是你在写的时候渲染是实际上是不能读的，只有你在写完的时候才实际上才能才能去读。

但这里边的一个问题就是说，你看你这个呃锁是应该加在什么地方，然后我们现在一个策略呢，就相当于首先你肯定不能加到整个场景啊，因为如果真的加到整个场景的话，你这样的话会导致整个场景，就是因为整个场景的话。

它其实开销还是比较大的，你锁的话，你会导致整个会呃就大量的卡顿的出现，所以我们实际上会把锁，加在具体的一个模块里头，也就是说比如说某个特定的一个模块，我们在写的时候，这样的话就是。

当然其他的可能模块已经准备好了，这样的话就是特定的模块的写的时候呢，只需要对这一块加锁，然后呢这样不影响其他的谋划的一个更新，所以也就这样的话，就两边可以啊，近大最最大可能的比如保持仿真跟渲染之间的。

他们的一个呃相当于互斥的一个，就相当于尽可能的帮他们，相当于发生那个互斥的啊，读写的一个互斥冲突啊。

然后最后的话这里我讲一下，就是因为这第一期因为第一次课的话，主要还是讲讲，就是整个框架的这么一个呃这种概念，所以呢也比较笼统。

里边的很多东西呢，也其实也不需要就是详细的去去了解，就是因为我们在后面的话，实际上会包含具体的一些法律相关的一些例，比如说像后面像这种s p h的，然后包括后面有计算动力学的。

所以就是说相当于对第一次课的话，主要是给大家有个这么一个大致的一个了解。

就是嗯你知道就整个引擎，大概是整个它是怎么搭建的，然后呢里边每一个某块到底怎么去运行的。

所以有一个大致的一个了解，然后当然具体的后面的话会结合具体的案例啊。

逐步的去加深，就比如这个仿真应该仿制算法应该怎么去设计，然后包括渲染算法应该怎么去设计，然后以及交互的，比如说那个你想写个那个拖拽的模块，应该怎么去做啊，然后反正逐步的会加深这个概念。

所以呢这个东西其实也没关系啊，就是前面的讲那些东西如果不太清楚的话，其实我们后面会反复的会去提到应该怎么去做，然后当然这里边我先预告一下，就是因为这里边看到的有些样例。

比如像这个样例，其实我们现在还没开源啊，但是后面的话实际上我们会把啊，结合具体的课程，然后把这些案例给他开出去，然后呢，当然有些东西呢也是嗯到时候也可以提供。

就是说呃一些学习的一些样例，然后呢去帮助大家以后呢，把各种各样的那个啊纺织相关的，一个知识给运用起来了，然后这个是一个流体的一个场景，其实流过耦合的一个场景，然后呢还有一部分，因为是这样。

有一次课我们会专门讲讲动力学，所以呢这个呃有一部分涉及到，就是怎么用这样动力学去求解。

超弹性的一个材料的一个一个模拟。

然后当这个场景实际上就会是综合的运用，比如说是前面讲的那个仿真啊，渲染啊，交互的一些模块，然后呢怎么去搭建这么一个一个interactive，当然这里边主要现在啊没有做到特别快。

因为当时其实有一个性能瓶颈，其实仿真可能还是有一定的瓶颈啊，然后但是总体来说就是说呃，实际上就是这里就涉及到了，就是前面讲的就是呃仿真的模块的一些呃研发，然后当然渲染的模块的一些呃。

当然现在文化一般来说，这个就是尽可能的用现有的其实就行，然后当然有些除非有些满足不了需求的，你可以自己再去额外的补充一些新的一些功能，然后当然还有就是交互的，比如这个交互的一个功能。

然后比如说你脱着衣服啊，然后呢相当于你去拖拽等等这些功能，然后怎么去写，然后这个后面其实我们也会去讲嗯。

那今天讲的其实主要就是差不多这些，然后当然这个，因为我们现在现在这个系统也比较比较庞大，然后呢，我讲的可能也不一定是包含全部的一个东西，所以当然这里边也是我们前期的啊，对这个系统做出不少贡献的一些呃。

呃一些研发人员这样的话就是当然有问题，当然我们群里边有呃，有问题也可以在里边去讨论啊，然后今天我讲的差不多就是这些，然后呢呃因为今天可能有点拖了，就是反正看看也看，大家有问题的话，我们可以简单交流一下。

呃这里的这个场景是有那个rpc的这个场景。

就比如这个，然后这个当然我们在后面会开源，会开出来，然后现在的话因为你看到的那个开源版本，现在里边会没有哦，然后移动平台的话，这里是这样，就是呃我也我讲一下，就是，我们现在的后端实际上支持两个后端。

一个呢是呃扩大的后端，就所以你点进去看的话，这里的呃，比如库里的，它实际上你可以看到两个back and，然后呢一个是呃walking，还有一个是kda的，然后呢。

won的后端实际上理论是支持这个移动平台的，然后在构建的时候呢，这里有一个选项需要大家去注意，就是因为默认的话实际上这个是空打的，然后呢当然如果你要去要用挖坑去写，用移动端的话，你这个要选挖坑。

当然还有一种就是考虑到打个比方，有些同学可能确实没有嗯，就确实没有gpu，这样的话就你可以选择low gpu，然后这样的话就纯粹用c加加的代码去写，但这里边呃也得提醒一下。

就是因为呃这里不ka的那个版本，实际上是最稳定的，然后另外那两版本呢，确实可能会有各种各样的问题，然后大家有问题的话，可以到时在群里边去可以去讨论，然后第三方的库的话主要是这样，就是呃可以看这个目录。

就是这里有个external的那个啊文件夹，然后这个文件夹呢，它里边就是现在实际上里边不需要你，你自己去写下载那个加仓库，就是你可以因为这里边刚刚前面也提了，就是你只要把那个杠杠。

recursive的那个指令加音之后，它会自动的把这个第三方的那个库，给它下载下来，所以这里的比如包含像啊olympics啊，或者是ion fire system等等啊。

就这些这些电话其实会自动的给你下下来，呃s p h的规模，应该理论上实时的话，最高能达到100万的一个例子左右的一个规模，差不多这么这么一个规模，然后mac的话其实还是刚才讲的，就是呃walking。

如果welcome这个后端如果可以的话，mac应该可以的，包括md应该也行，但是这里边还是一个还是一个问题，就是其他的平台我们呃我们这边确实没怎么测，就是所以大家有兴趣的话，可以自己测一下。

现在要不差不多没有问题的话，我们那个要不今天就到这，主要我今天那个嗓子有点不舒服啊，就是你可能那个啥有有点影响那个讲课啊，行那我们今天就就到这哦。

GAMES401-泛动引擎(PeriDyno)物理仿真编程与实践 - P10：10. 工程CAE仿真中的有限元分析原理 - GAMES-Webinar - BV15M4y1U76M

好各位同学呃，线上的各位网友大家好，非常高兴，我们又在昨天的这个晚上有，在我们games这样的一个在线交易平台上面，大家一起来学习啊，那么今天呃主要想跟大家介绍的是。

工程C1访问中的有效分析的一个基本原理，那么在上一次的话，在上周的话，我们主要是讲解了这个ca软件对吧，ca软件相关的呃，和CE技术相关的一些知一些一些知识啊，类似于是一种科普性的。

和呃介绍性的这样的一个课程一样啊，那么在今天的话，我们主要就讲解一下，有些人分析它的一个基本的原理，就是我们在呃上上上周已经看到了ca技术，它有非常强的一个这种工程分析的一个能力。

那么它背后的一个基本的力学原理是什么，我们今天主要是讲解这一个，那么在下节课的话，我们就会结合我们判断了，和我们继续攀登的开发的match siml来讲解啊，具体的如何用我们这样的一个平台来。

做这样的一个C仿真的一个分析，那么嗯今天的课程的话主要是分为三部分啊，首先第一部分是有限分析的作用与地位啊，当然这个在上节课已经介绍一些，所以这几个是呃快速的过，那么第二个是我们讲的这个有限元分析。

它的基本的一个力学的基础啊，我们是在这个弹性力学的一个基础，那么第三个是基于弹性力学的基础，我们再来介绍一有渲染法的一个基础啊，那么这节课的话相对来讲的话，他的理论性啊可能相对会强一些啊。

理论会相对强一些啊，但是我还是尽量吧，尽量的用呃这种比较通俗的语言吧，就经常用比较通俗的这个观点，给大家来讲解一下，游戏人的一个基本的这样一个原理呃，那么首先的话其实有些人的C1的地位啊。

这个我们在上节课已经讲过了是吧，他主要是啊我们来回顾一下的话，就是他所谓的CA技术，它主要是在这个产品的研发设计过程中，利用这个计算机啊，和数值分析的这些手段，来进行建模和啊性能的一个仿真啊。

当然我们嗯轮廓的来讲啊，在工业软件几个大的几个行业就包括CAD啊，这这这个就是cad的这个啊几何的啊，绘图啊等等，还有CMCM的话就是计算机辅助制造啊，那么我们主要就叫的是CAE计算机辅助工程。

那么它具体在讲就是用计算机来进行建模，以及性能的一个仿真分析，那么我们在上节课也讲过对吧，所以一其实他CA软件来讲，其实它包含的数字计算的方法也有很多种啊，当然这个里面最常见的还是。

有些人分析的方方方法，那么它主要是起源于这个固体力学啊，然后迅速地扩展到了流体啊，传热啊，电池等等的这样的一个其他的领域，那么啊我们在今天可能在我们这个课程上面，主要是围绕着固固体力学来说啊。

但实际上他往流体啊，传染电视来讲，它基本的这些理论呢基本的原理是类似的，那么我们在上节课也讲过对吧，有些人分析的一个基本的的思路啊，这个也是回忆一下，它是利用这种数学近似的这个方法。

对真实的物理系统进行一个模拟，对我们讲的它是一种嗯，是这样的一个近似的一种求解的一个方法，也就是有些人求解的话，它求解的不是一个啊精精确解，它是一种工程中的数字分析方方法，它适合适用于在工程中。

能够解决非常复杂的工程问题，有这样的一个通用性啊，但是它的精度不是百分之百的，它基本的这个原理我们在上节课也讲过对吧，有单元的这样一个概念啊，就是我们讲的有单元的这样一个概念。

也就是说他利用简单而又相互作用的，这样的一个元素，我们称的是element的，就是单元啊，我们在上节课讲过，我们把一个复杂的几何通过网格的划分对吧，划分为三角形，四面体，六面体或者是四边形。

有很多的这种元素，我们叫网格来逼近我原始的这样子一个几何，那么我在计算的时候就是基于每一个元素啊，或者是每一个网格，我们把它们称为单元的计算而去逼近，而无线位置量的这样的一个真实的系统。

那么所谓的有些人的模型啊，它就是指我们真实系统理想化的一个，数学的一个抽象，我们在上节课也讲了这样子，一个梯子的一个例子对吧，我们在这个绿在这个左在左手边，这个绿色的是我们一个真实的系统啊。

是一个真实的信息，这个系统当我们在有序员分析的时候，我们就会用右手边的这个有序员的模型，来进行一个分析和计算对吧，他就是有一些简单的形状，那么在这里的话就是指这种一个个的线段。

来构成我们整个梯子的一个模型对吧，那么单元之间就每个线段和线段之间，它是通过节点的连接啊来来进行一个连接，而且在这些在这个节点上，它是承受一定的载荷啊，就比如说我们说考虑到真实系统，它受到一个力。

其实我们是要考虑到，它最终是加载到我们这个节点上面啊，而且我们每个节点上面，它是具有一定的这个自由度，对我们上节课讲过，有XYZ以及绕XYZ的这样子，一个转动和XYZ的屏动啊，这样子六个自由度啊。

对于我们这样在这样一个三维问题中来讲，来讲的话啊，那么所谓的自由度的话，它是描述我们一个物理场的一个响应的特性啊，对吧，这个就是有些人分析的一个基本的一个原，一个原理，那么他的思路的话。

我们在上节课也讲过对吧，它实现了一个方法，一个方法就是用有限种类的一个标准件，去构造出任意复杂的对象对吧，这个有限种类的标准件，就是讲我们的各种单元感单元呢，这种哦量这种量单元或者是333角形。

这种四边形，这种翘单元，或者是四面体，六面体这种实体单元，然后去构造出任何复杂的一个对象，那么它的一个技术的路路线啊，他其实首先基于是一种标准化的这样的，一个思路啊，标准化求解的这样的一个思路。

也就是说哦我任何复杂的这个问题，我任何复杂的一个问题，我都是进行标准化的分解啊，用这种标准化的go这种基本这种构建，这种单元进行标准化的分解，然后我在这个单元上面进行计算啊，也就是说我在单元进行建模。

那么就形成我具有有限种标准的单元，就是我这个标准单元的这种种类啊，种类它是有限的对吧，我们四面体啊，三角形啊，是这种六边形啊，它是有限的这种标准的单元，另外一个呢，它的整个的分析的路线又是很规范化的啊。

到我们所以到后面的讲解，也就到我们在下节课到下节课，当我们实际机软件来进行分析讲解的时候，大家就会发现啊，为什么我们可以用PANO这样子一个增增量集成，开放式的这样一个平台来做这样一个事情。

也是因为它的整个的技术路线，是非常规范化的啊，是非常规范化的，那么它整个的一个流程是吧，就是从我们上节课学学我们也讲过啊，就从cad的几何到数字模型啊，这里就包括是力学的这个求解啊。

然后再次进行我们这样子一个后处理的一个显，一个显示啊，当然有些人还有非常好的一个特点啊，就是它可以计算机化啊，为什么有些人可以在众多的这种，数字分析方法中能够脱颖而出啊，能够快速的发展。

它计算机化的能力是非常重要的一个原因啊，它可以形成一个标准的一个程序啊，然后构造出开发出各种的一种模块对吧，我们可以构建出各种的前处理模块啊，求解模块啊，或者是各种单元模块啊，这种本科计算的这些模块啊。

然后再形成我们这样的一个软件啊，它是非常符合于我们这种增量式软件的架构，或者是模块化编程的这样的一个思路啊，这是有些人他在啊程序化方面它的一些优点啊，他是不是可以程序化好。

那么这个就是我们呃算学习也算是回回顾一下，我们在上节课说啊，大家我们在上一次的这里讲的这种，关于CAE和有限分析相关的一些知识啊，那我们接下来就从弹性力学的基础讲讲起啊，先从力学基础啊，在这过渡呢。

我们有些人圆的一个基本的一个基础啊，那么我们首先来看一些基础的知识点啊，这个可能会比较简单，但是我考虑到可能大家啊，各位同学可和我们咱们的各位B站的网友，可能我们这个涉及到的每个专业的。

这个基基础不一样啊，所以我还是从一些最基础的讲解，那么首先我们来看这种最基本的，在弹性力学里面，我们最基本的一个定义，我们叫做胡克定律是吧，胡克定律它也就是说我们一个弹性体。

它的变形与外力是成正比的对吧，就好像我们这样子有一个弹簧，我们这样子有一个有这样的一个弹簧，诶，这怎么就放不了算了，就我们这样子一个弹簧，那么它在受拉的时候，这个弹簧就会张开是吧。

就好像我们在右手边这一幅图啊，当这样子是个弹簧的一个模型，当受到一个力拉扯之后，其实它是会有一定的生产量的是吧，弹簧最后一定的生产量，那么在这样子一个在这样子一个呃。

在这样子一个在这样的一个现象过程中的话，那么我们就说这个里面就包含有一个弹性体啊，比如说我们的弹簧其实它就是个弹性体，也就是说它的变形量与外力是成正比的啊，这个大家要记住一点，F非常关键。

就是我们所谓的弹性比弹性力学，它就是说它仅仅只是在这个阶段，就是我的受力和哦不，我的变形和我的外力是成正比的，这样的一个阶段啊，那么在这个里面外力与变形之间的关系，我们用一个F乘上K乘上一个DX是吧。

那么这个叫X的话，我们就知道就是我们整个一个生产量，那么F就是它产生的一个力对吧，就是单一，这个K就代表着我们这个弹性体的一个变形，的一个能力对吧，是弹性系数，把它的一个弹性系统弹性系数。

那么得到的一个曲线应该就是这样子的，就是力和变形量之间它是一个线性的关系啊，是一个线性的关系，当然在我们实际的过程中对吧，有可能如果说我把画笔调出来一下啊，大家稍等我调出来一下，那么其实我们当时实际上。

当我们用很长的一个量，大家不知道小时候有没有玩过对吧，我们拿一个弹簧，我用很大的力气去扯，扯完之后，大家就会发现这个弹簧，是不是他就回不去了是吧，它就产生了一个，就相当于这个弹簧被拉直了一样对吧。

我们在小变形之内，我去拉，拉完之后，我一松开这个弹簧又回到了原来的样子，但是如果说我拉的很很大的力，就把这样一个弹簧就拉直了，其实这就是因为它在后面，它会进入到一种塑性变形的一个阶段啊。

就是我现在画出来的，这个是在弹性变形的这个阶段，也就是说我的力合外力和这个变形是成正比的，而且关键的是什么，当我的外力去掉之后，当我的外力去掉之后，我的变形是可以回到原来的这个样子啊。

就是我外力撤销之后，弹簧的变形又消失了，那么这就是一个弹性变形的一个过程，但是如果说我们的力加载过大，就好像我把弹簧拉直了，那么就涉及到了后面这一个塑性变形的数，数性塑性变形的这样的一个阶段。

那么在竖线变形的这个阶段，首先它有几个以太一的特点，就是说它的力和它的位移之间，它不是一个线性的关系了啊，它不是线性的关系，它可能是这样一个动震荡的，这样的一个很随机的这样的一个关于关系，另外一个特点。

也就是说当你发生了竖线变形之后，你的外地撤掉之后啊，你的这个变形是回不去了啊，就像我把弹簧拉直的，他是回不去了啊，他就保持到现在的这个样子，或者是呃稍微有一点变，有点变形，反正他是回不到原来的那个样子。

这就是说我们从从弹性和塑性，它们之间的一个关系，但是我们在这里，我们首先从学习的简单程度来讲，我们首先从弹性变形这个角度开始学，开始学习，那么这就是逆对吧，关于力的这个概念。

但是这个我相信大家都学过是吧，我们从初中啊，从高中啊，大学啊都会学到力的基本概念，但是我们也来来快速的回顾一下吧，因为后面都会围绕着力来讲，那么力其实它是指的，物体间的一个相互的机械作用是吧。

它的这个作用的结果呢，是指的我们物体的这个形状或者是运动的状态，发生改变啊，发生改变，那么它的一个效应是吧，它的一个效应，也就是说它的这样的一个运动状态啊，等一下啊，这个电脑端的弹出窗口，不好意思。

它的一个效率，就是我们运动的这个状态变变化啊，是一种运动的效应，那我们是进行理论力学的一个研究，因为我们其实关于力力学，我们学过很多的力学是吧，理论力学，材料力学，结构力学到这种弹性力力学。

其实在不同的这种我们在不同的这种假设，或者是在不同的研究的对象哇，我们采用的这种力学的研究的方法，其实是不一样的啊，其实是不一样的，当然对于力来讲的话，有基本的三要素对吧，有基本的一个三要素。

那么就是它的大小啊，方向和作用点，力的大小，方向和作用点，这是它的三要素，那么表示的一个方法，我们力当然是它是有方向的对吧，所以它是一种矢量矢量，那么采用的是矢量计算的这种符号来进行表示。

那么单位制的话，力的单位我们都知道是牛对吧，就是牛顿牛啊，这样子一个力的一个基本的概念啊，那么我们再来看一些扩展的，讲一下我们主要研究的一些对象啊，一些主要研究的一些对一些对一些对象。

那么我们比如说我们研究这种改进结构啊，就像这样的一个改进的一个结构，也就是说像这种结构的特点呢，它就是说它的长度是远大于我的横截面积是吧，长度是远大于这个横横截面面积。

就是它长远远比它的长宽和高都要大一些，那么我们就可以把它看成是一个杆件结构，那么对于杆件结构的研究呢，我们一般是采用这种材料力学进行研究啊，这材料力学进行研究，那么第二种结构我们叫做薄壁结构啊。

薄壁结构大家看到，那么对于薄壁结构常见的，如果说你是一块平的，那我们一般是讲它是一种板啊，是一种这是一种这种板，那么如果说我的这个面是一个曲面啊，像下面这个它是个曲面，那我们就叫它是一种翘啊。

一个是一个板，也是一种翘，但是这两种结构的话，我们都归属于是薄壁结构啊，因为他们在两个尺寸两个方向上面的尺寸，也就是说它的长和宽远高于它另外一个尺寸，就是它的这个高啊，也是它的厚度是吧。

它的厚度也就是它像一个板一样，那我们这个叫叫的是薄壁结构，那么还有第三种结构呢，我们叫做实体结构，那么这个实体结构就比如图所示，非常的清晰是吧，就是我三个方向上面的尺寸。

具有基本上类似的这样子一个大小啊，那我们这就叫做做实体的结构，那么对于薄壁结构和实体结构的研究的话，那我们这里写了个弹代表什么，就是我们这个就会用弹性力学啊来进行研究，用弹性力学来进行研究。

那么对于这种杆件变形啊，如果说我们回到这种杆件变形，以杆件变形为这个特点，我们来这个了解他这种受到各种的外力啊，所产生的一个变形的一个特点对吧，如果说他是受到了一个轴向的拉伸或压缩对吧，那么横很明显啊。

他腕力的特点就是我沿着轴向还有个拉伸的力，或者沿着轴向有个压缩的一个力，那么它导致了一个变形，就是说如果说大家看这个变形的特点，是代表什么，就说如果说我受到一个方向上面的拉对吧。

我比如说受到走向的一个拉力，那么它在轴向的这个方向上面，其实它是伸长的，但是呢同时一定要注意到的话，他在这样子一个横向对吧，在这个跟走向垂直的这样的一个方向，他却是缩小的啊，就是变窄了。

就本来有一个宽宽的这样一个结构对吧，宽宽的一个一个结构，因为这个图画的有点复杂，受到一个例子后，它就会变成一个长的对吧，变长的就是轴向是伸长，另外一个方向就会缩短，那么相当于呃相反的。

如果我受到一个压力对吧，那么我可能就缩短了对吧，但是我缩短了，这其实我另外一个方向它就会变宽对吧，这个是受到它的这样子，一个拉伸和压缩的这样的一个情况啊，另外就是说如果说他是受到了一个。

比如说我们受到一个平面的弯曲对吧，受到的一个弯曲的话，那么它就可能会随着我们这个约束，就是我们支撑点的不同对吧，而产生这样子，一个连续的这样一个弯曲的一个变形啊，连续的这样的弯曲的变一个变形啊。

当然实际上在实际的情况中，这种感性的这种变形，它肯定不也不仅仅，只是受到单一的外力的作用是吧，它有可能是受到一个主和的一个受力，像这样子我既受到有弯曲，中间这里我又受到了有这样的一个力对吧。

那么就产生出这样的一个变形出来啊，这个是它变形的一些基本的形式，也就是说我们在对于这种力学分析的时候，我们就要考虑到它的种类有很多种是吧，一个是轴向拉伸，一个是轴向的压缩，另外另外还有剪切是吧。

剪切剪切，也就是说我们对于这样的一个物体啊，我这受到了两个相对的这样子一个力啊，少相对的这样子一个力，那么他就会在我们这样的这个表面上，会产生一个剪切力对吧，剪切力就是我们在做啊材料拉伸实验的时候。

就会导致我们在这样的一个事件啊，应该找一个那个图片啊，我没注意，就是说受到了一个拉伸，它有减轻力之后，它就会呈45度的这个方向发生一个断裂，还有一种我们讲的变形的形式就是扭转啊，就是牛就是扭转。

就是绕着一个点这样子给他一个扭转，对这样子一个转距的这样的一个加载啊，还有就是受到一个像这种平面的弯曲对吧，就是这样子一种受力和变形的一个情况啊，当然还有一些基础的一些知识知识点啊。

就是我们经常会讲到什么强度啊，刚度啊等等，那么其实所谓的强度呢很简单，它就是我们讲啊，我们这样子整个构建抵抗破坏的一个能力啊，抵抗破坏的能力，也就是说当我这样子一个构建。

当我受到这样子一个很重的一个外力，比如我一个钩子，我上面受到一个很重的一个力，但我这个钩子的这个B它会不会断掉是吧，它会不会断断断掉，那么这个就是通过强度来进行一个评估，当我的强度很足够的话。

那我整个这样子一个感情是不会发生断断裂的，它能够承受得住我这样子这个重物啊，这个就是我们评价的强度啊，这个我们在啊接下来的两节课，包括在下节课我们讲软件使用的时候，会经常讲的强度的分析啊，刚目的分析啊。

模特的分析啊，他们主要是做什么功能啊，这个大家都知道，那么强度就是指构件抵抗破坏的这样的，一个能力，那么还有一个呢我们就叫做它的刚度啊，刚度和强度的区别就在于刚度。

它讲的是我们构建去抵抗变形的一个能力啊，强度就是我有多硬是吧，我有多硬，那么刚度其实你就把它想象成，我有我有多么的这个稳定啊，有多么的稳定，就是我去抵抗并行的这样的一个能力，比如说我像这样的一个支架。

那么我去放一个很重的一个物，那我就要去去去分析诶，我下面这个支架，当橙色这个重物的时候，这个支架它会不会发现很大的一个变形对吧，也就是说他虽然没有断掉，没有断掉，但是它发生了一些形状的变化。

比如说被压被压矮了是吧，被压变形了啊，那么这个就是我们讲的一个刚度，刚度的一个概念，那么还有一个问还有一个概念，我们叫做稳定性分析的一个概念啊，稳定性分析的一个概念，其实它评价的就是说。

我们的构建在保持原有平衡状态的，这样一个能力啊，也就是说我当受到外力的这个加载的时候，我能不能圆始终保持，我原来是已经有了这样的一个，平衡状态的一个能力啊，这个的话我们相对可能提的会少一点。

稳定性能上面会少一点，那么在有限元分析里面，那我们讲的哎呦，不好意思啊，嗯没事，不好意思啊，这个PPT怎么一下子跳过去，好在再回过来啊，大家稍等一下啊，也就是说我们在有在有限语言里面。

其实我们最常见的还是去分析它的刚度啊，和它的强度啊，和他的一个强度，其实这里面都有动画的，但都放不了，为什么，啊这个就是我们讲的一些基本的知识点啊，一些非常基本的一个知识点，好。

那我们接下来看这个弹性力学的一个，研究的对象啊，弹性力学学的一个研究的对象，那么首先我们现在弹性力学是干什么的，弹性力学是干什么的，那么弹性力竭我们前面讲过，它主要是研究这个弹性体在外界因素。

那么这个外界因素就包括外力的作用，温度的变化呀，以及边界的约束等等，它的一个影响上，它内部所产生的应力形变和位移的，这样的一个学科啊，就是说我一个弹性体啊，类似于有个弹簧能保一个弹性体。

它在外界的作用下，他受到一个力，那么它在内部会产生怎样的一些应力啊，形状的变化呀等等的这样的一个学科，就好像我一个弹簧受到外力，它的形状发生改变，会伸长对吧，那么伸长量是多少呢。

那么我们就是用弹性力学来进行一个分析，当然弹性体的话，我们前面以弹簧为例，已经给大家讲解的很清楚对吧，它是只有弹性性质的一种理想物体，也就是说它的这个变形和力是成正比的，而且当外力撤销之后。

变形是能够哦，或或者是也是会撤销，回到原来的这个状态对吧，那么这个就是一种具有弹性性质的，一种理想的物物体，那么它的性质就如我前面讲的，就是，应力和应变之间存在着一一对应的这个关系，其实也就是力和。

因为我们还没讲应力和应变啊，可能大家学学过的，知道，没学过的同学，就还是把它想象成是力和这个变形，它们之间的一一对应的关系，而且是当作用去除之后对吧，它能够回到它原来的这样的一个状态，的一个特性。

那么它的研究对象啊，他的一个研究对象，就包括我们前面讲的几种对象，都要包括板翘啊这种薄壳的这种结构啊，这这种薄壁的这种结构，那么也包括像我们在土木里面地基啊，水坝呀，防土墙啊等等这样的一些实体结构啊。

当然在工程中那就更多了对吧，我们的发动机的这种发动机的啊，这种这种机的壳子呀，变速箱的这种箱体啊对吧，各种汽车的车身啊，其实他们都是啊我们属于一种实体的这个结构，那么其实它相对于杆件结构的这种研究。

它是会作为更为精密的一个研究对吧，我们前面讲的那个楼梯分析楼梯的时候，我是直接用杆单元去简化我那个楼梯对吧，就把原来的一个楼梯转化为几个杆，但是如果说你用弹性力学来研究的话。

那我们就会进行更加精密的一些研究啊，不会说仅仅只是作为一维的一个单元啊，可能用二维或者三维的单元来进行一个分析，那么他的研究的任务啊，研究的任务就是我们要弹性，用弹性力学，我们要研究的任务。

主要是分析结构物和构建，在弹性阶段的应力和位移，去教和它是否具有所需的强度，刚度和稳定性对吧，强度刚度和稳定性我们前面已经讲了，寻求或改进他们的计算方法，采取最优的方案去解决安全与经济的矛盾。

我为什么要在这里把这个研究任务，是这样子来总结啊，就是又又要回到它的一个作用上来讲，其实我也是想跟大家再次回到，我们在上节课讲过讲过的这种C1仿真，就是工业仿真和物理仿真之间的一个区别对吧。

大家就发现在C1仿真里面它的一个目的，我再分析出它的应力和位移对吧，它受到的力和它的变形，那么在物理方程中，大家也知道，我们也能算出它的一个力，和他发生了一个形状的变化嘛，也是一种位移对吧。

但是在工程中我不仅算完之后，我还要进一步的去把它转化为去评价啊，去评价它的刚度强度和稳定性，就是力和位移，我算出来，我要是进行刚度强度和稳定性的评价的对吧，那么在物理访谈中。

我们更多可能啊从很多的场景中，很多的场景中，包括电影啊，游戏啊，可能它更多的是一种哦呃视觉啊，图形上的一种近似对吧，但这里我们就不一样，我们要把它反馈到它具体的一个物理的性能，更重要的就是说。

我们还要去寻求和改进它们的计算方法，也就是什么呢，就是我当分析完之后，我发现刚度不够，强度不够，我一定还需要去改变去进行优化对吧，比如说我的刚度诶，我设计完一个结构诶，我发现这个刚度啊强度有点太低了。

达不到我预期的目标，那我就要改进我原来的这个结构，根据我工业仿真所得的结果对吧，改进它的结构来提高它的强度和它的一个刚度，当然我们为什么说要解决安全与经济的矛盾，对吧。

那么这个是计算机仿真非常重要的一个特点，也是它的一个对照的，为什么现在在工程中啊，在我们比如说在在我所熟悉的，在汽车这个行业中，它的应用非常广，泛，是因为它能够通过计算机仿真的这种手段。

得到一个最优的一个方案，而且而而我不需要去做大量的实验呀，或者是我得到一个非常高的这样的一个，安全的玉玉度是吧，我们为什么说在这种军工以前说在军，但现在也不一样了啊，以前在军工里面。

比如说我们去造一个飞机，造一个坦克，其实我们不太需要用到4A1分析，为什么不需要用啊，尤其是坦克这种对吧，飞机其实是旋翼飞机，我要考虑到它的一个轻量化，它一个起飞的重量，那么坦克其实我不太需要去考虑它。

进行CA分析为为什么，因为我反正我不太追求它的轻量化呀，燃油经济性，因为它这种小批量生产的这样的一个产物，我可以把它的结构做得非常的扎实对吧，根据工人的经经验，本来做的很扎很扎实，那么它的安全。

它的性能肯定是够的啊，对肯定是够的啊，那么这种啊就是我不需要考虑经经济性，那么在实际的民用产品中，那就不行对吧，你既要安全，也要考虑我的经济性啊，那么在材料力学和弹性力学的这个区区比啊，因为我们在呃。

我不知道在在座的各位有没有学这个啊，是工程相关这个专业的，就是我们一起学，可能最开始学理论力学啊，再到材料力学，再到产量，弹性力力学，当然这个简单讲一讲，弹性力学和材料学的一个区别。

因为一般来讲像我们上课啊，我以前读书上课，我们先上的是材料力学，然后再上弹性力学，材料力学应该是到了大三大四，我们才去上这门课，那么他首先对于材料力学来讲啊，其实前面也讲过对吧，我们对这种杆状结构。

它主要是用材材料力学，但是对于这种实体结构，我们就是用弹弹性力学来进行一个研究，那么呃研究的范围呢，弹性力学我们讲的是研究它的这个呃这个啊，弹性阶段这段是吧，但是对于材料力学，材料力学来讲的话。

它还会研究到物理的一个塑性阶段，包括不变啊和疲劳啊啊这个叫什么意思，就是会研究到我前面讲的到的曲线的，这个后面的这个阶段对吧，他发现了这种塑性变形的这一个阶段，那么研究的方法的话。

就是说大家都会有一定的讲，有一定的假设，但是我们在做些力学问题求解的时候，都会有一些假设，那么材料力学的话，它主要是对于应力的分布或者是形状的状态，做一些近视的假设，那么得到的结果呢往往是近视的初等的。

那么只能在一定的条件下来进行使用，就是我们很多一些呃，就是在我们弹性力学的书上面啊，我记忆最深的就是他有一张表对吧，然后在表里面就有一些常用的一些结构啊，受到一些利之后，其实你就用代入代入这个经验。

经验性的公式去进行计算，就可以得到一个近似的一个结果，但是弹性力学就是不一样对吧，他是从基本假设出发，它对物体的应力啊变形进行精确的分析，那么得到的结果更为的精精确，但有时候它也可以用来去教。

和我们产线列举的一个结果，因为它结果更更准确嘛，那么我们在进行弹性力学，这样之后，弹性力学它有几个基本的假设啊，这是我们在进行弹性力学讲后面的一些公式啊，分析的时候，它有几个基本的假设。

那么举分别是它的连续性假设，完全弹性假设，这种均匀性假设，各项同性假设和小并行的这个假设，那么引入这个假设的目的，主要是希望我们能够用数学的工具啊，来研究我们的弹性力学对吧。

因为我们用数学的这种工具来研究弹性力学，那我们来一一的看一下，那么首先第一个我们叫做连续性假设，那么所谓的连续性的假设，它从宏观上他是说我这个物体它是连续的，也就是说我在整个一个物体中。

我的物理量像应力啊，应变呀和位移啊，那么他们都可以用坐标的这个连续函数，都可以表示的是坐标的一个连续函数，就是FX对吧，那么这个X代表是坐标，也就是说我的这个力或者是我的这种啊，伊利啊。

我的sigma啊，我的是sigma西格玛X啊，那么它都是随着坐标的一个连续的一个函数，那么这样子的一个假设的好处是什么呢，为什么我们要把它假定是连续的，那是因为我们在进行计算的时候，进行推导的时候。

我们就可以用连续和极限的概念，来采用我们讲的微积分，微分呢，这样子一些数学的工具来对弹性力学进行研究，对吧，如果说你不是连续的，那么你都是不可都是不可导的，对对对吧，是不可导的，无法去求一个极限。

那么就会非常的困难，所以我们有个连续性的一个假设，那么第二个我们叫做是完全这个弹性，假弹性假设，那么它是指这个当这个物体产生变形的外力，被去除之后，物体能够完全的恢复物这个圆形对吧，这我已经讲过很多次。

这样子的话，当温度不变的时候，也就是在任何一个损失的形状，完全取决于他这个损失所受到的外力，与他过去所到的历史无关，也就是说我任何时候的这个的形状，是因为我这个时候受到的力所产生的一个变形。

而不是说因为我这个形状，是因为我前面那一个时刻，手动的力度是达到的一个结果啊，这个大家要记住，当然它有两个阶段是吧，一个是线弹性阶段，一个是完全弹性阶段，那么对于我们的两个材料参数的话。

我们有一个叫做比例极限啊，线弹性下面有一个比例极限，以及我们的弹性极限，这样子两个值，那么这样子的一个假设啊，我们为什么要做完全这种线性，完全弹性假设的这种假设的话，它能够使得我们的本构方程。

也就是说去描述应力和应变这样子的一个方程，我们的本构方程它是一个线性的方程，它是一个线性的一个方程，这也可以为我们后面用数学工具进行计，算和推导，产生很大的便利性和好处啊和好处啊，嗯那么对于啊单元。

我们在实际过程中遇到的材料，也不一定完全是一些弹性材料对吧，它可能是一些脆性材料，也可能是一些塑性材料，但是脆性材料和塑性材料，我们也可以用弹性力学来进行研究，但是对于脆性材料。

比如说我们就说要求它的应力啊，在没有超过比例极限啊，这是在我这种线性弹性的阶段，那么它可以来进行把它近似为这种完全弹性体，来进行分析，那么对于塑性变形材料，就好像前面我说的。

将你没有超过这个屈服直线对吧，也就是说当你的材料变形，我把它画一下对吧，像我们现在讲的对于塑性材料，它的一个变形，立刻变形，应该是这样的一个关系是吧，当当然在这个地方。

这个啊这个点这就是我们讲的这个屈服极限啊，屈服极限，也就是说当你的整个应力，你的应力没有超过这个区域，直线都还只是在这一个线性这个阶段的话，那么它也可以采用弹性力学来进行研究。

当然你要去分析它超过屈服极限，到了数性变形的这个阶段，那你就可能要用塑性能力这个力学啊，去进行一个分析啊，进行一个分析，那么这是他的第二个假设，第二个假设的意义啊，大家一定要记住啊。

是为了让我们后面讲的本构方程，是一个线性的方程，那么还有第三个均匀性的假设啊，均匀性的假设，那么均匀性的假设，他是说我的整个的物体，是由同一种材料所构成的啊，这个大家也要记住啊，它是由同一种材料。

就比如说我们在汽车里面有一个零件啊，我一个变速箱的箱体，那么它可能都是由柱体啊，有这样的一个金属材料，同一种材料所组成的，这样子的一个好处是什么呢，就是说可以保证我整个物体所有的各个部分。

它都会具有相不同的物理性质对吧，那么由于是同一个材料相同的物理性质，那么我们这样子的话，它这个物体的弹性常数啊，就比如说我的弹性模量和泊松比啊，后面会讲就不会随着位置和坐标和改变，这样的好处是什么。

好处呢，就是我们后面得到一些，比如说刚度矩阵的这种矩阵对吧，它就可以进行一个模块化的表达，模块化的一个表达啊，这个大家后面可以看到它的好处啊，那么我们就可以取物体中任意的一小部分，能够分析。

然后把分析结果运用到整个整体对吧，我们讲的有限元分析，有限元分析是一个整体，我这样这个总体我是把它划分为一个，很多个单元对吧，很多个单元啊，这样子我随便画啊，很多个单元来进行分析。

那为什么我可以说中间的这一部分的，比如我只要去计算某一个单元，然后就可以把分析结果应用于整个物体呢，是因为我们整个物体，它是由同一种材料所构成的啊，这个是我们讲的均匀性的假设啊，均匀性的假假设。

那么还有第四个假设，我们叫做各项同性假设，各项同性假设是说我们在分析的这个对象，它的每一个点在不同的方向上啊，就是说我一个材料对吧，我一个材料我一个材料在不同的方向XYZ啊，在不同的这个方向上。

在不同的方向上，我都是具有相同的物理性质和机械性质啊，那么这就可以保证它的弹性模量和泊松比，这些弹性常数啊，不随着方向而改变对吧，均匀性假设是假设什么，大家总结一下。

均匀性假设是假设我们的弹性材材料参数，不随着坐标变化对吧，不随着XY的我的位移坐标变化，那么各项同性假设是，假设我的弹性模量和泊松比这些弹性常数啊，它不随方向变化啊，它不随方向变化，那么还有第五个假设。

我们叫做小变形假设啊，这个也非常重要非常重要，因为我们到后面去进行计算的时候，我们很多的高阶项我们都会忽略不计啊，高阶项忽略不计，那么高阶项忽略不计的原因，就是我们前面也会有一个小变形的一个假设。

那么所谓的小平行的这个假设是指，当这个物体它受力之后，那么我整个物体所有点的位移，都小于物体的原有尺寸，也就是说我的变形量对吧，我比如说我这样子一个悬臂梁，我这样的一个悬臂梁。

我可能发生了一点点形状的改变啊，发生形状的一个改改变，变成了这样的一个形状，变成这样的一个形状好，那么就或者说我这边这个点A点A点对吧，那么它就变大了，到这个点A1撇变到这一点了，那么它的这个位移呢。

我们当我这画的有点夸张啊，这个其实是比较大的，这种变形的，也就是它的这个位移量都小于物体原有的尺寸，相当于原来的物体的尺寸变量是很小的啊，那么这样子啊我们就可以得到一个什么好处呢。

在我们在考虑物体变形之后的平衡状态，因为我们要构建平衡方程进行求解对吧，我可以直接用变形之前的尺寸，来进行一个近似的代替变形之后的尺寸，而不产生显著的误差是吧，他肯定会产生误差对吧。

因为我比如说我这一个变形对吧，我这一个尺寸本来是从这里变形完之后，变成这么多，他肯定是伸长的，但是我为了简化计算，我还是用原来这个尺寸来进行计算，他肯定会有误差对吧，但是这种误差可以接受啊，可以接受啊。

这就是再次强调吧，我们讲的弹性力学啊，或者是有些人分析他这种近似求解的方法对吧，它是有假设在这个里面的，那么这个是它的第一个好处，那么第二个好处就是我刚才提了一嘴，就是说在考虑物体变形的时候。

那么关于应变和转角的平方向或者是乘积项，也就是说它的高阶项对吧，比如说X的平方呀，或者是X乘以Y啊，这种平方向，那么我们就可以把它忽略不计啊，成这种乘积项或者是X平方，这种平方向肯定忽略不计。

那么这样子的话，我们就能够将弹性力学中的微分方程，把它变成线性方程来进行求解啊，大家有发现这个时候我们前面讲了对吧，我们要确保我们的物理方程是线性方程，那么其实这个小变形的话又是进一步的。

要保证我们在里面形成的，其他相关的一些微分方程的话，它都是线性方程啊，线性方程，所以这个就是小变形的假设，这个弹性力学的五个假设非常重要啊，因为我后面在讲的时候都会反复的讲的A2，为什么会是这样子算的。

那就是因为它有五个假设在这个里面，有五个假设在这个里里里面啊，那么在连续性完全弹性，均匀性，各向同性小变形这五个假设之下，那么我整个的弹性力学问题，就成功地转变为了一个线性问题，好线性问题有啥好处啊。

我一个是求解方面，另外非常关键，我们可以直接利用我们的叠加原理啊，叠加原理，所谓的叠加原理，也就是说我们的一个物体，在这种线弹性和小变形的这个情况下，作用于物，作用在物体上的几组的载荷。

产生的应力和变形的紧总效应啊，可以由单独的每组载荷的作用效用之和，来进行计算对吧，你就算大家看一开始我是一个这样的物体对吧，我既受到了一个外力批，我内部又有我的体力Q。

然后在这边这个策略还受到一个这种非均匀的，这样的一个均布力对吧，均一个均布力，那对于像这样子一个受到一个三项外力作用的，一个三项外力，这种三组载荷的这样子一个问题的求解，我就可以利用叠加原理。

我分别计算啊，分别计算第一个计算，在这种啊非均布面临的这样子一个情况下，面，我的一个呃应力和变形的一个效应，然后再算受到体力Q的一个应力和变形的，计算力，再算受到一个P，他这样子。

一个万历这一个应力和变形的一个效应对吧，然后我再把它累加到一起去啊，就得到这样一个复杂，这样子一个受力情况，下，面的一个整体的一个应力和变形的一个总效应，这是叠加原理，这个后面我们也会用得到的。

那么接下来我们再来还是一些基本概念啊，这个后面我就快一点了，因为前面的五个假设是比较重要的啊，这个我就讲的稍微快一点，那么因为我觉得这种理论课的课程啊，不适合于上的很长啊，时间上久了。

大家觉得很难集中注意力，那我们就把挑一些重点来讲啊，不种这种概念性的，我们就快点过了，那么外力啊我们讲包括体力和魅力对吧，它是指是其他物体啊，对研究对象的作用力啊，就是外部嘛，就是我的研究对象。

外部其他物体对我的注意力，那就是外力对吧，他包括有这种体力对吧，就是说分布在物体，当然这里面有个体力对吧，就是说分布在物体体积内的力，如重力啊，惯性力啊，电磁力啊等等是吧。

那么它是以单位体积内的力来进行一个度量啊，进行进行度量，这是体力，那么它的符号的话，它也是个矢量对吧，它沿着我的力的这个方向，是它的一个极限的一个一个方向，那我们在计算的话，其实它是等于。

如果我们进行一个三个方向的自由度对吧，XYZ3个方向的自由度，我收受到了一个体力，那么它的一个合力就是三个方向的力的平方，在之和再开功放啊，再开根号对吧，就是它的一个核的一个体力。

那么它是沿着坐标的正向为正对吧，还有面积，面积的话就是分布在物体表面的力，其体力是在物体体内的力，命令就是表面能力，比如说我们受到一个流体的压力啊，或者是一个结节处理，那么它是以单位面积啊。

前面是单位体积，就是单位面积所受到的力来进行一个渡衡对吧，同样的也是我们笔试有三个方向，我们进行一个啊累啊，平方累加，再开根号，那么它是以对外为正，那么体力和面力呢它是军事表示。

表示的是单位体积面积上的作用力，所以在考虑平衡条件求和时，必须要乘以相应的体积力和面积啊，这个大家要注意，那么你在写一个有限的程序啊，其实我以前就走过这种弯路啊，我在最开始学的时候啊，在做一些课题。

在写就有线性程序的时候，比如说他说他给的体力和命令是多少，那么我在计算的时候，我就直接把这一个物体所受到的整体力和命令，就是认为是他给的这一个值，但实际上它不是这样子的对吧，那你在求合力的时候。

因为它是指单位面积上的一个力，那么你要乘以它相应的体积，或者是它的面积对吧，体力的话，那你就要以他的单位例乘上它的一个体积，面积的话，就以它的单位率乘上它的一个面积，才是它的一个合力啊，这个大家要注意。

那么再就是内力，内力的话，它的定义的话，是我物体本身不同部分之间的相互作用的力，相互作用的一个一个力，其实大家就把它夹一下，为我把一个物体切开，把一个物体切切开，那么截面两边相互作用的这个力啊。

我把它切开之后，截面两边相互作用的这个力啊，那么这个我们就把它叫做是啊内力啊，就是我在本身这个不同部分之间，我在物体内部内部，不同部分之间的一个作用力啊，物体内部之间的一个作用，一个作用力。

这就是应力了啊，当然前面已经讲了很多是应力啊，相信大家应该也知道应力的概念，让我们回顾一下，其实应力，他这是截面上单位截面积上的一个类离子对吧，那我们就知道它的应力其实是等于A，F要除上A对吧。

F要求上A，也就是说我的力除上我的一个面积啊，除上我的一个面积，那么就是我的应力得到的是单位截面积上面的，一个内力值对吧，那么我们一般的在这种力学里面，我们都是用的sigma对吧。

用sigma这个符号来表示应力啊，来表示应力，当然它是指这种，如果是我是作用在截面法向啊，再比如说我的这个方向法向上面，这个方向上面，反向就是垂直于这个表面的这个方向，我们说是它的法向方向。

我们就称之为是正义里用sigma，那么还有一个剪切下的，就是平行于我这样的一个表面，平行于我这个表面上面的这样子一个硬币的话，我们是用top，我们叫做是这样子一个剪应力是吧，剪应力来进行表示啊。

这是用套这个符号来进行表示，这个我们讲的应力的概念啊，那么对于对应于力对吧，我们前面回应的是力的基本概念，那么应力的话呢其实它也一样的，它也有几个要素，它除了力所有的大小方向和作用点之外。

那么应力还有非常重要的一点，就是它有一个作用面，对吧，它有一个作用面，因为它是指单位面积上面的一个力嘛，所以它有一个一个作用，一个一个作用面，那么不同的这样子一个截面上，就点边上，在不同的截面上。

它的应力呢它是不同的，也就是说我们在这样的一个物体中是吧，我们在这样子一个物体中，如果说是吧，如果说我是受到的是这样子一个情况啊，就是我一个物体两端都送到了一个N对吧。

受到了一个N那么在这里在中间这一点的话，N两个方向N相反的力他就抵消掉吧，那我们就没有力，它就为零，它就没有应力，但是对于像这种情况，如果说我只是一端受力，只有这一段受到的一个力对吧，受到的赢一个力。

然后我要分析它是这一个垂直的这个截面上的，这个利率的话，那我们的这个应力是吧，sigma正，它的正应力就是等于N除上，A就是等于逆除上面积对吧，这是他的正义力，但如果说我要分析在这样的一个斜的面。

上面的一个应力，那么它又跟这个不一样，虽然都是过点P这个截面对吧，都是过顶皮，这个面都截面都要过的皮，但是它的不一样，那如果说我是这种鞋的话，那么斜的话，那我们就要考虑他干两个方向上对吧。

一个是他的正应力啊，就是在垂直的这个方向上面这一个力对吧，有个西格玛，那么还要在平行于这个面的上面呢，我们还有一个力，我们叫做掏啊，他那么他们的一个计算，无非就是我要乘上一个角度嘛。

乘上它的一个角度就是把这个N对吧，把N沿着这两个方向上面进行一个力的分解嘛，然后再去除上我的面积啊，除上的面积，就得到了它在两个方向上面的这一个应力，一个是正应力，一个是检验力。

那么也就是说我们只啊虽然说对于一个物体中，它过了点P，但是它不同截面上的应力呢是不相同的，那么我们为了要分析点P的这个应力状态，我们可以通过P点上各个截面上，应力的大小和方向，采用的一个方法呢。

就是我们在P点取出一个无穷小的一个平，行六面体，然后用六面体表面的应力分量，来表示P点的应力，也就是说我们在实际的分析中，我们会在这个里面，在我这样一个实体结构中，取出一个小小的六面体出来啊。

取出一个小小的一个六面体出来，来进行一个分析，那么取出六面体之后，这个时候从我整个物体中哎，取出了一个小的一个六一个六面体，那么我要分析P点，它的状态的话，就是分析包含PDP点的这样的一个。

微小的正六面体是吧，那么他有些基本的一些啊特性是吧，他首先它有一些能编对吧，对应于三个坐标轴的长度，分别有这种啊pa对吧，就这个长度，然后有PB1，还有PC对吧，这个对应的就是我在三个坐标轴上面的。

一个长度，那么呢对应于这里我们用这个data x啊，就是在X上面我们截取的这个长度为Y上面，解决了这个长度data y，然后再在Z上面几层是data z啊。

那我们就形成了一个我们叫做是data x data，这个鼠标写字不太好写啊，大家注意一下，因为要推直播啊，用那个平板又不太好弄，那么就得到X对Z和对的Z是吧，这样子一个微小的一个六面体。

我们来进行一个分析啊，我们来进行一个分一个分析，然后我们再将每个面上的应力啊，我就分析它六它六面体有六个面嘛，那么我在分析，他把每个面上的应力都分解成，一个正应力和两个切应力。

因为它是在XYZ这样子一个三维坐标系中，那么我对于每一个面，比如说我以这个面为例啊，以这个面为为例，那我们就可以分解成一个，是沿着我这个面的法向，就是Y这个反向对吧，我看的是这个面啊。

大家看的是这个侧面最右边的这个侧面，那么我沿Y就是它的反向有个正应力，就是sigma y，那么同时呢我沿着另外两个方向X和Z对吧，我分别还有两个减一力啊，用减一力toy z x和toy x啊。

Toy x，那么在这个里面sigma y toy z toy x这些下标，那么这些下标都是有明确的含义啊，有明确的含义，那么比如说对于检验力套IJ，比如我们套YX套YZ对吧，那么它总体表示就是套IJ。

那么IJ就分别等于XYZ对吧，那我就组合为XYXZYZXZ是吧，各种组合的这个形式有六有六种，对应于第一个I我们它表示的一个作用力，是讲作用面的一个外法向的一个方向，那么大家就看还是看我讲的这个面对吧。

我们发现YZ和套YX在这个面上面，它的第一个下标都是Y，那是因为它的第一个下标，代表的是作用面的外法向方向，也就是说Y是它的外方向方向嘛，这代表的是Y是吧，那么第二个Z这个J啊，J就指的是逆的指向对吧。

那么我想我们有YZ，那么我们就是这个力分解完之后，就是指向ZZ的，因为我们是把逆向XYZ3个方向进行分解吗，朝Y方向分解了，变成了我们的正义力对吧，朝Z方向分解了。

就变成了我们的toy z这样的一个减一力，那么它X方向分解的这一个力，我们在除上面积就可以得到它的套YX这样子，一个减一力，那么X就是沿着X轴的一个力的方向对吧，这是它的下标的意义，那么对于正应力啊。

SIGMI啊，semi这个里面虽然说我只有一个字母I，但实际上我们这里其实用到了我们后面会讲的，wait法则是吧，warning的法则，那么其实它表示的是IIII，也就是说套X其实它是等于套xx是吧。

它也包含两点，其实是作用力面的法向方向和力的方向，但是因为其实大家看一下套Y他的Y方向，方向和力的方向都是YY是吧，所以说你如果写完整，其实他应该是sigma y y对吧，但是我们为了简写。

我们用这个VOLU法则啊，用word规则，问题规则v o LT word规则的话，那么我们其实旁的简写是sigma y对吧，sigma y啊用一个来进行表示就够了啊，所以这个是我们讲的应力向标的。

这样的一个含义啊，这个也很重要，因为要不然的话，很多公式大家可能后面就看不懂了，就看不懂了，还有就是力的表示对吧，当然我们讲还有力的方向和他的政府啊，它的方向和政府，那么对于印度的政府。

如果说我们在某一个面上面，外法线是沿着坐标轴的正方向，那我们就说这个面上的应力，就是沿坐标轴正方向为正，沿负方向为负对吧，那比如说对于sigma y对吧，它的是沿着X轴的正方向。

那么就说我沿着这个X轴正方向的应力就是正，那如果说我沿着X方的反方向的，那么它就是负啊对吧，负那么相反的嘛，所以这个它的一个正这样子一个啊正负啊，当然这个里面呢我们也要注意啊。

其实对于这种对于这种材料力学，材料力学的这个分析来讲的话，它的政府规定是不一样的啊，这个往后面再讲，在这里，如果截面两侧的物体上的内力和应力，都是成对出现，且数值相等，方向相反作用于你反作用力。

那么采用上去的规则，则则解开则则解开两部分啊，遵守同一个规定啊，这个就是说我们对于呃，两侧物体上的这个力的一个规定，因为在这里为什么要强调，因为对于弹性力学来讲，其实他给我们分析的方法是不一样的。

弹性力学分析，它是假设包大家记得一种这种左右手，左左左手原则，或者是右手右手原则的一个概念啊，也就是说截面上面的剪应力，对于截面上任意一点的举为顺时针转动，那我们就是正如果是一直能转动啊，它就是为负。

那么这个就是我们讲的它的方向啊，当然这里呢就会要讲到一个切应力互等的原理，所谓精力不等的原理呢，前面刚才讲了一下，因为我没这个图不好解释，我们这得解释，也就是说在受力物体相互垂直的两个表面上。

寿命物体相互垂直的两个表面上，它的切应力必然是成对存在啊，比如说我们像这样子这个表面和这个表面对吧，这个表面和这个表面相互处，表面上它有一个套ZX也有个TXZ对吧，也就是它的切应力是成对存在的。

而且它的数值呢是相等的，也就是说大小是相等的，而且两者都垂直于两平面的交线，那么它们都垂直于这个交这个交线，因为它们的方向都是沿着坐标轴嘛，所以说它是垂直于这个交线的，那么方向是共同的指向或者是被啊。

像这种就是都指向了这个交线，同时指向同时背离啊，不能说一个是指向，一个是这个背离的啊，那么对于像这样的一个情况，弹力和弹性力学和材料力学的规定就来了，就不一样，这只要在方向上啊，弹性力学就规定。

像这种情况下面我的力就是相等的，但是材料力学就否是规定你力是相等，但是你的方向是相反的，方向是相反的啊，这里提醒一下大家，还有应力的表述啊，应力的表表述前面我们已经讲过对吧。

那么我们是以一个面来进行解释，但如果说我们把六个分量全部都表示出来，其实它就包含有西格玛X，西格玛ZY和ZAZ对吧，三个坐标轴方向上面的正应力，以及套xy toy这一套ZX这六个量是吧。

为什么没有套YX和套ZY的呀，大家想一想为什么呀，为什么没有了，因为我们刚才讲的是用的切应力互动的原理嘛，这两个都是相等的，我们就没必要了对吧，我就分析这三个就够了。

那么对于这六个量在这个P点是已知的啊，如果说我们说这六个量是否值的，那我们就可以求得，经过该点的任何面上的正应力和它的检验力，也就是说我们通过这六个量，可以完全确定P点的一个应力的状态。

那我们就称为它们是该点的一个应力的分量啊，那么一般来说对于弹性电线来讲呢，它的应力不相同呢，他描述这个战略的房，这些分量的也并不是常量啊，他们一般都会带XYZ的函数，就说我们是在一个微元体里面嘛。

他是不带这个X没有带这个坐标函数的对吧，但如果说我这是一个微体是不带的，但如果说我是放分到我整个的这个题里面，来对吧，那么你在描述里面任何的这一个，比如说另外一个点P的话。

那么你边缘就要用一个坐标的函数来进行表示，对吧，你去表示XYZ嘛，那么它就是变成了一个比sigma，那么这里的话他应该是带X和YZ啊，这两个坐标的函数的，那么我们经常会用这样的一个列阵啊。

来进行应力的表示，大家记住啊，我会用一个sigma，用一个应力的一个列阵，它就包含有三个正应力和三个减一力啊，用这样的一个列阵来进行一个表，进行一个表表示，那么再就是位移和应变啊。

位移和应变呢其实跟应力有点类似，所以我们就快点过啊，那么当然他们表示的物理现象不一样，只是我们表表示的方法有点类似，它是指在弹性体受到外力之后，它要发生变形对吧，那么我们怎么去描述这个物体的变异。

这个形状的这个改变，也就是说我这个物体受到外力之后，它会发生形状的变化，那这个形状的变化怎么去描述对吧，比如说我原来是一个这样的形状啊，我原来是个性这样的形状，那当我发生变形之后。

可能我变成了是这样子一个形状对吧，我形成变成这样的一个形状，那么从这个红色的形状，我们变成这个蓝色的这个形状，我们怎么去描述这样的一个变形对吧，我不是说我看着它变形，我要用数学，用公式。

用这种方法进行一个明确的描述，那么描述的方法有两种，一种就是基于点的位移啊，第二种就是基于体素的一个变形，那么所谓的位移是吧，位移也就是说我们任意一个点，比如说我这个点是吧，我这个点A，我这个点A对吧。

我这个点A它会沿着我的坐标轴对吧，我们始终要考虑一个坐标轴的概念啊，就是XYZ啊，这个三维坐标轴上面，他的位移，在三个坐标轴上面都会有对应的一个位移，是UVW啊，就在X上面产生一个U的位移。

在Y上面打成一个V的位移，在Z上面转成一个W的位移，那么这个时候我们就可以用这种位移来表示啊，我的一个A点的一个位置的一个变化是吧，当位移有两种啊，一种叫做形状有关的位移，就是说它被改变形状。

还有一种就是形状无关的位移，就是说它是缸体育这个位移，那什么意思啊，就比如说我形状改变的位移，就是我这种位移以后红的变成这个男的对吧，那么还有一种情况，就是假设我受到了一个逆之后。

我这一个物体受到一个例子后，其实它仅仅就是说从这个位置，它移动的到了这里，移动到了这里对吧，我的形状并没有发生改变，我的A从这里变量的这个A1撇对吧，哎我确实产生了位移，但是因为他是个钢铁啊。

钢体就是说我没有形变，发生不了形变这个缸体，那么它就没有发生形状，真的只是一个位置的改变，我们把它称作是寻遍无关的这个位移啊，那么关于体术的这个变形，如果说我们用体术来进行表示，这个是什么时候用到。

比如说我们进行解压力啊，角度的变化对吧，我们就是用体术，那么它就有两种变化，一种是长度的变化，一种是角度的这个变化啊，比如说，我们任何一个限速的长度，与原来的这个长度的比值，我们叫做是应变。

也就是说我们对于像这样子一个物体对吧，我原来的长度是这个虚线好，我把它受到一个外力之后，收到一个外力之后，两端的外力之后它变长了对吧，变成这个实现产生的一个DX的一个这样子，一个线性的长度的变化对吧。

那么这个data x除上L啊，data x除上L就是长度的变化量，除上它原来的长度，我们就等于我们的应变，我们就称作是它的这个应变啊，我们是用一用这种IP来进行表示，用IP来进行表示。

那么对应于这个阴历其实是一样的啊，它也同样的会沿着各个方向上面，都有应变的分量，所以有有EUXEPTIONALY和一撇的Z是吧，那么当限速我的长度是伸长时，我说应力是正当缩短时，让它的应力去负啊。

这个就是我们讲的一个应变，那么还有一种情况呢，就是我原来是皮脂相交的一个元素啊，皮子相交的一个元素，也就是说比如说我原来有一个元素，大家看这个虚线啊，是一个虚线，那么他这里这两个元素相交。

这两个线段相交有一个90度的直角对吧，当受到力之后呢，它的形状变成了这个实现的这个形状对吧，那么这个时候原来90度的夹角，就变成了这个角度对吧，它就产生了一个伽马，产生的伽马这样子一个角度的变化。

角度的一个变化，那么这个时候我们也可以称之为，是它的一个检验病，好像这个我们称之为这种长度的变化，我们称之为是它的正应变对吧，那么对于角度的变化，我们就称之为是它的一个简易变。

那么对应于跟我们的阴历一样，它有沿着各同的这个方向，有伽马XYYZ和ZX啊，汤而且它也是同样的，但角度变小时他是呃为为为正啊，当这个角度变大时，它是为负啊，这个是我们有些约束在这个里面的。

再一个我们就来讲弹性力学的两类问题啊，这个我们快点讲吧，我已经讲了一个小时了，我靠你再讲快一点点，那么对于弹性力力学的这一个分类，其实它根据我们研究的对象不同，我们分之为是空间问题和平面问题对吧。

如果说我们分析的是一些呃实体结构，比如说一个啊发动机的一个缸，一个缸体啊，像这种可能是一个空间立体的这样的一个结构，我们通知是空间问题，当然对于一些薄一些薄壁件对吧，薄壁结构我们可以简化为平面问题。

来进行一个分析啊，对前面分一个分析，我们就根据平面的这种或者是空间的这种，问题的啊，这种呃形状的特点啊，就把一些空间问问题，我们可以把它简化简化为是这种平面问题，那么简化为轴。

我们就可以因为我们前面考虑到它的位移呃，应变分量都是有有有六个是吧，有六个当我简化之后呢，我可以只分析它部分的位移分量，应变分量和它的应力分量，那么简化有两种，一边一种我们称为是平面应力问题。

因为我是称之为是平面的应变问题啊，平面应变的问问题，那我们首先来看平面应力问题啊，平面应力问题，那么首先是什么是平面应力问题呢，平面应力问题它的特点，第一个就如这样子，它是一种等厚的一种薄板啊。

大家要注意它这种薄板的一个结构，那么它的特点是什么，就是我是一种薄板的结构，也就是我们前面讲过的薄壁结构对吧，我在两个方向上，不在一个方向上面的尺度，是要远远大于在另外两个方向上面的一个尺度，对吧。

就比如说我的在这个方向上面，在Y方向上面的这个尺寸是要远大于它，在哦不它在Z和X上面，这个尺寸是远大于我在这个呃X方向，就是我的这个方向上面的一个尺寸是吧，他这种薄壁的结构，那么还有一个特点呢。

就是它的体力呢，体力我们前面讲的是作用于体内，而且它是平行于板的正中间面啊，平行于这个中面，那么而且它沿板的厚度方向，我的体力是不变的，那么第二个就是面积，面积呢它只作合于我们板的这个边啊。

只注意我们板的边，那么它平行于板的这个桌面，平行于板的这个桌面，就是我作为这个边上，而且沿着这个厚度啊，它也是不改变的啊，但这就是我的约束也是只作用于板边，也是平行于我这个板的中面，也是沿厚度不变。

那么几何特征就是前面讲课的宝贝结构啊，这个这这不重复了，那么他这种受力的特点啊，就是我们在这样的一些情况下面，就得到它的一个受力的特点，就是说它的外力就是说包括体力和面积啊。

它的约束只平行于板的平面作用，沿厚度呢只是平行于板的平面，就平行于这个板的平面来来作用，因为厚度它是不改变的咳，那么这样子的话就可以得到他任意一个，就是垂直于这个Z啊，大家看就是垂直于这个Z项。

在这个方向，它相关的一个正应力和它的两个减应力，都是等于零的啊，都是等于零的，那我们就可以简简化一下是吧，简化一下，也就是说它的外力不如他的，他在这个中面上面啊，但我们这里说他是在中间这个表面上面对吧。

中间面XYZ上面，他Z的正应力和Z的两个解应力都是等于零的，但是同时我们又不是假设的嘛，它都不影厚度变化对吧，所以就假设在整个保本之内，这都是满足的，都是满足的，也就是说对于平面应力问题。

那么我们要剩下研究的三个应力分量呢，就只剩下了这样子的一个四个西格玛X，西格玛YTOX和toy x啊，单元这两个又是相等的，所以他就只剩下了三个，我们就称之为是平面应力问题，那么它的应力矩阵。

我们前面讲的应力矩阵是六个对吧，那我这里已经删掉三个，划掉三个了，那就只剩下了另外的三个啊，这个就是平面应力问题，可以用这样的一个，就是除掉他的，沿着板后的方向的，正应力和两个减应力都要去掉啊。

只剩下另外两个XY方向面正应力和剪应力啊，那么还有一个跟它相反的，我们就叫做是平面应变问题，那么所谓的平面V面问题我们全部给出来，它是一种很长的一个截面的圆柱体啊，嗯就像这种情况。

就这样子一个很长的截面的样子，对我有一个截面对吧，我有一个截面，但我沿着Z方向对吧，沿着Z方向的这个长度是很长的，就是沿着这样子一个很长的一个长截面，所谓的长截面就是沿着这个方向，我的截面面积是截面。

是不变的对吧，那么像这样子一个问题的话，他的体力是作用于体内，平行于我们这个截面啊，平行于这个截面，那么面积也是一样的，那么约束也是一样的，那么像这种情况下面，像这种情况下面他的这一个情况。

下面我们就是说所有的点对吧，跟前面的平面应力问题就是相相相反，由于它是对称的对吧，它的任何一个截面，它任何一个截面都可以看的是个对称面，为什么任何一个截面都可以看成一个对称面，为什么大家想一想。

因为它很长对吧，很长很长，那么我就可以把任何一个截面都可以看成，是一个对，是一个对称面，那么所有的点他就都只会有XY方向上的位移，而不会有Z方向的位移啊，也就是说它只会有X和Y这两个方向，上面的位移。

他不会有W，它只会只会有U和V，它不会有W啊，它不会有W，那么这个我们就把它叫做平面位移问题啊，因为它的位移都在这个面上面，叫做平面位移，当然习惯在我们跟的架构是。

因为位移其实它跟应变之间是一个关系的话，我们就是平面应变的这个问题，那么在这个时候，平面应变问题呢就跟前面相反的对吧，它因为只在XY这个面上面有嘛，所以说他就在这个表面上面。

它就会有什么垂直于它的反向就会有套，还有西格玛Z，还有这个有这个应变是吧，有这个IP是Z和这个伽马YZ和伽马ZX对吧，它就有应变，所以这个就是平面应变问题，那么再就是我们讲的弹性力学的三大类方程。

三大类方程首先是平衡方程，那么平衡方程是表示着物体内任何一点的一个，微分体的平衡条件啊，那么对于平面应力问题的话，他就是说它的平衡条件，就是说Z面上面的力就跟我们前面分析的一样，正面上面的力。

以及指向Z轴平行的力均为零对吧，我们根据平面应力问题前面分析出来的对吧，这是它的一个平衡条件，那么对于平面应变问题呢，这面上的力是吧，它只有这个它的这个Z方向的这一个正应力啊，它是不为零的。

那么其他的力以及指向于与之平行的力，它均是为零的啊，这个就是平面应变问题，那么这里我们讲的就是，它有一个平衡的一个微分方程啊，平衡平衡微分方程，那么我们在构建这个平衡方程的话。

其实我们也是取一个微元来进行一个分析啊，来进行一个分析，比如说我们在一个物体上面对吧，我们取出这样的一个啊，取这样一个微元微元出来，那么它在这个XYZ在Z方向上面，它有一个增它有一个增量啊。

比如说我们在对一个V有全部画出来吧，那么在这样的一个物体取出了微元之后，他在这个FX和XYZ的两个方向上面，分别有力对吧，那么对应于在每一个表面上面，在每个表面上面都会有什么，我们上面讲过的。

都会有它的一个正应力和他的一个剪应力是吧，每个表面都会有正应力和一个减一个简易力，那么这里给出的是这两个，那么我们就是说沿着在这里，假设说他在这里产生了一个增量啊，DX这样的一个增量之后。

那么对于在这个面上面的这个力，我们就可以用西格玛X再加上一个偏这个MX，Spx dx，又是加上这样的一个微分的，这样的一个偏导的一个增量啊，用增量来进行一个表达，这个表面上的一个力好。

那么对应于从这个西格玛这个Y对吧，到我们在这一到下面这个面也是一样的，我们也会增加出一个增量对吧，也会增加出它的一个增量出来，来进行一个表一个表示，那么这里的话我们就要回到我们前面。

有了这样的一个增量的一个表达之后，我们要用到我们前面的一些假设啊，比如说我们讲到的一个连续性的一个假设，连接线的一个假设，就是我们的应力可以用连续函数来进行表示，对吧，小变形的一个假设。

就是我们变形后的尺寸来代替变形嗯，变形前的尺寸呢变形变形后的一个尺寸，那么基于这两个假设，然后我们再列出它的平衡条件，平衡条件是在我们前面讲过，我们要算它的合力对吧。

合力的话就是应力要承受它的面积和体力，要承受它的一个体积，然后用正向的这个微物理量来进行一个表达，那我们就可以得到，在这样的一个平面问题中是吧，它的X方向的力合列式为零，Y方向的合力是为零。

绕Z的这个这个这个呃转距的，这个是为零的对吧，这个是我们讲的平面问题，它的三个平衡条条件，那么我们就基于这三个等于零嘛，我们再又回到前面的，就是根据这个图啊，根据这个图我们把这一个方向是吧。

把这个方向和这个方向，把FX和FY的逆全算出来对吧，比如说我FX对吧，我X在FX这个方向上面，那我就必然会有西格玛X乘上一个A对吧，然后我还有sigma加上这个偏好PC感，把偏X乘上一个A对吧。

同时我们还要看还有toy x和套XY是吧，这两个简易力他们也要分别乘上这个面积对吧，这样子四个分量啊，这四个分量我们全部列到一起来，就得到一个FX要等于零嘛，就是我们前面讲过的，这个是这边的呃。

是我把它画到这里对吧，画到这里，那么这一项大家回忆一下是吧，这一项其实就对于你就是在这个地方的一个，正应力是吧，乘上面积面积的话就是它的这个侧面积，它的侧面积肯定就是等于把坐标轴画到这里啊。

坐标轴画到这里，那么就是X和Z吗，那么我是沿着X方向的，那么我的面积可能就是在5YZ这个方向，所以是DY加上DZ，那么还有这一项套啊，西格玛X因为西格玛X是沿着X轴的反向，是在这里对吧。

所以说它就是减去sigma xx，那么同样还是乘上这个面积是吧，这是两个正应力所得到的力，我们把它累加到一起，同时我们还要计算这个表面上面的，两个减压力是吧，两个减应力。

那么一个是这个方向上面的这个这个减音量啊，这个应该放缓了，应该是这个方向，这个箭头是在这个方向，那么这一项，这一项其实对于我们在这里的一个解，一个简易力是吧，就他YZ加上之后乘上它的一个面积。

这个时候我要乘算的是下面这个底面积啊，这个底面积，那么这个底面就是DX乘上dz，然后我再去减上上面啊，上面这一项啊，这个是toy x啊，这一项再乘上他的这一个底面积，也是DXDZ，然后把它加到一起。

当然我们还要有个体力是吧，FX它这个内部我们不要忘了，它内部还受到了一个体力啊，体力啊，收到了一个体力FY和FZ，那么FY我们不考虑，因为每一只都没有在X这个方向，X方向只有一个FX这个体力。

然后乘上我的整个体积，那么这三个这些力加在一起，我们要满足一个平衡条件，就是它的合力要等于零啊，合计要等要等于零，那么进行一系列的合并计算，这样我们就不计算了啊，就可以得到这样一个式子啊。

得到这样一个式子，那么同样的对吧，我们有用同样的一个思路，我们也可以向Y方向，那也同样的是等于零对吧，就可以得到这样的一个平衡方程出来，那么这个就是我们得到一个平衡微分方程，那么同时对于这个转转距啊。

围绕着中心点的这个转距，这个一样的，大家想想，你就是考虑所有的这种检验力了是吧，因为我这个就都复刻都不去考虑了是吧，我的啊，这个正应力正应力都是通过这个中心点的，所以说它是不存在的，我就只考虑看嘛。

只是考虑套了，只考虑剪应力的啊，正应力是通过中心点的，体力也是通过中心点的，所以他就没有力矩，没有力矩嘛对吧，所以我们就考虑减应力加在一起，也让它等于零，那么这个时候我们就可以得到这样子，一个公式啊。

当然这里我们要根据我们的最小变形的原理，我们把这个微小的增量去掉对吧，微小的最小变原理，微小增量去掉，就是说这个时候就得到是这样的一个形式，套X等于套YX是吧，那么整合一下对吧。

我们就得到了我们整个的平衡的这个方方程啊，这个具体的解说我们就都不去讲了，这个大家有兴趣的课后可以再仔细看一下啊，那么这个是各种呃，在材料力学和弹性力学和理论力学里面，其实都会有平衡方程啊。

只是说他们表达的方式和他们的研究目标，也是不太一样的，但是整体来讲的话，我们弹性力学的平衡条件它是最严格的啊，这个大家记住就行，他是最严格的嗯，当然有了这样的一个呃呃平衡方程之后呢。

我们也再来看一下一点平面问题，是每个点的一个应力的状状状态啊，其实这个呃快点过吧，有一说我们在这个坐标面上面啊，我们的应力有西格玛YS玛Y和TX，那我求斜面上面的一个应力是吧，就是我只我知道坐标面上面。

坐标面上面的一个应力这三点，那这个时候我要去求这个斜面上面的这个应力，那这个时候我们就可以取出一个三角形啊，也是用这样一个微元体是吧，它包含有这样的几个面啊，就是X面Y面和N面A面，就是这个面嘛。

就是斜的这一这一个面，那我们就先进行一定的这个分解啊，就是沿着它的一个法向上面，就是把我的体力嘛，把它这个上面的这一个力啊，PX就是它斜面上面的这个力，P沿垂直于它的，沿着它的法向分解到XY上面去是吧。

然后分别计算出它的一个方向余弦啊，所谓的方向余弦就是跟他的角度，根据这个角度是相关的，而且他这个斜面ab的这一个长度啊，然后我们再进行计算，其实就是通过一个投影和相关的一个计算的。

一个关系来进行一个计算，同样我们也是要满足这样子，一个平衡的一个条件对吧，那么计算的一个方法其实一样啊，也是把比如说我们算到这个PX啊，算到PEX，那么我们也是去乘上它的一个面积啊，它的一个灭一个面积。

然后再把西格玛X啊，toy x啊，体力啊，在这个方向上面都要考虑进去嘛，就包括PX啊，包括有C啊，西格玛X哎，不贵啊，这个套XY是吧，应该是这个啊啊不不不，t toy x套XY是这个方向啊，包括他对吧。

把这些力全部弄起来，也构建出一个平衡方程，计算的方法就是一样的啊，这个我们就过了，再就是几何方几何方程，那么几何方程的话，它表达的是什么，它表的是我们一个微分体上面，形变和位移之间的一个关系啊。

大家记住前面讲的是平衡方程，现在是几何方程，几何方程表示的是形变和位移，之间的一个关系啊，位移之间的一个关系，也就是比如说我们在一个物体中有个PX是吧，有这样一个有这样的一个有这样子三个点呃。

呃构成了一个体吧，就是呃AP和B构成了这样的一个形状对吧，当P发生了一个位移，就是P移动在P1撇这个地位，第一地方产生了一个位移U是吧，那么在这个方在Y方向产生了一个位移V。

那么它就从P移动到了P1撇是吧，通过这两个位移的作用移到的这个P1撇这里，那么A也是一样对吧，A也是由对应于像这个物体里面，它也是由这个里面，根据我这里面的一个增量对吧，有个位移的一个增量。

也产生了一个U加上这样的一个增量，的这样的一个位移，从这里啊在X方向上发生了一个的位移，在P方面也是一样的，发生了这个位移，就移动端的A1撇对吧，那么对应于这个我们的整个这个pa这个形状。

就通过了这个位移是吧，就变成了P1撇和A1撇这一个形状对吧，就是说这个时候它就发生了一个形变，也就是说由这些位移就产生了一个形变，那么我们如何来构建几何方程呢，跟B1样的，B1样的。

我们就直接就给就给就给出来了，那么其实在这个时候，我们讲的P点在X方向的位移分量是U是吧，那么A点在X方向的一个分量呢，就是要加上U，加上这个由于它的这个位置的改变，它有一个微小的增量是吧。

Data u，所以我们加上它的一个V，它的一个微分项，那么限速PX的正应变是吧，它的正应变很简单呀，它的正应变就是等于它变形之后的这个形状，就是P1撇一撇是吧，减去我原来的形状U就是减去它。

然后再乘上我的整个原来的长度，就是DX是吧，就是我的变形后的存量减去我的这个增量，但DX就等于它啊，当然同理对于BP也也是一样嘛对吧，也就是说我也是用它的一个增量是吧，也是由它原来的这个长度啊。

由它变形之后的这个长度，P1比BB这个B1撇减去PB嘛，也就是由这一项相减，然后除了他原来长度，就得到了它的一个正应变啊，得到它的一个正应变，那么对于这个解应变伽马X啊。

也就是说它表示的是他们之间夹角的变化是吧，就是这个夹角的这一个改变，是这个夹角的这一个改变，那么对一个夹角的这一个改变的话，当然这个类似于是一种啊，这种呃几何问题的一个求解啊，其实它也是一样啊。

就是把我们比如说求这个啊，求求这个阿尔法是吧，求阿尔法这个角度的话，我们求它的一个正弦是吧，tan阿尔法就是等于什么，就是等于这个线段，再除上这个线段对吧，除上这个线段是它的一个正弦的一个值。

那么这一个线段对吧，这个线段这个线条是怎么来的，这一个线段其实就是等于大家看啊，就是等于它整个的这个长度，整个的这个长度减去什么，减去这个位移是吧，减去这个位移，减去这一段嘛。

减去这一段就都等于它这个长度，所以就等于他，然后再除上这个长度啊，这个长度又怎么来呢，这个长度就是等于什么，就是等于我原来的这个长度DX是吧，然后我再加上我的这样的一个增量啊，加上我的这样的一个增量啊。

就可以得到这个长度，那么它的一个探险值就可以得到，又是因为引入小变形，假设就是我变形量很小嘛，那么对于小变形的话，我们的这个正弦值和角度值就是相等的，所以就可以得到它的这样一个值。

那么同样类似的我们也可以去计算出贝塔啊，这个转角的这个值我们也是能够算出来，那么整理一下，我们就把平面问题的几何方程啊，就是通过他们这样的一个变形状，位移和形状之间的关系就可以得到伊布是的。

X是等于U对X的偏导，那么一说Y是等于V对Y的一个偏的，那么伽马X就是等于一个相互的一个偏导啊，当然这个就是它的一个几何方程，这些结论性的我就不去讲了，因为这个就是比较多了，但这里要给出一个关键点。

就是大家要这个要记住啊，这个结论还是跟大家讲一下，就是说我们要记住几何方程它表述的是什么，表述的是形变和位移之间的一个关系，但是呢他之间不是完全的一个充分，必要的一个关系啊，就是说当形变是确定的时候。

那么与形变有关的位移呢它是可以确定的，但是与疾病无关的这种刚性位移，它是没有去确定，它就必须要通过边界条件才能够确定，也就是说什么，也就是说形变和位移之间的关系是位移，确定它的形变就完全确定。

就是我知道了他的UVW这些位移之后，我可能知道它的形变，但是我知道它的形变，我是并不能够得到它的位移的是吧，并不能得到它的位移的，因为它可能会产生很多什么，我们前面讲到的位移对吧，与形变无关的位移。

就是我在发生形状改变的时候，我的位置从A点，整体从我有从这里变化到了另外一个地方，那么这种刚性位移我是不知道的，所以说它不是一个冲锋，必要的一个计算的关系哦，位移可以得到形变，但形变得不到位移啊。

这个大家要记住这点就行了，关于几何方程啊，这个我们就过了，还有一个方式，我们中的物理方程，以及我们讲的本构方程非常重要啊，那么他讲的是应力和应变之间的一个关，一个关系，那么最简单的物理方程。

其实就是我们讲的复合定律是吧，那我们把它延伸一下，就变成一个广义的复合定律对吧，我们讲的材料力学中，我们说这个应力和应变直接关系，是满足一个弹性材料，弹性模量一的一个关系是吧，弹性模量一的一个关系。

那么，那么我们在这个在这个弹性体中，在弹性体中，我们就可以用到我们前面的叠加的原理对吧，就是说因为叠加的一个原理，我们要考虑什么，因为我们说在弹性假设的时候，它是叠加的，那么这个时候我们要考虑。

应力和应变之间的一个关系，那我们就需要将三个应力中，每一个应力所考虑的应力分量要叠加起来，也就是说我这个物体当发生一个变形的时候，那么它其实是受到什么。

它会受到西格玛y sigma z和sigma x是吧，三个应力分别产生作用，那我说到西格玛Y对吧，那我是在Y方向上面有拉伸，但是在另外两个方向上面是有压缩好，我收到这个嘛Z那么我是在Z方向上面有拉伸。

那么在XY方向上面是有压缩的对吧，前面讲过一个方向上面受力生长，另一个方向上面就会减小，那么我们就要考虑将这三个方向，三面力的作用要叠加起来啊，叠加起来之后，我们就可以得到这样的一个形式啊。

这个我们就不去展开去去说了，那我们就可以得到这个应力啊，西格玛二不一不是X啊，它是由这种西格玛XX就是说我Z方向，我在X方向上面的，在哦这个是X方向，我在X方向上的正应力一不行的，X对吧。

它是由西格玛X这样子一个正应力啊，直接导致了我的一个伸长对吧，我拉长了对吧，但是同时呢我的为什么在这里又是减，大家想想为什么它是减，为什么只有C和max是真是是假呀，因为Y和Z这个方向上面产生的应力啊。

它是不会使这个X方向怎么样是变小的是吧，它是会压缩的，所以说它就会减，当然这个前面也会乘上对应的一个系数啊，就是E和mu啊，弹性模量和泊松比这样子一个系一个系数啊，具体的一个推导。

其实也是用的广义的符合定律，进行一个推导的是吧，那我们就可以得到它们之间的这样子，一个整体的一个关系啊，就我们用叠加法，就像我前面讲的这样一个大概的一个叠加法，我们就将六个关系式全部写在一起啊。

就是六个三个呃正应力和三个三个正印表，三个简易变，那么写在一起，我们就构成了它整体的一个本构方程啊，本构方程啊，本构方程就是这么来的，当然在这个里面有些系数啊，这个G我们称为是剪切模量。

那么一是弹性模量，而波斯还有一个波斯比是mu是吧，因为物理方程它是本构方程，是描述我们材料的性这种变形性质的，这就是为什么说大家在做有限元分析，涉及到材料模型的时候，我们就要去输入它的弹性模量一。

以及它的一个波斯比的系数，相关的这样的一些材料啊，这这相关的一些材料，那么再就是整体得到的是吧，当然我们也可以将它进行一个改写啊，进行一个改一个改写，就是用韵力和应力之间相互的一个关一个关系。

那么我们也可以写出用应变来表示的，这个公式啊，这举的是怎么去改变呢，大家有兴趣大家可以去算一下，像这个我是用阴力用应变来进行表示是吧，当然我可以通过应力和应变之间关系，我可以用应应应变来进行一个表。

一个它的第二种形式啊，那么前面的这种复杂的形式呢，我们可以用矩阵的形式来进行一个表达，这就是我们在计算机编程的时候啊，我们讲的一个D几个D矩阵啊，一个D矩阵，我们用矩阵的形式来进行一个表一个表征。

那么在这个里面大家就可以发现对吧，其实在这个矩阵里面，前面的这一块对吧，前面的这一块它对于弹性计算来讲，其实它就类似于是个常量一样，因为它就是弹性模量和波斯米，这跟我的材料相关的，我不管在哪。

在哪一个地方，它都是材料，是，这是我们讲的是它的连续性材料性质是一样的，也就是说，我不管是在我这个材料体内的哪一个部分，其实我的这一个弹性模量，不知道我的这个第一矩阵，第一矩阵它是与坐标无关的是吧。

所以说它是就很好的去计算的这个问题，那么这个D矩阵我们一般称为是弹性矩阵啊，到弹性矩阵它完全取决于弹性，才是E和U，它与位移是没关系的，那么它表征的是我们弹性底的弹性啊，当然我们也可以采用这种拉梅系数。

就是G和X就是他的这种剪切模量啊，他的这个剪应该是G，这讲出来G应该是它的一个剪切模量啊，用他的剪切模量这里写这里写错了，来进行一个表表，进行一个表进行一个表示。

那么最后我们就可以得到它的另外一种形式啊，就是这样子一个请一个形式，也就是说这里的话，我们就得到一个C的这样的一个形式，这样一个矩阵，那我们称为它是个柔度的这样的一个矩阵，那么这里得到的是什么。

是应变等于C乘上sigma乘上应力对吧，那么D的话是等于应变，是等于D乘上一个一部分的乘上一个应变对吧，他们是这样子一个关系，那么很显然C和D就肯定是一个互逆的，这样的一个关系啊。

就柔度矩阵和弹性矩阵是互利的一个关系，当然在我们又回到前面的平面，应力和平面应变问题的话，那么它们的物理方程肯定就会有一些简化对吧，因为我不需要这么多项嘛，对于平面应变应力问题，我们只需要考虑这些对吧。

那么对于平面应变问题，他们对应的不需要的分量我们也可以去掉嘛，就会得到一个简化的一些形式啊，这个我们就快点去过了，大家其实就是把我们全员不需要的分量，把它去掉就可以了。

那么同样对于平面应变问题也是一样是吧，我们只保留我们有需要的，就是西格玛Y西格玛啊，这个Y这个MYX和TXY嘛，这些相关的就行啊，相关的一些就行就行，那么对于这种两种问题对吧。

它的物理方程的总体表达式肯定是一样的，都是等于西格玛乘上弹性矩阵，乘上一个伊斯法形成应变对吧，只是说对于平面应力问题来讲，它的弹性矩阵是它的弹性矩阵，低的表达式是这样子，对于平面应变问题讲。

他的举人谈论矩阵就是这样子，对不对不对，就是说我用同一个方程来进行表示，只是说我的弹性矩阵是不一样，那么单元物理和应变和硬币之间，他们之间也有这样的一个转化的关系啊，就是用这样的一个转化关系。

也可以去得得到是吧，其实这个给大家就是讲一个好处，就是反馈的，为什么说有些是很好编程的，他很好编程的原因也是因为什么，也是因为他们之间很多都可以进行模块化的，求解对吧，你看我对于同一个不同的问题。

但它的表达式是你是是是一样的，也就是说我对于结构化编程来讲，我的模块是一样的，只是说我的输入是吧，我一个输入的是这个弹性矩阵，另外一个输入的是这个弹性矩阵，输入是不一样，但我程序的模块是一样的。

所以说它的编程是非常之方便的啊，好最后再快速讲一下它的边界条件啊，边它的边它的边界条件，那么也就是说我们在进行物体的分析的时候，我们还要考虑到就是我们像这样一个物体，在空间中。

它还会受到外界的给他的一些作用啊，就是说我们把研究对象以外，那其他的物体我们称为边边界，那么把属于连接配上本身，与外界接触的那一个边界面呢，我们称之称为其他物理，称为外界，那么外界与研究对象本身的话。

我们称为边界，那么边界的限制就包括边界的形状，边界所受的外力以及他给的一些线，一些一些限制啊，那么对于弹性类型来讲，其实它的边界性质就两就两类啊，一个就是力的边界啊，一个就是位移的边界，那么力的边界呢。

我们用S这个西格玛来进行表表示，那么位移的边界呢我们用SU来进行一个表示，也就是说大家考虑什么，就是说我在分析一个问题的时候，我这个边界上面是受到了一个力是吧，还是说他给了我一定的位移。

它让我的位置发生了一个改变啊，就是这样子一个也是改变它这样子的一个形，一个形式啊，那么对于这些编边界的话，它也是要通过同样的，我们进行应力和应变的这种分解的计算，把它融入到我们这种合理当中去啊。

所以说我们在这种有限求解的里面，我们就专门有一块的模块，我们是进行力边界和位移边界的一个求解啊，这个我们到啊，下一次我们再讲吧，因为我看今天已经讲了有将近这个两个小时了，两个小时了，我觉得呃。

这样子我们把第三部分有有限元分析的基础，和我们下一章基于mc lab的软件和编程，合到一起来讲好，那我们呃今天的这门课我们就上到这里了啊，非常非常感谢大家。

希望大家我们下周天不见不散哈。

GAMES401-泛动引擎(PeriDyno)物理仿真编程与实践 - P11：11. 从PeriDyno到CAE软件增量集成开发平台MxSimLa - GAMES-Webinar - BV15M4y1U76M

好尊敬的各位网友，这个各位同学大家好，那么我们又如约来到了我们game401晃动引擎，物理仿真编程与实践这门课的啊，应该算是我们整个课程的最后一节课啊，呃前面我们围绕的PANO和呃，基本的这种物理仿真。

这种编程算法啊，但我们的C1呃基本的一些理论和算法，包括C1E的一些基本的知识点都进行了讲解，那么我们今天呃，难道我们呃，本次本文这么课程的最后一节课是啊，主要是跟大家介绍从判断那到啊。

我们自己所开发的一个呃，C软件的一个增加集成开发平台mesh sim nel，那么主要还是分为三部分，第一部的话还是因为在上节课，我们主要是讲的，有些人的一个基本的力学的一个理论，就是这个弹性力学理论。

那么在这节课，我们还是再简单的跟大家介绍一下，这个有限元的一个基本方法就是如何啊，我们从前面讲的力学理论，到我们有校园是怎样的转化过来的，那么第二个是讲的从这个PANO到match nel。

我们具体做的一些工作啊，第三部分就是基于这个matheme level这个软件，来进行我们这个软件的一个呃，简单的一个介一个介绍和一个教学，那么首先我们还是呃讲一下，有些人基本的一个方法。

那么为了这个便于理解，我们以最简单的一个弹簧单元为例啊，首先我们来看一下一个弹簧的一个力学，分析的原理，当然这个会用到我们上节课呃，所讲到的一些弹性力学的一些基本的理论啊。

呃就是我们在屏幕中看到的这个弹簧系统是吧，一个弹簧系统它的这个左端是固定的，那么在右端呢收到了一个力F，那么它就会产生一个德尔塔的这样的一个啊，生产量对吧，我们知道弹簧设计就会升就会升就会生产量。

那么这个力和这个它的生产量之间啊，我们在上节课讲过，其实他们之间会有一个一定一定的关系对吧，如果是属于弹性变形阶段的话，我们说它的这种关系的话，其实还是一种这个线性的这样的一个关系啊。

线性的这样的一个关一个关系，那么这种关系就是我们讲的复合定律，让我们在上节课也讲了这个复合定律，哎，那么它是我们弹性理论中一个最基本的一个，一个定理啊，它是描述就是我们的固体材料在受力之后。

那么材料的应力应变啊是吧，就是在我们上节课所讲过的物理方程啊，它们之间是乘这样的一个线性的一个关系啊，线性的一个关系，那么对于弹簧的力和位移的关系，其实就是中间F是等于K乘上一个代号是吧。

就是说K是我们弹簧的刚度的一个系数啊，刚度的一个系数，那么这个其实就是相当于描述我们弹簧变形的，一个物理方程是吧，大家还记得吗，我们在啊在上一节课的时候，其实跟大家讲，我对老公说。

描述应力和应变它们之间关系的这个方程，我们就叫做是物理方程，那么在这样一个系统中，其实我们是基于这样的一个端点的一个描述，对吧，我们说它的右端的这个点受到的一个力F，那么在有左端这个点它是被固定住的。

那么关于这种一个关于端点的这个描述，我们就回回回应到在有些人中，那么在有限言中，我们为了进行规范化的描述对吧，大家回忆一下，我们讲有限元中是有节点和单元的，这样一个概念是吧，节点和单元的这样的一个概念。

那么我们就可以把整个这样子的一个系统，我们就不是基于端点是吧，端点是我们讲的物物，这个物体它本身的一个几何的一个特征，我们把它描述为基于节点对吧，节点就是我们在有限元分析中，用到的一个体系啊。

单元和节点这样一个体系，这样的一个模型，用节点来进行这个弹簧的描这个描述，那么我们就说整个在这样子，整个一个系统中对吧，这前面这个弹簧系统中就包含有两个节点对吧，一个是它右端的这个端点。

我们把它定义为一号节点，那么第二个是在左端的这个啊，不在左端的这一个端点，我们定义为一号节点，那么在右端的这个我们定义为2号节点，那么定义完这两个节点之后，我们呢。

如何用基于节点对我这个单元来进行描述的，就是我们放在有有限元中对吧，我的节点进行描述的话，那我就说在节点上，就在一号和2号这两个节点上，他们分别有位移对吧，我用U表示。

那么U1就代表的是一号节点的位移啊，那么U2就代表的是2号节点的位移，那么对应的它有节点力是吧，它也有节点力，那么对于F1啊，这代表的是我一号节点上面的力啊，那么还有F2。

代表的是我2号节点上面的节点力对吧，那我们这样子就基于节点，将我们整个弹簧的这种物理状态，我进行了一个描述对吧，它的位移和它的一个节点力，那么有了这样的一个机遇，节点的这个描述之后。

我们就可以构建出一系列的这个方程数了是吧，我们所经看这个最上面的这个方程，最上面的这个方程是吧，这上面这个方法方程，那么第一个方程就是F2对吧，就是我要算F2，那么F2我们前面不是说他的这个力是等于K。

就是弹簧系数乘上一个带的，就是它的一个生产量对吧，那么它的生产量第二的其实就是等于什么啊，就是等于U2减去U1，所以说就是K乘上U2减去U1，就等于F2，那么同时我整个弹簧系统，它是一种平衡状态是吧。

它是一种平衡状态，那我们就是F1加上F2，它是等于零的啊，它是属于一个平衡状态，就是说它是等于零的，那么我们有了这个方程，我们就可以把它吓退位，到下面这个方程对吧，就是K乘上U1减去U2是等于F1。

因为F1加上F2等于零嘛，所以F1是等于负的F2的，那么F2是等于这么多二，F1等于A负负的F2，就代表这个位移要反向嘛，就是这样子的，那么对于像这样的一个方程组啊。

描述我们整个节点的这个呃这个方程组的话，我们通常在有些语言中，我们会把它写成矩阵的形式，写成矩阵的一个形式，那么就把这样的一个方程，就把它转化为这样的一个矩阵的形式，那么它就包含有我们把它定义一下。

像前面这一个就是由弹簧的这个呃，呃这谈这个这个弹簧的刚度系数所构成的，这个K对吧，我们就把它组成的这一个矩阵充分是矩阵系数，然后再就是节点位移啊，再就是节点力，那么像这个其实就称之为是弹簧的一个平。

衡方程啊，或者是它的一个刚度方程，其实像这一个方程虽然看起来很简单，但是以后啊，就大家以后再有兴趣，对有序员进行更这个更详细的学习的时候，就发现，其实我们队有序员的分析，最终都是归纳于一个K乘上一个U。

等上一个F对吧，我们对于弹簧来讲，它是这样的一个平衡方方程，或者叫做刚刚刚度方程啊，其实在有些人经常讲刚度方程也会比较多，因为我们经常会把这个矩阵有这个系，有这种材料相关的。

它的一些物理特性所表征的这一个矩阵，我们称之为刚度矩阵啊，称之为是刚度矩阵，那么就是K乘上U等于F，也就是说我们不管是多么复杂的，有些人问题，其实他最终都是归纳于去求这样的一个方程组。

求上K乘上U等于F啊，这样子一个方程组啊，那么当然这里为什么要强调矩阵的形式啊，为什么要强调矩阵的形式，其实这主要是为了什么，主要是为了在计算机中啊，对有些人来讲，有些人它是一种很好计算机去编程的。

所以它很好的可以在计算机中来进行编程的，一个实现啊，当然了啊，这另外一个方面也是为了我们去写啊，去没去描述，去写我们整个计算过程的时候，能够比较方便的，能够准确的把它给诶表示出来是吧。

要不然我们用一堆的上下标啊，会一堆的公式啊，其实看起来也比较烦，比较繁琐，而且你从公式从到计算机的程序，其实这种思维转变是比较大的，但是我从这种矩阵的形式到我计算机的程序，转化其实是比较容易的啊啊对。

还有我们下面这个二维码啊，这个magic level的二维码，这个是我们需要有个games的一个，交流的一个QQ群嘛，然后因为我们这节课主要讲magic m nel。

所以我又建了magic nel的一个群啊，大家有兴趣可以加入我们这个群啊，哪个呃，另外一个的话，其实大家都知道，有很好的一个矩阵计算的一个软件，叫做MAD level对吧，这么像MAD level。

所以其实在啊，我们很多时候在做一些算法研究的时候啊，像像像我们在做一些很多算法研究的时候，其实我们一开始会用MADLIB，来进行一些算法的研究和实现啊，等基本的原理啊，和这些算法的推导都结都结束之后啊。

我再会把呃这种麦就把my dl的这种程序，把它翻译成这种C或者是fortune的，他的一些程序的一些呃这些语言的一些格式啊，这个是我们讲的矩阵的一个形式，那么前面我们讲的是一个弹簧系统对吧。

那如果是两个弹簧系统呢，就是比如说我们对整个系统中，我们讲的单元是吧，那么对于怎样子这样子一个弹簧系统，它有两个弹簧是吧，有两个弹簧的话，那我们就可以进行节点的编号，其实这个节点的编号啊。

这个节点的编号，其实就类似于是我们有限原句啊，构建一个有限元分析模型的这样的一个过程啊，比如说我们首先对它对它的节点进行编号对吧，就是有ABC它的三个端点是吧，ABC3个端点。

那么把这三个端点我们把它分明定义为一号，2号三号这三个节点，同时的话我把第一个弹簧，这种比较细线代表的弹簧，和这个出现所代表的这个弹簧，我是分别定义为第一号弹簧单元，和第2号弹簧单元是吧。

就是我对就是说我这样子一个系统，我这样子一个两个弹簧的系统，在我的有限元的这样子一个模型里面，它是包含有三个节点，两个单元的，这样子一个有限元分析的一个模型好，那我们在对于这样的一个模型来进行一个。

力学的一个分析对吧，那我们前面讲过，我们有序员分析的时候，是针对每一个单元独立分析是吧，每个单元独立的分析，然后再把它先离散嘛，再把它合并，那么所以我们首先分析一号单元对吧，一号单元就把单独的拿出来。

那么同时我们在分析2号单元是吧，2号单元，那么对于一号单元来讲的话，它有一号节点和2号节点对吧，那么它分别在一号节点和2号节点上面，分别都受到了一个位移和他的一个力，和他的一个执法力FR1是吧。

和他的一个内力FIR，那么对于2号单元是吧，2号单元的话，它也是由2号节点和3号节点所构成的，这样的一个弹簧单元，那么在2号节点上面，它就分别收到有我们一个是这个内力，FIR是吧。

同时有一个这个F2这个外力对吧，大家注意到啊，这里有个外力F2，它是加在了我们这个B端点，那么对于有渲染模型，就是加载到我们2号节点上面来了，那么再一个就是说它在三这个节点上面对吧。

也受到一个执法力fr3啊，这样的几个例和位移的这样子一个做一个作用，那么我们分别对这两个单元啊，一号单元和二单元去构建它的平衡方程，就跟我们前面单个系统平衡方程一样对吧，那么这些构建跟前面是一样的啊。

跟前面是一是一样的，跟前面单个单元是一样的，也构建出这样的一个平方平衡方方程，那么对于2号单元，也同样的去构建它的平平衡方程是吧，也得到它的平衡方程的表达式是这样子的。

那么构建成一号平衡单元和2号平衡单元之后，我们前面讲的这是两个离散的过程是吧，就是分别去算一号单元和2号单元，但最后我们是要去形成1+1，这算完个体之后又把它合到一起，去形成一个整体的一个平衡方程是吧。

所以这个是我们就是要思考的一个问题是什么，我们思考的问题是，我们为了能够方便地计算和我们这个编程，能够方便地实现这个计算机编编程，我们如何去构造一个整体的一个平衡方程对吧，那我们就需要把这两个方程。

我们分别拎到这里是吧，那我们分别都把它写成矩阵的形式对吧，这是一号单元的啊，这是一号单元的，这是2号单元的，我们分别把它写成矩矩阵的形式，然后我们再在一个系统里面去进行主张，大家注意啊。

在前面这在车上面这些部里面，我们都是在每个单元的内部啊，在每个单元自己的系统里面去组去去完成的，那我们接下来就把它放在一个系统里面，来进行组装啊，那么这个时候我们就需要进行一个扩充啊，进行一个扩充。

那么扩充的方法是什么呢，扩充的方法就如大家在pp上面看到，就是我们在相应的位置上去加零去嘉陵，也就是说我们首先要知道你要扩充数多大，扩充数多大对吧，那么对于我们整个这样的一个系统来讲。

我是有三个节点对吧，我是有三个节点，那就代表我是有U1U2，还有U3对吧，只有三个节点和三个D啊，那对应于这边是一个1×3的列阵，这是个1×3的列阵对吧，那么计算来讲，我们就知道我们的这个刚度矩阵是吧。

刚度矩阵它肯定是一个三三的是吧，是个3×3的，我们的每一个单元，他自己所得到的是一个2×2的，也就是说如果说我要把它扩成一个整体，那我就需要把这个2×2的这样子一个矩阵。

把它扩充为一个3×3的这样子一个矩阵，那么我采用的方法就是说比如说对于一号单元，我扩充到3×3的话，那么我就把我扩充的部分，我就全部放零就可以了对吧，我就全部放零就可以了，那它对应的位置是吧。

它对应的位置是U1U2，FRE和F2都是在上面，那么对应于这个刚度系中这一块的话，它也是属于在它的右上角啊，根据它的节点中方也在右上角，好在它的左上角，那么对于2号单元同样是吧，他也一开始是个2×2的。

我也要把它库存是3×3的，那么也是采用在它我扩充的部分去加零是吧，我在扩充的地方去填充零，那么对于2号单元来讲，它对应的位移是U2和U3是吧，它有着对应的是U2和U3，在下面这两个地方是吧。

在下面这一个部分，那么对应于它的刚度系数的话，我们去计算它的一个下一个坐标的话，其实它就属于在这个右下角啊，在这一个部分，当然对于它的力的列阵，我们也放到这里来，那么通过这样的一个扩充。

我们就把整个这样子一个一号单元和2号单元，全部扩充为一个3×3的这样子，一个大小的一个矩阵的形式，那么我们进行组装，那么组装就很容易了，那么组装的话，我们就根据我们前面讲的弹性力学的一个叠加。

原理类似啊，叠加原理是类似的，那我就把这两个相加，就把这两个加到一起啊，加到一起来就行了，加到一起来之后，我们就得到了整体的这样子一个平衡方程啊，就是我们这里是两个单元独立的平衡方程对吧。

然后我进行一个组装，主先进行扩扩充，扩充为整个系统所要求的一个大一个大小啊，所以说要求的一个大小，那么控制完之后把它累加累加之后，就得到我们整体的一个平衡方程的一个系统啊，得到我们整体的一个平衡方程嗯。

那么这里就体现出什么，这里就体现出我们有限元的一个思路对吧，我们首先是计算单个的单元，然后再把它组装在一起啊，当然这里提示的是说在我们整个这个系统中，这个FIR和F啊，这个I2嘛就是我们中间这个点。

因为中间这一个这一个点，我们是把它它是这个2号节点，是既属于一号单元啊，它又是属于在2号单元的，那我们在用的时候，其实都会在两个单元里面都会重复计算，单元二对吧，但是它形成了内力，这个FI是吧。

代表的内力，内力，其实它是一个作用力与反作用力的一，个关系是吧，就是我分到两个节点上面去，弹力的大小一样，但是它的方向是不一样的，所以这个时候它的合力就肯定还是为零的，合力肯定还是为零的。

那么有了这个就得到了我们这个整个系统，整体的一个平衡方程是吧，整体的一个平衡方程，那么接下来就是说我们怎么去求对吧，怎么去求解这样的一个平衡方程啊，求求解这样的一个平衡方程，当然在这个里面。

我们就说这里有很多的一些未知量对吧，我们就要去分析这个里面呢它的未知量是哪些，以增量器是哪些对吧，我们构建这样一个方程组之后，我们要去求解啊，我们过这种方式要要要去求求解，求解的话。

那我们就需要找到它的未知量，或者以及它的一个已知量对吧，那么对于未知量和已经那个这个考虑，就是要考虑到我们上节课所讲过的边界条件，大家记得我们上节课讲过，整个系统它是有边界条件的是吧。

他有位移边界条件或者是力的边界条件，那么对于像整个这样的一个弹簧系统，我们就要分析到它的边界条件，有哪些是有哪些对吧，那么很明显，首先我们可以得到的是，你看在这个系统里面分析一下。

是两个系统价值串联在一起，然后第一个弹簧它的由它的右端点是吧，它的左左端点是固定的，第二个弹簧它的右端点是固定的，那么对应于我们整个整个我们的有限元的系统，我们说它对应的节点分别是一号节点。

2号节点和3号节点对吧，那么很显然是不是，A点就是一号节点和3号节点，因为它直接是固定住的嘛，是固定住的，所以说它的位移可能是为零的是吧，这个就是我们的已知已知量，能找到的已知量之一是吧。

就是它的位移是为零的，那么我们找到这样一个已知量之后，我们在在我们的整个的平衡方程组，方程组里面去体现的话，其实我们采用的就是一种划线的一个方方法，所谓换线的方法是什么意思呢，就把我们和U1和U3。

因为它都是等于零嘛对吧，他都是等于零，那我们就把能涉及到跟它相关的一些行和列啊，就全部都把它删掉对吧，那我们就因为它的计算都是为都是为它，这两个是为零，那我们就把它对应于的第一行和第三行。

第一列和第三列啊，我们都把它删掉啊，都把它删掉，删掉完之后，我这样子，我这样子一个整体的平衡方程，其实就变成了简化的一个方程，那其实如果说因为我们这个很简单，是个3×3的啊，是个3×3的很简单。

但实际上我们在有序员，大家如果有兴趣去写个有序员的程序，那如果说你是一个很庞大的一个系统，但是你需要你采用的这种方法其实也是类似，当然有有几种方法，我们这里介绍的是划线的一个方法。

那就是说如果说我们在边界条件里面，已知有哪些位移是为零的，那么我们我们就把这一个位移啊，它所带它所对应的这个行和列就是一号位移，就把一号一第一行和第一列3号位移，就把第三行和第三列全部都把它删掉啊。

对应的在整个方程组里全部都把它删删掉，然后我再去求接下来的一个把剩下的方法，把剩下的值再构建出一个简单的一个，有缩减之后的这样的一个方程组对吧，然后我再进行求解，那么在这样子在这个系系统里面。

我们把这U1U3之后都把它删掉之后，我们就可以得到它是吧，那么得到它之后，我们大家想想我们就可以得到哪一个位移了，有了它之后，因为我们在这个里面UR对吧，UR是不是以这个F2我们是已知的是吧。

F2是已知的，因为F2就是说我们加载在2号节点上面，这个外力F2我们是知道的，就是我们加载的一个力的边界条件是吧，这个F2我们是已知的，那么同时K1和K2，这个是我们弹簧的物理性能，谈它的这个这个。

它它它的这个它的这个系数对吧，也就是K1和K2我们也是知道的，那我们就可以从这里就可以得到，U2是等于F2乘上K1加上K2对吧，K1加上K2，那么有了这样的一个计算之后。

我们首先三个节点上面的位移就都得到了是吧，三个节点上面的位移我们就都得到了，就是说第一号节点它的位移是零对吧，它是固定的，第2号节点我们计算出来的，它的位移是等于这么多。

第3号节点它的位移也是等于这么多，那也就是说我们基于节点的描述的话，它的第一个位移的变量，三个位移变量U1U2U三全部都得到了，那么接下来我们就再看它力了对吧，就是在123上面，他们所受到的力的情况啊。

所说的力的情况，那么有了这个力的情况之后，我们就可以反带到什么，反带到我们这个方程里面来是吧，反带到我们这个方程里面，把U1U2U三我们都带进来，带进来之后我就进行计算计算，我就可以分别得到。

我又把它给带到这个里面去是吧，把这些我都可以带到这个里面去啊，都带到这个里面去，那我们就可以得到什么F21和FR3对吧，它的这一个值啊就都可以得到，那么这另外一个DFR是已知的嘛，是我们的边界条件。

也就是说通过这样的一个计算的话对吧，通过这样的一个计算的话，我们就把这三个节点预约123，三个节点上面的力和它的位移啊，我们就全部都求解出来了啊，就就调解出就全解出来了啊，我看到有同学说这个太专业了啊。

这个这个这个确实啊，因为这个是从这个呃，应该说是算是有几层的一个啊进阶吧，首先我们是从你要理解最基本的一个弹簧的，一个力学的一个系统对吧，它的基本力力学，传统的力学采用复合定律来进行。

弹簧系统的一个计算，然后我们又把它上升到在我们讲的，在CA分析中常用的有些人的分析对吧，我们就有有限元的方法来进行一个记，一个记一个计算，那么对于有些人来来讲的话，我们就要把它划分为有限元。

我们所讲的有限元计算的模型，那么有限元计算的模型的话，它就是用节点和单元在我们前面课都讲过是吧，来进行模型的一个表述，那你的你把整个的这个模型计算完之后，那你就要把你所有的这些节点上面的未知量。

都通过这样的一个过程都把它计算出来啊，都把它计算出来啊，虽然说这个啊其实弹簧系统嗯，其实算是比较简单的，但是啊不管是我们以后多么复杂的，有些人他的基本的思路啊都是跟这个是一样啊。

都这个是一都跟这个是一样的，那么对于像整个这样的一个计算的过程啊，如果说我们用有限元的程序来实现啊，如果说我们用有限元的程序来实现的话，其实它的一个呃程序的这种模，这种模这种模块化还是比较强的啊。

首先我们要去构建，比如说我们在里面会用到的一些，基本的一些变量，我们要分析出来对吧，比如说我们在这个里面，每个弹簧源就是每个弹簧单元，就算站着，每个弹簧单元是吧，它是有两个节点，两个节点所构成是吧。

中间的这个就是弹簧的单元，那么我们前面已经分析了每个单元的刚度矩阵，就是在刚度系数，刚度系数嘛就是这样子一个2×2的一个矩阵，那么整钢的一个矩阵是N乘N对吧，整体的刚度矩阵就是N乘N。

这个N就代表了我整个节点的个数对吧，对于我们前面前面的我们是两个弹簧是吧，两个弹簧是有三个节点，所以说它整体的刚度矩阵是3×3，所以我们前面讲过，我们在进行刚度矩阵组装的时候。

我们要把这个2×2的这个刚度矩阵，就把它扩充为是一个3×3的这样子，一个刚度矩阵啊，扩充为3×3的这样子一个刚度矩阵，那么它整体的一个结构方程或者是平衡方程，就是K乘上U等上等于F对吧，这个是我们讲的。

就有关于有限元计算的一个基本的思路啊，和他们涉及到了一些变一些变量等等，我们先把它理理理，把它理把它理出来好，那我们再进行呃这个单元这种程序计算的话，其实就是采用完全模模块化的这种计算的。

这种编程的方式对吧，我们首先会涉及到一系列的函数的编写，比如说我们第一个函数是用于计算，我单元的刚度矩阵啊，对第一个单元刚度矩阵，当然对于弹簧原来讲，它的刚度矩阵的形式是固定的对吧。

就是说我们前面我们发现一个问题对吧，我们对于前面是两个单元，前面是两个单元是没错对吧，但是每个单元，它的刚度矩阵的形式是一样的是吧，就是跟它的单元工作，其跟他的这个弹簧，这个这个这个弹性系数。

这个弹簧的系数是像这个K是相关的，无非就是说我不同的单元它的K的取值不一样，但是它的形式是一样的对吧，所以我们就可以构建出像这样子，一个计算单元刚度矩阵的一个函数，非常简单，输入是K对吧，输入是K。

就说你输入是你当前这一个单元的这一个呃，系数，这个系数，然后我返回的就是你的这个单元刚度矩阵啊，这是他的第一个函数，那么对于整体的刚度矩阵的形式对吧，整体的单元刚度矩阵。

就是我们如何把我每一个弹簧的刚度矩阵，K小小K每一个单元的刚度矩阵小K是吧，然后我要把它组装到我的大K，就是我整体的刚度矩阵，就是把我的小K对吧，要组装到这个大K啊，因为没办法搞粗细啊。

所以我就把它放大小K对吧，把它组装这个大K里面去，那么我们对于像这样的一个函数，我们就是输入的就是他的小K，以及它的这个两个节点的编号对吧，一号对于每个弹簧不是有两个节点吗，I和J是吧。

两个节点的编编号，那么我们有了这个小K以及它两个节点的编号，我们就可以在它对应的这个大K里面，找到它的这个位置是吧，其实这个单元这个函数实现的就是这个，这个函数实现的就是我们这一步对吧。

就是我们这一步啊，就是就是这一步是吧，就是它就实现的是这一步，就是如何把这一个小K和这一个小K对吧，每个单元的单元刚度矩阵，组装到我这个整体的单元刚度矩阵来是吧，那么它是需要一个I和J是吧。

就是它的两个单元，它的两个节点啊，它的两个节点的编号啊，去计算它的位置啊，就是我这个位置应该在哪个地方，我是通过节点的变化来进行计来进行计算的啊，这个在哪里，比如说我这个字应该放放在哪里。

应该放到这里了对吧，它是其实放到这里了，它是通过计算得到啊，他通过这个节点的下标计算所得到的，所以这个就是我们在这一个函数所做的一个工，一个工作啊，然后再就是我们对于载荷是吧，对于载荷的一个节点。

载荷的一个基于一个计算对吧，那么这里的话其实就是我们等于说Y是等于，K乘上U嘛，很方便是吧，我K是一个矩阵，U是一个列阵，那么K乘上U，只要他们的这个呃，能够满足一个计算的一个关系。

那我就直接U就等于K乘K乘上U对吧，那我得到这一个Y，就是说我的输入就是我的单元，刚度矩阵的K是吧，和我这个单元的一个位移，U就得到了每个单元的一个节点的一个列阵啊，它也是一个1×2的对吧。

连节点的列阵，那么我们在进行实际应用啊，其实它的程序就很简单，这样子其实就把它编写完成了，其实非常非常非常非常简单，那么编完这个程序之后，我们再进行计算啊，就是我们进行实例计算，那比如说我们对像这样子。

也是有两个弹簧所构成的一个系统对吧，那我们又有英语有些人来进行分析啊，他要得到的是整个系统的刚度矩阵，按节点二三的位移，节点一的支反力和每个弹簧弹簧的内力对吧，那么我们对于像这样子。

一个有两个弹簧所构成的系统，我们也可以去构建啊，去构建一个有序的一个模型，而构建一个有效的一个某一个模型，那么首先去离散化对吧，就是我们要去画，就是类似于我们前面讲的，有需要里面去画网格啊。

那我们就可以列一个这样的表啊，大家其实在有些年代去写程序，都会习惯用中文笔表格来表示，那么第一个是我们的单元啊，就是一号单一号单元，那么一号单元它是有两个节点是吧，它的第一个节点是一号节点。

第二个节点是2号节点，那么第二个是第二个单元单元，第二行是首先是element number是吧，就是单元的编号是2号单元，2号二号单元的话，它的第一个节点是二，第三个节点是三对吧。

它的三第三个节点是三，那么这个就是我们整个有限元的一个模型对吧，我们就用简单的这个一个数字啊，去描述了我们这样的一个物，物物物理的一个模型，大家发现没有，其实这个也是有限元分析方法的一个好处对吧。

他把一个当然我们这里弹簧系统是很简单的，但其实是不管是多么复杂的这种几何形状，我们在以前都讲过通过网格划分之后，其实他都是通过这种单元编号节点编号是吧，就把我整个模型都把它表达出来了啊。

就把我整个模型都把它表达出来了，那么我们对于这样一个系统，我们就可以去调用我们前面的单元，前面编写的程序来进行计算对吧，首先我们要正式形成计计，计算每个单元的刚度矩阵是吧，那我就很简单。

我就把每个单元的刚度矩阵，其实在实际调用中它是一个循环嘛，是个for循环，那我们首先因为在这里讲的第一个单元，他的这个系数K1是等于一一百是吧，第二个单元K它的系数是等于两等于200。

那我要计算第一个单元的单元刚度矩阵，就把100带进去是吧，就得到了K1就是第一号单元刚度矩阵，那么第二个在计算第二个单元刚度矩阵的话，就把它的系数传进来200，这可以得到第二个单元的单元刚度矩阵是吧。

就是K2啊，简单的代入进去就得到了，那么得到之后我们再计算它整体的刚度矩阵，那么这又是一个for的循环，其实它是一个这样的一个顺序的执行的模式，对吧，那我们要去执行这个过程。

我们首先要去构建一个这个整体刚度矩阵出来，就是N乘N的一个整体刚度矩阵对吧，那么它是有三个节点，所以说它的大小是3×3的，我们首先形成一个这样的，就是一个零元素的，这样的一个3×3的刚度矩阵是吧。

全部是零的一个3×3的刚度矩阵，然后呢我们再去我们再去那个，然后我们再分别去调用，我们组装的这个函数是吧，第一个你看第一个的话，它的输入第一个单元输入是K1是吧，就是一号单元的刚度矩阵。

那么它的两个节点是一和二，那么带进去计算，就可以把它得到这样一个形式对吧，这这这个形式就把看大家看吧，就把第一号单元的这个刚度矩阵就把它啊，就是把它给计算的已经进来了对吧。

那我们接下来再把第2号单元的K2，把它的把它的刚度矩阵也把它计算出来对吧，也是调用这个函数啊，大家发现这一块对吧，那么这一块就是属于K2，当然中间这一个300，370是属于K1和K2。

就是100+200对吧，100+200是300，是他们累加重合的这一个地方，那么通过这样子的一个执行就得到了什么，就得到了我们整体的一个刚度矩阵啊，就得到我们整体的一个刚度矩阵。

那我们接下来就要引入边界条件是吧，引入边界条件，那么对于这一个边界条件啊，对于这一个系统的边界条件，那我们就要去找它有哪些边界条件是吧，那我们首先来看，首先他在这边啊，最左边的这一个端点。

它是怎么样是固定的是吧，左边这个观点是固定的，左边这个观点是固定的，那么也就是说他的U1，第一号节点的位移是为零的对吧，U1是等于零的，那么对于2号这一个节点，2号这个节点属于在系统内部的一个节点。

所以说他受到的肯定是一个力的一个作用，力与反作用力的一个关系是吧，但是它的力是为零，它的合力是为零的，所以说F2它是等于零的，那么还有就是F3，F3是受到的一个外在外地P，那么在前面这个外力是等于15。

是把这个题目中给出来的，就P等于15，那么也就是说在这个里面，我们知道F3是等于15，那我们接下来就可以把怎么样把这些边界条件，再带入到我们的这个整体的这样的一个，平衡方程里面去是吧。

整体的这样子一个方程里面去，那就说U1变成零了对吧，哎反变成零了，F35，对不对，带进去之后就得到了这样的一个方程组，那么在这样子一个方程组里面，它是有三个位置位置量，这样子有三个方程所构成的。

这样子一个是有三个位置的，F1U2和U3，我们就可以求解了对吧，因为要不然的话我们是这样子，一个由三个方程所构成的一个方程组，但是我们是有六个位置量，那我肯定求解不出来对吧。

我六个位置呢我肯定是计算不出来的，因此我们就要引入边界条件啊，把我们已知的边界条件带带进去，那么带进去之后，我们就发现只剩下三个位置量了，那么这个时候整个系统就变成可以求解的对吧，那我们就可以把它寄。

把它给计算出来是吧，那我们就可以把它计算出来，当然在这个时候我们前面讲过，我们不是说这里有U1吗，这个U1是等于零吗，所以我们可以把整个方程组简化一下是吧，可以把整个方程组简化一下，引入边界条件。

把第一行和第一列都删掉，因为这个U1是等于零对吧，就把第一行和列都删掉，我们就只剩下来这一个，2×2的这样的一个方程组了是吧，2×2的这样子一个啊，有两有两个方程构成的这个方程组。

那么通过这个方程组大家很简单，可以看到我们可以得到什么，这个这个下面左右下角这个方程组，我们就可以算到什么，可以算到U2和U3对吧，首先我们要把K第一行和第一列全部置为空，就这相当于是把它删掉啊。

就把他删，把它把它把它给全部作为空，那也就是说对于我就是说，在原来的这个方程组里面，我只取什么，只取第二行到第三列和第二行到第三行，第二列到第三列的右下角的这个方程组，构建出一个新的这个矩阵啊。

但这个属于MATLAB的一个编程的规则规则，也就是说得到这样的一个方程组，然后我就进行求解是吧，求解，我们直接用一个反一个除号啊，就可以就算得得到另一个反斜杠，就可以得到U啊，就说我这是F吗。

就是在这个里面就把它清空一下，在这里这是K嘛对吧，这是K这是U这是F啊，那么在MAD nel里面，我要求U我就直接用U等于K除上F啊，就得到了U，或者我们也可以写这样一个指令是吧。

U等于AMY就是把K乘上一个逆，就是它的一个逆，再乘上一个F，那么得到的也是U，那我就计算优势等于这么多啊，就算优势等于这么多，那么接下来就请一个后面的一些计算对吧，我们UU1我们前面知道它是等于零的。

它是边界条件是吧，U2和U3我都计算得到了，那么我接下来就是计算AF了，因为K4已知的优势已已知的对吧，那我就把F1计算，F就等于这么多嘛，我所有的力就都计算出来了啊，所以这个就完成了我们整个有限元。

计算的整个过程啊，整个过程当然这个只调用这些方程来计算，所以这个就是用一个弹簧的单元，跟大家讲解了，有限元基本的一个计算的一个流程啊，当然更复杂的往我们后面讲，我们还可以去讲等差单元啊，包括三角单元啊。

四边形单元啊，四面体，六面六面体啊，但限于这个课课时的时间有限，我们啊后面这些如果大家有兴趣，可以大家进行自学啊，但基本的思路都是这样子的啊，那么这个就是整体的一个有限元计算的，一个程序啊。

接下来就是当然没有，这是整体计算的一个流程啊，这些子程序都是有对应的一个，只是去调用这些子程序是吧，就大家可以发现我们就可以嗯，不管是怎样子的一个弹簧系统啊，对于这一个弹簧系统。

还包括我们前面做啊讲解的那样子，一个是两端固定的这样的一个弹簧系统是吧，两端固定的一个弹簧系统，甚至是可以是三个弹簧对吧，很多个弹簧啊，这种弹不管是多么弹多么多么复杂的弹簧系统。

其实我们都可以通过这样一个类似的f em对吧，有需要的一个计算的流程对吧，我们都可以计算得到啊，都可以计算得到，都可以计算得到它的一个解出来，那么关键的就是我们要学会去构建他的，这个有限的一个模型对吧。

节点和单元之间的一个关系，学会去分析它的边界条件是哪些啊，把边界条件找找准了，有些人的模型你建立正确了，那你就可以用这么简单的这样子几个函数啊，就可以完成一个复杂的一个，弹簧系统的一个计算啊。

完整性的一个计算，那么这个就是我们讲的有学法的一个基础啊，有宣法的一个基础好，那么好了，我们就相当于是前面呃利用了这个，算上上节课的时间，我们可能也花了大概有两三个小时的时间。

从啊弹性力学到有些人的基础跟大家讲了一下，大概有序员是怎么实现的对吧，然后我们接下来又回到了我们这门课啊，更谦虚的这种物理仿真引擎啊，和编程方面的一些教学对吧，我们首先来看一看啊。

就我们是如何从PANO啊，并为我们从一个物理缓存的引引擎，变成我们一个做4A1仿真软件啊，我们具体做了一些哪些事情啊，哪些事情，那么首先我们来讲一讲，为什么我们要来做这样一个事，情。

为什么要来做这样一个事实事情，其实这样一个事情的关键啊，就是我们想要去开发一个满足于增量集成的，ca软件的这样的一个框架出来，因为其实现在在啊我们在前面也讲过啊，ca应用的一些领域啊，和它的一些优点啊。

缺点等等，其实在未来来讲，对于CA软件开发，它其实更多的是朝这种智能化和集成化，以及这种开源的云云化和协同化啊，所谓的这种协同化，就是说我要做到啊多人或者是多部门，多工程师之间的一个软件的一个协同开发。

那么对于软件的这种形体形态的话，其实它更多的是关注于啊，我们比如说要做到一个计算平台的一个多，多平台的一个支撑对吧，做到在不管是在手机端呀，在IPAD呀，或者在平板呀，在笔记本啊，呃这种工作站呀。

平台的一个啊多屏的一个适用性，以及满足我多物理场仿真分析的一个需要，就他希望有一个平台把我们讲的这种结构厂啊，电子厂啊，生产啊，把各种厂之间能够耦合耦合起来，当然还有就是软件交互的一个多元化对吧。

就我们要有多种交互的一种形，一种形一种形形式啊，另外其实根据啊，我们我们国家刚刚颁布的这个，开源工业软件的这个白皮书啊，啊其实这个里面讲的CA软件集成框架来讲，我觉得里面的有个分析啊，也是非常正确啊。

你们讲过我们自主C软件发展的一个阶段，其实就提到，其实对于我们自主的学习软件发展来讲，前面我们的理论研究基础，其实啊还是研究的比较充足的啊，但是我们从理论研究到产品级的工业软件，因为我们其实在前面讲过。

目前来讲我们国内的工业软件是比较少的，我们国内的工，这种工业软件是比较少少少的是吧，主要是用的国外的这种工业软件，那么这里面就包括有要经历的一个必经闭源，要经过的一个阶段的话。

就是核心代码的一个开发是吧，软件核心代码的一个开发，以及软件的一个集成的一个封装，那么围绕着这个软件代码的开发，和软件基准的封装，我们要思考的一个问题，就是说有没有一个快速的一个平台。

能够帮助我们能够来做这样的一个事情啊，那么基于这样的一个思路啊，就我和何晓梅老师当然也是依托于我们啊，有一个国家对文化计划的一个支一个支撑，我们就来做这样的一个增量集成的这样一个，CA软件。

那么我们的想法也是能够去解决，在CA软件行业中一种低价值的一些重复，也就是说大家可能很多人，包括大家在上课的啊，各位同学可能很多人都想是来尝试着想做一些，所以软件的一些开发。

但是我可能有一些琐琐碎的工作，我我我不想重复去做对吧，我只想做我自己所感兴趣的这一个部分，对，完全可以用我们的平台来解决这样的一个，重复劳动的一个呃问题。

来保证我们学习软件一个高质量的一个发展，那么其实呃呃从另外一个角度来讲是吧，也是希望能够满足在这种不同任务驱动下啊，不同任务驱动下对CA软件的学习，开发应用的一个多层次的一个需求对吧。

相信大家啊上了这么几节课之后，肯定对于这些软件都有一种这种蠢蠢欲试的，这样一种想法对吧，都想来尝试一下，就说也同时在思考，我在ca软件中我能够去做怎样一些工作对吧，如果说啊我们是为了这个学习和科研。

是为了学习和和和科研是吧，那我可能是想啊去做一些软件开发的一个工作，比如说我想自己去搭建啊，梦想面面向每一个行业的一个C软件对吧，那我希望能够有这样的一个快速的，一个极集成的一个平台。

能够因为我们前面讲过ca软件分为像前处理啊，就是我们画网格向边界条件的加加载呀，然后到求解，然后再到后处理是吧，各个呃流程，那么我我希望能够快速的一个平台，帮我能够把这个流程快速把它集成在一起。

第二个我可能只是想做一些软件应用啊，比如说我想用cad软件啊，去做一些具体的一些分析对吧，那么这个时候就需要有丰富的一个软构件，其实有更丰富的C软件的功能模块跟你去使用，就要用我们前面讲的弹簧系统对吧。

其实它反复利用的几个函数，就是那么几个函数，一个是单元刚度矩阵阶段的函数，一个是单元刚度矩阵，整体刚度矩阵组装的一个函数，一个是我们一个呃，这个利益计算的一个函数对吧。

那么通过这样子三个简单的这一个函数，我们就可以完成一个非常复杂的一个，弹簧系统的一个计算啊，那么我们就希望有这种平台，能帮我们做一个事情，当然还有比如我们做一些科普性的学习对吧，就是我很好奇呀。

我尝试着去做一做啊，常我我我我，我尝试着自己去搭一个仿真的流程啊，等等之类的是吧，那么第二个场景啊，比如说有有同学对软件开发很感兴趣兴趣，当然在C这个行业里面，比如说我们已经有了一个求解器啊。

比如我已经开发了很好的一个求解器，但是呢但是CE分析是包括有这个前处理，求解器和后处理，我有求解阶段是没有前处理和后处理，怎么办对吧，那我就希望有这样一个平台，能够提供前处理和后处理。

把我的求解器集成进去，能够快速的完成一个完整，ca软件产品的一个开发，当然或者或者说有有有有有的同学说哎呀，我有很好的一些算法，我想去实现一下，比如说我想去研究一个单一个，我们前面讲过的一些。

而一些物理方程的一个算法，本构方程的一些算法，或者是单元计算的一些算法对吧，那我希望有一个平台，能够能够帮助我快速的实现和做一些测试啊，那么这个是从软件开发的一个层面，那么第三个是从软件应用啊。

这个应用就分为很多种，比如说在空在工程中唉，我有一些模型，比如说唉我现在要去算一个啊，去一个一个汽车或者是高铁的一个什么模型，我有这样一个模型，但是我没有软件啊，我要去找一个软件来算。

第二个就是说我可能要去测试不同软件的计，算结果啊，就是我一个模型我想用不同的软件去算啊，比如说用开源软件去算呀，啊用我自己开发的软件去算啊，用商业软件去计计算，我想去对比它的一些计算精度和计算效率啊。

那我在想我有没有一个快速的这样的一个平台，能够把这些软件都集成到这个平台上面来，那么我的模型可以很快的，在这几个软件上面进行一个测试，得到结果对吧，那么这个也是我们的一个这个，这个它的一个场景之一。

当然第三个也是我们的一个想法对吧，我们如果说能提供出一个很好的一个，开源的平台，那么通过大家共同的努力，那么我们是否也是有可能是能够去替代是吧，在有些场景中也能够去替代一些商业软件好。

那么具体的一个实现啊，为了满足这样一个功能，cad软件的一个功能，其实我们就是说围绕着PANO啊，piano前面何晓伟老师已经讲讲了很多课，我们就不再去讲，它其实是一个开源的一个增量集成的。

一个核心的框架是吧，它的一个主导的概念就是一种拖拽式的增加，集成了这样一个概念，一个概念，那么我们团队其实就围绕着看这个这个panel，我以及C1仿真的一个需求，我们首先是对于仿真数据域的一些扩充啊。

仿真数据就说我们在仿真计算过程中，比如说要涉及到一些单元呢节点啊，或者一些材料的数据等等是吧，那我们都要在这个panda，你把这个数据域要把它加入进来，同时呢当然更重要的。

我们加入了很多panda的一些load，或者这些model对吧，它的一些节点，那么做了很多这一核心算法的开发与实现，当然这种开发与实现都是基于panda dao所来，他的这样的一个平台的框架来实现的。

做到一个高可复用性的这样子一个啊，这样几个目就这样子一个目标，那么当然也做了一些软件的一些跨平台啊，和一些啊软硬件的一些自适应的一些工作，但这个就是比较琐碎的，那么最终我们就完成了整个从ca软件前处理。

求解器，后处理等软构件的开发与集成，然后就形成了我们在这节课讲的Mac sim nel啊，这样子一个ca软件的这样的一个平台，它我们称之也是一个开源的一个底座啊，就从一个增量开发的一个框架。

变成为一个适用于ca软件开发的，一个开源的底座，当然在这个期间，我们也做了很多供应工程应用的迭代啊，在很多场景中，我们也进行测试和一些一些应用的迭代，那么具体的一些算一些算法，其实我们融入了很多。

但这个我们就比较专业和有限相关的，我们就不再去呃很详细的去讲，但通过这些这些集成之后。

也使我们能够满足非常复杂的一些cc，仿真分析的一些需要，那么其实它整体的一个框架啊，其实跟呃，其实这个是完全跟PDL的架构是一样的啊，其实首先最开始我们讲的是有它的一个啊，它是四个层次对吧。

首先我们讲的材质运行它数据啊，这个大家在何老师前面也讲过，只是说在这个里面我们加入了很多，过门C仿真所需要的一些数据，加入到这个里面来，再一个就是我们在mod在model层是吧，那么在model层的话。

我们主要是各种仿真计算功能模块的实现是吧，我们各种功能的一些实现，当然在load在load的话就是具体的一些功能啊，具具体的一些功能等等，做我们到后面啊，可以跟大家啊再去也演示我们软件的时候。

我们再去讲解啊，再去讲解，那么在上面就是我们整个仿真场景对吧，就像这个一样，其实我们就把整个CE分析啊，就大家前面我们讲了各种理，各种理论，各种计算的流程都把它分解成一个个的节点，那么有了这些节点之后。

我就可以在这样的一个场景中，搭建出能够满足我所需要的这样子，一个C1仿真的这样的一个流程出来。

嗯当然这样子做完之后就也是得到了啊，也是基于PDA的一个先进性，这把我们就做到了C1仿真与渲染啊，就是我所以仿真计算与渲染的一个分离啊，这个是用到了我们PDA的这个仿真计算和渲染，两套独立的管线对吧。

这个以前和姚何老师在以前也讲过，但跟大家也介绍过，那么再就是C仿真与交互的一个分离，再就是cf仿真与底层的分离，仿真模块的一个通过这些分离，保证了我仿真模块的一个高考复用性对吧，高考复用性啊。

这个都是我们PANO它所具备的一个U1个优势，只是说我们在magic nel中，我们把这些优势很好地继承了下来，然后集成到了我们这样子一个啊。

maxim lab这样子一个平台里面来啊，这个是我们整体的一个框架啊，整体的一个框架，当然这个的话啊也是JPL的一个或筹码，只是说我们在这个里面，在他的这一块里面，我们加入我们一些仿真算法库是吧。

加入了一些仿真算法库，但是其他的这些模块层，其实还是完全继承了PANDEO它的一个啊，准备了一些思想啊，通过这样的一些开发之后，其实我们就面向于各种的科研的场景应用啊，都有一些很好的一些呃。

哎每每每每个应用的人员不同任务啊，都会有很好的一个应用的一些这个方方式，好了我们最后再来回到我们整个软件上面的啊，首先我们整个软件的话也是在这个呃，进行开源的，我们是在gay在这个git上面开源啊。

那么我们的网址是在这里啊，我们网址是在这里，然后大家啊有兴趣的话，可以在这个在这个这个马云上面，把我们这个词啊代码把它下载下来，然后我们整个网页上面也是，有非常详细的一个说明啊，有非常详细的一个说明。

教大家一步步怎么去编译啊，当然如果是有些同学觉得，如果编译觉得太麻烦啊，或者说在编译啊，在安装使用过程中有什么问题的话，那可以加入到我们这个群哦，我们max level的这样的一个呃。

扫这个码加入到我们这个微信群里面啊，加入到我们群里面来进行随时的啊，我们主要的一些研发人员，我都拉到了这个群里面，我们可以随时进行一些交流和一些讨论啊，进行交流和一些讨一些讨论，好，那我们目前的话啊。

因为整个的这一个啊meim lab的话，其实它的编译的一些流程和思路，其实跟判断呢也是非常类似的，所以我在这节课里面，我就不再去跟大家去讲解一部，怎么去去进行编进行编译的。

那么目前我们整个呃呃整个平台的话，我们包含了几几大块啊，首先是啊我们在求解计算这一块，其实我们包含了有自己所研发啊，就是我们华就是湖南大学，我们自己团队所研发的一些啊，显示动力学的求解器啊。

影视求解器和流体的求解器，和多物理场的一些求解器，当然我们也集成了很多的一些开源的，这些软件进来啊，当然这里的话啊，比如说像这个啊，现在国内Y非常主流的这样一个显示的一个。

开源的切割机叫做open radio啊，他以前是必然的啊，就是今年才开始开源，那么可以用来做这些汽车的碰撞啊等等，这样的一些仿真分析分析，第二个就是开利克斯啊，这个也是一个非常成熟的这样的一个开源的。

一个有线的一个软一个软件，还有我们这个流体计算的一个软件叫做SU2啊，当然如果说大家有有需要，也可以基于我们这个Mac level这个平台，把自己想要的一些自己的求解器啊，或者是开源的求解器。

能够融入到我们这个平台里面来，因为融入到因为我们这里面同时也提供了，我们看到有很好的前处理的节点，和后处理的一个节点，也就是说你的前处理就我们前面讲过，包括画网格啊这些唉，往这些有有限元模型的建立啊。

模型的读取啊等等，那么我们都是可以在我们前处理节点里面，把它完成出来是吧，把它给把卖给嗯，嗯就是说都可以用我们这个这个节点，也就是说如果说你只是去开发求解器的话，你就去真假求有器这一部分就可以了。

那么你的前处理和后处理的节点，你都可以直接来用我们所提供的这些模块，就可以了，当然我们也有几何文件的导入是吧，像S像step和OBJ，目前我们是支持的这两种，大家大家有兴趣的话，也可以继续向欧洲向。

像这种OCC啊，把其他一些像IG或者接一些开源的库啊，把其他的一些几何文件读入的，这些也把它加到这个里里里面来，那么我们有了这样的一个节点之后，我们就可以把一些呃几何的一个。

cad的一些模型能够读入是吧，导入到我们这样的一个里面来，然后再进行一个C的一个分一个分析，当然我们也有我们的帮助系统，然后啊这也是继承了PARADIO的话，我们也有我们目前的一个单元协同的一个系统。

但这一块还在完整的一个开发中，还不是那么的玩那么的完善行。

那么这个就是我们啊，整个软这个PPPPT这一块啊，那我们接下来就是教我们软件这一块，那我们整个软件的界面大家看一下，其实跟PDA，如果大家前面已经用过PDD的话，其实跟PDA首先在风格上还是有一定的改。

一个改变，因为我们还是这对于C1工程师，他们所习惯的一个界面，借钱了一定的修改，但是它整体的一些布局啊等等之类的，跟这个呃呃拍照的还是很类似是吧，那么在这边的话，我们呃增加了这样子这样子一个节点数啊。

就是我们所有所开发的这些节点，我们都放在这里面，大家可以去找，可以去找的，大家可以发现包括有钱处理啊，包括单元计算后后后处理啊，包括有各种文件信誉系统，包括材料，包括各种求解器啊，包括渲渲染啊等等。

当然在这个上面也有一些插件性的哦，我们是支持比较好的一些插件式的一些开发，也就是说大家如果要基于my simon，来做一个事情的话，比如说你想自己在这里增加一个节点进来的话。

那么你可以采用插插件的形式是吧，或者是采用这种像前面PYL开发的，我们基于代码开发这种都是可以的，那么这种开发的模式啊，其实跟拍大脑是完全一样的啊，所以我们在这节课就不去重复讲这种模式啊。

那么着重讲一下，我们这个软件可以做哪些功能是吧，做哪些功能，那么首先我们来看一下，比如说我们要做一个完整的，有些人的一个分析对吧，我们讲的完完完整的有限元的一个分析，那我们首先是要进行前处理是吧。

前处理要解决的一个工作，就是从CAD模型到CA1的一个模型，那么在这里的话，我们就涉及到用cad模型的一个网格的划分对吧，所以我们这里会有一个网格的一个，设一个设置，但是在这里的话。

其实我们首先在这个节点，因为我们开发了在这里有个网格这个项目，这个模块，其实这一个模块的话是目前我们所开发的一个，画网格的一个引擎，那么在这里的话主要是有两个节点，一个就是进行网格的一些设置。

那么在网格设置里面的话，首先就有一个文件的这个路，这个路径是吧，在这个在这点的话，主要就是要啊这个这个文件其实是讲的你的C，你的cad模型的这个文件啊，比如说我们在在这里啊连接出来。

那么他这两个节点这一个网格设置，这个节点主要是把你的cad的模型把它传入进来，然后再去选择你所要采用的这样一个，网格剖分的一个引擎，比如说我们这里集成的是一个开源的引擎，是基于是GMASH啊。

是开源的这个GMASH这个引它是开源的一个软件，那我们就可以选择我的这个软件的一个路径，一个路径啊，那么在这里的话，接下来就是一个网格引擎，就是进行网格剖分，那么它所传入的就是说把我们网格设置。

相关的参数传入的网格引擎来进行颇丰啊，我们来试一下，首先我们有个网格的路路径，就是这个我们这个模这个模型的路径啊，我们模型应该是啊，比如说我们就用这个呃Impact dec的这个STP吧。

用pad用pad1这个模型，然后我自己的话，然后大家可以看这里提示，几何模型已经导入成功，但是我们这个视角啊，等这个软件还在不断的，我这种玩这种进行完善啊，大家发现在这里的话。

我们就可以把我们这个几何模型已经传入进来，对吧，那么这个时候其实它还是几何模型，就是cad的一个一个一个模型，那我们接下来进行网一个网格的部分，那我们在这里的话。

首先要指定到我们所采用的这样的一个开源的，这样一个破风的引，这个引这个引这个引擎，那么引擎完之后，在这里我们就可以选择一系列，与这些网格的参数，我们这是个实体模型是吧，实体模型的话，那我就要画网格。

是画题画体网格，那么体网格的话，那我也是选择的是用四面体网格，那么当然还有其他的一些参数啊，但这些参数我们可以默认都不去管它，你就选择你是体网格还是面网格，然后你是体网格，你就选择四面体网格就可以了。

然后最重要的就是网格的大小对吧，就是你画这样一个模型，你用什么网格的大小把它把它给画，把它画出来，比如说我们这里把最大尺寸，最大值都设为一个六对吧，但这个你可以根据你实际的需要。

如果你的网你的网格尺寸比较小，那么它的网它这里离散出来的网格数量就很多，那么需要的这种内存的空间就比较大，然后计算量也会比较大，那如果说但是它的精度就会比较高对吧，如果说我的网格尺寸选的很大。

那么它的计算比较快，但它的精度就会比较低啊，那么在这一点的话，我们就点一次保存啊，点一次点一次保存，那么其实像这个对吧，我们整个网格的这一个啊，这我们在有限里面，我们网格这一块就可以搭建完完成了是吧。

那么对于网格搭建完成之后，我们接下来就讲过，我们要做很多的一些啊，有效分析的一些前处理对吧，那么在有限分析前处理的话，我们这里有两种模式，一种这也是体现出我们这个架构的一个，成属性啊。

一种就是我们可以用这种一个大的前处理的，一个这样的一个大的节点，那么大家会在这个大的节点里面，我们就可以把我们在进行有限分析里面，所需要的像一些材料啊，截面单元工况啊，载荷啊，边界的这些设置啊。

我就都能够在这里把它设置完成是吧，那么这个就是在前处理，那么在前处理计算完，在前处理完之后，我们说在有些人里面有前处理完之后，接下来就是要进行求解是吧，那么求解的话，我们在这里有很多的一些集成了。

很多一些求解器是吧，比如说一些开源的求解器和资源的一些求解器，那么在这个求解的这个过程中，其实比较关键的就是，我们首先要生成一个计算，求解的一个稳一个文件，比如说我们这里在这里。

我们打算用我们自己研究的这个影，这个隐私求解是吧，这里也有隐私求解，那我们首先就要把我们在前处理所完成的这些，哎这些设置啊，全部要通过我们这样的一个计算文件，输出的一个节点啊。

说出来这计算文件的这一个节点，通过这个节点就能够得到一个我们这个求解器，能够独处的一个CV1的一个计算的文件啊，这是得到一个计算的文一个文件，所以说它的一个连接关系，就是说把钱处理的一个数据据集是吧。

生成的通过这一系列所生成的一个数据数据集，传到我们这个计算文件输出的这一个节点，那么我的计算文件做出这个节点，它会生成一个计算文件，生成这个计算文件之后，它就会把这个计算文件传递到我们的自研的。

这个解器里面来，那我自研的这个球也接上，就会读取这个计算文件是吧，我然后我计算完之后计算怎么办，我们计算完之后就要进行后处理，那么在后处理，我们就是说就是要对它的结果进行查看对吧，我们后处理的查看。

基本上是基于VTK的文件来进行，这个显显示的，所以我们首先要去你把这一个，因为我这个求解器它计算完之后，其实就会得到一系列的VTK的一些文件，那我就需要把这些VDK的文件。

又传递到我进行VDK文件解析的，这样的一个节点，然后解析完了之后，我们再在这个云图里面把它渲染出来，就在我们这边这个窗口要看到我的一个节点，那么大家可以看到这个其实就是我们整个流程。

CA仿真的一个整体的一个流程是吧，其实在前面的在这1234这四个，其实在这四个漏这四个节点，这个流程就是对应于我们有限元分析的前处理，那么在这里对应的是我们的求解，后面就对于我们所有的后处理。

那么大家就可以根据自己的兴趣，来增加自己所所研究的一些成果进来是吧，比如说我们在这个求解，我不是用的这一个求解器对吧，那比如说我是用的第三方的求解器，就是我计算完之后，我不用我自研的求解器。

那我是用的这个开源的operator的这个求解器，那我也可以把我的文件录入进是吧，把文件路径链接到我们的这个operator，这个里面来啊，链接到我的这个文件里面呢，那他也是可以来进行计算。

也可以输出是吧，其实所以说这是我们比较我们这样的一个，增量集成平台，它的一个比较灵活，它的一个灵活性，也就是说，如果说你的兴趣点是去开发一个求解器，那么关于前面这些其他的前后处理的节点。

你都可以去用我们的这些节点就可以了，你就自己把接口定义好，把它连接起来就行了，如果说咱们啊，咱们很多很多很多同学都是搞图形学的是吧，学图形学的，那如果说你对这个网格颇丰非常感兴趣是吧。

你的网格颇丰感感兴趣，那你也可以去开发你的一个网格，破分的一个引擎是吧，去开发你一个网格破分的一个引擎，那么你的你就可以把你网格播放的引擎，把网格再传递给我们的球员起来用啊。

所以这个就是体现出我们这样一个平台的，一个优势，但在这个里面我们在网格引擎这一块，我们还要进去，把我们的这个数据把它输出来一下啊，这个是我们当时考虑到这个网格颇丰的一，个独立性。

我们就要把这个数据集把它单独输出来，好说出来我们就有了这个网络，我们引进的数学期，我们就可以传入到我们这一个这一个数据集，里面来啊，那么我们有了这个之后是吧，有了这个之后，我们到了这个。

我看一下这个就是我们整个的一个计算流程，这个是，好现在就已经进行了，我们现在就让整个流程开始开始，开始执行起来是吧，开始执行起来，前面刚才刚才调查出来的，是说我们的网格数据处理对吧，就是我们的网络。

我们的网格已经得到了，在网络我们的网格已经画，已经画画完了，那我们在这里，比如说，首先我们要去定义，我们这个分析物体的一个材料，那就是在这个前处理，在这里我们首先要定义它的一个材料。

那么在这个材料这里的话，比如说我们首先选择的材料类型，比如说我们就说是一个我们前面不讲的，都是弹性材料吗，那么弹性材料，我觉得这个弹性，就是各有各项同性的一个材料啊，设置它的一些呃随便设啊。

这我就我就随便就随便测的，是他的一个材料的一个参数，比如说养一个阳性模量和一个波升比啊，一些产业产品的一些参数啊，然后我们把它保把它保存下来，那么这里就会有我们这样的一个材料出，出现了对吧。

然后我们再就到它的截面，截面的话，其实就是说定于你的这一个模型，因为在我们要让ca1的这个求求解器认识，认识到你的这些网格，它是些什么网格对吧，那我们就要告诉C1的这个切割器，我的这些数据及这些网格。

它所对应的一个截面，其实它是一个三维实体的这样子一个啊，它是它是一个三维实体的这样的一个截面，所以我要创建一个属性是吧，然后上去一个属性之后，我就把这个材料把它确定赋予到啊，赋予到我们这个上面上面去。

这边呢就会有一个这就赋予的，我们整个的这一个啊上面去，当我们在这里可以把我们这个把它输出来啊，就我们这个界面大家大家可以看到我这个几何，当然刚刚在前面忘记给大家看这个了啊，看其实大可以。

大家大家可以看一下，其实我们现在整个模型它其实是一个网格模型，大家大家注意注意到没有，因为我们比如说在这里啊，我们在这里是前面，在我们前面没有进行网格剖分之前，如果说我们把它显示出来。

其实它是个几何模型是吧，但是我们经过网格剖分完之后，大家可以看到，其实它是一个已经变成一个网，一个网购模型了，当然如果说我们把几何模型和网格模型，同时显示是吧，大家看一下，如果我同时同时来显示这一个啊。

这些限制啊，哦不不不，这个不能点掉，这个不能点掉，这也不能点掉，同时显示大家可以看一发，现网格和实体之间，其实他们有些地方也没有完全重合是吧，其实这就代表着我们C1和这个，CAD模型的话。

他们之间其实有一定的这种物，这种物这种误差在在这个里面的是吧，他这种近似计算的这种这种形式啊，但我们继续回到回到这里来啊，还是到这个节目这个地方来诶，请处理建筑材料，是没有，但是。

简介我们再重新来一次啊，好吧，这前面我们再把这些材料参数再把它设置，把它把它设置一下啊，前面可能给我冲掉了，等一下好用到这个材料数据，然后我们再设置它的截面数据，好截面数据在这里截面数据有。

然后我们创建它的属性，把它的这一个材料啊，洁面这里也赋予成功，然后接下来就是我们它的单它的单元对吧，我们前面讲过单元的话，因为我们的网格是四面体的形式，但是四面体形式在计算的话。

其实是有很多种单元计算的形式，就是如果大家也这也是体验的，如果说你是做一些这个单元算法的开发，其实你可以在这里开发一个单元算法，然后把这种把刀倒进来，但像这些我们就不去改变了，我们就默认的还是用D3。

T4这样的一个单元来进行计算，把这些单元赋予成功，然后接下来就是一个工况啊，当然工况这一块的话，我们都不用去管它，因为我们要做的其实就是一个这样子一个信，一个一个这样的一个线性经济学的一个分析。

信息经济学的一个分析，所以在这里涉及到一个求解器的一些，选一个一个选择啊，这些我们都不管，就创建了一个工况，然后公告完之后，我们就去定义它的一个边界吧，边界就我们上面讲过我哪些地方是固定的。

因为我要分析它，它肯定不可能是一个完全就是一个这种嗯，空白的嘛是吧，就是一个自由体，那比如说我正在把它的这两端，我把它固定起来啊，我这里加一个边界呃，加一个边界，我们可以把它给固定起来。

我首先选选它的一个面对吧，选它的一个面，比如选择这个面，哦对对对对对对对对，BC选一列载荷类型，我们选它的一个面，单面全全全选，让我们选择这个面好，把这个面都把它选都，把它都把它选上。

然后同时我们把它转到这边来，把这个面也选上好，这就把这两个面选上，然后我们就把这两个面上的节点我们给他哦，这个是呃，这个是加载荷，不好意思，我我搞错了，这个是加载荷载荷就是说我们要给他加。

给他加载一个力对吧，我们比如说我们在这个上面这个表面，我们给它加加一个力，好在上面这个表面我们给它加一个力，加一个集中力，集中力的话，我们就说是沿着F3，比如说沿着FZ方向的一个100的这样的。

一个集中力，那么这个就是我们就创建了一个，载荷进来啊，找一个创成功啊，这啊这创建创建的一个载荷，然后最后就是给他增加一个约束对吧，增加一个约约一个约束，比如说我们把这两边把它给约束住啊。

约束住来把它限制住好，新手做之后，我们把它这边把它全部把它固定，把它给固定，然后我们也给它增加一个边界，赋予好，做完之后做完这些之后是吧，做完做完这些之后，我们就可以来进行一个，计算文件的一个输出。

一个输一个输出对吧，然后接下来就可以到我们这个求解啊，我们就可以让他开始来求解啊，TK的证据，这个一下就算完了对吧，我看一下啊，大家看一下，我把这些不必要的隐藏起来啊，把这个前缀都隐藏起来哦。

这个不要这个也不要，这个要不要这个不要看，大家可以看一下，其实这个就把我们前面再加上这样一个力，受到这样一个集中载荷的话，它的这样一个求解的结果就把它计算出来的啊，其实就是说我们可以用这样的一个平台。

可以搭建出这样子一个比较啊，灵活的这样子一个ca分析的一个流程，那么大家可以根据你的喜好啊，你自己的这个兴趣，你的研究点也可以加入一些新的节点进来，如果说你只是去做这些哎求解器的开发呀。

那你可以去复用我们做前处理的这些节点，就达到这样的一个增量开发的，这样的一个模式啊，当然我们也可以把整个流程，我们也可以把整个流程做到更加的，而且这种细化是吧，比如说我们从网格颇丰开始。

我们前面讲的前前处理不是一个大的，包含所有的这些嘛，但如果说你你的兴趣是开发里面的某一类对吧，那么我们也可以用这种比较灵活的，这样一个形式来进行搭建，比如说我的材料这一块。

我用单单单独的材料这一个模块是吧，我的截面我先把它全部拿出来，我的截面还有我的工况对吧，我们前面所用到的一些工工况，还有载荷，还有边界条件，对不对，载荷边界条件工况，其实像这些我们都都可以嗯。

在前面还是把画网格对吧，我们的网格设置后，画网格的引擎对吧，都拿过来，然后再把我们的这个VDK后处理的文件解析，然后再次云图的渲染对吧，都拿过来，那么其实像这里的话，我们把它分一下。

我们也可以用这种更加小的这些节点是吧，更加灵活的节点来完成一个工作，那么对应于在这里的话，其实就是说我把它排下序啊，还排成这样子就很好理解，很理解，也就是说其实在这一块就是我们的前处理是吧。

中间这一块的话，中间这一块的话就是我们的求我们的求解啊，当然这一块其实都是前处理啊，前处理这都是前处理，都是前处理，都是前处理，都是前处理对吧，包括我们的文件的输出啊，文件的输出，文静的输出对吧。

这都是属于前处理，然后我们求解器这一块的话，其实就属于在哪去了，这里对吧，我们求我们求解器就是在中间这一块，然后这就是在后处理对吧，那我们也可以说去年这样子，一个把这些全部连起来是吧，一样的。

中牌也是在这里把这个数据集要导出一下，这是最大的，我们现在这，啊这个数据还没有，主要是我先不管吧，就后面这些是吧，全部把它连起来，这种数据集连起来，并且边界到载荷嘛载荷，然后再到我的MC文件生成。

再到文件数，再到文件啊，再到我的这个输出对吧，这是我的输出，其实我也可以用这样的一个流流流程，也可以达到我们前面一样的仿真的一个过程啊，里面大家看到我进到每个里面来，其实我定义的这个窗窗口。

跟我前面用这一个大的，用这个大的节点节点的窗口其实是一样的是吧，其实用这个大的节里面是一样的，我对应的每个小的在这个是好处，就比如说你在这个里面，你自己开发了这样的一个功能，那就把它删掉是吧。

你删掉之后，你把你的开发的功能放到这里来进行替代，就可以了啊，所以这个就是他的这样的一个优势啊，当然还有就是说再跟大家再简单演示一下，比如说我们讲的另外一个场景对吧。

你要去集成一些比如说开源的一些软件进来，那比如说我们在集成一些开源的软件进来的话，比如说我们集成的是这个啊，我们要用operators是吧，用open radius的这样子，一个开源的这样子一个技能。

哎呀多多多弄的一个技能，我先删掉一下啊，然后其实也也是一样的啊，像这个的话，OPERRADIO的话，这个是我们所开发的一个节约点，那么这个节点的话，它就是用来去调用我们open radio的这个求解器。

那么在这个里面，我们要用到我们其他的一些模块，比如用到一个文件输入的一个模块，那么这个所谓的文这个文件输入的一个模块，就是说我可以把我的一些绩效文件，输入到我的开源的这个切水器里面来对吧。

我增加这个切水器里面来，然后open radios算完之后，我就要去对它结果进行分析对吧，比如我这里又开，我自己又开发了一个节点，因为open rider是它的一个求解器，他的介绍文件不是VDVDK的。

所以我们又开发了一个节点，把它求解器的一个文件转换为VDK，那么有的VDK之后，我们就可以用我们前面这个VDK，解析和云图渲染的节点对吧，就可以在我们的这个系统里面里，对你的计算文件进行查看。

比如说这就是整个流程，那么在这个里面的话，我们在这个节点，在这个节点我们要去定义我们的这一个，当然你也可以把它改成是默是默认有的，我这里是为了演示，就是我们去选择是吧，选择这一个哦，不我们的在我们这。

我们电脑里面所安装的这个open radio的求解器，在什么地方对吧，就把这些我们要去把它给选好，我先把这些求解器选好啊，好有这样子我们把它的求解器都定义完之后，我们接下来就可以去选我的输入文件啊。

比如说我这里有有一个文件，我要用or用这个operator进行求解，那我就可以把我的文件，把它这个文件输入的这个节点，顾名思义嘛，就是把文件把它传入进来嘛，嗯再找啊，稍等啊，找一找那个在哪里加点丝啊。

比如说我们用一个我们有个气囊的吧，用一个气囊的文件吧，因为气囊的文件给大家演，给大家演示一下，大家看一下，我把我把文件进传进来之后，其实他这个时候就已经自动的调用了，这个ODIOS。

在进行这样子一个开源软件来再进行求解了，这个是我们整个一个求解的一个过程啊，当然这个大下面有用，会对应的提示啊，现在用open the dose进行求解的计算，这个是我们的这个求解节点再进行解析啊。

这个就是我们算完了一个结果啊，这个比例我再调一下，我们以前有一个自动调整的那个功能，但是在这个版本里面更新的时候，出现了一点问题啊，出现了问题啊，像这个其实就是模拟的一个气囊的，一个撞的一个过程。

我们要看它的一个结果的话，比如说在我们的平台里面也可以直接去看啊，直接看到它的一个结果，它其实是一个动态的一个过程，看到没有，就是模拟的，大家我们汽车里面不都是有气囊吗，对吧。

那么当这个汽当这个汽车发生碰发，这个发生碰撞之后，当这个汽车发生碰撞之后，这个气气囊的展开是怎样子的一个过程，像这个我们就可以在我们这个软件里面，进行一个方便的一个实现啊，这种开可以用可以用开源软件。

可以非常方便的实现这样一个过程对吧，这个是反方向放啊，那么整个计算就是这样子的，模拟它整个爆炸的一个过程是吧，整个爆炸的这一个过程，那么大家就可以发现，我们用我们这样的一个平台的话。

我们就可以非常方便了是吧，非常方便的去调用其他的，像这样一些开一些开软件对吧，但我们也可以去调用像这种啊KX啊，或者是我们还有这种开这种流体计算的，我还能计算到哪里去了，都会长的啊，多独立厂的。

我们流体的这种这种这种，s u two的这些求解器啊，其实都可以在我们这里面方便的来使用，那么如果说你也有你想用的一些求解器，那么也可以基于我们的平台，把你的取水器可以集中精难，但是像文件啊。

像后像后处理这些啊，就可以来复用我们的这些就可以了，那么你就只需要去开发一个节点，把你的切水器给调用进来就可以了啊，所以这个就是我们整个max level，目前所做的一些功能，当然未来的话。

我们目前整个团队也在做一些，更加细细化的一些功能啊，比如说我们做了一些，因为目前现在做增量开发，前面那个何耀伟老师也讲过，一个就是基于代码对吧，我们可以复制一个空的一个工程。

然后你去进行基于模板进行修改就可以了，第二个就是基于插件系统，那么目前我们团队也在做一些，更加细化的一些功能，比如说我们在这里可以有一个空白的节点，那么在这个空白的节约点里面。

我可以基于Python进行一些RR1R一R，进行python2次开发，那我就直接可以在拍在这一个界面里面，用Python完成整个节点，比如说我在这个节点上完成某一个呃，方程组的求解啊。

或者是完成我某一个单元的计算啊，我就在这里可以直接去去完成这样的一个，真正开花就可以了，另外的话我们还在整个啊单元单元结，结合这一块，我们团队和何小何，何嘉伟老师团队，也尽量的会想把它做得更好一些啊。

当然对于这种库的这些复用的这些呃，呃这些软控件我们也在逐步的在完善啊，呃具体的一些加一些一些应用啊和交流的话，还是希望大家如果需要可以呃加入到哦。

在马云上面下去，在这个仓库里面去下载我们的软件啊，或者是加入到我们这个群里面，跟我们进行有呃更多的一些呃交流啊，那么我们整个的这一个嗯，我们的整个的这个game，401。

这门课就是半动引擎物理仿真编程与实践，我们整个课程就上到这里了，应该说从前面最基本的PYTHO的架构设计，设计，到基本的物理仿真算法，到我们C1的算法。

到这个magic level的一些开发和一些情况的一些介绍，和应用的一些方法等等，希望也是希望这门课程给给大家一个，从物理仿真到ca仿真的一个启蒙和启，发的这样子一个作用吧。

啊好那我们的呃今天的这门课就上到这里了啊，谢谢谢谢大家啊。

谢谢各位同学好。

GAMES401-泛动引擎(PeriDyno)物理仿真编程与实践 - P2：2. GPU硬件架构简介及CUDA编程基础 - GAMES-Webinar - BV15M4y1U76M

嗯行这样我看八点了，那个这样，要不我们就开始了。

然后上周的话应该主要讲了，就是这个系统怎么搭建啊，然后但凡大家对这个系统有个初步的认识啊，然后因为这个系统里面就会着，这里边会包含大量的那个呃gpu相关的一些代码，然后包括并行的一些实现。

所以这样的话就这节课主要还是给大家呃，普及一下，就是怎么去gpu来做一些算法的研发，那其实是这样，现在gpu的后端的话其实比较多啊，就是呃比如像那个kda是一种，当然还有open c啊。

或者或者是那个挖坑等等啊，就是包括dx等等，就这些实际上都可以，然后但是呢总的来说呢是这样，就是挖坑相对来说还是更容易上手，所以呢就这次课呢主要还是以马克为基础啊，就比以扩大为基础啊，就扩大比较简单。

也以扩大为基础，来介绍一下那个呃gpu的一些硬件架构，然后呢以及基于就是说gpu怎么用呃，扩大这个并行编程语言，然后来实现一些呃一些并行的一些算法，然后呢，因为之前好像上次的好像反映，那个网页有问题啊。

这是我调了一下，当然有问题后面也可以反馈一下，这样到时候再看一下啊，然后呢接下来我们就开始啊，就是啊这次的话主要讲几方面，一个呢是会首先会讲一下就gpu的一个硬件架构，然后这个跟啊就是我们了解一下。

就是跟呃，我们以前所认识的就cpu到底会有哪些差异，然后第二个呢就是主要讲一下就是基于这个gpu，然后呢这个呃我们实现算法来说，它整个的一个编程模型是什么样子的，然后当然接下来会介绍重点讲两个呃样例。

然后这两个样例呢是这样，就是实际上用的会非常的普遍，就是如果后面你写仿真算法的话，就是其中一个就是归约算法，然后第二个呢是前缀和算法，这两个算法其实几乎在每一个防御算法里面，可能都会涉及到。

所以呢就基于这两个，就是呃非常普遍的这两个算法来讲讲，就是说gpu啊编程到底需要注意哪些哪些问题，然后当然最后呢就是会讲一下，就是c加加模板的一些相关的东西啊，其实主要也是为了让这个算法更加通用。

然后最后就是呃会讲一下，这个这个算法的一些应用的一些场景，主要主要实际上是这个前面两个，就是包括算法和前缀和算法，就是scan这两个算法的一些典型应用场景啊，然后呢来了解。

就是说这个东西到底会有哪些的一个用处啊，然后接下来我们这来我们来看一下啊，就是整个gpu硬件架构的这么一个一个发展，然后这个呢实际上是以英伟达的这个，gpu的架构为主线。

然后呢相当于列的这么一个发展的一个路径呢，然后总的来说呢是这样，当然其他时间点是非常多啊，然后这里边实际上笼统的可以分呢，实际上分成两个阶段，实际上第一个阶段呢是在呃，相当于左边这个2006年以前。

然后这个以前，为什么说是把这个作为一个时间点呢，因为实际上是在2006年以前呢，是这样啊，当时显卡其实也有也叫gpu，然后呢，但是呢呃之前的显卡主要是用来，就是说比如玩游戏的时候用来做图渲染的。

所以呢它实际上是一个专用的一个图形处理器，所以它一般来说主要是为了做图形渲染，然后当然其实它里边也包含一些，就是说嗯就是呃可编程的能力，因为比如说它实际上就是最最早的话，它其实是一个固定管线。

但是后来的话就是啊其实特定的阶段，它实际上也是可以编程的，但是总的来说呢，它其实很多功能呢还是固化的，所以呢为啊这本质还是为图形服务的，所以这样的话，实际上就整个到2006年以前啊。

这都是呃称之为这个传统传统gpu的这么一个，一个时代啊，然后但是到2006年呢，就这里实际上是一个标里程碑的一个事件，就是呃其实就是英伟达发布了一个test tesla的，这么一个呃一个图形架构啊。

就是这个通用计算的一个架构，然后这个架构跟以前的架构，会有一个什么差别呢，就是以前的gpu的那个处理器，它主要是用来做图形渲染相关的，它很就是很难去，比如说做一些通用计算。

比如说这个时候我要做一个访问计算，那这样的话以前的那个很多很多的那个硬件，实际上是可能不太不太方便或者不太支持的，然后这样的话就是到了这个tea架构停车之后呢，他实际上就是把这个那着色器模型。

或者是这个计算模型呢进行了一个统一，那这样的话也就是说这个计算模型可以用来计，算，就是除了图形渲染以外的其他的一些任务，然后当这里也还有一个很重要的，就是因为以前的话啊。

大家如果看过学过open gl的话，也知道就是以前要编程的话，必须是用比如写这个协定language，当然像是比较典型的，像这个呃gsl或者是h i s l这种，然后这样的话实际上是需要把这个呃脚本。

其实类似于脚本的形式啊，然后发给这个图的那个这个gpu，然后呢相当于它编译完了之后，然后呢去执行，所以这个东西总的来说还是不太不太方便的，包括调试啊啥的，其实很很麻烦，所以这样的话。

实际上那个特斯拉架构发布之后呢，它实际上就在直接在编程的方面，就直接支持c语言的一个编程，这样的话对于很多以前，比如说对孙语言比较熟的话，其实是相对是比较友好的这么一个过程，那当然这个再往后的话。

到2010年的话，实际上就是呃随着那个飞米架构的复建之后呢，它实际上就是呃更进一步的完成了，这个gpu的通用计算的一个架构，然后他这个实际上基本就逐渐越来越成熟了，就相当于从以前的专用的图形处理器。

逐渐的转化，演化成了一个相当于一个通用的一个一个计，算计算的一个架构，然后当然这个后面的再往后的话，实际上就是总的来说大同小异，但是呢其实会有一些差别，就比如主要体现在可能这种呃。

kindle就是这种core的那个变化，比如扩大core，它可能就是要有些像菲米架构32个，然后到开普勒的话，比如是三一百92个等等，然后当还有其他的，就是可能性能上等等会有些差别。

然后当然总体来说其实变化不太大，然后当然到了后来，因为就是整个欧美知道就过去十几年的话啊，深度学习其实发展的非常快啊，所以这样的话到2016年之后，这个帕斯卡这个架构出来之后呢。

他实际上就是呃他特特别的针对这个深度学习，这个任务啊，然后呢就是相当于对他进行了一些支持，所以呢，这里边就是到后面这个瓦瓦瓦特架构之后呢，它实际上就引入了一个叫tea pot，这么一个一个呃计算单元。

然后这个单元，实际上本质主要是为深度学习服务的，然后当然另外还有一个比较啊，有啊就是这个比较特殊的一个地方，实际上是他对那个以前的这个扩大core，进行了一个拆分，因为传统的扩大core里边。

它其实包含了呃整形计算，以及它的浮点型计算的那个两个单元，但是呢到啊后面的价格之后呢，对它进行了一个拆分，这样的话实际上整个就是可以更有效的去利用，就是呃他每个每个单元的一个计算能力，然后当再往后的话。

实际上整个还是也是一些不断的优化，调整或者加速等等各方面的一些变化吧，所以整个实际上就是这个实际上就是，整个是差不多能看清楚，这个gpu的一个发展路程啊，到时候，所以对于有些可能一开始就直接就是接触的。

就是哭大，或者是啊现在比如说大家都用a i啊，就是去训练模型的时候，真的可能对于这个呃以前的这个，他这个历史不太不太清楚，所以这样的话整个啊这块就讲一下，然后当然这里边后面我具体再介绍一下。

这是每一个到底是有什么差异，首先这样就是我们还是来看一下，就是传统的那个图形架构啊，就gpu的架构到底是什么样子的，就是这个是这样，一般如果学图形学的，一般肯定是都会讲的，实际上就是一个传统渲染管线里。

设计的一个内容，然后他当然包含几个阶段了，就是因为传统渲染管线，它其实最主要的一个特点，就是它很多的功能实际上是固化在里头的，比如说一般来说最重要的两个，实际上就是包含一个呃顶点着色器。

然后还有一个天然着色器，然后这两个东西干什么呢，就是因为我们知道渲染的话，实际上它的一个输入啊，对一般来说就是比较基本的一个几何单元，可能就是一些呃离散的点，然后呢或者是一些线段。

或者是一些比如三角面片，然后就这些呢几何单元输进来之后呢，相当于是要经过这个顶点着色器，然后呢对比如说对这每个顶点它进行赋值，或者是比如说颜色计算，或者法向计算这个系列的。

相当于在顶点的层面去完成这个操作，所以这样的话也就这个顶点热射器这个单元呢，实际上只支持，就是说相当于顶端左侧这个这么一个功能，然后呢，这样的话，实际上这个东西就在传统的内存管理里边。

这部分这个计算单元，它是不太可能用来被用来做其他的一些，比如计算任务的说，这样的话再往后的话，比如是一个裁剪啊，影面剔除啊，这等等的一些操作，那当然这个整个这个做完之后呢。

到后面这个片源处理器这个阶段呢，相当于是啊这个就是图形图形学里边学的，就是所谓的就是工程化的一个过程啊，就是把输入的那个点，然后其实是一些呃，基本几个单元转换成一系列的一个像素，因为我们看到这个屏幕啊。

它其实是有一些像素构成的，所以这样的话就需要把一些连续的图源，变成一些离散的点，然后呢，最后呢对每个离散点做一个光影啊等等，这一系列操作，然后这些操作的话，实际上其实也是在这个啊，片源处理器列表去完成。

当然最后完了之后，相当于就是说它会根据这个深度缓存啊，或者那个遮挡剔除等等，这一系列的算法，就相当于最后会把每个片尾送到，就是说他一个真缓存里头，当然这里边会包含真缓存，里面其实包含两个结构。

一个是那个z buffer，还有一个是rgb buffer，rg buffer其实就是我们看到的那个显示器啊，就比如看到那个屏幕，它其实就是一个rgb buffer，其实就是相当于它其实就是可理解为。

就是一个带三通道的，就是r这代表红色，红绿蓝这三个通道的这么一个颜色的一个图像，然后呢还有一个那个深度缓存，这个深度缓存，主要就是用来做片源轴色的时候啊，比如说他要体现前后的一个遮挡关系。

那这样的话就有这个深度缓存之后呢，它实际上就相当于可以辅助，就是说你有些片源进来之后呢，就是被遮挡的那个时间，就不需要输送到那个平面，所以整个实际上是这么一个流程，所以这个是整个管线啊。

就在刚刚讲的2006年以前的那个啊，传统的这个呃，呃gpu里边这个实际上是固化下来的，当然这个东西随着后面的那个就是20年，你们tea架构提出来之后呢，这个东西就发生了一些变化，就是呃因为本身这样。

刚才讲这个有个最主要的一个问题，就是你很多的一个计算单元，它实际上那只能固化，用来做特定的一个处理任务，那这样的话就是这样，我们就要通用这个通用计算任务的话，它实际上它的那个任务的类型啊五花八门。

所以这样的话就啊一个比较好的一个呃，就比较理想的一个状态，肯定是，我希望就是说他们每个计算单元，可以根据我们的需要去去做，就是说相当于去执行，我们按我们的需求去执行特定的一个任务。

所以这样的话实际上就是到后面，就是逐步演化成了，就是我们现在所看到的这个啊，就是叫通用的gpu的这么一个一个架构，然后呢那我们来看一下这个，其实右边那个图代表的，实际上。

就是我们现在看到的一个通缉p c，1r一个架构啊，然后它其实和cpu的一个架构呃，其实也非常像，就是我们知道首先就看左边那个cpu的架构的话，其它主要包含哪几种东西啊，就是一个呢就是最最最核心的。

其实就是它的一个计算单元，就是相当于他实际上去执行指令啊等等，都是在这些库里边去执行，比如像这个cpu它包含了四个core，那这样的话就是实际上就是可以，比如说多线程去执行啊。

然后这样的话整个计算的过程中呢，就是指令的控制啊，然后包括那个数据存取的话，需要依赖，比如这个控制单元，以及当然还有他因为这样的整个cpu的话，他为了保证这个整个呃数据访问啊，以及整个计算的效率的话。

它需要有多级缓存，比如说有l一就是一级缓存，二级缓存，三级缓存，那这样的话就可以减少这个数据访问的那个，这个延迟，所以这个实际上整个是一个cpu的架构，然后其实我们可以看到就是说呃，比如像左边那个图。

可以看到其他cpu的架构里头呢，它整个计算单元跟那个控制单元，你发现其实是一对应的，也就是这样的话，其实有一个专门能力控制单元，去协助你的整个所有的一个计算，所以这样的话。

他其实可以处理更加复杂的一些任务的一个流，就分更加复杂的一些逻辑运算，所以这个是一个cpu的一个特点，然后接下来我们看一下右边那个gpu的一个架构，然后呢其实你可以看到它很多的单元，其实它也是有的。

比如像绿色这一块，它实际上都代表的是他的一个计算单元，然后呢像黄色那个其实他也有控制单元，同时呢也有各种的缓存，比如说呃这个一级缓存，垃圾缓存，当然还有那个嗯显存比较大的一个线程啊。

但是他的那个不一样的地方，就在于发现，你发现就是他整个比如说它的控制单元啊，它其实跟它的计算单元并不是一一对应的，也就是说什么意思，就是他一个控制单元可能要去控制，比如说这里有十哎，应该是几个啊。

这需要有十几个的这个计算单元，所以这样的话也就他相比于cpu来说，它其实它所对应的这个控制单元，计算单元实际会更多，那就正是基于这么一个特点呢，就是也会造，这就导致了就gpu那个整个运行的逻辑。

跟cpu实际上会有一个差异，就是说整个cpu，比如说他因为他的那个控制单，相对来说比较简单，所以呢就是说它实际上比较适合于那种啊，计算密集型的，因为我们可以看到它整个计算单元非常多。

但是它的控制逻辑单元，它实际上非常比较相对cpu来说是比较弱的，所以他比较适合这种计计算密集型的一个任务，然后呢，对于这种比如说有大量的这种逻辑判断的，这个法是cpu的一个优势啊。

然后当然这里边整个就是呃我这里圈出了一块，然后这个呢实际上相对来gpu来说，其实就叫一个呃流逝的一个多处理器，然后呢，他每一个他的那个绿色的一个计算单元呢，它实际上是一个对应的，实际其它绿色的一个。

实际上代表着它实际上实际执行的这么一个，计算单元啊，所以这个架构呢，实际上是构成了一个gpu的一个基础啊，所以后面的话我们会具体讲，就是呃一个所谓的这个流式处理器。

以及跟他的那个流式多处理单元，是一个什么概念啊，然后这个实际上这个右边那个图啊，实际上就是代表了一个流逝的，流逝的多处理器的这么一个结构，然后啊当然这个结构是这样的。

不同的gpu里面实际实际上会有一定的差异，就是说因为本身不同的那个呃架构的话，它实际上为了兼容不同任务吧，稍微有一定的调整，但是总的来说实际上就是从就是tesla发布之后啊。

就大的那个结构实际上基本都固化下来了，就是比如说这里边包含几个最重要的东西，就是首先就是一个流式多处理器的话，它包含肯定是这样，它包含多个的一个独立的一个处理器，然后这个处理器相当于实际上就是。

比如这里有八个显示八个的话，实际上它是每一个他可以去独立的去执行，这个这种运算指令，然后呢，当然这个扩的那个数量就是这个sp的数量，当然每个价格可能不太一样，就刚才讲这个有可能分别架构，比如32。

cp价可能是192，当然这个其实不重要啊，就是实际上就是，因为这个本身也是为了兼容不同任务，然后做了一些债务的一个调整，然后呢除了这个之外，因为整个计算的话，它相当于需要接收指令。

那这样的话就需要有一个指令的一个收发器，也就上面就是这里黄色标的这一块，这块呢实际上相当于是从，比如说他从cpu里边接收到一个分类调用之后，它实际上需要就把那个课程调用转换成。

比如说这个gpu能识别的一个一个指令，然后呢这样的话去分发到这个每个扩张表，具体去执行，然后当然除了这个之外，因为执行的过程中呢实际上会有用到，比如说因为我们知道那个除了算法，你还有数据是吧。

这样的话就需要就是说在呃它每个寄存，就是每个处理器里边实际上会有寄存器，当然这个寄存器是每次上每个处理器是特有的，然后除此之外呢，就是还有比如说像一些需要的memory，这个新的memory。

实际上是所有的这个呃处理器相当于是共享的，所以这个这个实际上就是整一个的一个呃，也是构成，相当于实际上是gpu里面最核心的一个计算单元，相当于是一个构成整个gpu的最重要的一部分。

所以这样的话后面我们再看一下，就是呃具体到比如说某个特定的一个架构，因为这个是最早发布的，就特斯拉架构，然后呢这里边实际上就是刚才讲到的，其实那几个基本都是有的，就比如这个中间那个实际上是它的一个呃。

扩大扩就是它的一个核心的一个处理器，然后当然除此之外呢，这里还有一部分就这个实际上是用来做，就是说比如说一些呃，比如说数学运算，比如像三角函数，sin，sin等等的。

这些特殊的函数的运算的是这个这个处理器，然后当然除此之外的话，其实就刚才讲到的，比如寄存器，当然这里你发现寄存器的数量啊，就一般来说gpu的技术数量其实都很小，就是他跟那个比如说跟我们通常理解的。

比如内存多少个g啊，多少个那个啥，这个其实不太一样，你说它所以它一般来说可能，比如说像这里表示多少个beat，就是呃，所以就是说而且这些寄存器，它实际上是所有的那个core，它实际上是共用的。

就是也就是说你比如你一个q占用太多了，它实际上会挤压，就是说其他扩的那个计算器的一个数量，那当然除此之外呢，还有就是像呃呃敞亮的一个catch，然后包括视频的catch等等，然后这里还有一个很重要的。

就是前面来讲就是有一个shadomemory，但shadomemory其实要比整个要比寄存器要大，但是呢其实也相对来说还也不太大，就是要比整个显显存实际上要很小很多。

当然这两个其实最大的一个好处就是后面会讲，就他们其实在他们的他们的存取的一个速度，实际上是非常快的，然后呢我们再到这个，比如说这个费米架构的话，其实总体差不多，但是呢你发现它其实主要多了几个东西。

就是一个呢就是他的指令的一个呃收发器，它其实你发现它有两组，他跟以前那个就通常只有一组，这个不太一样，所以这样的话它其实具有更强的一个指令，说他的一个能力，但他的扩的数量其实也呃相当于也增加了不少。

然后呢同时你可以看到库里边呃，其实每个扩的话，它其实就主要就包含一个浮点运算单元，以及它的整形逻辑运算单元其实主要是这两个，但后面其实刚才讲了，后面实际上整个在新最新的一个架构里边。

其实这两个东西就进行拆分了，所以我们看那个安培架构里边，你可以看到，就是嗯除了就是说这个标准的一些结构以外啊，就是最核心的就是你会发现它里边的这个呃，计算的那个核心，这就是中进行了一个拆分。

就是以前的话统一这两个东西，就是int跟float这两个东西统一合在一起，实际上就叫一个扩大扩，然后呢到最新的架构里边呢，实际上这两个东西就变成了啊，独立的一个计算单元，那这样的一个好处。

就是因为以前的如果合在一起的时候呢，它主要是这样，它不能同时处理整形，那就是说int和float这两种运算，所以这样的话就需要呃，就是比如说你这个时候有一个call，你在计算浮点运算的时候。

你相当于你接下来有一个整形运算的话，你需要去等待，然后这个相当于拆了之后呢，就可以更有效的更充分的去利用，就是说他们不同的一个运算能力，也就是说浮点型跟整形，它可以同时去进行一个一个计算。

当然其实还有更其他的一个特点，就是因为它整个为了支持ai啊，就是各种深度学习的算法，所以这里边实际上就引入了这个啊tensor core，然后这个东西主要是为了支持深度学习，但更仿真啊。

反正我们可能现在呃这块探索可能相对比较少，然后呢主要还是生活区为主，然后同时它可以支持更丰富的一些数据类型，就因为比如说像因为通常我们知道这个int啊，一般比如说是32位的话，实际上就是一个四个字节的。

但是有的时候很多时候呢就比如说或者浮点型，然后我们实际上不需要那么高的啊，就是其实可能比如说我不需要32位的精度，其实就算了，这样的话我可以用半精度的，或者是甚至甚至是比如说int可以用八字。

也就八个币投四个币，甚至有一个beat啊啊这等等，就这一系列的就是呃较低精度的一些数据，然后去计算就相当于获得更快的一些效率，所以这个实际上就是主呃，就这不同的一些架构上的。

那就不同gpu的架构上的一些一些差别啊，但是呢整体对于我们理解这个呃，整个怎么去用这个gpu去编程啊，其实关系不太大，就是因为它整体的逻辑上的架构。

实际上在第一代实际上就已经确定了，所以接下来我们就看一下，就是用这样的一个硬件架构，我们具体啊就是怎么去做一个算法的一个研发，那就根据前面的那个就是呃可以看到，就是说实际上就是我们如果买了个显卡之后啊。

其实可以看他实际上可以分成三个层次，就是首先就是你看到的，这是一个整合的一个一个gpu，然后呢这样的一个整个gpu呢，它实际上是由一系列的呃，叫流式多处理器来构成的，然后呢这个流多处理器呢。

实际上可以独立的执行一些批量的一些任务，然后当然具体的执行的任务呢，又是依赖于就是里边的，具体的每个计算的一个单元就行，所以这样的话，实际上一个gpu你可以看到它实际上一个三层，三个层次的这么一个结构。

就是从整个gpu到呃流式多处理器，然后到当然是到流式处理器，这么一个三层的一个结果，那对应到我们的软件模型啊，就或者我们的编程模型的话，实际上也是分成三个层次，就是比如说我们现在。

相当于针对一个特定的任务啊，实际上首先我们可以对它进行方块，就是，然后当然块所有的块组成了，类似这样的一个grade，当然这个grade可以是一维的或者是二维的，三维的，实际上都可以。

因为这个实际上取决于你的一个任务，比如说你做的是一个呃，打个比方是s p h的流体的粒子的，那个流基粒子的一个流体模拟的，这样的话实际上只要一味的，但是比如说你是一个欧拉的流程呢，实际上有可能是二维。

当然有可能三维啊，这实际上这个取决于，就是说你具体的一个问题的一个描述，然后呢这breed里边的每一个块呢，实际上就是因为是这样，就是我们知道这个sm，它实际上它的扩的那个数量是有限的。

所以呢你不可能说你任意大的一个任务，你进来之后，我直接都可以塞到这个里边，实际上这也不现实，所以呢实际上是对他需要按照block那个形式，相当给他分块，然后分分块之后呢，实际上每一个块就可以塞到。

就是这个流失的多处理器里，投sm里头去，相当于让他去具体的一个去执行，当然具体执行的时候，就实际上就是会进一步的会拆分成，就我们叫做一个线程，就是每个线程的话，实际上对应的就是一个呃。

这个流式的一个处理器，然后具体去执行他的一个一个指令，然后呢那我们来看一下啊，就是呃结合刚才的那个这个结构，我们看看就是说具体到某个算法的话，就怎么去理解啊，就是这里假设我们有这么一个简单的一个问题。

就是呃如果我输入两个数组，然后呢，我相当于需要把这两个数组里边的那个，逐个元素的把它加起来之后，然后存到呃第三个数组就乘到c的这个数组，然后当这个东西在cpu里面啊，其实这个很很容易啊。

就是其实就两行代码可能就搞定了，就是你输入一个数组，然后呢你写个for循环，然后相当于把a跟b对应的，每个i的元素的a跟b加起来之后，你放到c，然后因为这个东西。

实际上整个它实际上cpu的话是一个串行的，所以它会依次的从0~1到二，一直到最后的n相当于逐个元素的，是把所有的元素都处理一遍，然后当这个东西实际上你会发现就是这样的话，因为其实效率很低啊。

就是因为其实你发现，就是因为他们两两之间其实相互独立的，也就是你在计算零的时候，它其实一它其实并不影响一的计算，所以这个时候呢实际上比较适合于用gpu来计算，当然这里边其实我们先来考虑一种。

比较简单的情况，就是说因为我们知道这个gpu的扩的那个数量，实际上是有限的，然后我们现在一开始，我们如果假设就是呃如果是你的问题，就是你这里也有，因为有个数字嘛，你这个n的那个数量，如果打个比方。

你是小于呃，小于你的扩大的那个或者那个数量，那这个时候什么意思呢，就是也就是你每可以为每个元素相加，你相当独立的分配一个线程去做，那这样的话其实怎么啊，怎么就写代码的话，你怎么去做呢。

实际上这个就比较简单，就是你只需要根据你向他获取他的那个一个，因为这个是扩大的一个呃一个代码，然后它其实这里边像global，是它的一个特定的标识符，然后呢这里边输入三个数组之后呢，你实际上具体的说。

比如说你分配了n个线程，因为你现在扣的数量是大于它的那个呃，数组的数量的，所以你完全可以分配n个，就是n个线程，然后呢每个线程去算一个，相当于算一个元素，就针对的，比如第二个线程。

你可以把这两个氧量加起来，所以这个问题实际上就比较简单，就是也就是说你每一个线程相当于独立的去，可以去计算这里的呃一个元素，那当然现在问题就变成就是说另外的，比如说那如果我们现在输入了一个数组之后。

它它的数量远远超过这个，比如那个扩大扩的那个数量，然后这个时候我们应该怎么去做，然后这里实际上就呃要介绍一个概念，就是啊有个叫wap的那个概念，这个是gpu特有的，实际上就是因为我们知道就是gpu数量。

比如像这个这个sm的，他的那个里边的cos呢，就是包含了差不多32个呃，差不多32个扩吧，那这样的话如果超出这个的额数量的时候，因为我们知道就是具体执行的话，实际上是需要依赖这个破局执行的。

也就是说我现在如果是32个线程，那这个正好是一对应，比如说每个扩只是一个线程，但是呢现在问题如果打个比方，我现在已经超出了，我只有33个了，那这个时候怎么办，这个时候实际上就要对它整个进行分组。

所以呢比如这里边我有一个block，因为block的那个它允许最大的话，实际上是1024个线程嘛，然后这个时候如果是它的线程数，比如说大于这个流式处理器的，多处理器里面扩的数量的话，他接下来怎么做呢。

它实际上就需要对它进行分块，比如这里边呃，里边比如说这里输入的那个数据是72，然后这样的话就是对应的到它的扩的那个数量，或者一个wap的那个数量啊，他其实是相当于32，所以这样的话就需要给它分成三块。

然后呢，这样的话每一块，它其实它的数量实际上就是一个32的，这么一个呃一个值，然后当这里边比如72，它你发现它分成三块的时候时候，它其实是少一部分，就是啊比如像最后一个wap。

它其实你发现它只有八个元素，那这样的话，这个时候它实际上会自动的给它后面去填，就补充完整，就是自动的选择上，都会变成一个32的一个整数倍，所以这里比如对72的话。

他会也就是他在这个rap的那个schedule，或者那个指定的分发单元里面，它实际上会去处理这个事情，就是你一个指令就一个kernel调用进来之后呢，它会根据你的那个调用的那个小区的一个，线程数量。

然后对他按照以rap为单元进行啊分块，然后呢接下来就是美实际上执行的时候，实际上是把每一个rap，一个rap逐步的送到这个呃多呃，这流失的处理多处理器里边去执行啊，所以当然这里边就是呃。

也就是说我们那这样的话，其实其实告诉我们，就相当于就是你如果去呃去准备数据啊，或者是分块的时候，最好这一段实际上就是相当于是，最好是这个wap那个数量的一个整数倍，比如说wap数量32。

那你应该是32乘以n，这样的话，实际上可以保证那个他那个最充分的一个调用，不然的话你相当于后面多出一块的话，实际上会造成比如说你前面有八个计算单元，你实际上在运行的话，后面比如说有24个。

可能实际上处于闲置的这么一个一个状态啊，然后呢接下来我们看一下，就是说那结合这个概念，我们看看这gpu到底是怎么怎么工作的，就是比如说我这里首先在cpu里边，我们创建了一个kernel。

然后呢它对应的如果会有呃，有五条指令，四条五条指令集啊，当然这个指令集我们先不管他到底是干什么的，就是就假设它包含了，就是从0~4这么五条指令集，那我现在创建一个任务呢。

就是比如说他的那个可以分成三个wap，然后呢每个wap实际上在gpu里的执行的，实际上是独立执行的，因为是这样，它其实不能确保，就是你一定是比如说你buff领先执行map一后执行。

或者这个实际上是不能保证的，因为gpu的话，他这个整个进去，它首先它是这样，它可以保证就是说你因为你所有的指令啊，这个因为对，这个是得确保你的整个算法是正确的，所以就说同一个wap里的指令。

他肯定是顺序执行的，因为不然的话你这个零不执行，直接执行一的话，你整个计算结果是不对的，所以它实际上它只能保证的就是说你同一个wap，在比如这个sm里头，你相当于是顺序执行。

就比如说你这个指令零执行完了之后到一，然后到2~3到四，但是呢你看不同up之间啊，其实你发现它其实它整个是乱序的，那这个是什么原因导致的呢，其实就是因为每个指令，它实际上都是有一定的延迟。

然后呢另外就是它指令之间啊，就是呃它实际上相互之间呢又是独立的，所以呢也就他执行的时候需要等这个指令，所有的所需要的那个，比如他需要依赖定的数据准备，也就等他的那个数据都准备完了之后。

他才能执行这个指令，所以这样的话就是你会发现如果不同的指令，它比如说它的延迟不一样，那这样的话他需要等待的那个时间不一样，所以也就是说比如说你这个wap 0的第一个指令，你这会儿已经执行完了。

然后呢嗯接下来就比如执行第二个指令的时候，他因为需要依赖一个数据准备的时候，他这个处于一个等待的一个状态，所以这个时候，那如果是其他的一个wap的那个指令，比如他有指令零，他已经准备好了。

那这个会优先去执行这个map一的一个指令，所以这样的话，整个这个呃也就这里边你会发现有个特点，就是呃因为它相互之间啊其实相当于相对来说，它其实因为是独立执行的，就是所以这个时候你一定要注意。

就是说他们之间的那个数据啊，就一般来说不能相互依赖，就是你不然的话会导致就比如你你wap 0的数据，你要依赖wap 1，你这样的话会导致他整个那个计算结果，有可能会出现问题，或者会整个会有可能会卡死。

然后呢这里边就前面刚刚讲的就是，就是因为这样，就它实际上最后是分成一个一系列的wap，去执行嘛，所以这里边怎么去保证整个执行的一个，那最高效的这么一个状态的话，其实这里有几个问题需要解决。

就是一个就是叫所谓的那个wap divergence，这个问题需要处理，第二个呢就是呃延迟需要去隐藏，然后这里当然延迟主要是包含两部分啊，就是一个是它的一个算算术指令的一个延迟。

第二个呢是一个他的memory指令的一个延迟，然后也就是说你整个因为是这样，就是什么状态下肯定它能运行的最高效，肯定是这样，实际上就是说，也就处理器一直处于工作的一个状态，也就是它不存在。

就是说闲置的状态，那这样的话肯定它的效率是最高的，所以这样的话我们就需要解决这两个问题，然后呢让gpu尽最大可能的相当于去呃，呃就是满腹的去去工作啊，那么这里边首先我们来看一下，第一个问题怎么去解决。

就是，就我们先来看一下这个rap这个什么概念啊，就是因为我们写算法的时候，通常会有很多的这个分支结构，就是比如说有一分二四，然后或者是有这种for循环外循环等等，那这种结构会有一个什么特点呢。

就是因为他其实呃比如说他到某个指令之后，它实际上会分叉，分叉之后呢，他可能有一部分指令实际上是执行的，有一部分的实际上是不执行的，比如像下面这个下面这个结构，如果我们专门的呃，就看中间这一块钱，其他的。

因为实际上每个实际上都是一样的，就是啊对所有的，因为它其实所有的线程其实都没什么差别，但是呢对于中间这一块，因为它有一个bios的剪头，然后这里呢其实你会发现，这是因为这个t i d代表的。

实际上是它的一个线程啊，当然我这里标的是0~3角，实际上我可能只画了16个16个格子，就是我们假设它实际上就是一个wap里的，就是因为这样一个wap，它其实是执行的时候是是去一起执行的。

他也就是说一个wap里的所有的那个指令，它必须是一样的，所以这样的话，也就是说你可以看到这个分支结构的时候，比如他如果到了if，那这样的话对于零的线程，零个线程的话。

那实际上就是呃这里这个条件就判定就成立了，所以这样的话他会去执行这个，比如这个a等于100这么一个指令，然后呢这个时候对于这个你可以看一下，比如后面有个第一个线程，然后呢第一个线程的话。

实际上在判定这个条件的时候，它实际上是不成立的，那也就这个时候他对于这个指令，它实际上是不能执行，但是呢因为呃前面讲，就是如果你一个wap的那个指令啊，其实它必须是一样的。

就是你你不管就是说它是那什么什么结构，什么分叉结构啊，虽然你即使它不执行，但是呢对于这个一的这个线程啊，它虽然就不执行，但是他这个地方还是需要去嗯往前，就因为他诉讼指令的时候，他送的还是这一条指令。

所以呢实际上只是说你这个零执行了一步执行，同样的比如你后边二执行了啊，三不执行等等啊，所以这样的话你会发现有一个什么问题呢，就是嗯你可以看到差不多有一半的那个线程，是处于这个等待的一个状态。

就比如说像这一块儿，针对针对这个上半部分的这个if的这个分支，有一半的线程实际上处于一个等待的一个状态，所以这个整个就会导致就是你相当于gpu，比如说你有一半处于闲置状态的话，你的整个运行效率啊。

就差不多就会呃极大的受到一个影响，那当然到后面那个那else那个部分，其实也是一样的，因为到else的话，其实你的这个零的这个线程，实际上它实际上是不执行的，因为它这个if语句。

它实际上我觉得els以及它实际上进不去，但是呢到一的那个线程实际上就进去了，所以呢你发现到后面那个部分其实也是一样，就是啊这个时候呢，相当于变成了你偶数的一个线程，它实际上处于这个等待的一个状态。

然后呢基数线程处于一个运行的一个状态，所以整个就是相当于也是造成了一半的那个啊，call的那个，相当于他处于一个闲置等待的一个状态，所以呢这样的话，其实会极大的降低这个运算的效率啊。

然后接下来我们就看看，就是说这个问题应该怎么去解决啊，然后当然这个解决办法其实很简单，就是因为我们讲的就是一个wap里的那个，所有的线程啊，其实尽可能的，实际上是要保证他的那个计算的啊。

一个指令是尽可能是一样的，所以呢这个我们怎么做呢，实际上就是那我们是不是可以，就是说比如说我们给它分成几个wap，然后每个wap呢其实进入不同的一个分支，比如说我对于rap 0，比如说0~32个线程。

那这样的话我让他去执行上面那个指令，然后那这样的话实际上这个执行完了之后，下面那本所有的这个指令都不需要执行的，是整个实际上就这个wap实际上就可以直接跳过，跳到下面那部分，继续去执行。

所以这样的话就可以提升整个仿真的一个啊，就计算的一个效率啊，然后当然对于就是说第二第二个瓦盆，那这样的话就是你你相当于是if的这个这部分，实际上它不需要去执行。

那这样也就在后面那个你只需要else这部分，相当于指定区去执行这个，所以这样的话整个就是可以保证，就是说你同一个wap里边，你这个怎么计算的那个指令是一样的，也就是他如果是要跳的话。

他相当于统一的跳过去，然后你如果要执行的话，统一的执行，所以这样的话就可以呃比较好的去保证，就是说你相当于你的整个计算的一个单元里头，你的计算的处理器里头尽可能的被填满，所有的一个一个一个指令啊。

所以这个实际上就是呃降低这个web divergence的，一个最关键的一个地方，就是实际上就是保证就一个wap里面的，所有的计算指令尽可能的一致，然后呢，这样的话就是呃增加就整个呃运算的一个。

存储量事件，那当然这里边就是还有刚才讲的，第二个比较重要的概念，就是延迟的一个隐藏，就是呃因为就是这里，当然我讲我先讲一下这个延迟什么概念，就是呃其实像不管是运算还是这个，就是比如说我们要取数据。

它实际上都是会有一定的需要，消耗一定的一个时间的，然后这里边做了一个统计，就差不多，就比如一个运算指令的话，差不多是10~20个一个周期，然后呢这个时候如果你要去取一个。

比如说你从啊显存里边去取一个数据，那这个延它这个延迟实际上就非常大了，就差不多会在400~800的这么一个时钟周期，然后那这样的话会导致整个计算的话，就是你如果有大量的这种取数据的操作的话。

就整个计划会时间会被这个取数据给卡死，所以这里边就必须得，因为你可以看到它实际上整个gpu的计算啊，就是你发现他整个计算的主要瓶颈，实际上就是在这个呃memory的，那个取取数据的这么一个过程里边。

所以也就是说我们就需要用一定的手段，就是把这个过程的造成的那个影响给它降下来，然后当然这里边就是有一个很重要的一个概念，就是叫它实际上就相当于这个，比如这对应这个流式多处理器啊。

实际上是衡量他就说他工作的一个状态，就是他叫奥特曼，他占有率是这样，也就是刚才讲的就是你一个吧，你相当于他实际上是以rap为单元，不断的去执行的，所以呢你比如说我们最理想的状态肯定是这样。

他无时无刻的呃，就相当于都有wap去填充它的一个呃计算，所以这样的话，就整个它实际上就可以保证，满负荷的一个工作啊，但是呢实际上就是你如果比如说存在这种，额较大延迟这种举止的这种操作的话。

这个会导致就是说你你比如说你现在有三个buff，然后呢你现在三个wap可能都需要去取地址，那这个呢可能到比如说执行到某个阶段之后，然后呢，有可能后面可能都处于一个等待的一个状态。

那这样的话再往后可能就会闲置，然后呢需要等待三个wap里面的所有的指令，它比如说它的所有的数据都准备好了之后，然后再往后执行，那这样也就是说整个它的计算效率啊，会降得非常的一个低啊，所以这里边提高这个。

所以这里是这样提高这个东西的，整个有两个办法，就是呃一个呢是这样，就需要尽可能的，相当于是增加这个vip的一个数量啊，然后呢第二个呢实际上就是，相当于就是说你要降低，整个就是取这个数据的一个延迟。

所以这个是解决这个嗯，嗯就解决就是说提高计算效率的一个，最关键的两个两个地方啊，然后我们后面来看看，就是说这个具体是怎么去理解这个东西，就首先是这样，就是呃刚才讲为什么会有延迟这个概念啊。

就是因为是这样，你比如说你现在对于这么一段代码，就是当这个很简单，其实就相当于是取了一个他的一个线程的id，然后呢你根据那个线程id，然后呢你相当于取两个呃值，然后呢给他做一个乘法的运算啊。

然后当然这里边最耗时间的，实际上你可以看到它实际上是在这个地方，就是a t i d，然后对应到汇编代码的话，其实你发现它其实有两个指令，就是呃，首先就是相当于从t a t i d里边去取一个。

直到计算器里边，直到那个另外一个计算器里边，然后当这个剩下的那个，相当于把这两个再乘起来，这个应该是主要是运算啊，所以这个相对于来说，他的那个延迟并没有那么高，然后我们就看这个呃。

然后我们就看看下面那个图啊，因为其实前面讲的就是如果是那个你取值的话，就是你去取数据的话，你的延迟的周，你的那个周期差不多会在400~800，所以就说他整个会比计算的，远远超出计算的那个延迟。

所以这里边我假设就是就在这里，是这样，就不是按400平方反应，不然就不好画，所以这里我就假设他画了16个周期，就是比如我取一个指令周，他需要等待16个周期之后才能呃去，相当于是把这个数据取到。

然后进行下一个指令计算，说这样的话，就是你可以看到就是说呃，我比如说我现在有多个wap，那这样的话每个wap实际上可能都需要去，因为不同就是一个block里边的那个所有的wap。

它其他的计算计算的那个任务可能都差不多，所以这样的话其实每个wap进来之后呢，他第一步可能都需要去取地址，就是比如说所以他有两个指令，就是第一个要取这个a里的数据，然后这个时候呢。

他这两个实际上都处于一个等待的一个状态了，就是因为它这里边取得有数个周期的话，他需要等到16周期都完了之后，才能进行那个哦，这个应该是后面那个标错了，应该是i2 。

所以才能到这个r2 的那个指令的一个执行啊，然后这个时候他也就那比如这里边他会呃，对于这个wap 0来说，它实际上就处于一个闲置状态了，就那这样的话gpu就没法再往后去运行了。

然后呢这个时候他就把它给挂起来，挂起来之后呢，他会去看第二个，那这个d w e这个也进来之后，第二个rap一也进来之后呢，它其实也是一样的，就是他也要去取地址，然后这个时候到第三个周期之后呢。

他依然也处于一个等待的一个状态，所以这样的话他也需要把这个给挂起来，所以逐渐逐渐的你会发现，就是他就是从0~7之后啊，他其实因为都需要去取地址啊，所以整个实际上就是他如果是针对这个。

比如说他有16个颜值周期的话，他这里边就需要去七个有呃，差不多有八个wap，那八个wap的话才能保证，就是说比如说这个对d这波w7 这个啊，他进来之后，然后这个时候他其实也处于等待。

但是再往后的话你会发现就在这个w0 ，就是它已经相当于是呃，就相当于从等待状态到了一个完整的一个状态，然后这样的话实际上就可以继续往后执行了，所以整个就是延迟隐藏到底是个什么概念，它实际上就是需要通过。

就是说你需要通过大量的这个map数量，就是来掩掩盖，就他这个中间的一个等待的这么一个过程，因为不然的话你如果打仗这里只有一个wap，那你会发现，就是说他这里的两两个周期执行完了之后。

它中间可能要等待总代，差不多14个14个周期，所以这个对于那个占用率来说，实际上是非常低的，所以这个时候就是需要通过尽可能多的，让它相当于分配更多的一个rap来来，就相当于是掩盖它的一个一个隐藏呃。

就相当于他的那个呃养性啊，就相当于它取值的一个延迟，所以这里边其实就很多人会发现就是什么意思，就是并不是说gpu运算的一定会比cpu快，其实得记住这么一个概念，就是cpu就gpu快，之所以快。

它其实是因为它的扩的一个数量比较多，但是呢如果你现在打个比方，你现在的问题啊就是呃很小，比如你可能就是几十个或者或者几个，甚至于啊这样的一个数量，就是计算的一个规模，然后这个时候你去用g p u的话。

你会发现因为它整个它的延迟就是非常的大，然后整个会发现就是它实际上它的运算效率啊，其实并不比cpu来快，然后只有也就是说只有当，就是说你的问题的规模，你的运算数量上去之后，这样的话。

其实他通过这个延迟隐藏的这么一个机制，然后才能保证，就是说实际上因为因为再往后的话，它实际上它整个运算量就上来了，这样的话就可以保证，就你整个计算是逐渐的把那个效率给提上去，所以这里边就是有几个建议。

就是呃对于这个解决这个延迟隐藏的，这么一个问题，就是呃首先就需要去尽可能去调整，它的那个block的一个一个现成的数量，当然前面来讲，就是你要尽可能的让他这个线程的数量，是这个wap的一个整数倍啊。

因为不自然的话就避免可能最后一个wap，它有一部分，实际上是相当于处于一个闲置的一个状态，当然第二个呢实际上就是呃，你要保就避免这个block的那个数量啊太小，因为太小的话你的buff数量不够。

所以呢我也就没法保证，就是说你相当于解决你举止，比如说你去一个新的memory和gloomy global memory，你去旗帜的时候，你们没法保证，相当于你有足够的wap数量。

去掩盖他的那个呃取值的一个呃延迟，然后当然还有，就是要尽可能的让那个boss那个数量啊，就是要尽可能远大于这个啊，流失多处理器的一个数量，因为其实这个问题也是一样的，就是因为流式处理多出一些。

他其实可以并行的去执行所有的那个block，所以这样的话你这个数量太少的话，它其实有一部分的那个流多处理器，其实也是处于等待的一个状态，当然最后就是啊对于最佳的一个性能，因为这个其实你会发现。

就是它很多东西可能都会影响整个运算的一个，性能啊，所以这样的话实际上就是呃针对每个显卡，你可能需要就尽可能多做一些测试，就是呃来发掘，就是说可能最佳的一个一个配置。

然后呢前面讲的就是一个延迟隐藏的一个概念，当然就是呃通过其实调整一个啊，wap就是通过调整那个相当于blood那个数量等等，就这个可以一部分的去降低这个延迟的，这么这么一个影响。

当然还有一个很重要的一个东西，就是实际上还有一种办法，就是直接通过就是多级这个多级缓存结构，来降低这个呃存储器，那就是memory的那个呃，那个相当于在指定的这个影响，然后这里边就是我介绍一下。

就是现在gpu啊包含几个呃典型的一个存储器，就是首先呢是这样最快的，实际上是你每个线程它都特有的，就是每个core它里边都特有的，就是它叫寄存器，然后这个寄存器呢，实际上相当于就是说他他数量也是这样。

他数量比较少，但是呢它效率非常的高，就是因为他呃可以相当于满足，就比如说一些呃，比如临时变量的一个额分配啊，或者这样的话其实可以加速整个整个计算，然后当然就不同的结构它可能也不太一样。

比如有二五的或者其他的一些数量的，然后呢，这个因为考虑到就这部分其实数量比较少的话，其实g p u里边还有一个概念，就是它叫local memory，然后这个memory什么概念呢。

就是如果当你的寄存器，比如说你分配的时候不够了，那这怎么办啊，因为他这个时候你也不能说你这个县城，要不要整个程序你跑不了，所以他这个时候实际上会分配一部分local memory。

那这个memory实际上它整个并不是呃一个一级缓存，它是这样，是从它实际上是从比如说他从global memory里边，其实它相当于映射了一部分进去，然后呢，这样的话就给你的感觉好像跟计算器是一样的。

但是他这个效率实际上是比较低的，所以这部分呢实际上是要要慎用啊，然后当然还有一个比较重要的概念，就是gpu里面有个叫需要的memory，这个学校的memory呢实际上是所有的block，实际上是共享的。

就是也就你一个block里面的所有的线程，其实都是可以共用这一部分写的memory，当然它的数量其实也不大，但是呢它的效率会非常的高，当然其他的是一些那个比如像产量寄存器啊。

因为他这个那常量的那个memory，其实主要是因为它有可读，它只是可读的，那就是他实际上只读的，所以这个时候会有一定的局限性，也就是说比如说你要用常量的话，你相当于你要编译阶段。

你就相当于把这个东西给分配好，当然还有纹理的，那么这也是制度的，这个其实主要是用来渲染的时候用的会比较多，然后当然最后呃最通用的，然后我们用的最多的其实就是以global map。

这个实际上跟内存是一样的，就是呃相当于显存，对应的实际上就是一个一个内存，所以这个这个显存呢，它实际上它的那个数量会比较比较大，然后呢一般来说我们用的时候，肯定也是优先先分配在这个地方。

然后呢再利用就是比如说利用这个呃写的memory，或者利用寄存器或local memory，然后去去加速整个程序的这么一个过程，所以这个实际上就代表了一个g pu的一个，多级的一个缓存结构。

然后呢实际上我们在写算法的时候，就需要依赖这个呃，它不同的这个memory的一个特性啊，然后相当于去尽可能的去发掘它的那个，提升效率的一个点，然后这里我们就看一下。

就是呃不同的这个memory到底它有什么啊，就在效率上啊，我们可以看一下它有什么差别，就是所以其实我们可以看到它，这里面哪几个东西就最快的，就是全寄存器，那肯定是最快的，然后当然也是最好用的。

然后但是他前面讲了，他最重要的一个问题就是额数量非常的少，就是你比如说你只有定义这种标准的，比如说int float或者double等等，这些一些标准类型的话，你可以用这个存器，但是呢你如果这个时候。

你要定一个比较大的一个数组啊，这个时候因为是在寄存器的结构，它不支持这种数组，所以这个时候他其实可能会定义在，直接就定义在这个look memory。

其实刚才讲的他no mary其实是映射到了一个global memory，所以他这两个的那个效率其实差不多，就是差不多是在，所以你可以看对比的话，其实差不多这两个唱两个数量级。

然后当然shield mary的话其实也很快，所以就是呃，也就是实际上在我们写算法的时候啊，就是因为shener要比这个呃，register要比寄存器实际上要大很多，这样这样的话。

也就是说我们在实际上写算法的时候，尽可能的用企业的memory，因为这些memory一方面它实际上相对来说比较大，第二个呢其实效率很高，然后呢对应到具体的那个代码的话，其实我们可以看一下。

就是呃它其实就是这么一个分配的一个模式啊，就是当然就是刚刚讲就是包括呃一些标识符，就比如希尔的，你如果是写代码的话，你想分配新的memory，必须前面加一个希尔的，然后呢或者是那个global的话。

长期就有个device啊，就是还有就是呃常量的话，你必须得按那个，这是当然这是库大的一个规范啊，就是你必须得按constant这么一个呃标识符，然后它每一个实际上会有一个还有生命周期。

然后你发现就是呃首先是这样，他的那个寄存器的话，它的生命周期实际上只在县城内是有效的，然后像包括那个local memory其实也是一样的，然后呢share memory实际上是在整个blog。

其实是所有的block实际上是共享的，然后当然最后比如像后面的global以及constant，这个答案是整个great的啊，这个实际上也就整个应用程序里的。

它实际上都是可以用用这些啊这些啊memory的，然后后面呢我们就看一下，就是呃就结合这个一些具体的2米角来讲一下，就是怎么用这些，就是各种的相当于是多级缓存结构啊，然后包括那时隐藏这些技术啊。

然后呢怎么提升，或者是通过提升那个呃，这个流流处理器的占有率啊，然后呢相当于怎么来提升这个效率啊，首先这样我们来看一下这个一个具体算法，就是第一个是一个叫归约算法，然后这个算法其实很简单。

就是其实你相当于输入一个数组，比如说你从a0 a1 ，然后呢到a n，然后当然你的输出的话，其实就是输出的话，其实就相当于是你把所有的这个书的这些书啊，做一个归约操作，然后当然这里边呃。

这个符号其实就代表一个约操作，但它它可以是比如说是求和或者是求最大值，或者是求最小值，然后将这个是其实都可以，也就是说你用不同的那个操作符，它算出来的实际上是不同的一个结果。

然后当这个东西在比如说你还是刚才讲，就是你如果cpu算的话，其实还是很简单，就是相当于串行的，比如你从第一个元素开始，然后呢到第二个元素，然后呢你逐步相加，然后呢到第三个元素相加组件。

最后把所有的元素给加起来，实际上它整个是一个创业的操作，所以这个呢它的复杂度实际上就是呃，实际上具体的加法指令啊，或者是运算指令，它实际上就是一个n，你输入如果是n的话。

实际上就只需要n减一的这么一个操作，实际上就做完了，所以对应到比如说这里的得一个c i代码的话，其实也是一样的，就是你写一个for循环，然后整个这个计算就完成了，但这个时候我们来看一下。

就是到gpu之后啊，我们看看怎么来处理这个这个算法，当然这里边因为这样他之所以可以用来做gpu，并行的话，因为这样的话，它实际上肯定是存在一定的并行的一个特性的，就是说呃，它相当于它相互之间有一些计算。

是可以独立的去完成的，那这里边我们看一下，哪个计算就可以独立的去做呢，就是首先就是我们可以看一下，就是两两之间，因为他整个最后最后的，它实际上是把所有的加起来，那所以这样的话我们实际上可以。

所以这个东西进行分组，就比如前两个我们算一个值，然后呢逐步的去把两两的算起来，算完之后呢，当然我可以一层一层的，最后给他逐步的算到最后啊，然后这个哦这个可能哦下面那节可能写错了啊。

其实这个后面那几个好像没写，就是其实应该是求和的一个操作，那这样的话最后相当于我们就可以得到，就是一个总的一个求和的一个结果，所以整个gpu的话实际上也是依赖这么一个啊结，构就相当于从最顶层。

因为这个实际上就是一个二叉树了，然后你会发现就是每一个指数的话，那其实完全可以独立的去进行计算，然后这样的话对应到一个gpu的一个代码的话，其实这里啊这个其实比较简单，就是如果是啊还是跟前面一样。

我们假设如果说我们县城的数量，如果是比较，就是数据的数量是小于线程的数量的时候，我们看怎么来做呢，实际上就是我们每一个线程对应一个数据，然后这样的话就两两相加，然后也就比如从第一层开始，然后呢我1+2。

然后3+4，5+6，7+8等等，这样的话就可以从八个再减到四个，减到四个之后呢，然后再是两两相加，然后最后逐步的就把这个一层一层的，把这个东西给加到最后的一个远处。

然后这样的话实际上就完成了一个标准的一个，呃叫库大写的一个代码，然后左边的那个代码的话，我简单讲一下，实际上就相当于就输入一个数组，然后呢它对应的一个数组的一个长度，就是它有个n。

然后将这个thread a d d x呢，代表了它的一个线程的一个id，然后呢就这里边其实有个重要重要的东西，就是它实际上需要有一个计算一个偏移量，就是因为比如你算第一层的时候，它实际上就是呃。

相当于他只是他实际上就比如1357，它实际上是需要去计算的，因为它实际上只需要在第一个线程里边，它算第一跟第二这两个元素，然后当然到后面的时候，你会发现他这个时候呢是变成了啊，从第一个县城。

然后到第五个县城，那就是相当于就是变成了就是呃呃，呃第一个线程到第三个线程，然后呢这两个需要相加，然后呢第五个县城跟第这个第七个线程啊，然后这样的话需要相加，所以这个时候实际上就是你具体哪个线程。

去执行这个操作啊，所以这里边实际上就有一个呃偏移的这么一个，一个操作，相当于是保证，就相当于是让你具体到某一个线程去去算，当然这里边的问题啊就是也比较多，就是呃首先当然第一个就是呃。

因为你这里边你这个数量啊，就是直接用的线程的话，因为刚刚前面讲的就是你扩的数量是有限的，所以这个第一个问题肯定是这样，你怎么去呃，处理更大的这么一个，那规模的一个数据量的一个一个计算。

然后当然这里边就是也比较简单，就是那我大不了，就是比如说因为其实这样的整个呃gpu的话，它其实你一个问题进来之后，你可以对它进行分，就是按block的那个形式去进行拆分，然后当然这里边就是好。

这里写有写的有点问题，就block 3，因为是它一般小于零，小于等于1024，所以呢实际上就是你如果你的问题的一个数量，如果大于这个1024的话，那这样的话你就需要对它进行拆分，就是比如按照1024。

当然你这个具体标和size是多少，你可以自己定，就是比如他主要是有1024以下的都可以，比如51225892562128等等，实际都没问题，然后呢也就这样的话，实际上你就需要按照那个就是block。

然后给它拆分成多a多个，然后呢每一个block呢，就是给他送到一个流失多处理器里包去计算，然后呢当然它局部的就可以得到一个呃，相当于规约的一个值，然后呢这些值都算出来之后呢。

当然你可以把这些值汇总汇总完了之后呢，你相当于再比如说你再用一个block，然后呢对它进行计算，那这样的话其实可以解决，就是呃相当于就是说你数据量，比如说你超过一个block限制的这么一个大小的。

这么一个数据应该怎么去处理，当然这里边其实第二个比较重要的一个问题，其实就是一个延迟的一个呃，如何降低这个延迟的一个问题啊，就是当然这里边就需要呃，相当于是用到一个呃写的memory。

因为前面的话其实这个算法，这个算法的话其实没有用的memory，你发现它直接比如他这个地方取地址的话，实际上直接都是从global memory啊去取地址，然后globe memory的话，这样的话。

他们差不多会有很大的一个延迟的一个开销，所以这里边就是需要，我们第一步要做一个什么事情呢，就需要相当于是从比如这个灰色的，它实际上代表的是global memory。

需要从global memory里边，把他那个数据依次的给它，取到对应的这个shared memory，然后这个新版的memory，相当于就是实际上你可以理解为，其实就是bloom memory里边。

在他的那个数据，在这个新的mary的一个一个镜像的一个拷贝，然后这部完了之后，你可以看到就后面所有的一个操作，实际上就是基于这个其他的memory来做的，就是那这样的话。

因为他也就是他的那个存取的开销啊，差不多快100倍的话，也就是后面的那个计算啊，可以就可以极大的提升它的一个啊一个效率，就是因为他这样的话就是可以减少它，因为就比如说取数据的时候的一些。

等待的一些也开销，所以左边那个代码实际上就是相当于，比如这里被我声明，就是它需要有一个cl的这么一个标识符，然后呢就声明这么一段啊，就是共享内存，共享内存啊，供养险吞噬啊啊啊，然后这个生命完了之后呢。

相当于就是把这个数组就是global，因为这个传进来的实际上一般都是在global memory，然后把global memory的那个数据，然后呢考到这个学校的memory里头，然后考完之后呢。

那接下来就是呃，相当于就是逐步的对他这个呃进行就两两，其实跟前面就一样了，就是相当于两两求和，比如说然后呢相当于在一层一层的从上往下，然后最后呢相当于算到最后一个一个值。

当然这里边你会发现其实这里边还有一个问题，就是呃你会发现这里边有一个，就gpu这是实际上这个gpu特有的一个地方，就是因为这里我只画了八个线程，然后呢呃实际上就是如果是你，比如这里是32个线程画满的话。

就是这里边就会有一个问题，就是它实际上会带来大量的这个啊，叫bank conflix的这个问题，然后这个我们看一下，就是后面我讲一下这个这个什么概念，就是因为gpu的话实际上是这样。

他为了保证就是说他那个呃访问的一个高校啊，所有的那些memory，它实际上是被划分成了大小相等的一些，我们叫一些bank，然后这里当然这里可能标错，就是实际上从011直到31。

然后这个东西实际上你会发现他跟那个wap，实际上是一一对应的，然后呢另外就是它实际上它的连续地址空间啊，实际上是这样，从0~1啊，其实是连续的，就是比如这32个字节跟这三个字节。

32个b词实际上是连续的，就是这里这是连续，然后这个完了之后呢，他又从这里开始，然后呢相当于是这么一个一个排布，然后呢，这样的话就是但是他们之间的有一个特点，就是呃如果是就比如说我现在有32。

32个bank，然后呢这里这是我有32个线程，然后依次去访问这32个呃bank，那这个时候效率是最高的，因为他们之间这个时候就不会啊发生冲突，就是但是呢如果我现在碰到另外一种情况，比如说打个比方。

我们现在我不知道什么原因，然后呢可能导致就是说我所有的那个线程，然后呢，可能就需要去访问同一个bank里头的一些数据，那这样的话会导致就是说你相当于是，比如说我这个第一个线程去访问了，那在后面那个32。

30个线程去访问的时候呢，他就需要在后面排队等待，然后这样的话也就是把原先一个，比如我原先一个指令，我相当于把三就是32个数据，我可以都都取出来的这么一个问题，就变成了。

比如说我想当每个线程要逐步的去去，这里边的一个数据，也就这样的话，你相当于32线程就变成了一个创新的，这本来是应该并行执行，32线程，变成了一个串行的一个这么一个操作。

所以这个实际上就是这个写的memory，比较特殊的一个地方，所以呢就是说也就是你设计算法的时候，要尽可能的去避免呃这样的一个问题发生，所以这里边就是，具体这个时候怎么去做啊。

就是前面那个比如说呃因为这里只画了八个，我假设就是呃1_{4是一个wap，然后呢4}8是一个wap，然后那这样的话，其实前面的话你如果两两去取的话，就有可能会导致他的那个相当于就是呃，因为那个相当于冲突。

然后造造成的这个比如说顺序去取，就是比如说你呃这两个线程你在做了，比如一跟二，这个时候你已经在计算了，然后这个时候你如果五个六也是计算，然后这个时候比如一跟五，它访问的是同一个bank的时候啊。

这个这个时候你相当于它就会变成一个串行的，这么一个操作，所以解决这个问题的办法其实也很简单，就是这样的话，实际上我那怎么办呢，我相当于是把呃，就是说那比如我这里是前四个对应的一个bank。

然后面对应的另外那个呃四个bank，所以这样的话，我相当于是把这前四个相当于去计算的时候，我第一个线程我相当于可以跟第五个去计算，因为这个你会发现，它虽然比如说对应的是同一个bank。

但它其实对应的是两条不同的指令，也就是说我第一个线程去计算的时候，就是它相当于先会去取第一个呃，比如这里这个bank对应的这么一个额数据，然后这个时候呢取完之后呢，然后他还会去取。

比如说这个bank的数据，就是说虽然他两个实际上就是有冲突，但是呢它因为它整个执行也是顺序的，所以这个实际上就不会造，造成这个整个那个bank conflicts，所以说这样的话就是怎么吃。

也就是说后面的话也是一次的，就是这样的话，就是逐步的就把剩下的那个操作做完，然后呢也是两点，当然这个后面的计算整个是一样的，所以这里边整个改动的话，你看这个代码其实主要做了一个什么改动。

就相当于是把以前按照就两两，就是前后两两相计算的，这个就变成了就是按照好rap，一般就是就按照相当于啊对半分，然后相当于按照block，然后呢呃取bar，然后这样去去处理。

然后这样的话就可以尽可能的避免就是，就是共享显存，然后相当充足的那么一个问题啊，当然除此之外还有一个好处，就是你会发现这样的话，就是他因为他所有的线程实际上都挨在一起了，就比如1234。

他这四个线程实际上都挨在一起，然后挨在一起的话，他其实可以保证，他的那个指令是尽可能是一致的，也就也就是说尽可能的提升了他的那个啊，相当于整个gpu的一个占占有率，是这样。

然后讲了前面那个我们后面再看一下，就是另外一个还有一个算力啊，就是呃叫一个前缀和的这么一个算力，然后这个算力跟前面的那个其实差不多，就是输入的话也是从零到n这么n个一个数。

然后当然输出的话就稍微有点差别，就是他因为主要相当于是要呃，相对需要前去的一个计算，就是比如a0 的话，它当然是本身，当然a一的话到a的一的话，它需要相当于把前面的那个所有的数据。

然后跟他做一个这个操作，然后当然到最后的那个数据的话，实际上就是从a01 直到a n啊，所有的那个数据得得操作起来，然后这样的话我先讲一下，这里边这个思想是怎么去做的，就是嗯这里其实有个经典的一个算法。

时间当然就1999年，这个本来是提出来的，然后他其实就是从它包含两个阶段，就是一个呢是从啊从底向上的这么一个阶段，然后这个阶段呢，实际上他用了一个二叉树的这么一个概念，就是呃相当于逐步的从底下。

相当于因为把比如说把底下那个元素啊，实际上都当做一个叶结点的话，它实际上是可以完整的构建出，这么一个二叉树的，然后呢从底向下的过程呢，它会逐渐的去把这个值，就是因为是这样。

这个前任何操作相当于需要把前面那个数据啊，就跟后面那个数据，然后相当于操作完了之后，然后呢要存到后面，所以这样的话他先创建它的，比如说从叶子节点先去创建它的那个，就是相当于他的那个内部节点。

然后这里呢实际上就像比如我这里，假设是两求和操作，所以这里比如两两之间求和求和完了之后呢，再往上也是两两之间求和求和完了之后，当然这个到最顶上的话，其其实就代表的是所有的这个叶子节点的一个。

一个所有的这个求和的一个结果，然后呢，这个你会发现就是最顶端的那个叶子节点啊，它其实就是我们要的这个最后面那个，因为这样我从前往后求和的话，最后一个呃，这个点实际上应该是存在。

相当于是整个数组的一个求和的一个结果，所以说你相当于如果你看这个结构的话，其实你发现如果是你单独拎出来数的话，它其实这个值应该是放到这个最后，然后当然其实我们额外的，我们可以看一下它那个结构。

还有一个什么特点呢，就是你如果你再去看他的两棵子树的话，就是呃一个是他的左指数，一个是右子树，因为你如果看这个指数，当他这个36当当包含，包含的是在前面八个元素的一个一个和，然后这里的100。

相当于包含的是这里边的那个，八个元素的一个和，那也就是说你可以看后面那部分，就假设啊，如果我们这两部，就前面的部分跟后半部分已经独立排序，就是计算完了，那这样的话，你可以看一下后面那个最后那个元素。

就是我现在按照那两颗指数线去呃，先去操作，那这样的话操作完了之后，你会发现它缺一个什么东西，就是它实际上就缺这里的一个值，这个36它实际上没有算到这个呃，又把这棵子树里头，所以呢。

也就是他接下来会有一个向下的一个操作，就相当于需要把左子树的这个包括，以及因为它上面因为也是需要有一部分，相当于要累加到呃这个叶子节点里边，那两个值需要逐步的相当于又从从上往下。

相当于把这个东西给算下来，所以具体是怎么做的，就是我们来看一下，就是嗯接下来就是从呃，从从上到下的这么一个过程啊，首先就是这里边需要第一步就需要去替换掉，就是100 136。

最最root那个节点里面那个值，因为它这个只替换成这个代表什么意思呢，就是它代表的就是我这个节点需要加到，比如说底下叶子节点里面，到底需要加加上啊多少，比如像这里边最顶上那个叶节点，因为它已经136了。

所以它实际上并不需要，就加到这个底下的每个叶子节点，然后呢对应的就是那这个叶子节点，其实也就这个中间的一个节点，其实也是一样的，因为它这个36，实际上并不需要加到这里边的，因为它实际上是一个总和。

但是这个36要加到啊，右边的那半颗子树里头，所以这里边有个操作，就相当于他需要把这个零呃副导这里边，然后同时把这个36跟零加起来之后，因为这两个他的就是这里左边这个节点，以及它的附节点，这两个是对应的。

实际上是都需要加到其它的右子树的，那个所有的这个叶子节点里头，所以一次的话实际上后面也是这么一个操作，就是你相当于比如说你这里的再往下的，好像把这个灵庙附到这，然后把十十跟零加起来之后就放到这儿。

然后这个地方呢也是一样的，就是你把这个36，就原来那个36就要放到这里边，然后呢同时两个加起来之后呢，要放到这个后面这个地方，那我这个地方可能有点又有点搞错了，就是应该是哎我看一下啊，因为这个36。

然后这个是36+42，36+42，然后这个才是78，所以这个可能就因为左边这个，实际上还是那个42，然后就这样完了之后，然后呃因为这个36完了之后，是加到这里边才能没错。

所以这里36+42之后才是才78，所以这样的话一层一层再往下的话，实际上才是最终，比如说到这个这一层，然后再往后的话，实际上就是你可以看到就变成了一个0136，10 15等等。

就一直到120这么一个一个操作，那么所向的话，就完成了整个前序和的一个所有的啊，就是先从下到上，然后从上到下这么两个两个过程啊，然后呢对应到我们这里来看一下，就是如果对应到整个gpu的一个实现里边。

那我们继续来看一下，这是啊怎么实现呢，其实也是一样的，就是呃从global memory里头我们相当于创建了一个数组，然后这个数字完了之后呢，当然这个第一步，因为这个主要是为了降低这个延迟的一个响应。

就是延迟的一个开销，就是取值的延迟开销，所以这样的话第一步就需要把从globe memory，我给他呃，取值啊，去这个数据到一个shamemory，然后完了之后呢，就两两往上那个逐渐的去计算。

然后计算完了之后，第二第二个阶段，实际上就是从上往下的这么一个过程，就是相当于从这个零，然后到这，然后呢零跟这个原来那个值相加，然后放到这里边，然后呢，这样每科指数呢，依次递归迭代的去完成这个操作。

然后当到最后的话，就是也是恢复出这么一个那个数据，然后当这个前面，因为是讲的是一个二叉树的一个结构，它实际上实际做的时候，它实际上是不需要额外的分配空间的，因为它可以在原地的。

那相当于就原来那个数组里边就去完成这个啊，整个所有的那个计算的这些任务啊，然后到这里边就是还是就是我们来看一下，就是呃就是以这个为一个基础的一个版本，我们看看它里边有哪些问题。

当然首先第一个还是因为他的那个就整个在，如果放到那个gpu里边去算的话，就是呃他的那个，gpu的占有率时间还是比较低，因为你可以看到就是呃如果是按最紧张，就是当然底下的还好，因为底下的话其实两两之间。

当然你可能只有一半的处于闲置的一个状态，当然你看上面的话，其实这样的话就是你会发现越往上，他整个闲置的概率就越高，就是它前置的线程数量会越来越多，然后呢解决这个问题，当然其实也呃其实这跟前面是类似的。

就是怎么做的，那这样的话，我因为比如说我实际上不需要顺序的，比如说从每个元素都分配一个线程，我其实比如说我对对于最底下这一层呢，完全可以，比如说我隔比如隔一个数据给他分配一个线程，那这样的话。

比如第零个线程处理的实际上是地理，第相当于第一个数据，然后第一个线程实际处理的第三个数据，然后依次这样的话，也就是说可以降低它，整个就是说闲置的这个线程的一些开销，然后当然这里除此之外。

还有一个比较重要的一个东西，就是呃memory就ban conflict，就是主要还是memory banconflict的这个问题啊，然后这里的问题就是跟前面的，可能稍微有点不太一样的地方。

就是因为是这样，它其实是一个二叉树嘛，这个二叉树的话，你会发现就是它越往就是它越往上的话，他其实它相互冲突的可能性会越来越大，就是因为比如说像这里边啊，你你可以看一下，就是如果是按照唉我看一下啊。

哦这里应该是，哦这里有可能标错，这里线程应该是一样的，就是也是32 32 32 64，因为他wap的那个数量跟那个地址是一样的，然后这里边就是你可以看一下，就是有什么问题呢。

就是比如说我现在在去取这里的一个，wap的这么一个地址的时候啊，然后比如说我这里有一个，还有我看看，好这里是这样，就是还是假设我们现在有一个32个一个wap，就相当于它包含了一个32个线程。

然后呢这里32个线程是这样，就是你如果去取地址的时候啊，其实就相当于，比如说因为你按照这里的结构去取的话，你会发现就这个线程应该是他要取两个，就一个呢是第零个，第二个呢是取第一个，然后呢。

这样第一个线程呢，就是这里是取第三个跟第四个，所以你到这里之后，你会发现就是对这一个wap它其实取地址的时候，比如说它是会跨越这个wap以外，它实际上就到了，就是我下面标的那个是地址啊。

所以这里边可能有点混乱，就是实际上就相当于你去第零个线程是取得，实际上是第零个地址，然后呢这个时候你第16个线程啊，第16个线程你实际上会去取第32个地址，然后这个时候你会发现。

这个零的地址跟30个地址，这个时候实际上是这两个是处在同一个bank，conflicts，那就相当于处在同一个bank，然后这个时候你会发现，就是因为他所有的这个线程啊，就0~32，就是31，是这样子。

0~31，这个线程的实际上都是处在同一个wap里头，那这样的话，也就是说你在执行第零个线程的时候，那你这个时候同时去执行第16的时候，你实际上是需要去等第零个线程，相当于执行完了之后才能继续往后去执行。

所以也就这个时候会造成一个什么问题呢，就是你相当于前一半，你在执行的时候会阻塞，后面一半，就是16~31这个线程的这么一个执行，那这样的话就是会造成大量的这个一个，就是线程运行的一个等待。

然后呢也就这里边解决这个问题，答案其实也比较简单，就是那这怎么办，就是因为其实相当于前面我们可以看到，它实际上就是这个主要是因为零跟16，实际上就是有一个呃，那这个时候我们怎么办呢。

我们相当于可以对它做一个偏移，就是相当于wap之间，就是我们这里因为是这样以rap为呃，就是相当于给他呃32，就是按那个他的那个相当于他需要memory啊，底下的学memory按32为单位。

然后呢相当于两两之间呢，我们给它插了一个32个bit的，这么一个数据进去，相当于这一部分数据实际上是空的，然后也就是说我们在取32个数据的时候呢，给他放到这个33的这个地方。

那这样的话实际上你会发现就是零跟16啊，他们这个时候去取值的时候，他们实际上就处处于不同的一个b，然后也就这个就可以解决，这个就是bank冲突的这么一个一个问题啊，当然具体代码的话。

其实这里边会有就是panama，其实会有一个叫呃scan，这么就call里头会有一个can的算法，然后大家感兴趣的话，可以去看一下里边具体怎么去呃，解决这个问题，相当于这里边实际上最核心的时间。

就是这里边需要有个offset，然后呢去给这个需要的memory，相当于可以增加一个偏移量，然后呢保证就是说你0~31个线程，它取值的时候呢不会取到同一个bank，然后接下来就是这里边很呃，就这样。

就假设我们现在已经写完，前面的那个算法之后啊，后面我们就是呃如果到具体应用的时候，我讲简单讲一下，就是这里边应该呃有些还有哪些额外的呃，一些需要去做的一个地方，就是这里主要就是涉及到c加模板。

编程的一个问题了，就是因为实际上这里边主要问题在于，就是我们通常写算法的话，可能比如说我们写完一个算法之后，就是这个时候如果存在一个什么情况，比如我们针对那个int，我们写了一个呃就是规约算法。

然后呢这个时候我们现在又进来一个float，比如我们可能也需要写一个归元算法，那这个时候呢我们不想，比如说我不想再重复写一遍啊，所以这个时候就需要依赖这个c加，加的一个模板。

然后呢这样可以减少我们整个编码的工作量，然后呢整个模板的话其实主要包含两类啊，就是一个是啊模板函数，就是它的这个声明的过程，实际上就是他以template打通，然后当然啊包含整个一个类型名。

就是type nt，然后当然就是哦后面这个应该也是t啊，然后比如说那个包括后面就这个函数名称，然后呢以及后面的一个电脑类型，然后当然还有函数，还有模板类，它其实也是类似的一个声明的一个形式。

然后呢当然声明完了之后呢，额外的还会有一个定义，就是啊比如左边那个实际上是一个函数呃，模板的这么一个定义，幽默哪个呢，实际上是一个函数类的这么一个定义，然后呢具体做的时候呢是这样，就是啊，因为像以往。

比如说我们不考虑这种函数模板的话，那这样的话我可能需要针对每个，比如说打个比方前面那个求和的一个函数啊，我们可能需要针对每一个都需要写一个呃，写一个实现，然后呢比如针对int或者floor。

我们可能都单独写一个，那这样的话就是有个问题，就是很多时候，我们的算法可能是需要去啊去更新，比如我们算法的效率，我们发现以前的算法效率偏低之后呢，我们可能要改进已有的算法。

那这个时候你如果是按遗忘的这种做法，你可能每一个算法你可能都需要去更新一遍，那这个实际上对于工作量来说其实会增加不少，那这个时候如果用模板的话，就是相当于整个就把呃，因为其实这里边是这样。

所有的函数的实现啊，就可能基本都差不多，但是呢唯一不一样的地方，可能就是他的那些类型，可能实际上就是需要替换掉，所以这个时候就很比较方便的，用这种函数模板的形式，比如说就是对于这个int和float。

然后就给他替换成模板，然后呢这个时候这个模板设备完了之后，然后具体我们调用的时候呢，这个时候有编译器，它会根据比如说我们传入的这个类型，比如说它是int或者float或者double。

那这样它实际上会去做一个，实例化的这么一个过程，也就是这个过程，实际上不需要我们自己显示去做，就编译器相当于就可以去帮你生成，就这个模板函数的各种实例，然后这样的话就可以减少整个我们的一个。

编码的工作量，然后当然这里边其实还有一个需要讲一下的，就是打个比方，如果我们现在碰到的是某一种类型，这种类型的是这样，可能是自定义的类型，或者是这样，我们还有一种需求呢。

有可能比如说我们现在这个求和操作，我们可能就需要针对特定的类型，我们需要去做一个特定的一个实现，那这里边实际上这个时候，就是我们需要怎么去做呢，就是这个就涉及到一个啊c加加的一个模板。

的一个特化的这么一个概念啊，就是这里我举了一个就是vector的这么一个例子，就是比如说我们通常说明一个模板，那这里边我们生命的一个模板，然后它包含啊，比如它的一个类型，然后它的一个维度，然后呢。

这里边你可以看到它的里边的一个结构啊，它其实也不包含任何的一个数据，那这个时候我们比如说我们可能需要针对呃，比如三维空间，那我们需要定位一个三维的向量，或者二维空间的定义，一个二维的一个向量，然后呢。

其实你可以看到右边，这是二维空间的向量和三维空间的向量，它其实它的那个包含的数据是不一样的，就是vlog空间呢，其实只包含那个x和y这两个量，然后呢当然三维空间的话实际上主要包含三个，就是所以这样的话。

也就是说我们需要对特定的模板做一呃，一些特殊的一个处理，所以这个过程实际上叫一个特化的，这么一个过程，也就是说我们相当于可以对某些呃，它的一个参数类型，然后做显示的一个特定的这么一个定义。

然后在当然这里边其实有两种概念啊，这个是全特化，全特化的话相当于我相当于里边的餐，这个模板参数里面啊，就是他所有的参数相当于都显示定义它类型，然后呢接着相当于去呃，相当于去做它的一个实现。

然后呢当然后面还有一种偏特化的，然后这样特化的完了之后呢，就是这里的呃是什么概念，就是因为以前如果我们不做特化的话，就比如用编译器去决定的话，这个时候他会相当于它默认的，可能就会生成这样的一个结构。

但是呢这里边它如果是识别到了，我们已经做特化了，那就这里边比如说我们输入的，如果是以后声明的，比如说一个float 2啊，flow 2这么一个类型的，这样的话它实际上会以这个定义，然后去替换掉。

就是说他编译器相当于默认生成的，这么一个结构，然后当然就偏特化的话，其实呃就我们可以对某一部分去做处理，就是比如说这个相相当于这里的定义一个类型，一个维度，那比如说我们相当于类型的话。

我想还是保留它作为一个它的一个，相当于作为它的一个参数模板，然后呢这个时候我们对如果是二维的，比如说对于三维的，比如这个特定的参数需要去做特化的话，实际上就相当于就是可以做偏特化。

也就是对于特定的一部分啊做特殊处理。

然后这是c加加的一个比较特呃，就是用模板来比较方便的一个地方，然后呢这里有有了这些东西之后啊，然后我们看看就是针对前面那个规则算法的话，就是有什么好处啊，就是这样的话，实际上就是比如说我们针对不同类型。

实际上我们只需要写这么一份代码，然后这个代码当然是也是在库里边也是存在的，然后呢这里边我们可以声明两个两个呃，模板参数，就比如一个类型，这个类型呢可以包含。

比如说是int或者float或者double等等啊，然后各种类型都可以，然后只需只需要保证就是这个类型，它实际上就是呃，就相当于它规约的那个操作是合法有效的，其实就可以，然后当然除此之外呢。

就是因为我们叫飞跃算法，其实有很多操作符啊，所以这样的话其实对于他的操作符呢，也可以以一个类似模板函数，这么一个形式给他传进来，然后比如说我们现在是求和或者是求啊，求机或者是求那个呃。

比如说是求最大最小等等啊，那这样的话可以函数的形式给藏起来，也就后面所有的你会发现就是那这样的话，就是所有用到这个比如参数类型的那个地方，实际上都用这个模板参数给它替换掉。

所以有了这个之后呢，实际在实际调用的时候啊，就是那编译器会根据你的，就比如说这个输入类型，比如说我输入的是一个，就是某个特定的一个数组，然后呢，比如这个时候我希望它是一个求和的一个模板，参数参数。

然后呢这个时候他去调用这个的话，实际上就会呃根据这个模板的参数的这个类型，然后进行进行进行求和一个处理，那当然额外的还有比如说像求最大值，求最小值等等啊，这一系列的一个操作。

那接下来的话就是我们结合前面讲的，我们来看看，就是说那个具体有哪些应用啊，就是呃包括前面的规约算法，以及比如说呃求个前缀和的算法，以及就是说刚才讲的那个啊，模板的那个那个一些操作。

然后看看具体在场景里边怎么用的，就首先我们来看一下，就是第一个场景就是是一个领域，就s p h里面的一个领域，球领域查找的这么一个操作，就是因为这sb它实际上每对于每一个点，他需要去计算。

就是他处在这个点周围到底包含哪些啊，哪些点，然后呢，这样的话需要把他们的那个i d，实际上需要给它记录下来，然后记录下来之后呢，后续比如说我这个时候需要去计算它的压强，或者就像他的一个密度等等。

这个时候可能都需要用到，然后呢这样的话对应到有个特有一种结构，就是这个实际上就是c加加里边的话，如果我们以c加加里cv的这个概念来描述，这些东西，实际上就相当于，它其实就是类似这样的一个结构。

它实际上就是一个vector里边再嵌套一个vector，也就是说心里边呃，privector对应的实际上就是你呃粒子的一个数量，然后呢里边的mtor就是你相当于每个数量，你就每个例子啊。

它其实呃包含相当于它领域的一些i d，啥也就相当于他也是可以存在一个vector，但这个结构就是呃虽然可以满足这个需求啊，但是这里边会存在一个什么问题呢，就是就他那个碎片化会比较严重，就是这样的话。

就是实际上你去用这个结构的时候，你会发现非常的非常的慢，因为主要是这样，你你发现就是呃每一个vector，因为这样你如果在呃内存里边，你去分配一个vector du vector。

它的那个在内存里边是连续的，但是呢你里边再嵌套一个vector之后啊，就是相当于这个比如它内存的vector，他的那个数据它可能是在整个内存空间呢，实际上并不连续，它是相当于是分段的。

所以这个时候呢就是你去取地址啊，或者取数据的时候，就会造成可能大量的一个miss，所以呢就严重的会拉低整个计算的一个效率，那这里的话就是我们信号就是在就是pdate呢。

实际上这样就是引入了一个叫release，这么一个结构啊，然后这个结构它什么意思呢，就是因为前面讲，就是你因为你实际上你要提升这个效率，主要还是要解决他的那个，碎片化的这么一个问题啊。

所以这样的话实际上我们希望做的什么呢，就是把就是所有的数据，尽可能的在一个比较大的一个连续的空间里边，给它给保存下来，就是或者开辟出来啊，所以这里边就是这个结构里面就包含三个结构。

就是其实其中最中间的那个实际上就代表了，就是实际上你要存的那个实际的比较领域的id，这个实际的一个数据，然后但是呢这里边针对每一个，比如说你针对每个例子，每个例子它其实有多少的领域的一个数量。

然后这样的话就把它保存在，比如针对第零个例子，他这里边比如说它需要有有两个那个呃，相邻的那个id，然后需要去保存，然后呢这个所以所以说这个前两个对应的，比如是d的一个例子。

然后呢后面两个对应的是第一个例子生，所以就是你可以看到所有的粒子，它对应的这个id啊，实际上都是保存在一个连续的一个空间里头，然后呢除此之外呢，当然这里面还有一个y的一个结构。

就这个实际上就跟c加里那个，s d l的那个结构就比较像了，就是因为它还有有需要有一个指针去，比如说去呃，代表它到底哪个是一个表图，所以呢针对这样的一个结构。

我们需要怎么去啊分配啊，就是那这里实际上就需要用到，就是前面讲的就是一个啊reduce，以及跟以及一个scan的一个操作，然后这里边假设我们现在已经知道了，就每个例子它对应的一个领域啊。

有比如说有啊起这么一个数组传进来，比如说第零个数据，它第零个例子它也需要两个空间，然后呢去纯它的一个领域的一个例子，然后呢比如第一个是也是两个，也就这个时候，我们需要相当于第一个要做的是什么。

就是相当于把所有的做一个求和，求完和之后呢，我们要知道诶这里一共需要多少呃，呃数据，然后呢去把所有的这个领域的那个id，存到一个大的一个数组里头，所以这里面你可以看到，就是你这个数组进来之后。

实际上第一步要做的，实际上就是叫一个去累累计求和的一个操作，其实就相当于是要统计里面，到底需要多少个元素，然后这个完了之后呢，接下来还有一个，就是因为前面还有一个辅助的一个结构，需要告诉每个例子。

它的就是相当于每个粒子对应的一个领领，领域列表，它相当于它的起始地址跟它的啊结束地址，所以这里边实际上还会有一个skin的一个，一个就是呃前聚合的这么一个一个操作。

然后这样的话这个结构实际上就是用来辅助帮，就是每个去相当于是你标每个粒子，然后去对应的去找他的那个起始的一个呃，列表的一个起始地址，以及它的一个结束的一个地址，当然完了之后后面是一个实际分配空间。

比如包括后面一个list的这么一个结构的一个，初始化的这么一个过程啊，所以呢这里针对这个结构呢，实际上就我们可以看到，就是里边就有包括reduce啊。

包括skin这两个算法的实际的一个，应用的一个场景，当然这里面还有一个场景，当然也比较常见的，就是比如说我们现在已经输入一个结合模型，然后那里边可能会有一堆的点，然后呢这个时候我们可能要做一个什么事情。

就是我们需要去求他的一个bbox，那这里边实际上就是主要，就是根据书的这些顶点，实际上就是相当于去算他的一个啊最小边界，然后当然包括啊这个上面那个是最大边界，然后下面那个是最小边界。

然后根据这两个边界呢，然后相当于是呃，实际上就得出了你相当于需要的一个bbox，然后这个是针对哪种表，比如说你数据量比较少啊，那这个实际上也没必要，就是比如你可能进来就是一个box，那你去再去算box。

你可能只有几个点，你cpu算也比较快，但这个时候你如果是输入了，可能是100万个或者是甚至更多的，那这样的话就可以用这个gpu的这个算法，然后呢整个可以高效的去计算他的一个bbox。

但这里面最后还要讲一个，就是呃一个驱虫的这么一个场景，就是这个呢实际上在，比如说我们有时候做拓扑更新啊啥的，实际上会非常常见，就是呃这个问题这样的，比如我现在假设输入了一个数组啊。

然后呢我们希望就是保留就是不重复的元素，然后把重复的元素都给它去掉，然后这里边也是结合前面的那个两个算法，怎么去做，当地这里第一步，实际上要做的是一个排序的这么一个工作，就是呃首先就是按照从小到大。

当你从小到小学，这都完全也没问题啊，就是你可以按日语的那个升序或降序去排，拍完之后，这个时候实际上就是需要去做一个什么事情呢，就是我们需要去统计，就是到底哪哪哪几个元素是呃。

相当于是呃跟其他元素是不一样的，所以这里面你可以看到，就比如从这个申升序排列之后呢，实际上这个元素你第一次，比如你从左往右走的时候，你第一个元素实际上他是第一次出现，那所以这个时候我们给它标记为一。

然后这个时候导第二个元素的时候，他因为已经出现过了，所以这个时候呢实际上给他标记零，那按这种方法呢，我们就可以统计到底里边包含几个，就是相当于是独立的几个元素，就是比较101啊，这里边当然还有二等等啊。

所以这里边就是每个标记一的那个地方，其实代表的是一个啊不重复的一个元素，然后这个完了之后，当然接下来还要做的就是一个东西，就是相当于你呃需要去求和，因为你将的话就是需要额外的开辟一个数组，然后呢。

把这个相当于把对应的一个数据给他存下来，所以最后的话实际上会有一个额外的一个数组，比如这里边有应该是七个，然后这样的话就相当于把这个一起加，用，那个相当于规约求和的这个操作，然后相当于给他加到一起。

然后呢，然后当最后一步实际上就需要就是呃，有一个exclusive skin，然后相当于是把这个东西，因为是这样，就首先是这样，你相当于前从前往后需要呃，相当于把这个东西依次累加。

累加完了就得到这么一个数组，然后这个数组呢再结合就是排序完的那个数组，然后相当于把要把对应的这个元素啊，相当于要给它放到这个，你新分配的这么一个数组里头，所以这个呢实际上也是用到了就是这里边一个。

但这里这个里边是用到了一个呃，叫reduce这么一个操作，然后这里呢用到了一个scan的一个操作，然后当然这里边就是呃，也是为了这样，加深大家对这个gpu整个编程的一个理解。

所以呢就是现在开源的舱里边呃加了一个样例，就是大家也可以把这个当做一个啊作业，然后可以去试一下，然后呢，就是包括前面比如说怎么去用邪恶的memory呀，然后怎么去分配blog等等，可以都去试一下。

然后这样我讲一下。

就是呃这个样例怎么去呃去做的，然后哦这里实际上就是呃这个开源仓的话。

实际上现在有一个新的分支。

然后叫homework 1，然后这里边你如果把它check out出来之后呢，然后呢你再重新用，比如说上上次讲的，比如用c mc，然后重新生成一下之后，然后你这里就可以看到在test里头。

然后就可以看到这么一个样例，然后这个案例里边我简单讲一下，其实就是啊输入一个比较大的一个数组，然后刚一开始以为是初始化的话，实际上是在呃cpu列表是完成的，然后完了之后呢。

相当于把他数据好到一个g p u g pu，完了之后，当然根据刚才最后一页就是讲的这个这个排序，排序完了之后，然后当然后面有两个算法。

这里是留空的，就是呃哪两个算法留空呢，一个是啊这个算法。

然后呢还有一个是这个算法，其实这两个是留空的，然后呢留给大家自己去，可以去当练手，可以去试一下，然后呢前面就是呃每个算法当然有些输入了，就是当然这个整个结构就已经定义好了，然后呢这里边无非是要去填的。

就是相当于是把这里边的，就是刚才讲的那个算法，就相当于把需要把它填到这里头，然后呢最后保证你相当于运行起来之后，当然这里因为整个是用那个啊，google的那个g test来做的。

所以这样的话你可以对结果进行一个验证，比如说你这里相当于因为正常的话，我这里按照这个结构书的话，它其实应该能得到啊，20个不一样的一个元素，所以就最后那个数组啊，就这个数组输出的这个数组的话。

其实应该是相当于它的维度是20的一个维度，所以你需要能保证，就相当于最后这个跑起来是正确的，当然现在的话你应该跑的话应该是不对的。

就是他应该会反馈错误对，所以这个是不对的，所以就是等大家把这两个填完之后。

就是这样的话就可以正确运行的话，应该就可以保证正确的结果，当然这个其实仅仅是一个练习的一个一个作用，就是当然也不做检查，所以大家有兴趣的可以去写一下，然后这样的话也正好是加深。

就是前面我们今天前面主要讲的这几部分的，一个一个呃印象吧，首先我今天要讲的主要是这几部分嘛，所以就是对整个gpu，然后它主要的一些特性，然后需要注意的地方，然后大致都过了一下。

然后剩下的话看看大家有什么问题吧，然后需要的话也可以讨论一下啊，嗯还有问题吗，没有的话，要不我们就今天就差不多就到这啊，反正其他的反正有什么问题的话，也可以在群里边，qq群里边可以再讨论吧。