Simple equation involving Complex numbers is solved incorrectly

[Francesco Casella]

I have a power system model containing the following equation

vAt = k*vA;

where vAt and vA are SI.ComplexVoltage variables and k is a Complex constant. In this specific case, k is a Real constant quantity, so

k = Complex(r, 0.0);

where r is a Real parameter.

In the specific model I am trying to run, vAt is computed first, so OMC tries to solve this equation for vA. This should be indeed trivial to do symbolically, and should lad to this result:

vA.re := DIVISION(vAt.re,r);
vA.im := DIVISION(vAt.im,r);

What I get instead is

$cse5 := Complex.'constructor'.fromReal(r, 0.0);
linear torn system with 2 unknowns, tearing variable is vA.re
(torn) vA.im := DIVISION($cse5.re * vA.re - vAt.re, $cse5.im)
(residual) $cse5.im * vA.re + $cse5.re * vA.im - vAt.im = 0

Unfortunately OMC does not solve this equation symbolically, which should be trivial in this case, as k.im is known to be a literal zero constant.

Even worse, it tries to solve this as an implicit system of linear equations, and it picks a tearing variable which leads to a division by k.im, which is in fact a literal zero, so it causes a singularity:

(torn) vA.im = (r*vA.re - vAt.re)/0.0 = 0.0/0.0

I don't think we should try to fix the tearing here, but rather try to make sure that equations dealing with Complex numbers are really brought down to their scalar components, so that all symbolic simplifications can be applied, particularly in those cases where the equations are actually decoupled, as in this case.

I tried to reproduce the problem with this simple model

model foobar
  Complex vAt;
  Complex vA;
  parameter Complex k = Complex(r,0.0);
  parameter Real r = 10;
equation
  vAt = k*vA;
  vAt = Complex(time,2*time);
end foobar;

but of course by Murphy's law, this time OMC selects vA.im as the tearing variable, so it can actually solve the equation. In any case it does so in this way;

(torn) vA.re := DIVISION(vAt.re + k.im * vA.im, k.re)
(residual) k.im * vA.re + k.re * vA.im - vAt.im = 0

which is not the right way to go for the reasons discussed above.

Anyone can help me to make sure that the foobar model is solved as

vA.re := DIVISION(vAt.re,r);
vA.im := DIVISION(vAt.im,r);

I guess that would also solve my original problem, because no tearing will be used then.

Thanks!