#
msgid ""
msgstr ""
"Project-Id-Version: Modelica by Example v0.3.6\n"
"Report-Msgid-Bugs-To: mail@modelica.co.kr\n"
"POT-Creation-Date: 2023-01-28 22:37+0000\n"
"PO-Revision-Date: 2023-03-12 22:37+0000\n"
"Last-Translator: Baek Youngjin, mail@modelica.co.kr / Ha HyeonSu, <iloveyou934671@gmail.com>\n"
"Language-Team: modelica.co.kr <mail@modelica.co.k>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.6.0\n"


#: ../../source/components/architectures/replaceable.rst:4
msgid "Configuration Management"
msgstr ""
"설정 관리(Configuration Management)"

#: ../../source/components/architectures/replaceable.rst:7
msgid "``replaceable``"
msgstr ""

#: ../../source/components/architectures/replaceable.rst:9
msgid ""
"What really enables the configuration management features in Modelica is "
"the ``replaceable`` keyword.  It is used to identify components in a "
"model whose type can be changed (or \"redeclared\") in the future. One "
"way to think about ``replaceable`` is that it allows the model developer "
"to define \"slots\" in the model that are either \"blank\" to begin with "
"(where an interface model is the original type in the declaration) or at "
"least \"configurable\"."
msgstr ""
"모델리카의 구성 관리 기능을 실제로 활성화하는 것은 ``replaceable`` 키워드입니다. "
"나중에 자료형이 변경(또는 "재선언")될 수 있는 모델의 구성 요소를 식별하는 데 사용합니다. "
"``replaceable`` 에 대해 생각할 수 있는 한 가지 방법은 모델 개발자가 시작하기에 "공백"인 모델의 "슬롯"을 정의하거나(인터페이스 모델이 선언의 원래 자료형인 경우) 적어도 "구성 가능" 하게 만드는 것입니다."

#: ../../source/components/architectures/replaceable.rst:17
msgid ""
"The advantage of using the ``replaceable`` keyword is that it allows new "
"models to be created without having to reconnect anything.  This not only"
" imposes a structural framework on future models (to ensure naming "
"conventions are followed, interfaces are common, *etc.*), it also helps "
"avoid potential errors by eliminating an error prone task from the model "
"development process, *i.e.,* creating connections."
msgstr ""
"``replaceable`` 키워드를 사용하는 이점은 아무것도 다시 연결하지 않고도 새 모델을 만들 수 있다는 것입니다. "
"이는 향후 모델에 구조적 프레임워크를 부과할 뿐만 아니라(명명 규칙 준수, 인터페이스 공동으로 사용 *등* 을 보장하기 위해) 모델 개발 프로세스에서 오류가 발생하기 쉬운 작업을 제거하여 "
"잠재적인 오류를 방지하는 데도 도움이 됩니다. "


#: ../../source/components/architectures/replaceable.rst:25
msgid ""
"To make a component replaceable the only thing that is necessary is to "
"add the ``replaceable`` keyword in front of the declaration, *i.e.,*"
msgstr ""
"구성 요소를 교체 가능하게 만드는 데 필요한 유일한 것은 선언 앞에 ``replaceable`` 키워드를 추가하는 것입니다. "

#: ../../source/components/architectures/replaceable.rst:33
msgid ""
"where ``DeclaredType`` is the initial type for a variable named "
"``variableName``.  In such a declaration, the ``variableName`` variable "
"can be given a new type (we will discuss how very shortly). But any new "
"type used for ``variableName`` must be :ref:`plug-compatible <plug-"
"compatibility>`."
msgstr ""
"여기서 ``DeclaredType`` 은 ``variableName`` 이라는 변수의 초기 자료형입니다. "
"그러한 선언에서 ``variableName`` 변수에 새로운 자료형을 부여할 수 있습니다. "
"그러나 ``variableName`` 에 사용하는 모든 새 자료형은 :ref:`plug-compatible <plug-compatibility>` 이 여야 합니다."


#: ../../source/components/architectures/replaceable.rst:42
msgid "``constrainedby``"
msgstr ""
"구속(``constrainedby``)"

#: ../../source/components/architectures/replaceable.rst:44
msgid ""
"As we just mentioned, by default the new type of any ``replaceable`` "
"component must be plug-compatible with the initial type.  But this "
"doesn't have to be the case.  As our earlier discussion on :ref"
":`constraining-types` pointed out, it is possible to specify both a "
"default type for the variable to have and a separate constraining type "
"that any new type needs to be compatible with."
msgstr ""
"방금 언급했듯이 기본적으로 ``교체 가능한`` 컴포넌트의 새 자료형은 초기 자료형과 플러그 호환되어야 합니다. 그러나 반드시 그럴 필요는 없습니다."
"이전에 다룬 것 처럼 변수가 가질 기본 자료형과 새로운 자료형이 호환되어야 하는 별도의 제약 자료형을 모두 지정할 수 있습니다."



#: ../../source/components/architectures/replaceable.rst:51
msgid ""
"Specifying an alternative constraining type requires the use of the "
"``constrainedby`` keyword.  The syntax for using the ``constrainedby`` "
"keyword is:"
msgstr ""
"대체 제약 자료형을 지정하려면 ``constrainedby`` 키워드를 사용해야 합니다. ``constrainedby`` 키워드를 사용하기 위한 구문은 다음과 같습니다."

#: ../../source/components/architectures/replaceable.rst:61
msgid ""
"where ``variableName`` is again the name of the variable being declared, "
"``DefaultType`` represents the type of ``variableName`` of the type of "
"``variableName`` is never changed and ``ConstrainingType`` indicates the "
"constraining type.  As mentioned previously, any new type attributed to "
"the ``variableName`` variable must be plug-compatible with the "
"constraining type.  But, of course, the ``DefaultType`` must **also** be "
"plug-compatible with the constraining type."
msgstr ""
"여기서 ``variableName`` 은 선언되는 변수의 이름이고, ``DefaultType`` 은 ``variableName`` 자료형의 변수형이고, 변경되지 않는 ``ConstrainingType`` 은 제약 자료형을 나타냅니다. "
"앞에서 언급했듯이 ``variableName`` 변수에 귀속되는 모든 새 자료형은 제약 자료형과 플러그 호환되어야 합니다. "
"그러나 물론 ``DefaultType`` 은 **역시** 제약 자료형과 플러그 호환되어야 합니다."


msgid "``constrainedby`` vs. ``extends``"
msgstr ""

#: ../../source/components/architectures/replaceable.rst:72
msgid ""
"Older versions of Modelica didn't include the ``constrainedby`` keyword."
"  Instead, the ``extends`` keyword was used instead.  But it was felt "
"that inheritance and plug-compatibility were distinct enough that a "
"separate keyword would be less confusing.  So don't be confused if you "
"are looking at Modelica code and the keyword ``extends`` is used where "
"you would expect to see the ``constrainedby`` keyword (*i.e.,* following "
"a ``replaceable`` declaration)."
msgstr ""
"이전 버전의 모델리카에는 ``constrainedby`` 키워드가 포함되지 않았고 ``extends`` 키워드가 사용되었습니다. "
"그러나 상속과 플러그 호환성은 별도의 키워드를 사용하는 것이 뚜렷하게 의미 전달이 되기 때문에 덜 혼란스럽다고 판단해서 만들어진 키워드 입니다. "
"따라서 모델리카 코드를 볼 때 ``constrainedby`` 키워드 (*즉,* ``replaceable`` 선언 다음에 오는) ``extends`` 키워드가 사용된 경우에는 혼란스러워 하지 마십시오."


#: ../../source/components/architectures/replaceable.rst:82
msgid "``redeclare``"
msgstr ""

#: ../../source/components/architectures/replaceable.rst:84
msgid ""
"So now we know that by using the ``replaceable`` keyword, we can change "
"the type of a variable in the future.  Changing the type is called "
"\"redeclaring\" the variable (*i.e.,* to have a different type). For this"
" reason, it is fitting that the keyword used to indicate a redeclaration "
"is ``redeclare``.  Assume that we have the following system model:"
msgstr ""
"``replaceable`` 키워드를 사용하여 자료 형을 변경할 수 있다는 것을 앞서 살펴 보았습니다."
"자료형을 변경하는 방법은 변수를 "재선언"하는 것입니다(*즉,* 다른 자료형을 갖기 위해). "
"이러한 이유로 재선언을 나타내는 키워드는 ``redeclare`` 라고 하는 것을 사용하고 있습니다."
"다음과 같은 시스템 모델이 있다고 가정해보겠습니다."


#: ../../source/components/architectures/replaceable.rst:100
msgid ""
"In this ``System`` model, only the sensor is ``replaceable``.  So the "
"types of each of the other subsystems (*i.e.,* ``plant``, ``controller`` "
"and ``actuator``) cannot be changed."
msgstr ""
"이 ``시스템`` 모델에서는 센서만 ``교체 가능`` 입니다. 따라서 다른 각 하위 시스템(*즉,* ``plant``, ``controller`` 및 ``actuator``)의 자료형은 변경할 수 없습니다."



#: ../../source/components/architectures/replaceable.rst:104
msgid ""
"If we wanted to extend this model, but use a different model for the "
"``sensor`` subsystem, we would use the ``redeclare`` keyword as follows:"
msgstr ""
"이 모델을 확장하고 싶지만 ``sensor`` 하위 시스템에 대해 다른 모델을 사용하려면 다음과 같이 ``redeclare`` 키워드를 사용합니다."

#: ../../source/components/architectures/replaceable.rst:116
msgid ""
"What this tells the Modelica compiler is that in the context of the "
"``SystemVariation`` model, the ``sensor`` subsystem should be an instance"
" of the ``CheapSensor`` model, not the (otherwise default) ``Sensor`` "
"model.  **However**, the ``CheapSensor`` model (or any other type chosen "
"during redeclaration) **must be plug-compatible with that variable's "
"constraining type**."
msgstr ""
"이것이 모델리카 컴파일러에게 알려주는 것은 ``SystemVariation`` 모델의 컨텍스트에서 ``sensor`` 하위 시스템이 ``CheapSensor`` 모델의 인스턴스가 아니라(그렇지 않으면 기본값임) ``센서`` 모델이라는 것을 나타냅니다."
"**그러나** ``CheapSensor`` 모델(또는 재선언 중에 선택한 다른 자료형)은 **해당 변수의 제약 자료형과 플러그 호환되어야 합니다**."


#: ../../source/components/architectures/replaceable.rst:123
msgid ""
"The syntax of a ``redeclare`` statement is really exactly the same as a "
"normal declaration except that it is preceded by the ``redeclare`` "
"keyword.  Obviously, any variable that is redeclared had to be declared "
"in the first place (*i.e.,* you cannot use this syntax to declare a "
"variable, only to *redeclare* it)."
msgstr ""
"``redeclare`` 문의 구문은 ``redeclare`` 키워드가 선행된다는 점을 제외하면 일반 선언과 완전히 동일합니다."
"분명히, 재선언된 모든 변수는 처음부터 선언되어야 합니다(*즉* 이 구문을 사용하여 변수를 선언할 수 없으며 단지 *재선언* 할 수 있습니다)."



#: ../../source/components/architectures/replaceable.rst:129
msgid ""
"It is **very important** to understand that when you redeclare a "
"component, the new redeclaration supersedes the previous one.  For "
"example, after the following redeclaration:"
msgstr ""
"구성 요소를 재선언할 때 새 재선언이 이전 재선언을 대체한다는 점을 이해하는 것이 **매우 중요** 합니다. 예를 들어, 다음 재선언 후:"

#: ../../source/components/architectures/replaceable.rst:137
msgid ""
"the ``sensor`` component **is no longer replaceable**.  This is because "
"the new declaration doesn't include the ``replaceable`` keyword.  As a "
"result, it is as if it was never there.  If we wanted the component to "
"remain replaceable, the redeclaration would need to be:"
msgstr ""
"``센서`` 구성 요소는 **더 이상 교체할 수 없습니다**."
"새 선언에 ``replaceable`` 키워드가 포함되어 있지 않기 때문에, 결과적으로 마치 거기에 없었던 것과 같습니다."
"구성 요소를 교체 가능한 상태로 유지하려면 다음과 같이 재선언해야 합니다."


#: ../../source/components/architectures/replaceable.rst:146
msgid ""
"Furthermore, if we choose to make the redeclared variable replaceable, we"
" also have the option **to redeclare the constraining type**, like this:"
msgstr ""
"또한, 재선언된 변수를 교체 가능하도록 선택하면 다음과 같이 **제약 자료형을 재선언하는** 옵션도 있습니다."

#: ../../source/components/architectures/replaceable.rst:154
msgid ""
"However, the original constraining type still plays a role even in this "
"case because the type ``NewSensorType`` must be plug-compatible with the "
"original constraining type.  In the terminology of programming languages,"
" we can narrow the type (reducing the set of things that are plug-"
"compatible), but we can never widen the type (which would make things "
"that were previously not plug-compatible now plug-compatible)."
msgstr ""
"그러나 ``NewSensorType`` 자료형이 원래 제약 자료형과 플러그 호환되어야 하기 때문에 이 경우에도 원래 제약 자료형이 여전히 역할을 합니다."
"프로그래밍 언어에서  자료형을 좁힐 수 있지만(플러그 호환 가능한 항목 집합을 줄임) 자료형을 확장할 수는 없습니다(이전에는 플러그 호환이 아니었던 항목이 이제 플러그 호환이 됨)."




#: ../../source/components/architectures/replaceable.rst:162
msgid ""
"Earlier, when discussing :ref:`arrays-of-components`, we made the point "
"that it was not possible to redeclare individual elements in arrays. "
"Instead, a redeclaration must be applied to the entire array.  In other "
"words, if we declare something initially as:"
msgstr ""
"이전에 구성 요소의 배열에 대해 논의할 때 배열의 개별 요소를 다시 선언할 수 없다는 점을 지적했습니다. 대신 전체 배열에 재선언을 적용해야 합니다. 즉, 초기에 무언가를 선언하면 다음과 같습니다."

#: ../../source/components/architectures/replaceable.rst:171
msgid "It is then possible to redeclare the array, *e.g.,*"
msgstr ""
"그러면 배열을 다시 선언할 수 있습니다. "

#: ../../source/components/architectures/replaceable.rst:177
msgid ""
"But the important point is that the redeclaration affects every element "
"of the ``sensors`` array.  There is no way to redeclare only one element."
msgstr ""
"그러나 중요한 점은 재선언이 ``sensors`` 배열의 모든 요소에 영향을 미친다는 것입니다. "
"하나의 요소만 다시 선언할 수 있는 방법은 없습니다.`"


#: ../../source/components/architectures/replaceable.rst:182
msgid "Modifications"
msgstr ""
"수정(Modifications)"

#: ../../source/components/architectures/replaceable.rst:186
msgid ""
"One important complexity that comes with replaceability is what happens "
"to modifications in the case of a redeclaration.  To understand the "
"issue, consider the following example."
msgstr ""
"교체 가능성에 의해서 발생하는 중요한 한 가지 복잡성한 경우는 재선언 할 때 발생합니다. "
"문제를 이해하려면 다음 예제를 살펴보아야 합니다. "


#: ../../source/components/architectures/replaceable.rst:195
msgid "Now, what happens if we were to redeclare the ``sensor`` as follows:"
msgstr ""
"이제 다음과 같이 ``sensor`` 를 다시 선언하는 경우를 보겠습니다."

#: ../../source/components/architectures/replaceable.rst:201
msgid ""
"Is the value for ``sample_time`` lost?  We would hope so since the "
"``IdealSensor`` model probably doesn't have a ``parameter`` called "
"``sample_time`` to set."
msgstr ""
"``sample_time`` 값이 손실되었을까요?"
"``IdealSensor`` 모델에는 설정할 ``sample_time`` 이라는 ``파라미터`` 가 없기 때문에 그렇게 되는 것을 의도했을 것 입니다."



#: ../../source/components/architectures/replaceable.rst:205
msgid "But let's consider another case:"
msgstr ""
"그러나 다른 경우를 생각해 보겠습니다."

#: ../../source/components/architectures/replaceable.rst:211
msgid ""
"Now imagine we had another resistor model, ``SensitiveResistor`` that was"
" plug-compatible with ``Resistor`` (*i.e.,* it had a ``parameter`` called"
" ``R``) but included an additional parameter, ``dRdT``, indicating the "
"(linear) sensitivity of the resistance to temperature. We might want to "
"do something like this:"
msgstr ""
"이제 ``Resistor`` 와 플러그 호환이 되는 ``SensitiveResistor`` 라는 또 다른 저항기 모델이 있다고 상상해 보면(즉, ``R`` 이라는 ``parameter`` 가 있음),"
"온도에 대한 저항의 (선형) 민감도를 나타내는 추가 파라미터 ``dRdT`` 를 다음과 같이 하고 싶을 수도 있습니다."


#: ../../source/components/architectures/replaceable.rst:221
msgid ""
"What happens to ``R`` in this case?  In this case, we would actually like"
" to preserve the value of ``R`` so it persists across the redeclaration."
"  Otherwise, we'd need to restate it all the time, *i.e.,*"
msgstr ""
"이 경우  실제로 ``R`` 값을 유지하여 재선언 전체에서 지속되도록 해야 합니다."
"그렇지 않으면 항상 다시 선언해야 합니다."


#: ../../source/components/architectures/replaceable.rst:230
msgid ""
"and this would violate the DRY principle.  The result would be that any "
"change in the original value of ``R`` would be overridden by any "
"redeclarations."
msgstr ""
"이것은 DRY 원칙을 위반하므로 ``R`` 의 원래 값에 대한 모든 변경 사항은 재선언에 의해 무시될 것 입니다."

#: ../../source/components/architectures/replaceable.rst:234
msgid ""
"So, we've seen two cases valid use cases.  In one case, we don't want a "
"modification to persist following a redeclaration and in the other we "
"would like the modification to persist.  Fortunately, Modelica has a way "
"to express both of these.  The normal Modelica semantics take care of the"
" first case.  If we redeclare something, all modifications from the "
"original declaration are erased.  But what about the second case?  In "
"that case, the solution is to **apply the modifications to the "
"constraining type**.  So for our resistor example, our original "
"declaration would need to be:"
msgstr ""
"우리는 앞에서 두 가지 유효한 사용 사례를 살펴 보았습니다. "
"어떤 경우에는 재선언 후에도 수정이 지속되는 것을 원하지 않고 다른 경우에는 수정이 지속되기를 원합니다."
"다행스럽게도 모델리카에는 이 두 가지를 모두 표현할 수 있는 방법이 있습니다."
"일반적인 모델리카 시맨틱은 첫 번째 사례를 처리합니다. "
"무언가를 재선언하면 원래 선언의 모든 수정 사항이 지워집니다. "
"그러나 두 번째 경우는 어떻게 해야할까요?"
"이 경우 해결 방법은 **제약 자료형에 수정 사항을 적용** 하는 것입니다. "
"따라서 저항 예제의 경우와 같이 원래 선언으로 변경하면 다음과 같아야 합니다."


#: ../../source/components/architectures/replaceable.rst:248
msgid ""
"Here we explicitly list both the default type ``Resistor`` and the "
"constraining type ``Resistor(R=100)`` separately because the constraining"
" type now includes a modification.  By moving the modification to the "
"constraining type, **that modification will automatically be applied to "
"both the original declaration and any subsequent redeclarations**.  So in"
" this case, the resistor instance ``R1`` will have an ``R`` value of "
"``100`` even though the modification isn't directly applied after the "
"variable name.  But furthermore, if we perform the redeclaration we "
"discussed previously, *i.e.,*"
msgstr ""
"여기서는 기본 자료형 ``Resistor`` 와 제한 자료형 ``Resistor(R=100)`` 을 별도로 명시적으로 나열하는데, 제한 자료형에 수정 사항이 포함되기 때문입니다."
"수정 사항을 제약 자료형으로 이동하면 **해당 수정 사항이 원래 선언과 후속 재선언 모두에 자동으로 적용됩니다**."
"따라서 이 경우 변수 이름 뒤에 수정이 직접 적용되지 않더라도 레지스터 인스턴스 ``R1`` 은 ``100`` 의 ``R`` 값을 갖게 됩니다."
"그러나 더 나아가 이전에 논의한 재선언을 수행하면 다음과 같습니다."


#: ../../source/components/architectures/replaceable.rst:262
msgid "the ``R=100`` modification will automatically be applied here as well."
msgstr ""
"``R=100`` 수정이 여기에도 자동으로 적용됩니다."

#: ../../source/components/architectures/replaceable.rst:264
msgid ""
"In summary, if you want a modification to apply only to a specific "
"declaration and not in subsequent redeclarations, apply it after the "
"variable name.  If you want it to persist through subsequent "
"redeclarations, apply it to the constraining type."
msgstr ""
"요약하면 수정 사항을 특정 선언에만 적용하고 후속 재선언에는 적용하지 않으려면 변수 이름 뒤에 적용합니다."
"후속 재선언을 통해 유지하려면 제한 자료형에 적용해야 합니다."


#: ../../source/components/architectures/replaceable.rst:272
msgid "Redefinitions"
msgstr ""
"재정의(Redefinitions)"

#: ../../source/components/architectures/replaceable.rst:274
msgid ""
"It turns out that the ``replaceable`` keyword can also be associated with"
" *definitions*, not just declarations.  The main use of this feature is "
"to be able to change the type of **multiple** components at once.  For "
"example, imagine a circuit model with several different resistor "
"components:"
msgstr ""
"``replaceable`` 키워드는 선언뿐만 아니라 *정의* 와도 연관될 수 있음을 보겠습니다. "
"이 기능의 주요 용도는 **여러** 구성 요소의 자료형을 한 번에 변경할 수 있도록 하는 것입니다."
"예를 들어, 여러 저항 구성 요소가 있는 회로 모델을 상상해 보십시오."


#: ../../source/components/architectures/replaceable.rst:294
msgid ""
"Now imagine we wanted one version of this model with ordinary "
"``Resistor`` components and the other where each resistor was an instance"
" of the ``SensitiveResistor`` model.  One way we could achieve this would"
" be to define our ``Circuit`` as follows:"
msgstr ""
"이제 일반적인 ``Resistor`` 구성 요소가 있는 이 모델의 한 버전과 각 저항이 ``SensitiveResistor`` 모델의 인스턴스인 다른 버전을 원한다고 상상해 보겠습니다."
"이를 달성할 수 있는 한 가지 방법은 다음과 같이 ``Circuit`` 을 정의하는 것입니다."


#: ../../source/components/architectures/replaceable.rst:313
msgid ""
"But in that case, our circuit with ``SensitiveResistor`` components would"
" be defined as:"
msgstr ""
"이 경우 ``SensitiveResistor`` 구성 요소가 있는 회로는 다음과 같이 정의합니다."


#: ../../source/components/architectures/replaceable.rst:327
msgid ""
"Note that we don't have to specify resistance values because the "
"modifications that set the resistance were applied to the constraining "
"type in our ``Circuit`` model.  But, it is a bit tedious that we have to "
"change each individual resistor and specify ``dRdT`` over and over again "
"even though they are all the same value.  However, Modelica gives us a "
"way to do them all at once.  The first step is to define a local type "
"within the model like this:"
msgstr ""
"저항을 설정하는 수정 사항이 ``Circuit`` 모델의 구속 자료형에 적용되었기 때문에 저항 값을 지정할 필요가 없음을 집중해서 보아야 합니다."
"하지만 모두 같은 값인데도 각각의 저항을 바꿔서 ``dRdT`` 를 반복해서 지정해야 하는 것이 조금 번거롭습니다."
"그러나 모델리카는 한 번에 모든 작업을 수행할 수 있는 방법을 제공합니다."
"첫 번째 단계는 다음과 같이 모델 내에서 로컬 자료형을 정의하는 것입니다."


#: ../../source/components/architectures/replaceable.rst:350
msgid ""
"What this does is establish ``ResistorModel`` as a kind of alias for "
"``Resistor``.  This by itself doesn't help us with changing the type of "
"each resistor easily.  But making ``ResistorModel`` ``replaceable`` does:"
msgstr ""
"이것이 하는 일은 ``Resistor`` 에 대한 일종의 별칭으로 ``ResistorModel`` 을 설정하는 것입니다."
"이것은 그 자체로는 각 저항기의 자료형을 쉽게 변경하는 데 도움이 되지 않습니다. 그러나 ``ResistorModel`` ``replaceable`` 을 만드는 것은 다음과 같습니다"


#: ../../source/components/architectures/replaceable.rst:370
msgid ""
"If our ``Circuit`` is defined in this way, we can create the "
"``SensitiveCircuit`` model as follows:"
msgstr ""
"``Circuit`` 이 이런 방식으로 정의되면 다음과 같이 ``SensitiveCircuit`` 모델을 생성할 수 있습니다."


#: ../../source/components/architectures/replaceable.rst:381
msgid ""
"All our resistor components are still of type ``ResistorModel``, we "
"didn't have to redeclare any of them.  What we **did do** was redefine "
"what a ``ResistorModel`` is by changing its definition to "
"``SensitiveResistor(dRdT=0.1)``.  Note that the modification ``dRdT=0.1``"
" will be applied to all components of type ``ResistorModel``.  "
"Technically, this isn't a redeclaration of a component's type, it is a "
"redefinition of a type.  But we reuse the ``redeclare`` keyword."
msgstr ""
"모든 저항 구성 요소는 여전히 ``ResistorModel`` 자료형이므로 이들 중 어떤 것도 다시 선언할 필요가 없습니다."
"``ResistorModel`` 의 정의를 ``SensitiveResistor(dRdT=0.1)`` 로 변경하여 재정의 **한 것** 입니다. "
"``dRdT=0.1`` 수정은 ``ResistorModel`` 자료형의 모든 구성 요소에 적용됩니다. 기술적으로 이것은 구성 요소 자료형의 재선언이 아니라 자료형의 재정의입니다. 그러나  ``redeclare`` 키워드를 재사용합니다."



#: ../../source/components/architectures/replaceable.rst:390
msgid ""
"Interestingly, with these redefinitions we still have the notion of a "
"default type and a constraining type.  The general syntax for a "
"redefinable type is:"
msgstr ""
"흥미롭게도 이러한 재정의를 통해 여전히 기본 자료형과 제한 자료형의 개념이 있습니다. 재정의 가능한 자료형의 일반 구문은 다음과 같습니다."

#: ../../source/components/architectures/replaceable.rst:398
msgid ""
"Just as with a replaceable component, any modifications associated with "
"the default type, ``DefaultType``, are only applied in the case that "
"``AliasType`` isn't redefined.  But, any modification associated with the"
" constraining type, ``ConstrainingType``, will persist across "
"redefinitions.  Furthermore, ``AliasType`` must always be plug compatible"
" with the constraining type."
msgstr ""
"교체 가능한 구성 요소와 마찬가지로 기본 자료형인 ``DefaultType`` 과 관련된 모든 수정 사항은 ``AliasType`` 이 재정의되지 않은 경우에만 적용됩니다."
"그러나 제약 자료형인 ``ConstrainingType`` 과 관련된 모든 수정 사항은 재정의 후에도 지속됩니다. 또한 ``AliasType`` 은 항상 제약 자료형과 호환되는 플러그여야 합니다."



#: ../../source/components/architectures/replaceable.rst:405
msgid ""
"Although this aspect of the language is less frequently used, compared to"
" replaceable components, it can save time and help avoid errors in some "
"cases."
msgstr ""
"언어의 이러한 측면은 자주 사용되지는 않지만 교체 가능한 구성 요소에 비해 시간을 절약하고 경우에 따라 오류를 방지하는 데 도움이 될 수 있습니다."


#: ../../source/components/architectures/replaceable.rst:410
msgid "Choices"
msgstr ""
"선택(Choices)"

#: ../../source/components/architectures/replaceable.rst:412
msgid ""
"This section has focused on configuration management and we've learned "
"that the constraining type controls what options are available when doing"
" a ``redeclare``.  If a single model developer creates an architecture "
"and all compatible implementations, then they have a very good sense of "
"what potential configurations will satisfy the constraining types "
"involved."
msgstr ""
"이 섹션은 구성 관리에 중점을 두었으며 제한 자료형이 ``redeclare`` 를 수행할 때 사용 가능한 옵션을 제어한다는 것을 배웠습니다."
"한 명의 모델 개발자가 아키텍처와 호환되는 모든 구현을 생성하는 경우 어떤 잠재적 구성이 관련된 제약 자료형을 만족시킬 것인지에 대해 매우 잘 알고 있습니다."


#: ../../source/components/architectures/replaceable.rst:419
msgid ""
"But what if you are using an architecture developed by someone else? How "
"can you determine what possibilities exist?  Fortunately, the Modelica "
"specification includes a few standard annotations that help address this "
"issue."
msgstr ""
"하지만 다른 사람이 개발한 아키텍처를 사용하고 있다면 어떨까요? 어떤 가능성이 있는지 어떻게 판단할 수 있을까요?"
"다행스럽게도 모델리카 사양(specification)에서는 이 문제를 해결하는 데 도움이 되는 몇 가지 표준 주석이 포함되어 있습니다."


#: ../../source/components/architectures/replaceable.rst:425
msgid "``choices``"
msgstr ""

#: ../../source/components/architectures/replaceable.rst:427
msgid ""
"The ``choices`` annotation allows the original model developer to "
"associate a list of modifications with a given declaration.  The very "
"simplest use case for this could be to specify values for a given "
"parameter:"
msgstr ""
"``choices`` 주석을 사용하면 원래 모델 개발자가 수정 목록을 주어진 선언과 연결할 수 있습니다. 이에 대한 가장 간단한 사용 사례는 주어진 파라미터에 대한 값을 지정하는 것입니다."

#: ../../source/components/architectures/replaceable.rst:438
msgid ""
"In this case, the model developer has listed several possible values that"
" the user might want to give to the ``rho`` parameter.  Each choice is a "
"modification to be applied to the ``rho`` variable.  This information is "
"commonly used by graphical Modelica tools to provide users with "
"intelligent choices."
msgstr ""
"이 경우 모델 개발자는 사용자가 ``rho`` 파라미터에 제공할 수 있는 몇 가지 가능한 값을 나열했으며, 각 선택은 ``rho`` 변수에 적용할 수정사항입니다. "
"이 정보는 일반적으로 그래픽 모델리카 시뮬레이션 소프트웨어에서 사용자가 편리하게 선택할 수 있도록 합니다."



#: ../../source/components/architectures/replaceable.rst:444
msgid ""
"This feature can just as easily be used in the context of configuration "
"management.  Consider the following example:"
msgstr ""
"이 기능은 구성 관리 컨텍스트에서도 쉽게 사용할 수 있습니다. 다음 예를 살펴보겠습니다."

#: ../../source/components/architectures/replaceable.rst:457
msgid ""
"Again, the model developer is embedding a set of possible modifications "
"along with the declaration.  These ``choice`` values can also be used by "
"graphical tools to provide a reasonable set of choices when configuring a"
" system."
msgstr ""
"다시 말하지만, 모델 개발자는 선언과 함께 가능한 수정 세트를 포함시킬 수 있습니다."
"이러한 ``choice`` 값은 시스템을 구성할 때 합리적인 선택 세트를 제공하기 위해 그래픽 시뮬레이션 소프트웨어에서 사용할 수도 있습니다."


#: ../../source/components/architectures/replaceable.rst:463
msgid "``choicesAllMatching``"
msgstr ""

#: ../../source/components/architectures/replaceable.rst:465
msgid ""
"But one problem here is that it is not only tedious to have to explicitly"
" list all of these choices, but the set of possibilities might change.  "
"After all, other developers (besides the original model developer) might "
"come along and create implementations that satisfy a given constraining "
"type.  How about giving users the option of seeing **all** legal options "
"when configuring their system?"
msgstr ""
"그러나 여기서 한 가지 문제가 있는데 모든 선택 항목을 명시적으로 나열해야 하는 것이 지루한 과정이고, 가능성 집합이 변경될 수 있습니다."
"결국 다른 개발자(원래 모델 개발자 외)가 함께 와서 주어진 제약 자료형을 만족하는 구현을 만들 어야 할 경우가 있습니다."
"시스템을 구성할 때 **모든** 규칙을 만족하는 옵션을 볼 수 있는 기능을 사용자에게 제공하는 것 모델리카에서는 가능합니다. "


#: ../../source/components/architectures/replaceable.rst:472
msgid ""
"Fortunately, Modelica includes just such an annotation.  It is the "
"``choicesAllMatching`` annotation.  By setting the value of this "
"annotation to ``true`` on a given declaration (or ``replaceable`` "
"definition), this instructs the tool to find all possible legal options "
"and present them through the user interface.  For example,"
msgstr ""
"모델리카에는 이러한 기능을 ``choicesAllMatching`` 주석이 하고 있습니다. "
"주어진 선언(또는 ``replaceable`` 정의)에서 이 주석의 값을 ``true`` 로 설정하면 가능한 모든 규칙을 만족하는 옵션을 찾아 사용자 인터페이스를 통해 제시하도록 시뮬레이션 소프트웨어가 지원합니다."
"예를 들어 아래와 같습니다."


#: ../../source/components/architectures/replaceable.rst:483
msgid ""
"By adding this annotation, the tool knows to find all legal "
"redeclarations when a user is reconfiguring their models through the "
"graphical user interface.  This can increase the usability of "
"architecture based models **enormously** because it presents users with "
"the full range of options at their disposal with trivial effort on the "
"part of the model developer."
msgstr ""
"이 주석을 추가하면 시뮬레이션 소프트웨어는 사용자가 그래픽 사용자 인터페이스를 통해 모델을 재구성할 때 모든 규칙으로 재선언할 수 있는 것을 찾습니다."
"이는 모델 개발자의 사소한 노력으로 사용자가 마음대로 사용할 수 있는 모든 옵션을 제공하기 때문에 아키텍처 기반 모델의 유용성을 **엄청나게** 증가시킬 수 있습니다."


#: ../../source/components/architectures/replaceable.rst:491
msgid "Conclusion"
msgstr ""
"결론(Conclusion)"


#: ../../source/components/architectures/replaceable.rst:493
msgid ""
"In this section, we've discussed the configuration management features in"
" Modelica.  As with other aspects of the Modelica language, the goals "
"here are the same: promote reuse, increase productivity and ensure "
"correctness.  Modelica includes many powerful options for redeclaring "
"components and redefining types.  By combining this with the "
"``choicesAllMatching`` annotation, models can be built to support a large"
" combination of possible configurations using clearly defined choice "
"points."
msgstr ""
"이 섹션에서는 모델리카의 구성 관리 기능에 대해 설명했습니다."
"모델리카 언어의 다른 측면과 마찬가지로 여기서 목표는 동일합니다."
"재사용 촉진, 생산성 향상 및 정확성 보장입니다. 모델리카에는 구성 요소를 재선언하고 자료형을 재정의하기 위한 많은 강력한 옵션이 포함되어 있습니다."
"이를 ``choicesAllMatching`` 주석과 결합하면 명확하게 정의된 선택 지점을 사용하여 가능한 구성의 대규모 조합을 지원하도록 모델을 구축할 수 있습니다."


#~ msgid ""
#~ "Is the value for ``sample_rate`` lost?"
#~ "  We would hope so since the "
#~ "``IdealSensor`` model probably doesn't have"
#~ " a ``parameter`` called ``sample_rate`` to"
#~ " set."
#~ msgstr ""

#~ msgid "modifications"
#~ msgstr ""

#~ msgid "in the context of redeclarations"
#~ msgstr ""

