#
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/behavior/equations/initialization.rst:5
msgid "Initialization"
msgstr "初始化"

#: ../../source/behavior/equations/initialization.rst:8
msgid "Overview"
msgstr "概述"

#: ../../source/behavior/equations/initialization.rst:12
msgid ""
"As we already touched on during our previous discussion on :ref:`steady-"
"state`, behavior is represented by both the equations contained in a model "
"as well as the initial conditions given to the state variables in the model."
"  In Modelica, the initial conditions are computed by combining the normal "
"equations (present in `equation` sections) with any initial equations "
"(present in `initial equation` sections)."
msgstr ""
"正如我们先前在\\ :ref:`steady-state`\\ "
"这节中提到过的，初始化是由一个模型中的两个方程和模型中初始条件给定的状态变量来描述的。\ "
"在Modelica中，初始条件是通过结合普通方程（在 \\ "
"`equation`\\ （方程）区域描述）和初始化方程（在\\ `initial equation`\\ （初始方程）区域中描述）来计算的。\ "

#: ../../source/behavior/equations/initialization.rst:23
msgid ""
"One of the first sources of confusion for new users is understanding how "
"many initial conditions are required.  The answer to this question is "
"simple.  In order to have a well-posed initialization problem (one where we "
"don't have too many or too few initial equations), we need to have the same "
"number of equations in the `initial equation` sections as we have states in "
"our system.  **Note**, we can get away with having too few, because tools "
"can augment the initial equations we provide with additional ones until the "
"problem is well-posed, but we cannot solve a problem where we have too many "
"initial equations."
msgstr ""
"对于初学者来说第一个混淆的来源是理解需要多少初始条件。\ "
"这个问题的答案是简单的。\ "
"为了有一个适定的初始化问题（就是没有过多或者过少的初始方程），需要如之前在系统中提到的在\\"
" `initial equation`\\ (初始方程)中具有相同数量的方程。\ "
"\\ **注意**\\ "
"，应当避免有太少的初始方程，因为工具可以增加我们给定的初始方程的数量直到问题适定，但是如果初始方程太多那问题就不能求解。\ "

#: ../../source/behavior/equations/initialization.rst:33
msgid ""
"Of course, saying the number of initial equations has to be equal to the "
"number of states answers one question, but quickly creates another, *i.e.,* "
"*how do we determine how many states there are*?  For the models we've seen "
"in this chapter, the answer is quite simple.  The states in each of our "
"examples so far are the variables that appear inside the ``der(...)`` "
"operator.  In other words, every variable that we differentiated in those "
"examples is a state."
msgstr ""
"当然，提到初始方程的数量等于状态的数量只回答了一个问题，却很快产生了另一个问题。\ "
"例如，\\ *要如何决定需要多少状态*\\ "
"？对于本章中的模型，这个答案很简单。\ "
"目前为止每个例子中的出现在\\ ``der(...)``\\ "
"操作中的状态都是变量。\ "
"换句话说，例子中不同的变量表示一个状态。\ "

#: ../../source/behavior/equations/initialization.rst:44
msgid "Ordinary Differential Equations"
msgstr "常微分方程"

#: ../../source/behavior/equations/initialization.rst:46
msgid ""
"It is important to note that **it will not always be the case** that every "
"variable that we differentiate will be a state.  In this chapter, all the "
"models we have seen so far are ordinary differential equations (ODEs).  When"
" dealing with ODEs, every differentiated variable is a state, which, in "
"turn, means that you need an initial equation for each of these "
"differentiated variables.  But in subsequent chapters we will eventually run"
" across examples that are so-called differential-algebraic equations (DAEs)."
"  In those cases, only *some* of the differentiated variables can be "
"considered states."
msgstr ""
"需要注意的是，我们进行微分的每个变量\\ **并不总是**\\ 状态。\ "
"这章中，目前看到的所有模型都是常微分方程（ODEs）。\ "
"当处理ODEs时，每个不同的变量都是状态。\ "
"也就是说，每个初始变量需要一个初始方程。\ "
"但是在接下来的章节中我们将会遇到所谓的微分代数方程（DAEs）。\ "
"在这些方程中，仅仅只有\\ **一些**\\ 微分变量可以认为是状态。\ "

#: ../../source/behavior/equations/initialization.rst:56
msgid ""
"As it turns out, understanding initialization doesn't really require us to "
"get into a detailed discussion about DAEs.  In practice, all Modelica tools "
"perform something called \"index reduction\".  While the index reduction "
"algorithms themselves are fairly complicated (so we won't get into those "
"now), the effect is quite simple.  Index reduction transforms the DAEs into "
"ODEs.  In other words, Modelica compilers will transform whatever DAE "
"problem contained in our Modelica code into this relatively easy to explain "
"ODE form."
msgstr ""
"事实上理解初始化不需要详细讨论DAEs。\ "
"实际上，所有的Modelica工具都要执行所谓的指标约简（index "
"reduction）。\ "
"但是指标约简算法本身是相当的复杂（因为现在不讨论），而效果却相当简单。\ "
"指标约简将DAEs转化为ODEs。\ "
"换句话说，Modelica编译器将包含Modelica代码的DAE问题转化为相对简单的ODE形式。\ "

#: ../../source/behavior/equations/initialization.rst:65
msgid ""
"So let's side-step the discussion about DAEs and index reduction and just "
"pick up our discussion of initialization assuming our problem has already "
"been reduced to an ODE.  In this case, the only thing we really need to "
"understand is that initialization is required for all states in the model "
"and that our model will have the following general ODE form:"
msgstr ""
"因此忽略DAEs和指标约简的讨论。\ "
"我们假定问题已经转化为ODE，然后再讨论初始化。\ "
"在这种情况下，只需要理解模型中的每个状态都需要初始化。\ "
"模型将具有如下的ODE形式："

#: ../../source/behavior/equations/initialization.rst:78
msgid ""
"where :math:`t` is the current simulation time, :math:`\\vec{x}(t)` are the "
"values of the states in our system at time :math:`t`, :math:`\\vec{u}(t)` "
"are the values of any external inputs to our system at time :math:`t`."
msgstr ""
"\\ :math:`t`\\ 是当前模拟的时间。\ "
"\\ :math:`\\vec{x}(t)`\\ 是系统时间为\\ :math:`t`\\ 时的状态值。\ "
"\\ :math:`\\vec{u}(t)`\\ 是系统时间为\\ :math:`t`\\ 时的外部输入。\ "

#: ../../source/behavior/equations/initialization.rst:83
msgid ""
"Note that the arrow over a variable simply indicates that it is a vector, "
"not a scalar.  Also note that the only variable that appears differentiated "
"in this problem is :math:`\\vec{x}`.  This is how we know that "
":math:`\\vec{x}` represents the states in the system.  One final thing to "
"note about this system is that neither function, :math:`\\vec{f}` nor "
":math:`\\vec{g}`, depends on :math:`\\vec{y}`."
msgstr ""
"注意，变量上部的箭头仅仅指的是这个变量是个矢量而不是标量。\ "
"这个问题中出现的唯一的变量是\\ :math:`\\vec{x}`\\ 。\ "
"\\ :math:`\\vec{x}`\\ 代表了系统的状态。\ "
"另外需要注意的是两个函数无论是\\ :math:`\\vec{f}`\\ 还是\\ "
":math:`\\vec{g}`\\ 都不依赖于变量\\ :math:`\\vec{y}`\\ 。\ "

#: ../../source/behavior/equations/initialization.rst:90
msgid ""
"If you think about it, both :math:`t` and :math:`\\vec{u}(t)` are external "
"to our system.  We don't compute them or control them.  The reason that we "
"call :math:`\\vec{x}` the state of our system is that it the only "
"information (from within our system) needed to compute "
":math:`\\dot{\\vec{x}}(t)` and :math:`\\vec{y}(t)` (which, in turn, are the "
"only things we need to compute in order to arrive at a solution)."
msgstr ""
"思考后，你会发现\\ :math:`t`\\ 和\\ :math:`\\vec{u}(t)`\\ "
"都是系统外部的量。\ "
"所以，我们没有必要计算或者控制这些量。\ "
"之所以认为\\ :math:`\\vec{x}`\\ 是系统状态，原因在于它是计算\\ "
":math:`\\dot{\\vec{x}}(t)`\\ 和\\ :math:`\\vec{y}(t)`\\ 时所需要（从系统中获取）的唯一信息。\ "

#: ../../source/behavior/equations/initialization.rst:97
msgid ""
"Getting back to the topic of initialization, during a normal time step we "
"will solve for :math:`\\vec{x}(t)` by integrating :math:`\\dot{\\vec{x}}(t)`"
" to compute :math:`\\vec{x}(t)`.  In other words:"
msgstr ""
"回到最初的初始化的主题，在一个正常的时间步内，将\\ :math:`\\dot{\\vec{x}}(t)`\\ 积分来求解 \\ "
":math:`\\vec{x}(t)`\\ 。\ "
"换句话说："

#: ../../source/behavior/equations/initialization.rst:106
msgid ""
"This all works as long as there **was** a previous time step.  When there "
"wasn't a previous time step, then the value of :math:`\\vec{x}` that we plug"
" into our equations has to be the very first value of :math:`\\vec{x}` in "
"our simulation.  In other words, our initial conditions."
msgstr ""
"这只要\\ **有**\\ 前一个时间步就可以进行下去。\ "
"当没有前面的时间步，那么插入方程的\\ :math:`\\vec{x}`\\ "
"的值将成为模拟的第一个\\ :math:`\\vec{x}`\\ 值。\ "
"换句话说，这也就是初始条件。\ "

#: ../../source/behavior/equations/initialization.rst:112
msgid ""
"One might imagine that we would specify our initial conditions by adding an "
"equation like this:"
msgstr "可以想象，通过指定如下方程来指定初始条件:"

#: ../../source/behavior/equations/initialization.rst:119
msgid ""
"where :math:`t_0` is the start time of our simulation and :math:`\\vec{x}_0`"
" is an explicit specification of the initial values. Providing explicit "
"values for states is a very common case when specifying initial conditions."
"  So we definitely need to be able to handle this case.  But this approach "
"won't work for the cases we showed in :ref:`steady-state`.  There we didn't "
"provide explicit initial values for states.  Instead, we provided initial "
"values for :math:`\\dot{\\vec{x}}(t_0)`.  So how can we capture both of "
"these cases?"
msgstr ""
"\\ :math:`t_0`\\ 是模拟的起始时间。\ "
"\\ :math:`\\vec{x}_0`\\ "
"是具体的初始值。\ "
"为状态提供具体的值是指定初始条件最常见的情况。\ "
"因此需要处理这种情况。\ "
"但是这个方法在\\ :ref:`steady-state`\\ "
"中是不起作用的。\ "
"那种情况下我们不需要为状态提供具体的初始值。\ "
"相反，我们要为 :math:`\\dot{\\vec{x}}(t_0)` "
"提供初始值。\ "
"那如何处理这两种情况呢？"

#: ../../source/behavior/equations/initialization.rst:130
msgid "Initial Equations"
msgstr "初始方程"

#: ../../source/behavior/equations/initialization.rst:132
msgid ""
"The answer is to assume that at the start of our simulation we need to solve"
" a problem that looks like this:"
msgstr "答案是假定在模拟开始时点我们需要求解以下问题："

#: ../../source/behavior/equations/initialization.rst:141
msgid ""
"Note the introduction of a new function, :math:`\\vec{h}`.  This new "
"function represents any equations we have placed in `initial equation` "
"sections.  The fact that :math:`\\vec{h}` takes both :math:`\\vec{x}` "
"**and** :math:`\\dot{\\vec{x}}` as arguments allows us to express a wide "
"range of initial conditions.  To define explicit initial values for states, "
"we could define :math:`\\vec{h}` as:"
msgstr ""
"注意到引进了新方程\\ :math:`\\vec{h}`\\ 。\ "
"这个新方程代表了\\ `initial equation`\\ 中的任何方程。\ "
"\\ "
":math:`\\vec{h}`\\ 将\\ :math:`\\vec{x}`\\ \\ **和**\\ \\ "
":math:`\\dot{\\vec{x}}`\\ 作为参数，这允许表达很多可能的初始值。\ "
"为了给状态定义一个明确的值，定义\\ "
":math:`\\vec{h}`\\ 如下："

#: ../../source/behavior/equations/initialization.rst:152
msgid ""
"But we could also express our desire to start with a steady state solution "
"by defining :math:`\\vec{h}` as:"
msgstr "如果希望从稳态解开始仿真，则应该定义\\ :math:`\\vec{h}`\\ 如下："

#: ../../source/behavior/equations/initialization.rst:159
msgid ""
"And, of course, we could mix these different forms or use a wide range of "
"other forms on a per state basis to describe our initial conditions.  So "
"when writing initial equations, all you need to keep in mind is that they "
"need to be of the general form shown above and that you cannot have more of "
"them than you have states in your system."
msgstr ""
"当然，对不同的状态，我们也可以对其各自使用上述不同的形式，乃至很多其他的形式，去描述初始条件。\ "
"因此在写初始方程的时候，需要明白的是方程需要为上面所示的一般通用形式。\ "
"而且你不能使用的方程数不能超过系统中的状态。\ "

#: ../../source/behavior/equations/initialization.rst:166
msgid "Conclusion"
msgstr "结论"

#: ../../source/behavior/equations/initialization.rst:168
msgid ""
"As we've demonstrated in this chapter, the `initial equation` construct in "
"Modelica allows us to express many ways to initialize our system.  In the "
"end, all of them will compute the initial values for the states in our "
"system.  But we are given tremendous latitude in describing exactly how "
"those values will be computed."
msgstr ""
"正如在本章中所演示的一样，Modelica中\\ `initial equation`\\ "
"结构允许应用多种方式去表达系统初始化。\ "
"最终，所有形式都是可以计算系统的初始值。\ "
"但是在描述这些值的计算时，我们有很大的自由度。\ "

#: ../../source/behavior/equations/initialization.rst:174
msgid ""
"This is an area where Modelica excels.  Initialization is given first class "
"treatment in Modelica and this flexibility pays off in many real world "
"applications."
msgstr "这是Modelica所擅长的领域。\ "
"Modelica内初始化拥有第一等的地位。\ "
"而这种灵活性也会为许多真实应用场景提供好处。\ "
