I wanted to implement an object using an array indexed by an enumeration value, as described in Section 10.5.1 of the Modelica Language Specification (`Indexing with Boolean or Enumeration Values'), but I couldn't quite get it to work.

That is, this works:

type Sizes = enumeration (small, medium);

model Test
  constant Real[Sizes] sz = {1.2, 3.5};
  parameter Real x0 = sz[Sizes.small];
  Real x;
equation
  x = x0;
end Test;

type Sizes = enumeration (small, medium);

model Test
  constant Real[Sizes] sz = {1.2, 3.5};
  //parameter Real x0 = sz[Sizes.small];
  parameter Sizes size = Sizes.small;
  parameter Real x0 = sz[size];
  Real x;
equation
  x = x0;
end Test;

class Test
  constant Real sz[1] = 1.2;
  constant Real sz[2] = 3.5;
  parameter enumeration(small, medium) size = Sizes.small;
  Real x;
  parameter Real x0 = sz[Sizes.small];
equation
  x = x0;
end Test;

Test.c: In function ‘bound_parameters’:
Test.c:309:10: error: ‘$Psz$lBUNKNOWN_SUBSCRIPT$rB’ undeclared (first use in this function)

Real[Boolean] bb = {10.0, 11.0};

[Test.mo:2:3-2:34:writable] Error: Variable Boolean not found in scope Test

O.K. then.

I guess there's not much point using CORBA system to edit init.txt and then CORBA system to run the old executable.

Thanks for the tip about sed.  It's a nice program.  I've been using awk for the same purpose.  Ultimately though I'll be doing it in Python, which shouldn't be very difficult.

Thanks too for the notice about the switch to XML for init.txt.  I won't bother writing an init.txt pyparser then.

I guess my immediate plan then will be to update my OpenModelica to get the init.xml behaviour, set up init.xml reading, modifying, and writing in Python, and then call the simulator with os.popen (or rather subprocess.check_call since os.popen is deprecated).

Thank you again for the prompt and clear responses.

Oh, but if I want to modify parameters between simulations, such as those appearing in the MyModel_init.txt, the OMShell/CORBA way is to use e.g. setComponentModifierValue, but these modifications won't be made known to the precompiled simulator binary MyModel; if I simply follow the calls to setComponentModifierValue by a call

    system("./MyModel")

it will just read the old MyModel_init.txt and my modifications will have been in vain.  Is that right?

What I want to do is compile once and then run many times with slightly different parameters.  I can do this via tinkering with MyModel_init.txt, but I wonder if it is possible via OMShell/CORBA.

Hey, that's easy. Thank you very much for the prompt response!

Hello.  I'm running an OpenModelica simulation from Python, much along the lines of `Python interoperability' in the `OpenModelica Users Guide'.  In particular, following the `second option', after having built the binary executable, I tinker with the parameters in *_init.txt and rerun using

   os.popen ('./CalledbyPython').read ()

What I wonder though is how to do this using the `third option' (`to use the Corba interface for invoking the compiler and then just use the scripting interface to send commands to the compiler via this interface').  I have this working, but in order to run a simulation after having modified the parameters (via Corba, using setComponentModifierValue, etc.), I can only find the `simulate' command which seems to involve (a) recompiling the Modelica model from .mo to .c, (b) compiling the .c program to an executable, and (c) running the executable.  I know I can do (a) and (b) with buildModel (either in OMshell or via Corba), but how do I do (c) without (a) and (b)?

In my case, I want to run the same model dozens or hundreds of times with different values in the _init.txt file, but no structural changes to the model, so recompilation should not be required; indeed it's not as I can do this via the OS shell.  The question is, can this also be done via the OMShell/Corba?