# 
msgid ""
msgstr ""
"Project-Id-Version: Modelica by Example 0.2.1\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2014-04-14 10:14-0400\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: ../../source/components/architectures/sensor_comparison.rst:4
msgid "Sensor Comparison"
msgstr "传感器比较"

#: ../../source/components/architectures/sensor_comparison.rst:6
msgid ""
"Let us start our study of architectures with an example that is similar to "
"one presented in my previous book [ItPMwM]_.  In it, we will consider the "
"performance of a control system using several different sensor models."
msgstr ""
"我们会以一个例子开始对架构的研究。\ "
"本例类似于我以前的书\\ [ItPMwM]_\\ 里介绍过的另一个例子。\ "
"在书里，我们将研究控制系统在使用几种不同的传感器模型时的性能。\ "

#: ../../source/components/architectures/sensor_comparison.rst:14
msgid "Flat System"
msgstr "单层模型"

#: ../../source/components/architectures/sensor_comparison.rst:16
msgid "Our system schematic is structured as follows:"
msgstr "我们的系统结构如下："

#: ../../source/components/architectures/sensor_comparison.rst:37
msgid "We can represent this using the following Modelica code:"
msgstr "我们可以用Modelica代码表示如下："

#: ../../source/components/architectures/sensor_comparison.rst:42
msgid ""
"Note that for this particular model, the ``sensor`` component is an instance"
" of the ``SpeedSensor`` model found in "
"``Modelica.Mechanics.Rotational.Sensors`` which is an \"ideal\" sensor that "
"reports the exact solution trajectory.  In other words, it does not "
"introduce any kind of measurement artifact."
msgstr ""
"请注意，在这个特定模型里，\\ ``sensor``\\ 组件是\\ "
"``Modelica.Mechanics.Rotational.Sensors``\\ 包内\\ ``SpeedSensor``\\ "
"模型的一个实例。\ "
"这是个报告精确解轨迹的“理想”传感器。\ "
"换句话说，该传感器不引入任何一种测量误差。\ "

#: ../../source/components/architectures/sensor_comparison.rst:48
msgid ""
"In fact, simulating such a system we see that using accurate speed "
"measurements, the control system is still not quite able to follow the speed"
" trace:"
msgstr "事实是在模拟后我们看到，即便使用精确的速度测量，控制系统仍不太能够跟踪给定的速度轨迹："

#: ../../source/components/architectures/sensor_comparison.rst:55
msgid ""
"We'll discuss why in a moment.  But the problem clearly isn't measurement "
"artifact since the measured speed is exactly equal to the actual shaft "
"speed."
msgstr "我们会在稍后讨论为什么。\ "
"但问题显然不是由测量误差带来的，因为所测量的速度是恰好等于实际轴速度。\ "

#: ../../source/components/architectures/sensor_comparison.rst:59
msgid ""
"Now, imagine we wanted to use a more realistic sensor model, like the :ref"
":`sample-hold-sensor` model developed previously, to see what additional "
"impact measurement artifact might have on our system performance.  One way "
"we could do that would be to replace the following lines in the "
"``FlatSystem`` model:"
msgstr ""
"现在设想我们要用一个更现实的传感器模型，如之前编写的\\ :ref:`sample-hold-sensor`\\ "
"模型，以观察测量误差可能对系统性能有何额外影响。\ "
"其中一点方法是将\\ ``FlatSystem``\\ 模型内的以下代码："

#: ../../source/components/architectures/sensor_comparison.rst:69
msgid "with these lines:"
msgstr "替换为："

#: ../../source/components/architectures/sensor_comparison.rst:75
msgid ""
"Note that **the only change being made here is the type** of the "
"``speedSensor`` component.  Simulating this system, we would see the "
"following performance for the control system:"
msgstr "注意\\ **唯一的改变这里是**\\ \\ ``speedSensor``\\ 组件\\ **的类型**\\ 。\ "
"模拟这个系统，我们将看到控制系统以下的性能表现："

#: ../../source/components/architectures/sensor_comparison.rst:82
msgid ""
"In this case, we can see that things are going from bad to worse. While we "
"were initially unable to track the desired speed closely, now (as a result "
"of the measurement artifact) our system has become unstable."
msgstr "在这种情况下，我们可以系统性能每况愈下。\ "
"虽然我们最初无法完全紧跟所需的速度，现在系统（由于测量误差）已变得不稳定。\ "

#: ../../source/components/architectures/sensor_comparison.rst:88
msgid "Hierarchical System"
msgstr "带层级系统"

#: ../../source/components/architectures/sensor_comparison.rst:90
msgid ""
"At this point, we'd like to explore this performance issue a bit more to "
"understand how characteristics of the sensor (*e.g.,* ``sample_rate``) "
"impact performance and potentially what kinds of improvements might "
"ultimately be required for the control system itself."
msgstr ""
"在这里，我们想稍进一步探索上述性能问题，以一方面了解传感器的特性（如：``sample_rate``\\ "
"）会如何影响系统性能。\ "
"另一方面，我们也希望进一步考虑对于控制系统本身的改进。\ "

#: ../../source/components/architectures/sensor_comparison.rst:96
msgid ""
"If we plan on substituting sensors, actuators and control strategies our "
"first step should be to organize our system into those subsystems. Doing so,"
" we end up with the following system model:"
msgstr "如果我们要更换传感器、执行器和控制策略，那么第一步应该是将这些子系统组织为模型。\ "
"如此，我们最终会得到了以下系统模型："

#: ../../source/components/architectures/sensor_comparison.rst:105
msgid ""
"Here we see only four subsystems at the system level.  They correspond to "
"the subsystems we mentioned a moment ago.  Our Modelica model is now much "
"simpler because the only declarations we now have are:"
msgstr ""
"我们在系统级只会看到四个子系统在。\ "
"这些模型各自对应于刚才提到的子系统。\ "
"我们的Modelica模型现在变得更为简单了，因为模型内仅有如下声明："

#: ../../source/components/architectures/sensor_comparison.rst:113
msgid ""
"Each subsystem (``plant``, ``actuator``, ``sensor`` and ``controller``) is "
"implemented by a subsystem in the ``Implementations`` package.  This is an "
"improvement because it means that if we wanted to change controller models, "
"we could simply change the type associated with the ``controller`` subsystem"
" and a different implementation would be used.  This is definitely an "
"improvement over having to delete the existing controller components, drag "
"in new ones and then connect everything back up (correctly!)."
msgstr ""
"每个子系统（ \\ ``plant``\\ 、\\ ``actuator``\\ 、\\ ``sensor``\\ 和\\ "
"``controller``\\ ）是由\\ ``Implementations``\\ "
"包内的一个子系统模型来实现的。\ "
"这是一种对模型的改进。\ "
"原因是这意味着如果我们想改变控制器模型，我们可以简单通过改变与\\ ``controller``\\"
" "
"子系统所关联的的类型，然后系统就会采用另外这个子系统的另一种实现。\ "
"相对于删除现有的控制器组件、拖拽新组件、然后（正确地！）重新连接所有关联部件这一系列繁复的步骤，这无疑是一种进步。\ "

#: ../../source/components/architectures/sensor_comparison.rst:122
msgid ""
"But switching our sensor model to a sample and hold version still involves "
"editing the text of our model, *i.e.,*"
msgstr "但是，我们在将传感器切换为采样保持版本后，仍然需要更改模型的文本，即："

#: ../../source/components/architectures/sensor_comparison.rst:130
msgid ""
"There are still a couple of issues with this solution.  First, recall that "
"we changed the implementation to be used by changing the name of the type.  "
"This raises the question \"What types *can* be used here?\" What if I change"
" the type of ``sensor`` to ``BasicPlant``?  That wouldn't make any sense.  "
"But we don't really know that by looking at the model.  But the **bigger** "
"problem is that to create a model that we end up with two models that are "
"almost identical.  As we learned :ref:`earlier in the book <dry-"
"components>`, it is always useful to keep in mind the DRY (Don't Repeat "
"Yourself) principle.  In these models, we see a lot of redundancy."
msgstr ""
"此方案仍然有数个问题。\ "
"首先，回想我们是通过更改类型名去改变子系统的实现。\ "
"问题是：“什么类型的\\ *可以*\\ 用在这里？”如果我将\\ "
"``sensor``\\ 子系统的类型改为\\ ``BasicPlant``\\ 呢？这会没有任何意义。\ "
"但是，仅通过观察模型其实我们不会知道这点。\ "
"但\\"
" **更大的**\\ 问题是，为创建一个模型我们最终会得到两款几乎相同的模型。\ "
"正如我们\\ :ref:`\\ 我们在本书前面\\ <dry-"
"components>`\\ 所学到的一样，大家应该紧记DRY （不要重复自己）原则。\ "
"而在这些模型中，我们看到了很多的冗余。\ "

#: ../../source/components/architectures/sensor_comparison.rst:142
msgid "Dealing with Redundancy"
msgstr "处理冗余"

#: ../../source/components/architectures/sensor_comparison.rst:144
msgid ""
"Imagine we start with our hierarchical model using the ``IdealSensor`` "
"model:"
msgstr "试想我们以\\ ``IdealSensor``\\ 模型为出发点建立层级模型："

#: ../../source/components/architectures/sensor_comparison.rst:155
msgid ""
"Previously, we dealt with redundancy by using inheritance.  We can certainly"
" use inheritance to pull the subsystems from ``HierarchicalSystem`` into "
"another model and then change *parameters*, *e.g.,*"
msgstr ""
"在前面，我们通过继承处理冗余。\ "
"我们当然可以使用继承来将\\ ``HierarchicalSystem``\\ 内的子系统转移到另一个模型，\ "
"然后改变此模型的\\ *参数*\\ ，如："

#: ../../source/components/architectures/sensor_comparison.rst:166
msgid ""
"But we don't want to change parameters, we want to change **types**. If we "
"could somehow \"overwrite\" previous choices, we could do something like "
"this:"
msgstr "但我们并不希望改变参数，要改变的是\\ **类型**\\ 。\ "
"假设我们能以某种方式“覆盖”以前的选择，这样就可以做到如下的事情："

#: ../../source/components/architectures/sensor_comparison.rst:178
msgid ""
"This is essentially what we want to do.  But this isn't legal in Modelica "
"and there are a couple of other problems with this approach.  The first is "
"that the original model developer might not want to allow such changes.  The"
" second problem is that we end up with two ``sensor`` components (of "
"different types, no less).  Even if it truly \"overwrites\" any previous "
"declaration of the ``sensor`` component, another problem is that we might "
"type the name wrong for the variable name and end up with two sensors.  "
"Finally, we still don't have a way to know if it even makes sense to change "
"``sensor`` into a ``SampleHoldSensor``.  In this case it does, but how do we"
" ensure that in general?"
msgstr ""
"这就是我们实际上想要做的。\ "
"但是，这不是合法的Modelica代码。\ "
"再者这个方法有若干个其他问题。\ "
"首先，原模型开发人员可能不希望允许这样的变化。\ "
"第二个问题是，我们最终会有（不同类型的，且不会少于）两个\\"
" ``sensor``\\ 组件。\ "
"即使模型真的“覆盖”了\\ ``sensor``\\ "
"组件其任何先前的声明，另外一个问题是，我们可能会键入名称错误的变量名，最后系统里有两个传感器。\ "
"最后，我们仍然没有办法知道，将\\ "
"``sensor``\\ 改成\\ ``SampleHoldSensor``\\ 是否有意义。\ "
"在这里这样改是有意义的，但在一般情况下我们如何保证呢？"

#: ../../source/components/architectures/sensor_comparison.rst:190
msgid ""
"Fortunately, there **is** a way to do almost exactly what we are attempting "
"here.  But in order to address these other complications, we need to be a "
"bit more rigorous about it."
msgstr "幸运的是，\\ **有**\\ 一种方式可以几乎达到我们的目的。\ "
"但为了解决这些附带问题，我们需要更严格地考虑这个问题。\ "

#: ../../source/components/architectures/sensor_comparison.rst:194
msgid ""
"We need to start by indicating that that component is allowed to be "
"replaced.  We can do this by declaring the ``sensor`` as follows:"
msgstr "首先，我们需要指示该组件允许被更换。\ "
"为了达到这一点，我们可以通过如下方式声明\\ ``sensor``\\ ："

#: ../../source/components/architectures/sensor_comparison.rst:204
msgid ""
"The use of the `replaceable` keyword indicates that when we inherit from the"
" model, that variable's type can be changed (or, \"redeclared\").  But "
"remember that this model also has a statement like this one:"
msgstr ""
"使用了\\ `replaceable`\\ "
"关键字表明，我们继承该模型时，该变量的类型是可以改变的（或者说，可以“重新声明”）。\ "
"但要记住，这个模型也有如下的语句："

#: ../../source/components/architectures/sensor_comparison.rst:214
msgid ""
"This introduces a complication.  What happens if we replace the ``sensor`` "
"component with something that **does not have** a ``w`` connector on it?  In"
" that case, this ``connect`` statement will generate an error.  In this "
"case, we say that the two sensor models are not **plug-compatible**.  A "
"model ``X`` is plug-compatible with a model ``Y`` if for every **public** "
"variable in ``Y``, there is a corresponding public variable in ``X`` with "
"the same name. Furthermore, every such variable in ``X`` must itself be "
"plug-compatible with its counterpart in ``Y``.  This ensures that if you "
"change a component of type ``Y`` into a component of type ``X`` and "
"everything you need (parameters, connectors, etc) will still be there and "
"will still be compatible.  **However, please note** that if ``X`` is plug-"
"compatible with ``Y``, this **does not** imply that ``Y`` is plug-compatible"
" with ``X`` (as we will see in a moment)."
msgstr ""
"这就带来了一个问题。\ "
" 如果我们更换的\\ ``sensor``\\ 组件\\ **没有**\\ \\ ``w``\\ "
"连接器，那么会发生什么？在这种情况下，这个\\ ``connect``\\ 语句将产生错误。\ "
"此时，我们会说这两种传感器型号不是\\ "
"**插件兼容的**\\ 。\ "
"当对于\\ ``Y``\\ 的每个\\ **公有**\\ 变量\\ ``X``\\ 都有一个具有相同的名字的对应变量，模型\\"
" ``X``\\ 插件兼容于\\ ``Y``\\ 模型。\ "
"此外，在\\ ``X``\\ 内每个这样的变量本身必须是插件兼容它在\\ ``Y``\\ "
"内的对应变量。\ "
"这样可以确保如果你将\\ ``Y``\\ 类型的组件到变更为类型\\ ``X``\\ "
"，你需要的一切（参数，连接器等）都将继续存在，并仍将是兼容的。\ "
"\\ **不过，请注意**\\ ，倘若\\ ``X``\\ 是插件兼容于\\ "
"``Y``\\ ，这\\ **不**\\ 意味着\\ ``Y``\\ 插件兼容于\\ ``X``\\ （我们将马上看到这样的例子）。\ "

#: ../../source/components/architectures/sensor_comparison.rst:229
msgid ""
"Plug compatibility is important because, in general, we want to ensure that "
"any redeclaration that we make is \"safe\".  The way we do that is to "
"require that whatever type we decide to change our ``sensor`` component to "
"is plug compatible with the original type.  In this case, that means that it"
" has to have a ``w`` connector (and that connector, in turn, must be plug "
"compatible with the ``w`` that was there before) and it has to have a "
"``shaft`` connector (which, again, must be plug compatible with the previous"
" ``shaft``)."
msgstr ""
"“插件兼容性”是非常重要的。\ "
"原因是在一般情况下，我们希望确保任何重声明都是“安全的”。\ "
"要做到这一点，我们必须确定在更改\\ ``sensor``\\ "
"组件时，使用的任何类型均插件兼容于原来的类型。\ "
"在这种情况下，这意味着这个类型必须有一个\\ ``w``\\ "
"连接器（同样地，这个连接器必须插件兼容于重声明前的\\ ``w``\\ ）。\ "
"另外，这个类型必须有一个\\ ``shaft``\\ "
"连接器（同上，其必须插件兼容于以前的\\ ``shaft``\\ ）。\ "

#: ../../source/components/architectures/sensor_comparison.rst:238
msgid ""
"So the question then is, does our ``SampleHoldSensor`` implementation "
"satisfy this requirement plug compatibility requirement?  Is it plug-"
"compatible with the ``IdealSensor`` model?  First, let's look at the "
"``IdealSensor`` model:"
msgstr ""
"所以接下来的问题是，我们的\\ ``SampleHoldSensor``\\ 能否实现满足插件兼容性要求？此模型是插件兼容于\\ "
"``IdealSensor``\\ 模型么？首先，让我们来看看\\ ``IdealSensor``\\ 模型："

#: ../../source/components/architectures/sensor_comparison.rst:247
msgid ""
"The public interface of this component consists only of the two connectors "
"``w`` and ``shaft``.  Looking at the ``SampleHoldSensor`` model:"
msgstr "此组件的公有接口包含两个连接器：\\ ``w``\\ 和\\ ``shaft``\\ 。\ "
"观察\\ ``SampleHoldSensor``\\ 模型："

#: ../../source/components/architectures/sensor_comparison.rst:260
msgid ""
"we see that its public interface also contains the connectors ``w`` and "
"``shaft``.  Furthermore, they are exactly the same type as the connectors on"
" the ``IdealSensor`` model.  For this reason, the ``SampleHoldSensor`` model"
" is plug-compatible with the ``IdealSensor`` model so we should be able to "
"replace an ``IdealSensor`` instance with a ``SampleHoldSensor`` instance and"
" our ``connect`` statements will still be valid."
msgstr ""
"我们可以看到，其公有接口也包含连接器\\ ``w``和` ` shaft``\\ 。\ "
"此外，两者与\\ ``IdealSensor``\\ "
"模型上的连接器具有完全相同的类型。\ "
"因此，\\ ``SampleHoldSensor``\\ 模型插件兼容于\\ ``IdealSensor``\\ 模型。\ "
"所以我们应该可以用\\ ``SampleHoldSensor``\\ 替换\\ ``IdealSensor``\\ 的实例。\ "
"在替换后，我们的\\ ``connect``\\ 语句仍然有效。"

#: ../../source/components/architectures/sensor_comparison.rst:268
msgid "So, if our ``HierarchicalSystem`` model were declared as follows:"
msgstr "那么，如果我们的\\ ``HierarchicalSystem``\\ 模型声明如下："

#: ../../source/components/architectures/sensor_comparison.rst:287
msgid ""
"Then we can achieve our original goal of creating a variation of this model "
"without repeating ourselves as follows:"
msgstr "然后我们可以以如下方式实现最初创建此模型变体的目的，而不必重复："

#: ../../source/components/architectures/sensor_comparison.rst:300
msgid ""
"There are several things worth noting about this model.  The first is that "
"the syntax of a redeclaration is just like a normal declaration except it is"
" preceded by the ``redeclare`` keyword.  Also note that the redeclaration is"
" part of the ``extends`` clause.  Specifically, it is a modification, like "
"any other modification, in the extends clause.  If we wanted to both "
"redeclare the ``sensor`` component and change the ``startTime`` parameter of"
" our setpoint, they would both be modifications of the ``extends`` clause, "
"*e.g.,*"
msgstr ""
"上述模型的还有几点值得注意。\ "
"首先是重声明的语法和正常声明几乎相同。\ "
"不同在于，其前面加上了\\ ``redeclare``\\ 关键字。\ "
"还要注意的是，重新声明是\\ ``extends``\\ 子句的一部分。\ "
"具体地讲，重声明语句如同其他所有修改一样，是一个在扩展子句内的更改。\ "
"如果我们想既重声明\\ ``sensor``\\ 组件又要改变我们工作点的\\ ``startTime``\\ 参数，\ "
"则两者均为\\ ``extends``\\ 子句内的更改，如："

#: ../../source/components/architectures/sensor_comparison.rst:321
msgid "Constraining Types"
msgstr "约束类型"

#: ../../source/components/architectures/sensor_comparison.rst:323
msgid ""
"Recall, from earlier in this section, that the public interface for the "
"``SampleHoldSensor`` model included:"
msgstr "回想一下，在本节的前面，\\ ``SampleHoldSensor``\\ 模型的公有接口包括："

#: ../../source/components/architectures/sensor_comparison.rst:332
msgid "and that the ``IdealSensor`` public interface contained only:"
msgstr "而\\ ``IdealSensor``\\ 模型的公有接口则只有："

#: ../../source/components/architectures/sensor_comparison.rst:339
msgid ""
"If redeclarations are restricted in such a way that the redeclared type has "
"to be plug-compatible with the original type, then we could run into the "
"following problem.  What if our initial model for our system used the "
"``SampleHoldSensor`` sensor, *i.e.,*"
msgstr ""
"如果重声明受限于新类型和原始类型的插件兼容性，那么我们可能会遇到下面的问题。\ "
"万一我们在系统初始模型中使用了\\ "
"``SampleHoldSensor``\\ 传感器，即："

#: ../../source/components/architectures/sensor_comparison.rst:360
msgid ""
"Imagine further that we then wanted to redeclare the ``sensor`` component to"
" be an ``IdealSensor``, *e.g.,*"
msgstr "进一步试想，我们想将\\ ``sensor``\\ 组件重定义为\\ ``dealSensor``\\ ，如："

#: ../../source/components/architectures/sensor_comparison.rst:372
msgid ""
"Now we have a problem.  The problem is that our original ``sensor`` "
"component has a parameter called ``sample_rate``.  But, we are trying to "
"replace it with something that does not have that parameter.  In other "
"words, the ``IdealSensor`` model is **not** plug-compatible with the "
"``SampleHoldSensor`` model because it is missing something, ``sample_rate``,"
" that the original model, ``SampleHoldSensor``, had."
msgstr ""
"现在我们有一个问题。\ "
"原来的\\ ``sensor``\\ 组件有个名为\\ ``sample_rate``\\ "
"的参数。\ "
"但是，我们试图把该组件替代没有这个参数的类型。\ "
"换句话说，\\ ``IdealSensor``\\ 模型\\ **不**\\ 插件兼容于\\ "
"``SampleHoldSensor``\\ 模型。\ "
"因为此新模型缺少一些原模型\\ ``SampleHoldSensor``\\ 具有的内容：\\ "
"``sample_rate``\\ 。\ "

#: ../../source/components/architectures/sensor_comparison.rst:381
msgid ""
"But when we look at source code of the ``InitialSystem`` model, we see that "
"the ``sample_rate`` parameter was never used.  So there is no real reason "
"why we couldn't switch the type.  For this reason, Modelica includes the "
"notion of a *constraining type*."
msgstr ""
"但是，当我们观察\\ ``InitialSystem``\\ 模型的源代码后，我们看到了\\ ``sample_rate``\\ "
"参数从未使用过。\ "
"因此，并不存在真正的理由阻止类型转换。\ "
"出于这个原因，Modelica包括\\ *约束类型*\\ 这个概念。\ "

#: ../../source/components/architectures/sensor_comparison.rst:386
msgid ""
"The important thing to understand about redeclarations is that there are "
"really two important types associated with the original declaration.  The "
"first type is what the type of the original declaration was.  The second "
"type is what the type *could be* and still work.  This second type is called"
" the constraining type because as long as any redeclaration is plug-"
"compatible with the constraining type, the model should still work.  So in "
"our ``InitialSystem`` model above, the type of the original declaration was "
"``SampleHoldSensor``. But the model will still work as long as any new type "
"is plug-compatible with ``IdealSensor``."
msgstr ""
"要了解重声明，重要的是需要清楚，其实有两个重要类型与原声明相关。\ "
"第一个重要类型是原声明的类型。\ "
"第二则是什么类型\\ *有可能*\\ ，而且可让系统运行。\ "
"这第二个类型被称为约束类型。\ "
"因为只要任何重声明的类型插件兼容于约束类型，该模型应该仍然工作。\ "
"这第二类叫做约束类型，因为只要任何重新声明是插件兼容约束类型，模型应该仍能正常工作。\ "
"因此，上述的\\ ``InitialSystem``\\ 模型内原声明的类型是\\ ``SampleHoldSensor``\\ 。\ "
"但只要新类型的插件兼容\\ ``IdealSensor``\\ ，该模型仍然能工作。\ "

#: ../../source/components/architectures/sensor_comparison.rst:397
msgid ""
"When we indicate that a component is ``replaceable``, we can indicate the "
"constraining type by adding a ``constrainedby`` clause at the end, *e.g.*,"
msgstr "当我们表明一个组件是\\ ``replaceable``\\ 时，我们可以在最末加入\\ ``constrainedby``\\ 去指示约束型，如：，"

#: ../../source/components/architectures/sensor_comparison.rst:408
msgid ""
"This declaration says that the ``sensor`` component can be redeclared by "
"anything that is plug-compatible with the ``IdealSensor`` model, **but** if "
"it isn't redeclared, then **by default** it should be declared as a "
"``SampleHoldSensor`` sensor.  For this reason, the original type used in the"
" declaration, ``SampleHoldSensor``, is called the **default type**."
msgstr ""
"上述声明的意思是\\ ``sensor``\\ 组件可以通过任何的插件兼容于\\ ``IdealSensor``\\ 的模型来重声明。\ "
"\\ **但是**\\ 如果不进行重声明，那么\\ **默认**\\ 会声明为\\ ``SampleHoldSensor``\\ 传感器。\ "
"出于这个原因，声明\\ ``SampleHoldSensor``\\ 时使用的原始类型被称为\\ **默认类型**\\ 。\ "

#: ../../source/components/architectures/sensor_comparison.rst:415
msgid ""
"Recall that our original definition of the ``InitialSystem`` model didn't "
"specify a constraining type.  It only specified the initial type.  In that "
"case, the default type and the constraining type are assumed to be the "
"initial type."
msgstr ""
"注意，我们原来的\\ ``InitialSystem``\\ "
"模型的定义并没有指定约束类型。\ "
"模型只指定了初始类型。\ "
"在这种情况下，默认类型和约束类型被假定为初始类型。\ "

#: ../../source/components/architectures/sensor_comparison.rst:420
msgid ""
"We will continue using this same system architecture in the next section "
"when we discuss how to develop such a system model using a top-down, :ref"
":`arch-driven-approach`."
msgstr ""
"在下一节讨论了如何使用自上而下\\ :ref:`arch-driven-approach`\\ 去开发这样的系统模型时，我们将继续使用相同系统架构。\ "

#: ../../source/components/architectures/sensor_comparison.rst:424
msgid ""
"Michael M. Tiller, \"Introduction to Physical Modeling with Modelica\" "
"http://www.amazon.com/Introduction-Physical-Modeling-International-"
"Engineering/dp/0792373677"
msgstr ""

#: ../../source/components/architectures/sensor_comparison.rst:25
msgid ""
"All the components within the magenta box represent the plant model. In this"
" case, it is a simple rotational system involving two rotating inertias "
"connected via a spring and a damper.  One of the inertias is connected to a "
"rotational ground by an additional damper.  The green box identifies the "
"sensor in the system.  The sensor is used to measure the speed of one of the"
" rotating shafts.  Similarly, the magenta box identifies the actuator.  The "
"actuator applies a torque to the other shaft (the one whose speed is not "
"measured).  Finally, all the components in the blue box represent the "
"control system, which tries to keep the measured speed as close as possible "
"to the setpoint supplied by the signal generator at the top of the diagram."
msgstr ""
"紫红色框内组件代表受控对象的模型。\ "
"在这种情况下，对象为经一个弹簧和阻尼器连接的两个转动惯量所组成的简单旋转系统。\ "
"其中一个惯量由一个额外的阻尼器连接到旋转元素的地面参考系。\ "
"绿框标示系统中的传感器。\ "
"该传感器用于测量其中一个旋转轴的速度。\ "
"类似地，紫红框表示执行器。\ "
"执行器对另一条轴（其速度没有测定的那条）施加扭矩。\ "
"最后，蓝框内的所有组件代表了控制系统。\ "
"该系统试图使所测速度尽可能地接近信号发生器在图的顶部所提供的设定值。\ "

#: ../../source/components/architectures/sensor_comparison.rst:152
msgid ""
"Now, we want to create a variation of this model where the ``sensor`` "
"component can assume different types."
msgstr "现在，我们要建立这种模式的变体，去更改其中的\\ ``sensor``\\ 组件。\ "
