Modelica 3.2.2 with alias name: Version 1 | Modelica 3 2 1 Build 4 with alias name: Version 2 | Version: 3.2.2 | Version: 3.2.1 |
Version date: 2016-03-06 | Version date: 2015-09-30 |
Component |
Version 1 |
Version 2 |
pi | Present |
Equations in Version 1 | Equations in Version 2 |
... |
|
equation if initType == InitPID.InitialOutput and (y_start < yMin or y_start > yMax) then |
equation assert(yMax >= yMin, "LimPID: Limits must be consistent. However, yMax (=" + String(yMax) + ") < yMin (=" + String(yMin) + ")"); |
if initType == InitPID.InitialOutput and (y_start < yMin or y_start > yMax) then |
|
Modelica.Utilities.Streams.error("LimPID: Start value y_start (=" + String(y_start) +            ") is outside of the limits of yMin (=" + String(yMin) +") and yMax (=" + String(yMax) + ")"); |
|
end if; | |
assert(limitsAtInit or not limitsAtInit and y >= yMin and y <= yMax,          "LimPID: During initialization the limits have been switched off.\n" +          "After initialization, the output y (=" + String(y) +          ") is outside of the limits of yMin (=" + String(yMin) +") and yMax (=" + String(yMax) + ")"); |
|
connect(u_s, addP.u1); ... |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
x1 | start=0 | |
fixed=true | | |
xext | each start=0 | |
each fixed=true | |
Component |
Version 1 |
Version 2 |
firstTrigger | start=false | |
fixed=true | |
Equations in Version 1 | Equations in Version 2 |
... |
|
equation assert(uHigh > uLow,"Hysteresis limits wrong (uHigh <= uLow)"); |
equation y = u > uHigh or pre(y) and u >= uLow; |
y = not pre(y) and u > uHigh or pre(y) and u >= uLow; |
Equations in Version 1 | Equations in Version 2 |
assert(uMax >= uMin, "Limiter: Limits must be consistent. However, uMax (=" + String(uMax) +                        ") < uMin (=" + String(uMin) + ")"); |
|
if strict then | if initial() and not limitsAtInit then |
y = homotopy(actual = smooth(0, noEvent(if u > uMax then uMax else if u < uMin then uMin else u)), simplified=u); | y = u; |
assert(u >= uMin - 0.01*abs(uMin) and               u <= uMax + 0.01*abs(uMax),              "Limiter: During initialization the limits have been ignored.\n"+              "However, the result is that the input u is not within the required limits:\n"+              " u = " + String(u) + ", uMin = " + String(uMin) + ", uMax = " + String(uMax)); elseif strict then y = smooth(0, noEvent(if u > uMax then uMax else if u < uMin then uMin else u)); |
|
else | |
y = homotopy(actual = smooth(0,if u > uMax then uMax else if u < uMin then uMin else u), simplified=u); | y = smooth(0,if u > uMax then uMax else if u < uMin then uMin else u); |
end if; |
Component |
Version 1 |
Version 2 |
uMax | Present | |
uMin | Present |
Equations in Version 1 | Equations in Version 2 |
assert(limit1 >= limit2, "Input signals are not consistent: limit1 < limit2"); |
|
if strict then | |
y = homotopy(actual = smooth(0, noEvent(if u > limit1 then limit1 else if u < limit2 then limit2 else u)), simplified=u); | uMax = noEvent(max(limit1, limit2)); |
uMin = noEvent(min(limit1, limit2)); |
|
else | |
y = homotopy(actual = smooth(0,if u > limit1 then limit1 else if u < limit2 then limit2 else u), simplified=u); | uMax = max(limit1, limit2); |
uMin = min(limit1, limit2); |
|
end if; | |
if initial() and not limitsAtInit then y = u; assert(u >= uMin - 0.01*abs(uMin) and               u <= uMax + 0.01*abs(uMax),              "VariableLimiter: During initialization the limits have been ignored.\n"+              "However, the result is that the input u is not within the required limits:\n"+              " u = " + String(u) + ", uMin = " + String(uMin) + ", uMax = " + String(uMax)); elseif strict then y = smooth(0, noEvent(if u > uMax then uMax else if u < uMin then uMin else u)); else y = smooth(0,if u > uMax then uMax else if u < uMin then uMin else u); end if; |
Component |
Version 1 |
Version 2 |
val | Present |
Equations in Version 1 | Equations in Version 2 |
... equation   if strict then |
|
der(y) = smooth(1,noEvent(if val<Falling then Falling else if val>Rising then Rising else val)); | der(y) = smooth(1, noEvent(min(max((u - y)/Td, Falling), Rising))); |
else | |
der(y) = if val<Falling then Falling else if val>Rising then Rising else val; | der(y) = smooth(1, min(max((u - y)/Td, Falling), Rising)); |
end if; |
Equations in Version 1 | Equations in Version 2 |
assert(uMax >= uMin, "DeadZone: Limits must be consistent. However, uMax (=" + String(uMax) +                        ") < uMin (=" + String(uMin) + ")"); |
|
y = homotopy(actual=smooth(0,if u > uMax then u - uMax else if u < uMin then u - uMin else 0), simplified=u); | if initial() and not deadZoneAtInit then |
y = u; else y = smooth(0,if u > uMax then u - uMax else if u < uMin then u - uMin else 0); end if; |
Component |
Version 1 |
Version 2 |
balance | Present | |
a1 | Present | |
b11 | Present | |
c | Present | |
d | Present | |
s | Present | |
x1dot | Present | |
xn | Present | |
a | Present | |
b | Present |
Equations in Version 1 | Equations in Version 2 |
der(x[1]) = a1*x + b11*u; | (b,a) = padeCoefficients(delayTime, n, m); |
if n > 1 then | [der(x); xn] = [x1dot; x]; |
der(x[2:n]) = s.*x[1:n-1]; | [u] = transpose([a])*[x1dot; x]; |
end if; | [y] = transpose([zeros(n - m, 1); b])*[x1dot; x]; |
y = c*x + d*u; |
|
initial equation |
|
(a1,b11,c,d,s) = padeCoefficients2(delayTime, n, m, balance); | x[n] = u; |
if balance then | |
der(x) = zeros(n); else x[n] = u; end if; |
Component |
Version 1 |
Version 2 |
u | Present | |
y | Present | |
Component |
Version 1 |
Version 2 |
u | Present | |
y | Present | |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
timeScale | Present | |
nextEventScaled | Present | |
timeScaled | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
timeScaled := time/timeScale; |
|
when {time >= pre(nextEvent),initial()} then | |
(a,b,nextEventScaled,last) = getInterpolationCoefficients( table, offset, startTime/timeScale, timeScaled, last, 100*Modelica.Constants.eps); |
(a,b,nextEvent,last) = getInterpolationCoefficients( table, offset, startTime, time, last, 100*Modelica_3_2_1_Build_4.Constants.eps); |
nextEvent = nextEventScaled*timeScale; |
|
end when; | |
equation y = a*timeScaled + b; |
equation y = a*time + b; |
Component |
Version 1 |
Version 2 |
tableID | =Modelica.Blocks.Types.ExternalCombiTimeTable(if tableOnFile then tableName else "NoName", if tableOnFile and fileName <> "NoName" and not Modelica.Utilities.Strings.isEmpty(fileName) then fileName else "NoName", table, startTime/timeScale, columns, smoothness, extrapolation) | =Modelica_3_2_1_Build_4.Blocks.Types.ExternalCombiTimeTable(if tableOnFile then tableName else "NoName", if tableOnFile and fileName <> "NoName" and not Modelica_3_2_1_Build_4.Utilities.Strings.isEmpty(fileName) then fileName else "NoName", table, startTime, columns, smoothness, extrapolation) |
timeScale | Present | |
t_minScaled | Present | |
t_maxScaled | Present | |
nextTimeEventScaled | Present | |
DBL_MAX | Present | |
timeScaled | Present |
Equations in Version 1 | Equations in Version 2 |
... end if; |
|
t_minScaled = getTableTimeTmin(tableID, tableOnFileRead); | t_min = getTableTimeTmin(tableID, tableOnFileRead); |
t_maxScaled = getTableTimeTmax(tableID, tableOnFileRead); | t_max = getTableTimeTmax(tableID, tableOnFileRead); |
t_min = t_minScaled*timeScale; t_max = t_maxScaled*timeScale; |
|
... end if; |
|
timeScaled = time/timeScale; |
|
when {time >= pre(nextTimeEvent),initial()} then | |
nextTimeEventScaled = getNextTimeEvent(tableID, timeScaled, tableOnFileRead); | nextTimeEvent = getNextTimeEvent(tableID, time, tableOnFileRead); |
if (nextTimeEventScaled < DBL_MAX) then nextTimeEvent = nextTimeEventScaled*timeScale; else nextTimeEvent = DBL_MAX; end if; |
|
end when; ... for i in 1:nout loop |
|
y[i] = p_offset[i] + getTableValueNoDer(tableID, i, timeScaled, nextTimeEventScaled, pre(nextTimeEventScaled), tableOnFileRead); | y[i] = p_offset[i] + getTableValueNoDer(tableID, i, time, nextTimeEvent, pre(nextTimeEvent), tableOnFileRead); |
end for; ... for i in 1:nout loop |
|
y[i] = p_offset[i] + getTableValue(tableID, i, timeScaled, nextTimeEventScaled, pre(nextTimeEventScaled), tableOnFileRead); | y[i] = p_offset[i] + getTableValue(tableID, i, time, nextTimeEvent, pre(nextTimeEvent), tableOnFileRead); |
end for; ... |
Component |
Version 1 |
Version 2 |
useConjugateInput | Present | |
uInternal | Present |
Component |
Version 1 |
Version 2 |
useConjugateInput1 | Present | |
useConjugateInput2 | Present | |
u1Internal | Present | |
u2Internal | Present |
Component |
Version 1 |
Version 2 |
useConjugateInput | Present | |
uInternal | Present |
Component |
Version 1 |
Version 2 |
useConjugateInput | Present | |
uInternal | Present |
Component |
Version 1 |
Version 2 |
useConjugateInput | Present | |
uInternal | Present |
Component |
Version 1 |
Version 2 |
useConjugateInput | Present | |
uInternal | Present |
Component |
Version 1 |
Version 2 |
useConjugateInput1 | Present | |
useConjugateInput2 | Present | |
u1Internal | Present | |
u2Internal | Present |
Component |
Version 1 |
Version 2 |
useConjugateInput | Present |
Equations in Version 1 | Equations in Version 2 |
y = k*(if useConjugateInput then Modelica.ComplexMath.conj(u) else u); | y = k*u; |
Equations in Version 1 | Equations in Version 2 |
y = k*uInternal; | y = k*u; |
Component |
Version 1 |
Version 2 |
useConjugateInput1 | Present | |
useConjugateInput2 | Present |
Equations in Version 1 | Equations in Version 2 |
y = (if useConjugateInput1 then Modelica.ComplexMath.conj(u1) else u1) - (if useConjugateInput1 then Modelica.ComplexMath.conj(u2) else u2); |
y = u1 - u2; |
Equations in Version 1 | Equations in Version 2 |
y = k1*u1Internal + k2*u2Internal; | y = k1*u1 + k2*u2; |
Component |
Version 1 |
Version 2 |
useConjugateInput1 | Present | |
useConjugateInput2 | Present | |
useConjugateInput3 | Present |
Equations in Version 1 | Equations in Version 2 |
y = k1*(if useConjugateInput1 then Modelica.ComplexMath.conj(u1) else u1) + k2*(if useConjugateInput2 then Modelica.ComplexMath.conj(u2) else u2) + k3*(if useConjugateInput3 then Modelica.ComplexMath.conj(u3) else u3); |
y = k1*u1 + k2*u2 + k3*u3; |
Equations in Version 1 | Equations in Version 2 |
y = u1Internal*u2Internal; | y = u1*u2; |
Component |
Version 1 |
Version 2 |
useConjugateInput1 | Present | |
useConjugateInput2 | Present |
Equations in Version 1 | Equations in Version 2 |
y = (if useConjugateInput1 then Modelica.ComplexMath.conj(u1) else u1)/( if useConjugateInput2 then Modelica.ComplexMath.conj(u2) else u2); |
y = u1/u2; |
Equations in Version 1 | Equations in Version 2 |
y = Modelica.ComplexMath.'sqrt'(uInternal); | y = Modelica_3_2_1_Build_4.ComplexMath.'sqrt'(u); |
Equations in Version 1 | Equations in Version 2 |
y = Modelica.ComplexMath.sin(uInternal); | y = Modelica_3_2_1_Build_4.ComplexMath.sin(u); |
Equations in Version 1 | Equations in Version 2 |
y = Modelica.ComplexMath.cos(uInternal); | y = Modelica_3_2_1_Build_4.ComplexMath.cos(u); |
Equations in Version 1 | Equations in Version 2 |
y = Modelica.ComplexMath.tan(uInternal); | y = Modelica_3_2_1_Build_4.ComplexMath.tan(u); |
Equations in Version 1 | Equations in Version 2 |
y = Modelica.ComplexMath.asin(uInternal); | y = Modelica_3_2_1_Build_4.ComplexMath.asin(u); |
Equations in Version 1 | Equations in Version 2 |
y = Modelica.ComplexMath.acos(uInternal); | y = Modelica_3_2_1_Build_4.ComplexMath.acos(u); |
Equations in Version 1 | Equations in Version 2 |
y = Modelica.ComplexMath.atan(uInternal); | y = Modelica_3_2_1_Build_4.ComplexMath.atan(u); |
Equations in Version 1 | Equations in Version 2 |
y = Modelica.ComplexMath.sinh(uInternal); | y = Modelica_3_2_1_Build_4.ComplexMath.sinh(u); |
Equations in Version 1 | Equations in Version 2 |
y = Modelica.ComplexMath.cosh(uInternal); | y = Modelica_3_2_1_Build_4.ComplexMath.cosh(u); |
Equations in Version 1 | Equations in Version 2 |
y = Modelica.ComplexMath.tanh(uInternal); | y = Modelica_3_2_1_Build_4.ComplexMath.tanh(u); |
Equations in Version 1 | Equations in Version 2 |
y = Modelica.ComplexMath.exp(uInternal); | y = Modelica_3_2_1_Build_4.ComplexMath.exp(u); |
Equations in Version 1 | Equations in Version 2 |
y = Modelica.ComplexMath.log(uInternal); | y = Modelica_3_2_1_Build_4.ComplexMath.log(u); |
Component |
Version 1 |
Version 2 |
useConjugateInput | Present |
Equations in Version 1 | Equations in Version 2 |
re = u.re; | |
im = (if useConjugateInput then -u.im else u.im); | im=u.im; |
Component |
Version 1 |
Version 2 |
useConjugateInput | Present |
Equations in Version 1 | Equations in Version 2 |
len = (u.re^2 + u.im^2)^0.5; | |
phi = (if useConjugateInput then Modelica.Math.atan2(-u.im, u.re) else Modelica.Math.atan2(u.im, u.re)); |
phi = Modelica_3_2_1_Build_4.Math.atan2(u.im, u.re); |
Equations in Version 1 | Equations in Version 2 |
... connect(C1.n,G.p); |
|
connect(R1.n,C2. p); |
|
connect(L1.p,C2.p); ... connect(C2.n,C4.p); |
|
connect(L1.n,C3. p); connect(L1.n,C4. p); connect(L2.p,C4. p); |
|
connect(C2.n,L2.p); | |
connect(C3.p,L2. p); |
|
connect(L2.n,C4.n); | |
connect(L2.n,C5. p); connect(L2.n,R2. p); connect(R2.n,G. p); |
|
connect(C4.n,C5.p); | |
connect(C4.n,R2.p); | |
connect(C3.n,G. p); connect(C5.n,G. p); |
|
connect(C1.n,C3.n); | |
connect(C1.n,C5.n); | |
connect(R2.n,C5. n); connect(R2.n,C3. n); |
|
connect(R2.n,C1.n); | |
connect(C5.p,R2. p); |
|
connect(R1.p,V.p); ... |
Component |
Version 1 |
Version 2 |
SaturatingInductance1 | i(fixed=true) | |
| i(start=0) | |
Inductance1 | i(fixed=true) | |
| i(start=0, fixed=true) |
Component |
Version 1 |
Version 2 |
switch2 | off(fixed=true) | |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
inductor1 | i(fixed=true, start=0) | |
inductor2 | i(fixed=true, start=0) | |
switch2 | off(fixed=true) | |
Equations in Version 1 | Equations in Version 2 |
connect(inductor1.n,resistor1. p); | initial equation |
inductor1.i = 0; inductor2.i = 0; equation   connect(inductor1.n,resistor1. p); |
|
connect(resistor1.n,ground1. p); ... |
Component |
Version 1 |
Version 2 |
Psi | | start=0 |
| fixed=true |
Equations in Version 1 | Equations in Version 2 |
... for s in 1:N loop |
|
Lm[s,s] = L[(s - 1)*N - div((s - 1)*s, 2) + s]; | for z in 1:N loop |
for z in s + 1:N loop | Lm[z,s]= if (z>=s) then L[(s-1)*N+z-div((s-1)*s,2)] else Lm[s,z]; |
Lm[s,z] = L[(s - 1)*N - div((s - 1)*s, 2) + z]; Lm[z,s] = L[(s - 1)*N - div((s - 1)*s, 2) + z]; |
|
end for; ... |
Component |
Version 1 |
Version 2 |
Ron | Present | |
Goff | Present | |
Vknee | Present | |
off | Present | |
s | Present | |
unitVoltage | Present | |
unitCurrent | Present |
Equations in Version 1 | Equations in Version 2 |
off = s < 0; | |
v = (s*unitCurrent)*(if off then 1 else Ron) + Vknee; i = (s*unitVoltage)*(if off then Goff else 1) + Goff*Vknee; LossPower = v*i; |
Component |
Version 1 |
Version 2 |
Ron | Present | |
Goff | Present | |
Vknee | Present | |
off | Present | |
s | Present | |
unitVoltage | Present | |
unitCurrent | Present |
Equations in Version 1 | Equations in Version 2 |
off = s < 0 or pre(off) and not fire; | |
v = (s*unitCurrent)*(if off then 1 else Ron) + Vknee; i = (s*unitVoltage)*(if off then Goff else 1) + Goff*Vknee; LossPower = v*i; |
Component |
Version 1 |
Version 2 |
Ron | Present | |
Goff | Present | |
Vknee | Present | |
off | Present | |
s | Present | |
unitVoltage | Present | |
unitCurrent | Present |
Equations in Version 1 | Equations in Version 2 |
off = s < 0 or not fire; | |
v = (s*unitCurrent)*(if off then 1 else Ron) + Vknee; i = (s*unitVoltage)*(if off then Goff else 1) + Goff*Vknee; LossPower = v*i; |
Component |
Version 1 |
Version 2 |
Ron | Present | |
Goff | Present | |
s | Present | |
unitVoltage | Present | |
unitCurrent | Present |
Equations in Version 1 | Equations in Version 2 |
off = control; | v = (s*unitCurrent)*(if control then 1 else Ron); |
i = (s*unitVoltage)*(if control then Goff else 1); LossPower = v*i; |
Component |
Version 1 |
Version 2 |
Ron | Present | |
Goff | Present | |
s | Present | |
unitVoltage | Present | |
unitCurrent | Present |
Equations in Version 1 | Equations in Version 2 |
off = not control; | v = (s*unitCurrent)*(if control then Ron else 1); |
i = (s*unitVoltage)*(if control then 1 else Goff); LossPower = v*i; |
Component |
Version 1 |
Version 2 |
Ron | Present | |
Goff | Present | |
p | Present | |
n | Present | |
s | Present | |
unitVoltage | Present | |
unitCurrent | Present |
Equations in Version 1 | Equations in Version 2 |
off = control.v > level; |
|
control.i = 0; | |
0 = p.i + n.i; p.v - n.v = (s*unitCurrent)*(if (control.v > level) then 1 else Ron); p.i = (s*unitVoltage)*(if (control.v > level) then Goff else 1); LossPower = (p.v - n.v)*p.i; |
Component |
Version 1 |
Version 2 |
Ron | Present | |
Goff | Present | |
p | Present | |
n | Present | |
s | Present | |
unitVoltage | Present | |
unitCurrent | Present |
Equations in Version 1 | Equations in Version 2 |
off = control.v < level; |
|
control.i = 0; | |
0 = p.i + n.i; p.v - n.v = (s*unitCurrent)*(if (control.v > level) then Ron else 1); p.i = (s*unitVoltage)*(if (control.v > level) then 1 else Goff); LossPower = (p.v - n.v)*p.i; |
Component |
Version 1 |
Version 2 |
Ron | Present | |
Goff | Present | |
V0 | Present | |
dVdt | Present | |
Vmax | Present | |
off | Present | |
on | Present | |
tSwitch | Present | |
quenched | Present |
Equations in Version 1 | Equations in Version 2 |
off = control; | when edge(off) then |
tSwitch = time; end when; quenched = off and (abs(i) <= abs(v)*Goff or pre(quenched)); if on then v = Ron*i; else if quenched then i = Goff*v; else v = min(Vmax, V0 + dVdt*(time - tSwitch))*sign(i); end if; end if; LossPower = v*i; |
Component |
Version 1 |
Version 2 |
Ron | Present | |
Goff | Present | |
V0 | Present | |
dVdt | Present | |
Vmax | Present | |
on | Present | |
off | Present | |
tSwitch | Present | |
quenched | Present |
Equations in Version 1 | Equations in Version 2 |
off = not control; | off = not on; |
when edge(off) then tSwitch = time; end when; quenched = off and (abs(i) <= abs(v)*Goff or pre(quenched)); if on then v = Ron*i; else if quenched then i = Goff*v; else v = min(Vmax, V0 + dVdt*(time - tSwitch))*sign(i); end if; end if; LossPower = v*i; |
Component |
Version 1 |
Version 2 |
Ron | Present | |
Goff | Present | |
V0 | Present | |
dVdt | Present | |
Vmax | Present | |
p | Present | |
n | Present | |
i | Present | |
v | Present | |
unitVoltage | Present | |
unitCurrent | Present | |
off | Present | |
on | Present | |
tSwitch | Present | |
quenched | Present |
Equations in Version 1 | Equations in Version 2 |
off = control.v > level; |
|
control.i = 0; | |
0 = p.i + n.i; i = p.i; p.v - n.v = v; when edge(off) then tSwitch = time; end when; quenched = off and (abs(i) <= abs(v)*Goff or pre(quenched)); if on then v = Ron*i; else if quenched then i = Goff*v; else v = min(Vmax, V0 + dVdt*(time - tSwitch))*sign(i); end if; end if; LossPower = v*i; |
Component |
Version 1 |
Version 2 |
Ron | Present | |
Goff | Present | |
V0 | Present | |
dVdt | Present | |
Vmax | Present | |
p | Present | |
n | Present | |
i | Present | |
v | Present | |
unitVoltage | Present | |
unitCurrent | Present | |
off | Present | |
on | Present | |
tSwitch | Present | |
quenched | Present |
Equations in Version 1 | Equations in Version 2 |
off = control.v < level; | off = (control.v < level); |
control.i = 0; | |
0 = p.i + n.i; i = p.i; p.v - n.v = v; when edge(off) then tSwitch = time; end when; quenched = off and (abs(i) <= abs(v)*Goff or pre(quenched)); if on then v = Ron*i; else if quenched then i = Goff*v; else v = min(Vmax, V0 + dVdt*(time - tSwitch))*sign(i); end if; end if; LossPower = v*i; |
Component |
Version 1 |
Version 2 |
q | SIunits.ElectricCharge | Real |
constant | | |
k | Present |
Component |
Version 1 |
Version 2 |
q | SIunits.ElectricCharge | Real |
constant | parameter | |
protected | | |
K | Present |
Equations in Version 1 | Equations in Version 2 |
... bf_t = Bf*pow((T_heatPort/Tnom), XTB); |
|
vt_t = (k/q)*T_heatPort; | vt_t = (K/q)*T_heatPort; |
ibc = smooth(1,(if (vbc/(NR*vt_t) < EMin) then is_t*(ExMin*(vbc/(NR*vt_t) -     EMin + 1) - 1) + vbc*Gbc else if (vbc/(NR*vt_t) > EMax) then is_t*(     ExMax*(vbc/(NR*vt_t) - EMax + 1) - 1) + vbc*Gbc else is_t*(exp(vbc/     (NR*vt_t)) - 1) + vbc*Gbc)); ... |
Component |
Version 1 |
Version 2 |
q | SIunits.ElectricCharge | Real |
constant | parameter | |
protected | | |
K | Present |
Equations in Version 1 | Equations in Version 2 |
... bf_t = Bf*pow((T_heatPort/Tnom), XTB); |
|
vt_t = (k/q)*T_heatPort; | vt_t = (K/q)*T_heatPort; |
icb = smooth(1,(if (vcb/(NR*vt_t) < EMin) then is_t*(ExMin*(vcb/(NR*vt_t) -     EMin + 1) - 1) + vcb*Gbc else if (vcb/(NR*vt_t) > EMax) then is_t*(     ExMax*(vcb/(NR*vt_t) - EMax + 1) - 1) + vcb*Gbc else is_t*(exp(vcb/     (NR*vt_t)) - 1) + vcb*Gbc)); ... |
Component |
Version 1 |
Version 2 |
UX01Conv | Present |
Component |
Version 1 |
Version 2 |
ResetMap | sizes= -1 | sizes= 9 |
Component |
Version 1 |
Version 2 |
ResetMap | sizes= -1 | sizes= 9 |
Component |
Version 1 |
Version 2 |
ResetSetMap | sizes=, -1-1 | sizes=, 99 |
Component |
Version 1 |
Version 2 |
ResetSetMap | sizes=, -1-1 | sizes=, 99 |
Component |
Version 1 |
Version 2 |
ResetMap | sizes= -1 | sizes= 9 |
Component |
Version 1 |
Version 2 |
ResetMap | sizes= -1 | sizes= 9 |
Component |
Version 1 |
Version 2 |
ResetSetMap | sizes=, -1-1 | sizes=, 99 |
Component |
Version 1 |
Version 2 |
ResetSetMap | sizes=, -1-1 | sizes=, 99 |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
nextstate := T.Buf3sTable[strength, T.UX01Conv[enable], T.UX01Conv[x]]; | nextstate := T.Buf3sTable[strength, T.UX01Table[enable], T.UX01Table[x]]; |
yy = nextstate; ... |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
nextstate := T.Buf3slTable[strength, T.UX01Conv[enable], T.UX01Conv[x]]; | nextstate := T.Buf3slTable[strength, T.UX01Table[enable], T.UX01Table[x]]; |
yy = nextstate; ... |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
nextstate := T.Buf3sTable[strength, T.UX01Conv[enable], T.UX01Conv[T.NotTable[x]]]; | nextstate := T.Buf3sTable[strength, T.UX01Table[enable], T.NotTable[x]]; |
yy = nextstate; ... |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
nextstate := T.Buf3sTable[strength, T.UX01Conv[T.NotTable[enable]], T.UX01Conv[T.NotTable[x]]]; | nextstate := T.Buf3sTable[strength, T.NotTable[enable], T.NotTable[x]]; |
yy = nextstate; ... |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
nextstate := T.MUX2x1Table[T.UX01Conv[in1], T.UX01Conv[sel], T.UX01Conv[in0]]; | nextstate := T.MUX2x1Table[T.UX01Table[in1], T.UX01Table[sel], T.UX01Table[in0]]; |
nextstate = T.StrengthMap[nextstate, strength]; ... |
Component |
Version 1 |
Version 2 |
wLoad | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
wLoad | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
wLoad | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
wLoad | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
wSwitch | displayUnit="rev/min" | displayUnit="1/min" |
wLoad | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
w_sim | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
wLoad | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
iq | k=Idq[2] | k=84.6 |
id | k=Idq[1] | k=-53.5 |
inertiaLoad | J=JLoad | J=0.29 |
quadraticSpeedDependentTorque | tau_nominal=-TLoad | tau_nominal=-181.4 |
w_nominal(displayUnit="rad/s") = wNominal | w_nominal(displayUnit="rpm") = 157.07963267949 | |
Idq | Present | |
wNominal | Present | |
VNominal | Present | |
fNominal | Present | |
f | Present | |
tRamp | Present | |
tStep | Present |
Component |
Version 1 |
Version 2 |
iq | k=Idq[2] | k=84.6 |
id | k=Idq[1] | k=-53.5 |
inertiaLoad | J=JLoad | J=0.29 |
quadraticSpeedDependentTorque | tau_nominal=-TLoad | tau_nominal=-181.4 |
w_nominal(displayUnit="rad/s") = wNominal | w_nominal(displayUnit="rpm") = 157.07963267949 | |
Idq | Present | |
wNominal | Present | |
VNominal | Present | |
fNominal | Present | |
f | Present | |
tRamp | Present | |
tStep | Present |
Component |
Version 1 |
Version 2 |
wActual | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
switch | closerWithArc(off(start=fill(true, m), fixed=fill(true, m))) | |
Component |
Version 1 |
Version 2 |
wLoad | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
wLoad | displayUnit="rev/min" | displayUnit="1/min" |
Equations in Version 1 | Equations in Version 2 |
... connect(volumeFlow.flowPort_b, cooling.flowPort_a); |
|
connect(dcpm.thermalPort, thermalPort); |
|
connect(armature.port, thermalPort.heatPortArmature); ... connect(fixedTemperature.port, thermalPort.heatPortPermanentMagnet); |
|
connect(dcpm.thermalPort, thermalPort); |
Component |
Version 1 |
Version 2 |
ir | =squirrelCageR.i | =-squirrelCageR.spacePhasor_r.i_ |
Component |
Version 1 |
Version 2 |
i | Present |
Component |
Version 1 |
Version 2 |
ToSpacePhasor1 | m=m | |
Component |
Version 1 |
Version 2 |
ToSpacePhasor1 | m=m | |
Component |
Version 1 |
Version 2 |
m | parameter | constant |
ToSpacePhasorVS | final m=m | |
deMultiplex2 | Present | |
Equations in Version 1 | Equations in Version 2 |
... connect(add.y, rotatorVS2R.angle); |
|
connect(ToPolarVSR.y[2], rotorDisplacementAngle); | connect(ToPolarVSR.y, deMultiplex2.u); |
connect(deMultiplex2.y2[1], rotorDisplacementAngle); |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
m | parameter | constant |
min=1 | | |
TransformationMatrix | =2/m*{+cos(+phi),+sin(+phi)} | =2/m*{{cos(+(k - 1)/m*2*pi) for k in 1:m},{+sin(+(k - 1)/m*2*pi) for k in 1:m}} |
InverseTransformation | ={{+cos(-phi[k]),-sin(-phi[k])} for k in 1:m} | ={{cos(-(k - 1)/m*2*pi),-sin(-(k - 1)/m*2*pi)} for k in 1:m} |
phi | Present | |
pi | Present |
Component |
Version 1 |
Version 2 |
m | parameter | constant |
min=1 | | |
TransformationMatrix | =2/m*{+cos(+phi),+sin(+phi)} | =2/m*{{cos(+(k - 1)/m*2*pi) for k in 1:m},{+sin(+(k - 1)/m*2*pi) for k in 1:m}} |
InverseTransformation | ={{+cos(-phi[k]),-sin(-phi[k])} for k in 1:m} | ={{cos(-(k - 1)/m*2*pi),-sin(-(k - 1)/m*2*pi)} for k in 1:m} |
phi | Present | |
pi | Present |
Component |
Version 1 |
Version 2 |
x | sizes= -1 | sizes= 3 |
m | parameter | constant |
=size(x, 1) | =3 | |
phi | Present | |
TransformationMatrix | Present | |
InverseTransformation | Present | |
pi | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
y := TransformationMatrix*x; | y := zeros(2); |
y0 = 1/m*sum(x); | for k in 1:m loop |
y = y + 2/m*{+cos((k - 1)/m*2*pi),+sin(+(k - 1)/m*2*pi)}*x[k]; | |
end for; y0 = 1/m*sum(x); |
Component |
Version 1 |
Version 2 |
m | | constant |
| protected | |
input | | |
| =3 | |
y | sizes= -1 | sizes= 3 |
phi | Present | |
TransformationMatrix | Present | |
InverseTransformation | Present | |
pi | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
y := fill(x0, m) + InverseTransformation*x; | for k in 1:m loop |
y[k] = x0 + {cos(-(k - 1)/m*2*pi),-sin(-(k - 1)/m*2*pi)}*x; | |
end for; |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
m | | constant |
=size(x, 1) | =3 | |
h | =TransformationMatrix*x | |
phi | Present | |
TransformationMatrix | Present | |
pi | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
y := sqrt(h[1]^2 + h[2]^2)/sqrt(2); | h := zeros(2); |
for k in 1:m loop | |
h = h + 2/m*{+cos((k - 1)/m*2*pi),+sin(+(k - 1)/m*2*pi)}*x[k]; end for; y = sqrt(h[1]^2 + h[2]^2)/sqrt(2); |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
wRef | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
wRef | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
wRef | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
Js | =Jr | |
| start=Jr | |
wMechanical | displayUnit="rev/min" | displayUnit="1/min" |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Equations in Version 1 | Equations in Version 2 |
connect(spacePhasorS.plug_n, plug_sn); | |
connect(thermalPort, internalThermalPort); connect(thermalAmbient.thermalPort, internalThermalPort); |
|
connect(strayLoad.plug_n, rs.plug_p); ... connect(strayLoad.flange, inertiaRotor.flange_b); |
|
connect(internalThermalPort, thermalPort); connect(thermalAmbient.thermalPort, internalThermalPort); |
Component |
Version 1 |
Version 2 |
wNominal | displayUnit="rev/min" | displayUnit="1/min" |
pi | Present |
Equations in Version 1 | Equations in Version 2 |
... connect(la.p, ra.n); |
|
connect(thermalPort, internalThermalPort); connect(thermalAmbient.thermalPort, internalThermalPort); |
|
connect(brush.n, pin_an); ... connect(inertiaRotor.flange_b, strayLoad.flange); |
|
connect(thermalAmbient.thermalPort, internalThermalPort); connect(internalThermalPort, thermalPort); |
Component |
Version 1 |
Version 2 |
wNominal | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
toSpacePhasor | final m=m | |
m | Present | |
rotator | Present | |
rotator2 | Present | |
y | Present | |
u | Present | |
Equations in Version 1 | Equations in Version 2 |
connect(phi, toGamma.u); | |
connect(rotator.angle, toGamma.y); | connect(rotator2.angle, toGamma.y); |
connect(toSpacePhasor.y, rotator.u); | connect(rotator2.y, y); |
connect(u, toSpacePhasor.u); | |
connect(rotator.y, y); | connect(toSpacePhasor.y, rotator2.u); |
Component |
Version 1 |
Version 2 |
fromSpacePhasor | final m=m | |
m | Present | |
rotator | Present | |
rotator2 | Present | |
y | Present | |
u | Present | |
Equations in Version 1 | Equations in Version 2 |
connect(phi, toGamma.u); | |
connect(rotator.angle, toGamma.y); | connect(rotator2.angle, toGamma.y); |
connect(rotator.y, fromSpacePhasor.u); | connect(rotator2.y, fromSpacePhasor.u); |
connect(i0.y, fromSpacePhasor.zero); | |
connect(u, rotator.u); |
|
connect(fromSpacePhasor.y, y); | |
connect(rotator2.u, u); |
Component |
Version 1 |
Version 2 |
off | =idealThyristor.off | |
| start=fill(true, m) |
Equations in Version 1 | Equations in Version 2 |
off = idealThyristor.off; |
|
connect(plug_p.pin, idealThyristor.p); ... |
Component |
Version 1 |
Version 2 |
voltageSource | gamma(fixed=true, start=0) | |
I_abs | Present | |
I_arg | Present |
Equations in Version 1 | Equations in Version 2 |
connect(f.y, voltageSource.f); | initial equation |
voltageSource.pin_p.reference.gamma = 0; equation   connect(f.y, voltageSource.f); |
|
connect(polarToComplex.y, voltageSource.V); ... |
Component |
Version 1 |
Version 2 |
currentSource | gamma(fixed=true, start=0) | |
V_abs | Present | |
V_arg | Present |
Equations in Version 1 | Equations in Version 2 |
connect(currentSource.pin_n, resistor.pin_p); | initial equation |
currentSource.pin_p.reference.gamma = 0; equation   connect(currentSource.pin_n, resistor.pin_p); |
|
connect(currentSource.pin_n, inductor.pin_p); ... |
Component |
Version 1 |
Version 2 |
voltageQS | gamma(fixed=true, start=0) | |
Itr | Present | |
Iqs | Present |
Equations in Version 1 | Equations in Version 2 |
connect(voltageQS.pin_p, resistorQS.pin_p); | initial equation |
voltageQS.pin_p.reference.gamma = 0; equation   connect(voltageQS.pin_p, resistorQS.pin_p); |
|
connect(voltageQS.pin_n, rectifierQS.pin_nQS); ... |
Component |
Version 1 |
Version 2 |
abs_y | Present | |
arg_y | Present |
Component |
Version 1 |
Version 2 |
abs_y | Present | |
arg_y | Present |
Component |
Version 1 |
Version 2 |
abs_y | Present | |
arg_y | Present |
Component |
Version 1 |
Version 2 |
abs_y | Present | |
arg_y | Present |
Component |
Version 1 |
Version 2 |
abs_v | Present | |
arg_v | Present | |
abs_i | Present | |
arg_i | Present | |
P | Present | |
Q | Present | |
S | Present | |
pf | Present |
Component |
Version 1 |
Version 2 |
gamma | Present |
Component |
Version 1 |
Version 2 |
source | gamma(fixed=true, start=0) | |
polarIS | | sizes= -1 |
polarVS | | sizes= -1 |
polarVL | | sizes= -1 |
polarIL | | sizes= -1 |
VS | Present | |
phiS | Present | |
VL | Present | |
phiL | Present | |
symmetricalComponentsIS | Present | |
symmetricalComponentsIL | Present | |
symmetricalComponentsVS | Present | |
symmetricalComponentsVL | Present | |
Equations in Version 1 | Equations in Version 2 |
connect(starS.pin_n, groundS.pin); | initial equation |
source.voltageSource.pin_p.reference.gamma=zeros(m); equation   connect(starS.pin_n, groundS.pin); |
|
connect(source.plug_n, starS.plug_p); ... connect(currentSensorL.plug_p, deltaL.plug_n); |
|
connect(symmetricalComponentsIS.u, currentSensorS.y); | connect(polarIS.u, currentSensorS.y); |
connect(symmetricalComponentsIL.u, currentSensorL.y); | connect(polarIL.u, currentSensorL.y); |
connect(symmetricalComponentsIS.y[1], polarIS.u); | connect(voltageSensorS.y, polarVS.u); |
connect(symmetricalComponentsIL.y[1], polarIL.u); | connect(voltageSensorL.y, polarVL.u); |
connect(voltageSensorS.y, symmetricalComponentsVS.u); connect(symmetricalComponentsVS.y[1], polarVS.u); connect(voltageSensorL.y, symmetricalComponentsVL.u); connect(symmetricalComponentsVL.y[1], polarVL.u); |
Component |
Version 1 |
Version 2 |
m | constant | parameter |
voltageSource | gamma(fixed=true, start=0) | |
i | Present | |
complexToPolar | Present | |
Equations in Version 1 | Equations in Version 2 |
connect(ground.pin, star.pin_n); | initial equation |
voltageSource.voltageSource.pin_p.reference.gamma = zeros(m); equation   connect(ground.pin, star.pin_n); |
|
connect(star.plug_p, voltageSource.plug_n); ... connect(currentSensor0.pin_n, star.pin_n); |
|
connect(currentSensor.y, complexToPolar.u); |
Component |
Version 1 |
Version 2 |
voltageSource | gamma(fixed=true, start=0) | |
i | Present |
Equations in Version 1 | Equations in Version 2 |
connect(ground.pin, star.pin_n); | initial equation |
voltageSource.voltageSource.pin_p.reference.gamma = zeros(m); equation   connect(ground.pin, star.pin_n); |
|
connect(star.plug_p, voltageSource.plug_n); ... |
Component |
Version 1 |
Version 2 |
abs_y | Present | |
arg_y | Present |
Component |
Version 1 |
Version 2 |
abs_y | Present | |
arg_y | Present |
Component |
Version 1 |
Version 2 |
abs_y | Present | |
arg_y | Present |
Component |
Version 1 |
Version 2 |
abs_y | Present | |
arg_y | Present |
Component |
Version 1 |
Version 2 |
voltageSource | Present | |
Equations in Version 1 | Equations in Version 2 |
omega = 2*Modelica.Constants.pi*f; | connect(plugToPins_p.pin_p, voltageSource.pin_p); |
v = {V[k]*exp(j*phi[k]) for k in 1:m}; | connect(voltageSource.pin_n, plugToPins_n.pin_n); |
Component |
Version 1 |
Version 2 |
variableVoltageSource | Present | |
Equations in Version 1 | Equations in Version 2 |
omega = 2*Modelica.Constants.pi*f; | for j in 1:m loop |
v = V; | connect(f, variableVoltageSource[j].f); |
end for; connect(plugToPins_p.pin_p, variableVoltageSource.pin_p); connect(variableVoltageSource.pin_n, plugToPins_n.pin_n); connect(V, variableVoltageSource.V); |
Component |
Version 1 |
Version 2 |
currentSource | Present | |
Equations in Version 1 | Equations in Version 2 |
omega = 2*Modelica.Constants.pi*f; | connect(plugToPins_p.pin_p, currentSource.pin_p); |
i = {I[k]*exp(j*phi[k]) for k in 1:m}; | connect(currentSource.pin_n, plugToPins_n.pin_n); |
Component |
Version 1 |
Version 2 |
variableCurrentSource | Present | |
Equations in Version 1 | Equations in Version 2 |
omega = 2*Modelica.Constants.pi*f; | for j in 1:m loop |
i = I; | connect(f, variableCurrentSource[j].f); |
end for; connect(plugToPins_p.pin_p, variableCurrentSource.pin_p); connect(variableCurrentSource.pin_n, plugToPins_n.pin_n); connect(I, variableCurrentSource.I); |
Component |
Version 1 |
Version 2 |
abs_v | Present | |
arg_v | Present | |
abs_i | Present | |
arg_i | Present | |
P | Present | |
P_total | Present | |
Q | Present | |
Q_total | Present | |
S | Present | |
S_total | Present | |
pf | Present |
Component |
Version 1 |
Version 2 |
abs_v | Present | |
arg_v | Present | |
abs_i | Present | |
arg_i | Present | |
P | Present | |
P_total | Present | |
Q | Present | |
Q_total | Present | |
S | Present | |
S_total | Present | |
pf | Present |
Component |
Version 1 |
Version 2 |
gamma | Present |
Equations in Version 1 | Equations in Version 2 |
Connections.root(plug_p.reference); |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Equations in Version 1 | Equations in Version 2 |
assert( NRD > 0, "NRD, length of drain in squares, must be greater than zero"); | assert( NRD <> 0, "NRD, length of drain in squares, must not be zero"); |
assert( NRS > 0, "NRS, length of source in squares, must be greater than zero"); | assert( NRS <> 0, "NRS, length of source in squares, must not be zero"); |
vDS = D.v - S.v; ... |
Equations in Version 1 | Equations in Version 2 |
assert( NRD > 0, "NRD, length of drain in squares, must be greater than zero"); | assert( NRD <> 0, "NRD, length of drain in squares, must not be zero"); |
assert( NRS > 0, "NRS, length of source in squares, must be greater than zero"); | assert( NRS <> 0, "NRS, length of source in squares, must not be zero"); |
cc = Spice3.Internal.Mos.mos2CalcNoBypassCodeRevised(         m1,         m_type,         c22,         p1,         m_bInit,         {G.v,B.v,Dinternal,Sinternal}); ... |
Equations in Version 1 | Equations in Version 2 |
... if (cp.m_dCapIsGiven < 0.5) then |
|
assert( L > 0, "Length of capacitor must be greater than zero"); | assert( L > 0, "Length of capacitor must be greater then zero"); |
end if; ... |
Component |
Version 1 |
Version 2 |
CONSTvt0 | =Modelica.Constants.k*SI.Conversions.from_degC(27)/CHARGE | =Modelica_3_2_1_Build_4.Constants.k*Modelica_3_2_1_Build_4.SIunits.Conversions.from_degC(27)/CHARGE |
Component |
Version 1 |
Version 2 |
r_mFe | material=Material.SoftMagnetic.ElectricSheet.M350_50A() | material=Modelica_3_2_1_Build_4.Magnetic.FluxTubes.Material.SoftMagnetic.ElectricSheet.M350_50A() |
Component |
Version 1 |
Version 2 |
pmActuator | material=Material.HardMagnetic.PlasticNdFeB() | material=Modelica_3_2_1_Build_4.Magnetic.FluxTubes.Material.HardMagnetic.PlasticNdFeB() |
Component |
Version 1 |
Version 2 |
actuator | material=Material.HardMagnetic.PlasticNdFeB() | material=Modelica_3_2_1_Build_4.Magnetic.FluxTubes.Material.HardMagnetic.PlasticNdFeB() |
Component |
Version 1 |
Version 2 |
pmActuator | material=Material.HardMagnetic.PlasticNdFeB() | material=Modelica_3_2_1_Build_4.Magnetic.FluxTubes.Material.HardMagnetic.PlasticNdFeB() |
Component |
Version 1 |
Version 2 |
material | =Material.HardMagnetic.BaseData() | =Modelica_3_2_1_Build_4.Magnetic.FluxTubes.Material.HardMagnetic.BaseData() |
Component |
Version 1 |
Version 2 |
material | =Material.SoftMagnetic.Steel.Steel_9SMnPb28() | =Modelica_3_2_1_Build_4.Magnetic.FluxTubes.Material.SoftMagnetic.Steel.Steel_9SMnPb28() |
Component |
Version 1 |
Version 2 |
material | =Material.SoftMagnetic.Steel.Steel_9SMnPb28() | =Modelica_3_2_1_Build_4.Magnetic.FluxTubes.Material.SoftMagnetic.Steel.Steel_9SMnPb28() |
Component |
Version 1 |
Version 2 |
useConductance | Present | |
G | Present |
Equations in Version 1 | Equations in Version 2 |
LossPower = V_m*der(Phi); | |
V_m =(if useConductance then G else 1/R) * der(Phi); | V_m = 1/R*der(Phi); |
Component |
Version 1 |
Version 2 |
material | =Material.SoftMagnetic.BaseData() | =Modelica_3_2_1_Build_4.Magnetic.FluxTubes.Material.SoftMagnetic.BaseData() |
B_N | Present |
Equations in Version 1 | Equations in Version 2 |
B_N = abs(B/material.B_myMax); | mu_r = if nonLinearPermeability then Modelica_3_2_1_Build_4.Magnetic.FluxTubes.Material.SoftMagnetic.mu_rApprox( B, material.mu_i, material.B_myMax, material.c_a, material.c_b, material.n) else mu_rConst; |
mu_r = if nonLinearPermeability then     1 + (material.mu_i - 1 + material.c_a*B_N)/(1 + material.c_b*B_N + B_N^material.n) else mu_rConst; |
|
R_m = 1/G_m; ... |
Component |
Version 1 |
Version 2 |
w_Load | displayUnit="rev/min" | displayUnit="1/min" |
Equations in Version 1 | Equations in Version 2 |
... aimcM.is = zeros(m); |
|
aimcM.rotorCage.electroMagneticConverter.Phi = Complex(0, 0); | aimcM.ir[1:2] = zeros(2); |
... |
Component |
Version 1 |
Version 2 |
w_Load | displayUnit="rev/min" | displayUnit="1/min" |
Equations in Version 1 | Equations in Version 2 |
... aimcM.is[1:2] = zeros(2); |
|
aimcM.rotorCage.electroMagneticConverter.Phi = Complex(0, 0); | aimcM.ir[1:m - 1] = zeros(m - 1); |
... |
Component |
Version 1 |
Version 2 |
w_Load | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
w_Load | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
smpmM | ir(fixed=true) | |
| ir(each fixed=true) | |
smpmE | ir(fixed=true) | |
| ir(each fixed=true) |
Component |
Version 1 |
Version 2 |
smpmM | ir(fixed=true) | |
| ir(each fixed=true) | |
smpm3 | ir(fixed=true) | |
| ir(each fixed=true) |
Component |
Version 1 |
Version 2 |
smeeM | ir(fixed=true) | |
| ir(each fixed=true) | |
smee3 | ir(fixed=true) | |
| ir(each fixed=true) |
Component |
Version 1 |
Version 2 |
smrM | ir(fixed=true) | |
| ir(each fixed=true) | |
smrE | ir(fixed=true) | |
| ir(each fixed=true) |
Component |
Version 1 |
Version 2 |
smrM | ir(fixed=true) | |
| ir(each fixed=true) | |
smr3 | ir(fixed=true) | |
| ir(each fixed=true) |
Component |
Version 1 |
Version 2 |
abs_V_m | Present | |
arg_V_m | Present | |
abs_Phi | Present | |
arg_Phi | Present |
Component |
Version 1 |
Version 2 |
abs_V_m | Present | |
arg_V_m | Present | |
abs_Phi | Present | |
arg_Phi | Present |
Component |
Version 1 |
Version 2 |
ir | =rotorCage.i | =rotorCage.winding.plug_p.pin.i |
Component |
Version 1 |
Version 2 |
v | Present | |
i | Present | |
V_m | Present | |
abs_V_m | Present | |
arg_V_m | Present | |
Phi | Present | |
abs_Phi | Present | |
arg_Phi | Present |
Component |
Version 1 |
Version 2 |
v | Present | |
i | Present | |
V_m | Present | |
abs_V_m | Present | |
arg_V_m | Present | |
Phi | Present | |
abs_Phi | Present | |
arg_Phi | Present |
Component |
Version 1 |
Version 2 |
i | =electroMagneticConverter.i | =strayInductor.i |
electroMagneticConverter | Present | |
strayReluctance | Present | |
winding | Present | |
strayInductor | Present | |
Equations in Version 1 | Equations in Version 2 |
connect(port_p, electroMagneticConverter.port_p); | connect(port_p, winding.port_p); |
connect(electroMagneticConverter.port_n, port_n); | connect(winding.port_n, port_n); |
connect(ground.p, star.pin_n); | |
connect(star.plug_p, electroMagneticConverter.plug_n); | connect(strayInductor.plug_n, resistor.plug_p); |
connect(strayInductor.plug_p, winding.plug_p); connect(star.plug_p, winding.plug_n); |
|
connect(thermalCollector.port_a, resistor.heatPort); ... connect(resistor.plug_n, starAuxiliary.plug_p); |
|
connect(strayReluctance.port_p, port_p); connect(strayReluctance.port_n, port_n); connect(electroMagneticConverter.plug_p, resistor.plug_p); |
Component |
Version 1 |
Version 2 |
i | =electroMagneticConverter.i | =-strayInductor.i |
electroMagneticConverter | Present | |
strayReluctance | Present | |
winding | Present | |
strayInductor | Present | |
Equations in Version 1 | Equations in Version 2 |
connect(port_p, electroMagneticConverter.port_p); | connect(port_p, winding.port_p); |
connect(electroMagneticConverter.port_n, port_n); | connect(winding.port_n, port_n); |
connect(ground.p, star.pin_n); | |
connect(electroMagneticConverter.plug_n, resistor.plug_n); | connect(strayInductor.plug_n, resistor.plug_p); |
connect(star.plug_p, electroMagneticConverter.plug_n); | connect(winding.plug_n, resistor.plug_n); |
connect(star.plug_p, winding.plug_n); connect(strayInductor.plug_p, winding.plug_p); |
|
connect(thermalCollector.port_b, heatPortWinding); | |
connect(resistor.heatPort, thermalCollector.port_a); | |
connect(electroMagneticConverter.plug_p, resistor.plug_p); connect(strayReluctance.port_p, port_p); connect(strayReluctance.port_n, port_n); |
Component |
Version 1 |
Version 2 |
abs_V_m | Present | |
arg_V_m | Present | |
abs_Phi | Present | |
arg_Phi | Present |
Component |
Version 1 |
Version 2 |
abs_V_m | Present | |
arg_V_m | Present | |
abs_Phi | Present | |
arg_Phi | Present |
Component |
Version 1 |
Version 2 |
abs_V_m | Present | |
arg_V_m | Present | |
abs_Phi | Present | |
arg_Phi | Present |
Component |
Version 1 |
Version 2 |
abs_V_m | Present | |
arg_V_m | Present | |
abs_Phi | Present | |
arg_Phi | Present |
Component |
Version 1 |
Version 2 |
abs_V_m | Present | |
arg_V_m | Present | |
abs_Phi | Present | |
arg_Phi | Present |
Component |
Version 1 |
Version 2 |
wMechanical | displayUnit="rev/min" | displayUnit="1/min" |
pi | Real | SIunits.Angle |
protected | |
Equations in Version 1 | Equations in Version 2 |
... equation   connect(stator.plug_n, plug_sn); |
|
connect(thermalPort, internalThermalPort); connect(thermalAmbient.thermalPort, internalThermalPort); |
|
connect(inertiaRotor.flange_b, flange); ... connect(stator.heatPortCore, internalThermalPort.heatPortStatorCore); |
|
connect(thermalAmbient.thermalPort, internalThermalPort); connect(internalThermalPort, thermalPort); |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
mounting1D1 | n={0,1,0} | |
mounting1D2 | n={0,1,0} | |
Component |
Version 1 |
Version 2 |
gearConstraint | checkTotalPower=true | |
Component |
Version 1 |
Version 2 |
checkTotalPower | Present | |
totalPower | Present |
Equations in Version 1 | Equations in Version 2 |
... a_b = der(w_b); |
|
if checkTotalPower then totalPower =         frame_a.f*Frames.resolve2(frame_a.R, der(frame_a.r_0)) +         frame_b.f*Frames.resolve2(frame_b.R, der(frame_b.r_0)) +         bearing.f*Frames.resolve2(bearing.R, der(bearing.r_0)) +         frame_a.t*Frames.angularVelocity2(frame_a.R) +         frame_b.t*Frames.angularVelocity2(frame_b.R) +         bearing.t*Frames.angularVelocity2(bearing.R); else totalPower = 0; end if; |
|
connect(actuatedRevolute_a.axis, idealGear.flange_a); ... |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
b | Integer | Real |
c | Integer | Real |
Component |
Version 1 |
Version 2 |
Inertia2 | phi(fixed=true, start=0, nominal=0.001) | phi(fixed=true, start=0) |
w(fixed=true, start=0, nominal=0.01) | w(fixed=true, start=0) |
Component |
Version 1 |
Version 2 |
Inertia2 | phi(fixed=true, start=0, nominal=1e-4) | phi(fixed=true, start=0) |
w(fixed=true, start=0, nominal=0.001) | w(fixed=true, start=0) |
Component |
Version 1 |
Version 2 |
springDamper | w_rel(fixed=true, nominal=1e-4) | w_rel(fixed=true) |
Component |
Version 1 |
Version 2 |
fixed3 | Present | |
elastoBacklash2 | Present | |
inertia3 | Present | |
Equations in Version 1 | Equations in Version 2 |
... connect(fixed2.flange, elastoBacklash.flange_a); |
|
connect(elastoBacklash2.flange_b, inertia3.flange_a); connect(fixed3.flange, elastoBacklash2.flange_a); |
Component |
Version 1 |
Version 2 |
J | | min=0 |
Equations in Version 1 | Equations in Version 2 |
tau0 = Modelica.Math.Vectors.interpolate(tau_pos[:,1], tau_pos[:,2], 0, 1); | tau0 = Modelica_3_2_1_Build_4.Math.tempInterpol1( 0, tau_pos, 2); |
tau0_max = peak*tau0; ... flange_a.tau + flange_b.tau - tau = 0; |
|
tau = if locked then sa*unitTorque else ( if startForward then Modelica.Math.Vectors.interpolate(tau_pos[:,1], tau_pos[:,2], w, 1) else if startBackward then -Modelica.Math.Vectors.interpolate(tau_pos[:,1], tau_pos[:,2], -w, 1) else if pre(mode) == Forward then Modelica.Math.Vectors.interpolate(tau_pos[:,1], tau_pos[:,2], w, 1) else -Modelica.Math.Vectors.interpolate(tau_pos[:,1], tau_pos[:,2], -w, 1)); |
tau = if locked then sa*unitTorque else (if startForward then Modelica_3_2_1_Build_4.Math.tempInterpol1( w, tau_pos, 2) else if startBackward then -Modelica_3_2_1_Build_4.Math.tempInterpol1( -w, tau_pos, 2) else if pre(mode) == Forward then Modelica_3_2_1_Build_4.Math.tempInterpol1( w, tau_pos, 2) else -Modelica_3_2_1_Build_4.Math.tempInterpol1( -w, tau_pos, 2)); |
lossPower = tau*w_relfric; |
Equations in Version 1 | Equations in Version 2 |
mue0 = Modelica.Math.Vectors.interpolate(mue_pos[:,1], mue_pos[:,2], 0, 1); | mue0 = Modelica_3_2_1_Build_4.Math.tempInterpol1( 0, mue_pos, 2); |
phi = flange_a.phi - phi_support; ... free = fn <= 0; |
|
tau = if locked then sa*unitTorque else if free then 0 else cgeo*fn*( if startForward then Modelica.Math.Vectors.interpolate(mue_pos[:,1], mue_pos[:,2], w, 1) else if startBackward then -Modelica.Math.Vectors.interpolate(mue_pos[:,1], mue_pos[:,2], -w, 1) else if pre(mode) == Forward then Modelica.Math.Vectors.interpolate(mue_pos[:,1], mue_pos[:,2], w, 1) else -Modelica.Math.Vectors.interpolate(mue_pos[:,1], mue_pos[:,2], -w, 1)); |
tau = if locked then sa*unitTorque else if free then 0 else cgeo*fn*(if startForward then Modelica_3_2_1_Build_4.Math.tempInterpol1( w, mue_pos, 2) else if startBackward then -Modelica_3_2_1_Build_4.Math.tempInterpol1( -w, mue_pos, 2) else if pre(mode) == Forward then Modelica_3_2_1_Build_4.Math.tempInterpol1( w, mue_pos, 2) else -Modelica_3_2_1_Build_4.Math.tempInterpol1( -w, mue_pos, 2)); |
lossPower = tau*w_relfric; |
Equations in Version 1 | Equations in Version 2 |
mue0 = Modelica.Math.Vectors.interpolate(mue_pos[:,1], mue_pos[:,2], 0, 1); | mue0 = Modelica_3_2_1_Build_4.Math.tempInterpol1( 0, mue_pos, 2); |
w_relfric = w_rel; ... tau0_max = peak*tau0; |
|
tau = if locked then sa*unitTorque else if free then 0 else cgeo*fn*( if startForward then Modelica.Math.Vectors.interpolate(mue_pos[:,1], mue_pos[:,2], w_rel, 1) else if startBackward then -Modelica.Math.Vectors.interpolate(mue_pos[:,1], mue_pos[:,2], w_rel, 1) else if pre(mode) == Forward then Modelica.Math.Vectors.interpolate(mue_pos[:,1], mue_pos[:,2], w_rel, 1) else -Modelica.Math.Vectors.interpolate(mue_pos[:,1], mue_pos[:,2], -w_rel, 1)); |
tau = if locked then sa*unitTorque else if free then 0 else cgeo*fn*(if startForward then Modelica_3_2_1_Build_4.Math.tempInterpol1( w_rel, mue_pos, 2) else if startBackward then -Modelica_3_2_1_Build_4.Math.tempInterpol1( -w_rel, mue_pos, 2) else if pre(mode) == Forward then Modelica_3_2_1_Build_4.Math.tempInterpol1( w_rel, mue_pos, 2) else -Modelica_3_2_1_Build_4.Math.tempInterpol1( -w_rel, mue_pos, 2)); |
lossPower = tau*w_relfric; |
Equations in Version 1 | Equations in Version 2 |
mue0 = Modelica.Math.Vectors.interpolate(mue_pos[:,1], mue_pos[:,2], 0, 1); | mue0 = Modelica_3_2_1_Build_4.Math.tempInterpol1( 0, mue_pos, 2); |
tau0_max_low = eps0*mue0*cgeo*fn_max; ... a_rel = unitAngularAcceleration*(if locked then 0 else sa - tau0/     unitTorque); |
|
tau = if locked then sa*unitTorque else (if free then 0 else cgeo*fn* Modelica.Math.Vectors.interpolate(mue_pos[:,1], mue_pos[:,2], w_rel, 1)); |
tau = if locked then sa*unitTorque else (if free then 0 else cgeo*fn* Modelica_3_2_1_Build_4.Math.tempInterpol1( w_rel, mue_pos, 2)); |
stuck = locked or w_rel <= 0; ... |
Component |
Version 1 |
Version 2 |
w | Present |
Equations in Version 1 | Equations in Version 2 |
w = der(phi); |
|
tau = -flange.tau; ... |
Equations in Version 1 | Equations in Version 2 |
f0 = Modelica.Math.Vectors.interpolate( f_pos[:, 1], f_pos[:, 2], 0, 1); |
f0 = Modelica_3_2_1_Build_4.Math.tempInterpol1( 0, f_pos, 2); |
f0_max = peak*f0; ... flange_a.f + flange_b.f - f = 0; |
|
f = if locked then sa*unitForce else (if startForward then Modelica.Math.Vectors.interpolate( f_pos[:, 1], f_pos[:, 2], v, 1) else if startBackward then -Modelica.Math.Vectors.interpolate( f_pos[:, 1], f_pos[:, 2], -v, 1) else if pre(mode) == Forward then Modelica.Math.Vectors.interpolate( f_pos[:, 1], f_pos[:, 2], v, 1) else -Modelica.Math.Vectors.interpolate( f_pos[:, 1], f_pos[:, 2], -v, 1)); |
f = if locked then sa*unitForce else (if startForward then Modelica_3_2_1_Build_4.Math.tempInterpol1( v, f_pos, 2) else if startBackward then -Modelica_3_2_1_Build_4.Math.tempInterpol1( -v, f_pos, 2) else if pre(mode) == Forward then Modelica_3_2_1_Build_4.Math.tempInterpol1( v, f_pos, 2) else -Modelica_3_2_1_Build_4.Math.tempInterpol1( -v, f_pos, 2)); |
lossPower = f*v_relfric; |
Equations in Version 1 | Equations in Version 2 |
mue0 = Modelica.Math.Vectors.interpolate( mue_pos[:, 1], mue_pos[:, 2], 0, 1); |
mue0 = Modelica_3_2_1_Build_4.Math.tempInterpol1( 0, mue_pos, 2); |
s = s_a; ... free = fn <= 0; |
|
f = if locked then sa*unitForce else if free then 0 else cgeo*fn*(if startForward then Modelica.Math.Vectors.interpolate( mue_pos[:, 1], mue_pos[:, 2], v, 1) else if startBackward then -Modelica.Math.Vectors.interpolate( mue_pos[:, 1], mue_pos[:, 2], -v, 1) else if pre(mode) == Forward then Modelica.Math.Vectors.interpolate( mue_pos[:, 1], mue_pos[:, 2], v, 1) else -Modelica.Math.Vectors.interpolate( mue_pos[:, 1], mue_pos[:, 2], -v, 1)); |
f = if locked then sa*unitForce else if free then 0 else cgeo*fn*(if startForward then Modelica_3_2_1_Build_4.Math.tempInterpol1( v, mue_pos, 2) else if startBackward then -Modelica_3_2_1_Build_4.Math.tempInterpol1( -v, mue_pos, 2) else if pre(mode) == Forward then Modelica_3_2_1_Build_4.Math.tempInterpol1( v, mue_pos, 2) else -Modelica_3_2_1_Build_4.Math.tempInterpol1( -v, mue_pos, 2)); |
lossPower = f*v_relfric; |
Component |
Version 1 |
Version 2 |
pumps | p_b_start=600000 | |
T_start=system.T_start | |
Component |
Version 1 |
Version 2 |
radiator | state_a(p(start=110000)) | |
state_b(p(start=110000)) | |
Component |
Version 1 |
Version 2 |
upperTank | redeclare package Medium = Modelica.Media.CompressibleLiquids.LinearColdWater | redeclare package Medium = Modelica.Media.Water.StandardWater |
massFlowRate | redeclare package Medium = Modelica.Media.CompressibleLiquids.LinearColdWater | redeclare package Medium = Modelica.Media.Water.StandardWater |
pressure | redeclare package Medium = Modelica.Media.CompressibleLiquids.LinearColdWater | redeclare package Medium = Modelica.Media.Water.StandardWater |
pipe | redeclare package Medium = Modelica.Media.CompressibleLiquids.LinearColdWater | redeclare package Medium = Modelica.Media.Water.StandardWater |
lowerTank | redeclare package Medium = Modelica.Media.CompressibleLiquids.LinearColdWater | redeclare package Medium = Modelica.Media.Water.StandardWater |
overflow | redeclare package Medium = Modelica.Media.CompressibleLiquids.LinearColdWater | redeclare package Medium = Modelica.Media.Water.StandardWater |
Component |
Version 1 |
Version 2 |
volume | medium(Xi(nominal=0.01)) | |
ductOut | mCs_scaled(each nominal=0.01) | |
mediums(each Xi(nominal=0.01)) | | |
ductIn | mCs_scaled(each nominal=0.01) | |
mediums(each Xi(nominal=0.01)) | |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
N_in | unit="rev/min" | unit="1/min" |
N_in_internal | unit="rev/min" | unit="1/min" |
Component |
Version 1 |
Version 2 |
max_dhdV | =c[2] + max(sum((i - 1)*V_flow_nominal .^ (i - 2)*c[i] for i in 3:N)) | =max({c[2] .+ sum((i - 1)*V_flow_nominal .^ (i - 2)*c[i] for i in 3:N)}) |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
pi | Present |
Component |
Version 1 |
Version 2 |
d | =(if use_T then Medium.density_pTX(Medium.p_default, Medium.T_default, Medium.X_default) else Medium.density_phX(Medium.p_default, Medium.h_default, Medium.X_default)) | =Medium.density_pTX(Medium.p_default, Medium.T_default, Medium.X_default) |
Equations in Version 1 | Equations in Version 2 |
... adeltax := abs(deltax); |
|
if x >= adeltax then | if noEvent(x >= adeltax) then |
dy = dx*pow*x^(pow - 1); | |
elseif x <= -adeltax then | elseif noEvent(x <= -adeltax) then |
dy = dx*pow*(-x)^(pow - 1); ... |
Component |
Version 1 |
Version 2 |
medium2 | X(start={0.2,0.8}, fixed=true) | X(start={0.2,0.8}, each fixed=true) |
Component |
Version 1 |
Version 2 |
medium2 | X(start={0.2,0.1,0.3,0.4}, fixed=true) | X(start={0.2,0.1,0.3,0.4}, each fixed=true) |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
state := ThermodynamicState(p=((d - reference_d) + (T - reference_T) *beta_const*reference_d)/(reference_d*kappa_const) + reference_p, T=T); |
state := ThermodynamicState(p=((d - reference_d) + (state.T - reference_T) *beta_const*reference_d)/(reference_d*kappa_const) + reference_p, T=T); |
Component |
Version 1 |
Version 2 |
X | start=reference_X | |
Component |
Version 1 |
Version 2 |
airConstants | chemicalFormula="N2+O2+Ar" | |
structureFormula="N2+O2+Ar" | | |
casRegistryNumber="1" | | |
iupacName="air" | | |
molarMass=0.02896546 | | |
criticalTemperature=132.5306 | | |
criticalPressure=3.786e6 | | |
criticalMolarVolume=0.02896546/342.68 | | |
triplePointTemperature=63.05 "From N2" | | |
triplePointPressure=0.1253e5 "From N2" | | |
normalBoilingPoint=78.903 | | |
meltingPoint=0 | | |
acentricFactor=0.0335 | | |
dipoleMoment=0.0 | | |
hasCriticalData=true | | |
hasFundamentalEquation=true | | |
hasAccurateViscosityData=true | | |
hasAcentricFactor=true | | |
| each chemicalFormula="N2+O2+Ar" | |
| each structureFormula="N2+O2+Ar" | |
| each casRegistryNumber="1" | |
| each iupacName="air" | |
| each molarMass=0.02896546 | |
| each criticalTemperature=132.5306 | |
| each criticalPressure=3.786e6 | |
| each criticalMolarVolume=0.02896546/342.68 | |
| each triplePointTemperature=63.05 "From N2" | |
| each triplePointPressure=0.1253e5 "From N2" | |
| each normalBoilingPoint=78.903 | |
| each meltingPoint=0 | |
| each acentricFactor=0.0335 | |
| each dipoleMoment=0.0 | |
| each hasCriticalData=true | |
| each hasFundamentalEquation=true | |
| each hasAccurateViscosityData=true | |
| each hasAcentricFactor=true |
Component |
Version 1 |
Version 2 |
waterConstants | chemicalFormula="H2O" | |
structureFormula="H2O" | | |
casRegistryNumber="7732-18-5" | | |
iupacName="oxidane" | | |
molarMass=0.018015268 | | |
criticalTemperature=647.096 | | |
criticalPressure=22064.0e3 | | |
criticalMolarVolume=1/322.0*0.018015268 | | |
triplePointTemperature=273.16 | | |
triplePointPressure=611.657 | | |
normalBoilingPoint=373.124 | | |
meltingPoint=273.15 | | |
acentricFactor=0.344 | | |
dipoleMoment=1.8 | | |
hasCriticalData=true | | |
hasIdealGasHeatCapacity=false | | |
hasDipoleMoment=true | | |
hasFundamentalEquation=true | | |
hasLiquidHeatCapacity=true | | |
hasSolidHeatCapacity=false | | |
hasAccurateViscosityData=true | | |
hasAccurateConductivityData=true | | |
hasVapourPressureCurve=false | | |
hasAcentricFactor=true | | |
HCRIT0=0.0 | | |
SCRIT0=0.0 | | |
deltah=0.0 | | |
deltas=0.0 | | |
| each chemicalFormula="H2O" | |
| each structureFormula="H2O" | |
| each casRegistryNumber="7732-18-5" | |
| each iupacName="oxidane" | |
| each molarMass=0.018015268 | |
| each criticalTemperature=647.096 | |
| each criticalPressure=22064.0e3 | |
| each criticalMolarVolume=1/322.0*0.018015268 | |
| each triplePointTemperature=273.16 | |
| each triplePointPressure=611.657 | |
| each normalBoilingPoint=373.124 | |
| each meltingPoint=273.15 | |
| each acentricFactor=0.344 | |
| each dipoleMoment=1.8 | |
| each hasCriticalData=true | |
| each hasIdealGasHeatCapacity=false | |
| each hasDipoleMoment=true | |
| each hasFundamentalEquation=true | |
| each hasLiquidHeatCapacity=true | |
| each hasSolidHeatCapacity=false | |
| each hasAccurateViscosityData=true | |
| each hasAccurateConductivityData=true | |
| each hasVapourPressureCurve=false | |
| each hasAcentricFactor=true | |
| each HCRIT0=0.0 | |
| each SCRIT0=0.0 | |
| each deltah=0.0 | |
| each deltas=0.0 |
Component |
Version 1 |
Version 2 |
eta | Media.Interfaces.Types.DynamicViscosity | SIunits.DynamicViscosity |
Component |
Version 1 |
Version 2 |
delp | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
Modelica.Media.R134a.R134a_ph.phaseBoundaryAssert(p, T); | assert(false, "A calculation of two-phase properties with input of pressure and temperature is not possible.\n" + "Please use setState_dTX or setState_phX instead."); |
state = ThermodynamicState(           d=dofpT(p, T, delp),           T=T,           h=hofpT(p, T, delp),           p=p,           phase=1); |
|
Component |
Version 1 |
Version 2 |
Region | Present |
Equations in Version 1 | Equations in Version 2 |
MM = fluidConstants[1].molarMass; | |
if Region > 0 then | if smoothModel then |
phase = (if Region == 4 then 2 else 1); elseif smoothModel then |
|
if onePhase then ... if dT_explicit then |
|
p = pressure_dT( d, T, phase, Region); |
p = pressure_dT( d, T, phase); |
h = specificEnthalpy_dT( d, T, phase, Region); |
h = specificEnthalpy_dT( d, T, phase); |
sat.Tsat = T; ... elseif ph_explicit then |
|
d = density_ph( p, h, phase, Region); |
d = density_ph( p, h, phase); |
T = temperature_ph( p, h, phase, Region); |
T = temperature_ph( p, h, phase); |
sat.Tsat = saturationTemperature(p); ... else |
|
h = specificEnthalpy_pT( p, T, Region); |
h = specificEnthalpy_pT(p, T); |
d = density_pT( p, T, Region); |
d = density_pT(p, T); |
sat.psat = p; ... |
Component |
Version 1 |
Version 2 |
region | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
d := IF97_Utilities.rho_ph( p, h, phase, region); |
d := IF97_Utilities.rho_ph( p, h, phase); |
Component |
Version 1 |
Version 2 |
region | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
T := IF97_Utilities.T_ph( p, h, phase, region); |
T := IF97_Utilities.T_ph( p, h, phase); |
Component |
Version 1 |
Version 2 |
region | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
T := IF97_Utilities.T_ps( p, s, phase, region); |
T := IF97_Utilities.T_ps( p, s, phase); |
Component |
Version 1 |
Version 2 |
region | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
d := IF97_Utilities.rho_ps( p, s, phase, region); |
d := IF97_Utilities.rho_ps( p, s, phase); |
Component |
Version 1 |
Version 2 |
region | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
p := IF97_Utilities.p_dT( d, T, phase, region); |
p := IF97_Utilities.p_dT( d, T, phase); |
Component |
Version 1 |
Version 2 |
region | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
h := IF97_Utilities.h_dT( d, T, phase, region); |
h := IF97_Utilities.h_dT( d, T, phase); |
Component |
Version 1 |
Version 2 |
region | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
h := IF97_Utilities.h_pT( p, T, region); |
h := IF97_Utilities.h_pT(p, T); |
Component |
Version 1 |
Version 2 |
region | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
h := IF97_Utilities.h_ps( p, s, phase, region); |
h := IF97_Utilities.h_ps( p, s, phase); |
Component |
Version 1 |
Version 2 |
region | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
d := IF97_Utilities.rho_pT( p, T, region); |
d := IF97_Utilities.rho_pT(p, T); |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
s := if dT_explicit then IF97_Utilities.s_dT( state.d, state.T, state.phase, Region) else if pT_explicit then IF97_Utilities.s_pT( state.p, state.T, Region) else IF97_Utilities.s_ph( state.p, state.h, state.phase, Region); |
s := if dT_explicit then IF97_Utilities.s_dT( state.d, state.T, state.phase) else if pT_explicit then IF97_Utilities.s_pT(state.p, state.T) else IF97_Utilities.s_ph( state.p, state.h, state.phase); |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
cp := if dT_explicit then IF97_Utilities.cp_dT( state.d, state.T, Region) else if pT_explicit then IF97_Utilities.cp_pT( state.p, state.T, Region) else IF97_Utilities.cp_ph( state.p, state.h, Region); |
cp := if dT_explicit then IF97_Utilities.cp_dT( state.d, state.T, state.phase) else if pT_explicit then IF97_Utilities.cp_pT(state.p, state.T) else IF97_Utilities.cp_ph( state.p, state.h, state.phase); |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
cv := if dT_explicit then IF97_Utilities.cv_dT( state.d, state.T, state.phase, Region) else if pT_explicit then IF97_Utilities.cv_pT( state.p, state.T, Region) else IF97_Utilities.cv_ph( state.p, state.h, state.phase, Region); |
cv := if dT_explicit then IF97_Utilities.cv_dT( state.d, state.T, state.phase) else if pT_explicit then IF97_Utilities.cv_pT(state.p, state.T) else IF97_Utilities.cv_ph( state.p, state.h, state.phase); |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
gamma := if dT_explicit then IF97_Utilities.isentropicExponent_dT( state.d, state.T, state.phase, Region) else if pT_explicit then IF97_Utilities.isentropicExponent_pT( state.p, state.T, Region) else IF97_Utilities.isentropicExponent_ph( state.p, state.h, state.phase, Region); |
gamma := if dT_explicit then IF97_Utilities.isentropicExponent_dT( state.d, state.T, state.phase) else if pT_explicit then IF97_Utilities.isentropicExponent_pT(state.p, state.T) else IF97_Utilities.isentropicExponent_ph( state.p, state.h, state.phase); |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
kappa := if dT_explicit then IF97_Utilities.kappa_dT( state.d, state.T, state.phase, Region) else if pT_explicit then IF97_Utilities.kappa_pT( state.p, state.T, Region) else IF97_Utilities.kappa_ph( state.p, state.h, state.phase, Region); |
kappa := if dT_explicit then IF97_Utilities.kappa_dT( state.d, state.T, state.phase) else if pT_explicit then IF97_Utilities.kappa_pT(state.p, state.T) else IF97_Utilities.kappa_ph( state.p, state.h, state.phase); |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
beta := if dT_explicit then IF97_Utilities.beta_dT( state.d, state.T, state.phase, Region) else if pT_explicit then IF97_Utilities.beta_pT( state.p, state.T, Region) else IF97_Utilities.beta_ph( state.p, state.h, state.phase, Region); |
beta := if dT_explicit then IF97_Utilities.beta_dT( state.d, state.T, state.phase) else if pT_explicit then IF97_Utilities.beta_pT(state.p, state.T) else IF97_Utilities.beta_ph( state.p, state.h, state.phase); |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
a := if dT_explicit then IF97_Utilities.velocityOfSound_dT( state.d, state.T, state.phase, Region) else if pT_explicit then IF97_Utilities.velocityOfSound_pT( state.p, state.T, Region) else IF97_Utilities.velocityOfSound_ph( state.p, state.h, state.phase, Region); |
a := if dT_explicit then IF97_Utilities.velocityOfSound_dT( state.d, state.T, state.phase) else if pT_explicit then IF97_Utilities.velocityOfSound_pT(state.p, state.T) else IF97_Utilities.velocityOfSound_ph( state.p, state.h, state.phase); |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
ddhp := IF97_Utilities.ddhp( state.p, state.h, state.phase, Region); |
ddhp := IF97_Utilities.ddhp( state.p, state.h, state.phase); |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
ddph := IF97_Utilities.ddph( state.p, state.h, state.phase, Region); |
ddph := IF97_Utilities.ddph( state.p, state.h, state.phase); |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
dl := if ph_explicit or pT_explicit then IF97_Utilities.BaseIF97.Regions.rhol_p(sat.psat) else IF97_Utilities.BaseIF97.Regions.rhol_T(sat.Tsat); |
dl := if ph_explicit then IF97_Utilities.BaseIF97.Regions.rhol_p(sat.psat) else IF97_Utilities.BaseIF97.Regions.rhol_T(sat.Tsat); |
Component |
Version 1 |
Version 2 |
region | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
state := ThermodynamicState( d=d, T=T, phase=if region == 0 then 0 else if region == 4 then 2 else 1, h=specificEnthalpy_dT( d, T, region=region), p=pressure_dT( d, T, region=region)); |
state := ThermodynamicState( d=d, T=T, phase=0, h=specificEnthalpy_dT(d, T), p=pressure_dT(d, T)); |
Component |
Version 1 |
Version 2 |
region | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
state := ThermodynamicState( d=density_ph( p, h, region=region), T=temperature_ph( p, h, region=region), phase=if region == 0 then 0 else if region==4 then 2 else 1, h=h, p=p); |
state := ThermodynamicState( d=density_ph(p, h), T=temperature_ph(p, h), phase=0, h=h, p=p); |
Component |
Version 1 |
Version 2 |
region | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
state := ThermodynamicState( d=density_ps( p, s, region=region), T=temperature_ps( p, s, region=region), phase=if region == 0 then 0 else if region==4 then 2 else 1, h=specificEnthalpy_ps( p, s, region=region), p=p); |
state := ThermodynamicState( d=density_ps(p, s), T=temperature_ps(p, s), phase=0, h=specificEnthalpy_ps(p, s), p=p); |
Component |
Version 1 |
Version 2 |
region | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
state := ThermodynamicState( d=density_pT( p, T, region=region), T=T, phase=1, h=specificEnthalpy_pT( p, T, region=region), p=p); |
state := ThermodynamicState( d=density_pT(p, T), T=T, phase=1, h=specificEnthalpy_pT(p, T), p=p); |
Component |
Version 1 |
Version 2 |
Region | Present | |
ph_explicit | Present | |
dT_explicit | Present | |
pT_explicit | Present |
Equations in Version 1 | Equations in Version 2 |
... hv = Regions.hv_p_R4b(p); |
|
else | end if; |
sl = Regions.sl_p_R4b(data.PCRIT); | x = max(min(if sl <> sv then (s - sl)/(sv - sl) else 1.0, 1.0), 0.0); |
sv = Regions.sv_p_R4b(data.PCRIT); | h = hl + x*(hv - hl); |
hl = Regions.hl_p_R4b(data.PCRIT); | |
hv = Regions.hv_p_R4b(data.PCRIT); end if; x = max(min(if sl <> sv then (s - sl)/(sv - sl) else 1.0, 1.0), 0.0); h = hl + x*(hv - hl); |
Equations in Version 1 | Equations in Version 2 |
... aux.R = BaseIF97.data.RH2O; |
|
aux.vt = 0.0 "initialized in case it is not needed"; aux.vp = 0.0 "initialized in case it is not needed"; |
|
if (aux.region == 1) then ... aux.vt = aux.R/p*(g.pi*g.gpi - g.tau*g.pi*g.gtaupi); |
|
aux.pt = -g.p/g.T*(g.gpi - g.tau*g.gtaupi)/(g.gpipi*g.pi); aux.pd = -g.R*g.T*g.gpi*g.gpi/(g.gpipi); |
|
aux.vp = aux.R*aux.T/(p*p)*g.pi*g.pi*g.gpipi; ... aux.vp = aux.R*aux.T/(p*p)*g.pi*g.pi*g.gpipi; |
|
aux.pt = -g.p/g.T*(g.gpi - g.tau*g.gtaupi)/(g.gpipi*g.pi); aux.pd = -g.R*g.T*g.gpi*g.gpi/(g.gpipi); |
|
aux.cp = -aux.R*g.tau*g.tau*g.gtautau; ... aux.vp = aux.R*aux.T/(p*p)*g.pi*g.pi*g.gpipi; |
|
aux.pt = -g.p/g.T*(g.gpi - g.tau*g.gtaupi)/(g.gpipi*g.pi); aux.pd = -g.R*g.T*g.gpi*g.gpi/(g.gpipi); |
|
aux.cp = -aux.R*g.tau*g.tau*g.gtautau; ... |
Equations in Version 1 | Equations in Version 2 |
... aux.R = BaseIF97.data.RH2O; |
|
aux.vt = 0.0 "initialized in case it is not needed"; aux.vp = 0.0 "initialized in case it is not needed"; |
|
if (aux.region == 1) then ... aux.vp = aux.R*aux.T/(p*p)*g.pi*g.pi*g.gpipi; |
|
aux.pt = -g.p/g.T*(g.gpi - g.tau*g.gtaupi)/(g.gpipi*g.pi); aux.pd = -g.R*g.T*g.gpi*g.gpi/(g.gpipi); |
|
aux.cp = -aux.R*g.tau*g.tau*g.gtautau; ... aux.vp = aux.R*aux.T/(p*p)*g.pi*g.pi*g.gpipi; |
|
aux.pt = -g.p/g.T*(g.gpi - g.tau*g.gtaupi)/(g.gpipi*g.pi); aux.pd = -g.R*g.T*g.gpi*g.gpi/(g.gpipi); |
|
aux.cp = -aux.R*g.tau*g.tau*g.gtautau; ... aux.vp = aux.R*aux.T/(p*p)*g.pi*g.pi*g.gpipi; |
|
aux.pt = -g.p/g.T*(g.gpi - g.tau*g.gtaupi)/(g.gpipi*g.pi); aux.pd = -g.R*g.T*g.gpi*g.gpi/(g.gpipi); |
|
aux.cp = -aux.R*g.tau*g.tau*g.gtautau; ... |
Equations in Version 1 | Equations in Version 2 |
... aux.T = T; |
|
aux.vt = 0.0 "initialized in case it is not needed"; aux.vp = 0.0 "initialized in case it is not needed"; |
|
if (aux.region == 1) then ... aux.dpT = -aux.vt/aux.vp; |
|
aux.pt = -g.p/g.T*(g.gpi - g.tau*g.gtaupi)/(g.gpipi*g.pi); aux.pd = -g.R*g.T*g.gpi*g.gpi/(g.gpipi); |
|
elseif (aux.region == 2) then ... aux.vp = aux.R*T/(p*p)*g.pi*g.pi*g.gpipi; |
|
aux.pt = -g.p/g.T*(g.gpi - g.tau*g.gtaupi)/(g.gpipi*g.pi); aux.pd = -g.R*g.T*g.gpi*g.gpi/(g.gpipi); |
|
aux.cp = -aux.R*g.tau*g.tau*g.gtautau; ... aux.vp = aux.R*T/(p*p)*g.pi*g.pi*g.gpipi; |
|
aux.pt = -g.p/g.T*(g.gpi - g.tau*g.gtaupi)/(g.gpipi*g.pi); aux.pd = -g.R*g.T*g.gpi*g.gpi/(g.gpipi); |
|
aux.cp = -aux.R*g.tau*g.tau*g.gtautau; ... |
Equations in Version 1 | Equations in Version 2 |
... aux.T = T; |
|
aux.vt = 0.0 "initialized in case it is not needed"; aux.vp = 0.0 "initialized in case it is not needed"; |
|
if (aux.region == 1) then ... aux.vp = aux.R*T/(aux.p*aux.p)*g.pi*g.pi*g.gpipi; |
|
aux.pt = -g.p/g.T*(g.gpi - g.tau*g.gtaupi)/(g.gpipi*g.pi); aux.pd = -g.R*g.T*g.gpi*g.gpi/(g.gpipi); |
|
aux.cp = -aux.R*g.tau*g.tau*g.gtautau; ... aux.vp = aux.R*T/(aux.p*aux.p)*g.pi*g.pi*g.gpipi; |
|
aux.pt = -g.p/g.T*(g.gpi - g.tau*g.gtaupi)/(g.gpipi*g.pi); aux.pd = -g.R*g.T*g.gpi*g.gpi/(g.gpipi); |
|
aux.cp = -aux.R*g.tau*g.tau*g.gtautau; ... aux.vp = aux.R*T/(aux.p*aux.p)*g.pi*g.pi*g.gpipi; |
|
aux.pt = -g.p/g.T*(g.gpi - g.tau*g.gtaupi)/(g.gpipi*g.pi); aux.pd = -g.R*g.T*g.gpi*g.gpi/(g.gpipi); |
|
aux.cp = -aux.R*g.tau*g.tau*g.gtautau; ... |
Component |
Version 1 |
Version 2 |
wNominal | displayUnit="rev/min" | displayUnit="1/min" |
Component |
Version 1 |
Version 2 |
lossTable | table=[0, 100, 500; 360, 1000, 500; 600, 100, 500] | table=[0, 100, 500; 360, 100, 500; 360, 1000, 500; 600, 1000, 500] |
smoothness=Modelica.Blocks.Types.Smoothness.ConstantSegments | |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
result := smooth(0, if length(v) >= eps then v/length(v) else v/eps); | result := smooth(0, noEvent(if length(v) >= eps then v/length(v) else v/eps)); |
Equations in Version 1 | Equations in Version 2 |
... if min(size(A)) > 0 then |
|
(xx,info,rank) = LAPACK.dgelsy_vec( A, b, rcond); |
(xx,info,rank) = LAPACK.dgelsx_vec( A, b, rcond); |
x = xx[1:size(A, 2)]; ... |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
(XX,info,rank) := LAPACK.dgelsy( A, B, rcond); |
(XX,info,rank) := LAPACK.dgelsx( A, B, rcond); |
X = XX[1:size(A, 2), :]; ... |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dgeev( "N", "V", n, Awork, n, eigenReal, eigenImag, dummy, 1, eigenVectors, n, work, size(work, 1), info); |
external "Fortran 77" dgeev( "N", "V", n, Awork, n, eigenReal, eigenImag, dummy, 1, eigenVectors, n, work, size(work, 1), info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dgeev( "N", "N", size(A, 1), Awork, size(A, 1), EigenReal, EigenImag, EigenvectorsL, size(EigenvectorsL, 1), EigenvectorsL, size(EigenvectorsL, 1), work, size(work, 1), info); |
external "Fortran 77" dgeev( "N", "N", size(A, 1), Awork, size(A, 1), EigenReal, EigenImag, EigenvectorsL, size(EigenvectorsL, 1), EigenvectorsL, size(EigenvectorsL, 1), work, size(work, 1), info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dgegv( "N", "N", n, Awork, n, Bwork, n, alphaReal, alphaImag, beta, dummy1, 1, dummy2, 1, work, size(work, 1), info); |
external "Fortran 77" dgegv( "N", "N", n, Awork, n, Bwork, n, alphaReal, alphaImag, beta, dummy1, 1, dummy2, 1, work, size(work, 1), info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dgesvd( "A", "A", size(A, 1), size(A, 2), Awork, size(A, 1), sigma, U, size(A, 1), VT, size(A, 2), work, lwork, info); |
external "Fortran 77" dgesvd( "A", "A", size(A, 1), size(A, 2), Awork, size(A, 1), sigma, U, size(A, 1), VT, size(A, 2), work, lwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dgesvd( "N", "N", size(A, 1), size(A, 2), Awork, size(A, 1), sigma, U, size(A, 1), VT, size(A, 2), work, lwork, info); |
external "Fortran 77" dgesvd( "N", "N", size(A, 1), size(A, 2), Awork, size(A, 1), sigma, U, size(A, 1), VT, size(A, 2), work, lwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dtrsen( job, compq, select, n, To, ldt, Qo, ldq, wr, wi, m, s, sep, work, lwork, iwork, liwork, info); |
external "Fortran 77" dtrsen( job, compq, select, n, To, ldt, Qo, ldq, wr, wi, m, s, sep, work, lwork, iwork, liwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dgesvx( "N", transA, size(A, 1), size(B, 2), Awork, lda, AF, lda, ipiv, equed, R, C, Bwork, lda, X, lda, rcond, ferr, berr, work, iwork, info); |
external "FORTRAN 77" dgesvx( "N", transA, size(A, 1), size(B, 2), Awork, lda, AF, lda, ipiv, equed, R, C, B, lda, X, lda, rcond, ferr, berr, work, iwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dtrsyl( trana, tranb, isgn, m, n, A, lda, B, ldb, X, lda, scale, info); |
external "Fortran 77" dtrsyl( trana, tranb, isgn, m, n, A, lda, B, ldb, X, lda, scale, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dhseqr( job, compz, n, ilo, ihi, Ho, ldh, alphaReal, alphaImag, Zo, ldh, work, lwork, info); |
external "Fortran 77" dhseqr( job, compz, n, ilo, ihi, Ho, ldh, alphaReal, alphaImag, Zo, ldh, work, lwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" anorm = dlange( norm, m, n, A, lda, work); |
external "Fortran 77" anorm = dlange( norm, m, n, A, lda, work); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dgecon( norm, n, LU_of_A, lda, anorm, rcond, work, iwork, info); |
external "Fortran 77" dgecon( norm, n, LU_of_A, lda, anorm, rcond, work, iwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dgehrd( n, ilo, ihi, Aout, lda, tau, work, lwork, info); |
external "Fortran 77" dgehrd( n, ilo, ihi, Aout, lda, tau, work, lwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dgeqrf( m, n, Aout, lda, tau, work, lwork, info); |
external "Fortran 77" dgeqrf( m, n, Aout, lda, tau, work, lwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dgeevx( "B", "V", "V", "E", n, AS, n, alphaReal, alphaImag, lEigenVectors, n, rEigenVectors, n, ilo, ihi, scale, abnrm, rconde, rcondv, work, lwork, iwork, info); |
external "Fortran 77" dgeevx( "B", "V", "V", "E", n, AS, n, alphaReal, alphaImag, lEigenVectors, n, rEigenVectors, n, ilo, ihi, scale, abnrm, rconde, rcondv, work, lwork, iwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dgesdd( "A", size(A, 1), size(A, 2), Awork, lda, sigma, U, ldu, VT, ldvt, work, lwork, iwork, info); |
external "Fortran 77" dgesdd( "A", size(A, 1), size(A, 2), Awork, lda, sigma, U, ldu, VT, ldvt, work, lwork, iwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dggev( "V", "V", nA, Awork, lda, Bwork, lda, alphaReal, alphaImag, beta, lEigenVectors, lda, rEigenVectors, lda, work, lwork, info); |
external "Fortran 77" dggev( "V", "V", nA, Awork, lda, Bwork, lda, alphaReal, alphaImag, beta, lEigenVectors, lda, rEigenVectors, lda, work, lwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dggevx( "B", "V", "V", "B", n, A, lda, B, lda, alphaReal, alphaImag, beta, lEigenVectors, lda, rEigenVectors, lda, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, iwork, bwork, info); |
external "Fortran 77" dggevx( "B", "V", "V", "B", n, A, lda, B, lda, alphaReal, alphaImag, beta, lEigenVectors, lda, rEigenVectors, lda, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, iwork, bwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dhgeqz( "E", "N", "N", n, ilo, ihi, Awork, lda, Bwork, lda, alphaReal, alphaImag, beta, Q, 1, Q, 1, work, lwork, info); |
external "Fortran 77" dhgeqz( "E", "N", "N", n, ilo, ihi, Awork, lda, Bwork, lda, alphaReal, alphaImag, beta, Q, 1, Q, 1, work, lwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dormhr( side, trans, m, n, ilo, ihi, A, lda, tau, Cout, ldc, work, lwork, info); |
external "Fortran 77" dormhr( side, trans, m, n, ilo, ihi, A, lda, tau, Cout, ldc, work, lwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dormqr( side, trans, m, n, k, A, lda, tau, Cout, ldc, work, lwork, info); |
external "Fortran 77" dormqr( side, trans, m, n, k, A, lda, tau, Cout, ldc, work, lwork, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dtrevc( side, howmny, select, n, T, ldt, lEigenVectors, ldvl, rEigenVectors, ldvr, n, n, work, info); |
external "Fortran 77" dtrevc( side, howmny, select, n, T, ldt, lEigenVectors, ldvl, rEigenVectors, ldvr, n, n, work, info); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dtrsm( side, uplo, transA, diag, m, n, alpha, A, lda, X, ldb); |
external "Fortran 77" dtrsm( side, uplo, transA, diag, m, n, alpha, A, lda, X, ldb); |
Equations in Version 1 | Equations in Version 2 |
external "FORTRAN 77" dorghr( n, ilo, ihi, Aout, lda, tau, work, lwork, info); |
external "Fortran 77" dorghr( n, ilo, ihi, Aout, lda, tau, work, lwork, info); |
Component |
Version 1 |
Version 2 |
pi | Present |
Equations in Version 1 | Equations in Version 2 |
algorithm |
|
result:=Complex(sum(v[:].re), sum(v[:].im)); | result:=Complex(0); |
for i in 1:size(v,1) loop | |
result= result + v[i]; end for; |
Equations in Version 1 | Equations in Version 2 |
when terminal() then Streams.close(file); end when; |
Equations in Version 1 | Equations in Version 2 |
... if Strings.find(oldName,"/") == 0 and Strings.find(newName,"/") == 0 then |
|
if replace then | Modelica_3_2_1_Build_4.Utilities.Internal.FileSystem.rename(oldName, newName); |
Files.remove(newName); end if; Internal.FileSystem.rename(oldName, newName); |
|
else ... |
Component |
Version 1 |
Version 2 |
fullName | | =Files.fullPathName(name) |
fileType | =Modelica.Utilities.Internal.FileSystem.stat(name) | =Modelica_3_2_1_Build_4.Utilities.Internal.FileSystem.stat(fullName) |
Equations in Version 1 | Equations in Version 2 |
... if fileType == Types.FileType.RegularFile or      fileType == Types.FileType.SpecialFile then |
|
Modelica.Utilities.Internal.FileSystem.removeFile(name); | Modelica_3_2_1_Build_4.Utilities.Internal.FileSystem.removeFile(fullName); |
elseif fileType == Types.FileType.Directory then | |
fullName = Files.fullPathName(name); |
|
removeDirectory(fullName); ... |
Equations in Version 1 | Equations in Version 2 |
... if fileType == Types.FileType.RegularFile then |
|
Streams.close(fileName); |
|
Modelica.Utilities.Internal.FileSystem.removeFile(                            fileName); ... |
Equations in Version 1 | Equations in Version 2 |
external "C" ModelicaInternal_readFile(fileName,stringVector,size(stringVector,1)); | algorithm |
for i in 1:size(stringVector, 1) loop stringVector[i] = readLine(fileName, i); end for; Streams.close(fileName); |
Equations in Version 1 | Equations in Version 2 |
external "C" exit(status); | external "C" ModelicaInternal_exit(status); |
Component |
Version 1 |
Version 2 |
G | =6.67408e-11 | =6.6742e-11 |
F | =9.648533289e4 | =9.64853399e4 |
h | =6.626070040e-34 | =6.6260693e-34 |
k | =1.38064852e-23 | =1.3806505e-23 |
R | =8.3144598 | =8.314472 |
sigma | =5.670367e-8 | =5.670400e-8 |
N_A | =6.022140857e23 | =6.0221415e23 |
Class | Version 1 | Version 2 |
class Modelica.UsersGuide.ReleaseNotes.Version_3_2_2 | Present | |
package Modelica.Blocks.Examples.NoiseExamples | Present | |
block Modelica.Blocks.Interfaces.PartialNoise | Present | |
block Modelica.Blocks.Math.ContinuousMean | Present | |
block Modelica.Blocks.Math.Variance | Present | |
block Modelica.Blocks.Math.StandardDeviation | Present | |
block Modelica.Blocks.Routing.IntegerReplicator | Present | |
block Modelica.Blocks.Routing.BooleanReplicator | Present | |
type Modelica.Blocks.Types.Regularization | Present | |
package Modelica.Blocks.Noise | Present | |
model Modelica.ComplexBlocks.Examples.ShowTransferFunction | Present | |
block Modelica.ComplexBlocks.ComplexMath.Conj | Present | |
block Modelica.ComplexBlocks.ComplexMath.TransferFunction | Present | |
block Modelica.ComplexBlocks.Sources.LogFrequencySweep | Present | |
package Modelica.ComplexBlocks.UsersGuide | Present | |
package Modelica.Electrical.Analog.Examples.OpAmps | Present | |
model Modelica.Electrical.Analog.Basic.Potentiometer | Present | |
model Modelica.Electrical.Analog.Ideal.IdealizedOpAmpLimted | Present | |
model Modelica.Electrical.Analog.Interfaces.IdealSemiconductor | Present | |
model Modelica.Electrical.Analog.Interfaces.IdealSwitch | Present | |
model Modelica.Electrical.Analog.Interfaces.IdealSwitchWithArc | Present | |
model Modelica.Electrical.Analog.Semiconductors.Diode2 | Present | |
model Modelica.Electrical.Analog.Sources.SupplyVoltage | Present | |
model Modelica.Electrical.Machines.Examples.AsynchronousInductionMachines.AIMC_Conveyor | Present | |
model Modelica.Electrical.Machines.Examples.SynchronousInductionMachines.SMPM_Braking | Present | |
block Modelica.Electrical.Machines.SpacePhasors.Blocks.QuasiRMS | Present | |
model Modelica.Electrical.Machines.Icons.QuasiStaticFundamentalWaveMachine | Present | |
model Modelica.Electrical.Machines.Utilities.MultiTerminalBox | Present | |
package Modelica.Electrical.Machines.UsersGuide | Present | |
model Modelica.Electrical.MultiPhase.Basic.MultiStar | Present | |
model Modelica.Electrical.MultiPhase.Basic.MultiDelta | Present | |
model Modelica.Electrical.MultiPhase.Basic.MultiStarResistance | Present | |
function Modelica.Electrical.MultiPhase.Functions.symmetricOrientationMatrix | Present | |
function Modelica.Electrical.MultiPhase.Functions.symmetricTransformationMatrix | Present | |
function Modelica.Electrical.MultiPhase.Functions.numberOfSymmetricBaseSystems | Present | |
function Modelica.Electrical.MultiPhase.Functions.factorY2D | Present | |
function Modelica.Electrical.MultiPhase.Functions.factorY2DC | Present | |
function Modelica.Electrical.MultiPhase.Functions.indexPositiveSequence | Present | |
function Modelica.Electrical.MultiPhase.Functions.indexNonPositiveSequence | Present | |
package Modelica.Electrical.MultiPhase.UsersGuide | Present | |
model Modelica.Electrical.QuasiStationary.SinglePhase.Examples.Transformer | Present | |
model Modelica.Electrical.QuasiStationary.SinglePhase.Basic.Impedance | Present | |
model Modelica.Electrical.QuasiStationary.SinglePhase.Basic.Admittance | Present | |
model Modelica.Electrical.QuasiStationary.SinglePhase.Basic.VariableImpedance | Present | |
model Modelica.Electrical.QuasiStationary.SinglePhase.Basic.VariableAdmittance | Present | |
model Modelica.Electrical.QuasiStationary.SinglePhase.Ideal.IdealTransformer | Present | |
model Modelica.Electrical.QuasiStationary.SinglePhase.Sensors.ReferenceSensor | Present | |
package Modelica.Electrical.QuasiStationary.Machines.SpacePhasors | Present | |
model Modelica.Electrical.QuasiStationary.MultiPhase.Basic.MultiStar | Present | |
model Modelica.Electrical.QuasiStationary.MultiPhase.Basic.MultiDelta | Present | |
model Modelica.Electrical.QuasiStationary.MultiPhase.Basic.MultiStarResistance | Present | |
model Modelica.Electrical.QuasiStationary.MultiPhase.Basic.Impedance | Present | |
model Modelica.Electrical.QuasiStationary.MultiPhase.Basic.Admittance | Present | |
model Modelica.Electrical.QuasiStationary.MultiPhase.Basic.VariableImpedance | Present | |
model Modelica.Electrical.QuasiStationary.MultiPhase.Basic.VariableAdmittance | Present | |
model Modelica.Electrical.QuasiStationary.MultiPhase.Sensors.ReferenceSensor | Present | |
model Modelica.Electrical.QuasiStationary.MultiPhase.Sensors.VoltageQuasiRMSSensor | Present | |
model Modelica.Electrical.QuasiStationary.MultiPhase.Sensors.CurrentQuasiRMSSensor | Present | |
model Modelica.Electrical.QuasiStationary.MultiPhase.Sources.ReferenceVoltageSource | Present | |
model Modelica.Electrical.QuasiStationary.MultiPhase.Sources.ReferenceCurrentSource | Present | |
model Modelica.Electrical.QuasiStationary.MultiPhase.Interfaces.ReferenceSource | Present | |
package Modelica.Electrical.QuasiStationary.MultiPhase.Blocks | Present | |
package Modelica.Electrical.QuasiStationary.MultiPhase.Functions | Present | |
package Modelica.Electrical.PowerConverters | Present | |
package Modelica.Magnetic.FluxTubes.UsersGuide.Hysteresis | Present | |
class Modelica.Magnetic.FluxTubes.UsersGuide.ReleaseNotes | Present | |
package Modelica.Magnetic.FluxTubes.Examples.Hysteresis | Present | |
model Modelica.Magnetic.FluxTubes.Basic.ElectroMagneticConverterWithLeakageInductance | Present | |
model Modelica.Magnetic.FluxTubes.Basic.ConstantPermeance | Present | |
model Modelica.Magnetic.FluxTubes.Basic.Idle | Present | |
model Modelica.Magnetic.FluxTubes.Basic.Short | Present | |
model Modelica.Magnetic.FluxTubes.Basic.Crossing | Present | |
model Modelica.Magnetic.FluxTubes.Shapes.FixedShape.GenericFluxTube | Present | |
package Modelica.Magnetic.FluxTubes.Shapes.HysteresisAndMagnets | Present | |
package Modelica.Magnetic.FluxTubes.Material.HysteresisEverettParameter | Present | |
package Modelica.Magnetic.FluxTubes.Material.HysteresisTableData | Present | |
model Modelica.Magnetic.FluxTubes.Interfaces.PartialGeneric | Present | |
model Modelica.Magnetic.FluxTubes.Interfaces.ConditionalHeatPort | Present | |
model Modelica.Magnetic.FluxTubes.Interfaces.PartialGenericHysteresis | Present | |
model Modelica.Magnetic.FluxTubes.Interfaces.PartialGenericHysteresisTellinen | Present | |
package Modelica.Magnetic.FluxTubes.Utilities | Present | |
model Modelica.Magnetic.FundamentalWave.Components.Permeance | Present | |
model Modelica.Magnetic.FundamentalWave.Components.Crossing | Present | |
model Modelica.Magnetic.FundamentalWave.BasicMachines.Components.SymmetricMultiPhaseCageWinding_obsolete | Present | |
model Modelica.Magnetic.FundamentalWave.BasicMachines.Components.SaliencyCageWinding_obsolete | Present | |
model Modelica.Magnetic.FundamentalWave.Interfaces.PartialTwoPortExtended | Present | |
model Modelica.Magnetic.FundamentalWave.Interfaces.PositivePortInterface | Present | |
model Modelica.Magnetic.FundamentalWave.Interfaces.NegativePortInterface | Present | |
record Modelica.Magnetic.FundamentalWave.Types.SalientPermeance | Present | |
package Modelica.Magnetic.QuasiStatic | Present | |
model Modelica.Mechanics.MultiBody.Examples.Rotational3DEffects.BevelGear1D | Present | |
class Modelica.Mechanics.Rotational.UsersGuide.ModelingOfFriction | Present | |
model Modelica.Mechanics.Rotational.Components.ElastoBacklash2 | Present | |
model Modelica.Mechanics.Rotational.Sources.SignTorque | Present | |
model Modelica.Mechanics.Translational.Sources.SignForce | Present | |
package Modelica.Mechanics.Translational.UsersGuide | Present | |
function Modelica.Media.R134a.R134a_ph.dofpT | Present | |
function Modelica.Media.R134a.R134a_ph.hofpT | Present | |
function Modelica.Media.R134a.R134a_ph.phaseBoundaryAssert | Present | |
package Modelica.Thermal.FluidHeatFlow.UsersGuide | Present | |
function Modelica.Math.Matrices.LAPACK.dgelsy | Present | |
function Modelica.Math.Matrices.LAPACK.dgelsy_vec | Present | |
function Modelica.Math.Matrices.balanceABC | Present | |
package Modelica.Math.Random | Present | |
package Modelica.Math.Distributions | Present | |
package Modelica.Math.Special | Present | |
package Modelica.Math.FastFourierTransform | Present | |
model Modelica.Utilities.Examples.WriteRealMatrixToFile | Present | |
model Modelica.Utilities.Examples.ReadRealMatrixFromFile | Present | |
function Modelica.Utilities.Streams.readMatrixSize | Present | |
function Modelica.Utilities.Streams.readRealMatrix | Present | |
function Modelica.Utilities.Streams.writeRealMatrix | Present | |
function Modelica.Utilities.Strings.hashString | Present | |
function Modelica.Utilities.System.getTime | Present | |
function Modelica.Utilities.System.getPid | Present | |
type Modelica.SIunits.DimensionlessRatio | Present | |
class Modelica_3_2_1_Build_4.UsersGuide.ReleaseNotes.Version_3_2_1_build_4 | Present | |
class Modelica_3_2_1_Build_4.UsersGuide.ReleaseNotes.Version_3_2_1_build_3 | Present |