计算机仿真中的HLA技术

第一章 概述                   
                   
 1. 1为什么HLA（High Level Architecture 高层体系结构）能用于建模和仿真                   
 1. 2  HLA联邦拥有软件和数据部件                   
 1. 3  HLA是一个标准                   
 1. 3. 1 HLA规则                  
 1. 3. 2对象模型模板(OMT)                   
 1. 3. 3接口规范                   
 1. 3. 4这个规范现在进展的情况*                   
 1. 4您能运行您自己的联邦                   
                   
 第二章 HLA背景                   
 2. 1引言                   
 2. 2 HLA如何诞生                   
 2. 3技术转化模型                   
 2. 4 技术开发                   
 2. 4. 1 多个小组共同提出HLA的初始概念                   
 2. 4. 2 用户指导产生HLA初始规范                   
 2. 4. 3 用原型联邦验证概念                   
 2. 4. 4 初始定义：深入开发的基础                   
 2. 5 产品开发                   
 2. 5. 1 从用户角度看联邦开发过程                   
 2. 5. 2 支持HLA应用的自动开发工具                   
 2. 5. 3  开发RTI软件                   
 2. 6 用户转化                   
 2. 7 为什么HLA能在同类产品中获得成功？                   
                   
 第三章  HLA综述                   
 3. 1 引言                   
 3. 2  HLA定义了一种软件体系结构                   
 3. 2. 1  HLA的目标：由组件构建仿真系统                   
 3. 2. 3  体系结构将仿真和支撑框架的功能分离                   
 3. 2. 4  HLA的信息模型：对象模型模板（OMT）                   
 3. 2. 5  HLA 规则                   
 3. 2. 6  管理对象模型（MOM）：RTI描述联邦                   
 3. 3  HLA提供六个领域的服务                   
 3. 3. 1 联邦管理                   
 3. 3. 2 声明管理                   
 3. 3. 3 对象管理                   
 3. 3. 4 所有权管理                   
 3. 3. 5 时间管理                   
 3. 3. 6 数据分发管理                   
 3. 3. 7 服务组尽可能独立                   
 3. 4 小结                   
                   
 第四章 寿司餐馆联邦                   
 4. 1  创建一个联邦                   
 4. 1. 1 "寿司船"餐馆                   
 4. 2 联邦管理：定义联邦                   
 4. 2. 1  是机制, 不是策略                   
 4. 2. 2  RTI和联邦成员的生命周期                   
 4. 2. 3  联邦执行数据和RTI 初始化数据                   
 4. 2. 4  创建联邦执行                   
 4. 2. 5  加入联邦执行                   
 4. 2. 6  迟到的加入                   
 4. 2. 7  退出联邦执行                   
 4. 3  联邦对象模型：世界的共同描述                   
 4. 3. 1  餐馆联邦中的类                   
 4. 3. 2  餐馆联邦中的交互                   
 4. 3. 3 数据：属性和参数                   
 4. 3. 4 FED文件                   
 4. 4 共享数据概述                   
 4. 4. 1  数据共享机制                   
 4. 4. 2  发布与订阅                   
 4.5数据共享：更多的细节                   
 4.5.1关键术语                   
 4.5.2发布者产生数据                   
 4.5.3订阅者消费数据                   
 4. 5. 4  来自RTI的建议                   
 4. 5. 5  RTI存储的信息                   
 4. 6 所有权：实体建模中的职责与合作                   
 4. 6. 1 建模的职责反映在所有权上                   
 4. 6. 2 不能删除所不拥有的                   
 4. 6. 3  仿真一个对象的职责可以被分享                   
 4. 7 小结                   
                   
 第五章 联邦同步                   
 5.1 创建联邦：例子的深入                   
 5.2 时间管理：事件都是有序的                   
 5.2.1 为什么需要对事件进行排序                   
 5.2.2  分布式仿真中的事件必须有次序                   
 5.2.3   以下概念适用于所有的HLA时间管理服务                   
 5.2.4  使用时间管理的技巧                   
 5.3 联邦执行的生命周期：协调独立的联邦成员                   
 5.3.1 问题举例：各联邦成员同时开始                   
 5.3.2  分阶段执行                   
 5.3.3 同步点                   
 5.3.4 判断所有的预期联邦成员都已加入：MOM简介                   
 5.3.5 判断联邦成员何时退出联邦                   
 5.3.6  每个联邦成员都有职责                   
 5.3.7 既使用同步点又使用MOM的管理者联邦成员                   
 5.3.8 联邦生命周期总结                   
 5.4 对餐馆联邦示例程序需求的增加                   
 5.4.1 联邦与墙钟时间同步                   
 5.4.2 观察餐馆联邦的运行                   
 5.4.3  餐馆联邦的规模成倍增加                   
 5.5 小结                   
                   
 第六章 一个例子的实现                   
 6.1 简介                   
 6.2 例子的内容                   
 6.3 运行例子                   
 6.4 所有联邦成员共用的类型                   
 6.5 PRODUCTION联邦成员的结构                   
 6.5.1 联邦成员的用户界面                   
 6.5.2 获取配置数据                   
 6.5.3 值得注意的对象                   
 6.5.4 线程执行                   
 6.5.5 厨师的状态                   
 6.5.6 事件：对象. 队列和主循环                   
 6.5.7 主线程                   
 6.5.8 不经过回调函数队列处理的回调函数                   
 6.5.9 时间推进                   
 6.5.10 更新发布的属性                   
 6.5.11 总结                   
 6.6 TRANSPORT联邦成员                   
 6.6.1 TRANSPORT联邦成员的用户界面                   
 6.6.2  BOAT的状态                   
 6.6.3 时间推进                   
 6.7 CONSUMPTION 联邦成员                   
 6.7.1 Consumption联邦成员的用户界面                   
 6.7.2  用餐者的状态变化                   
 6.7.3 时间推进                   
 6.8 MANAGER联邦成员                   
 6.8.1  MANAGER联邦成员的用户界面                   
 6.8.2 Manager联邦成员的主线程                   
 6.9 Viewer联邦成员                   
                   
 第七章 为新应用而扩展联邦                   
 7.1 把联邦用于新应用                   
 7.1.1   为使联邦具有新的功能而增加新的联邦成员                   
 7.1.2 FOM能在不影响现有联邦成员的前提下扩展                   
 7.1.3 协同仿真意味着所有权共享                   
 7.1.4 时间管理如何适应新联邦成员的加入                   
 7.1.5 新的联邦成员可以很容易地加入联邦的生命周期中                   
 7.1.6 FOM还能通过子类进行扩展                   
 7.2 总结                   
                   
 第八章. 高级主题                   
 8. 1 引言                   
 8. 2 零前瞻量                   
 8. 2. 1  零前瞻量和协同建模                   
 8. 2. 2  零前瞻量和插曲式仿真                   
 8. 2. 3  关于前瞻量的最后提示                   
 8. 3  用于优化联邦成员的时间管理方法                   
 8. 3. 1  推进时间和尽早获得事件                   
 8. 3. 2 回收事件                   
 8. 3. 3 总结                   
 8. 4  存储和恢复                   
 8. 4. 1  概述                   
 8. 4. 2 存储的细节                   
 8. 4. 3  恢复的细节                   
 8. 4. 4  联邦成员的类型                   
 8. 5 数据分发管理（DDM）                   
 8. 5. 1 为什么需要这些服务？                   
 8. 5. 2  总体的理念                   
 8. 5. 3  这些服务的细节                   
 8. 5. 4  解释寂静                   
 8. 5. 5  DDM存在时的实例管理                   
 8. 6  关于怎样使用MOM的更多内容                   
 8. 6. 1 继续停留在联邦成员和联邦的当前状态上                   
 8. 6. 2  控制MOM的报告                   
 8. 6. 3  其它信息的要求                   
 8. 6. 4  让MOM去整理混乱                   
 8. 6. 5 获得极为详细的调试信息                   
 8. 6. 6  为您的目的扩展MOM