Read Text Files from Dymola to Obtain Data & Assist Debugging


This article will explain some ways in which text files can be read into Dymola models. The article is intended for those seeking that specific information (go directly to summary of functions) and any student, or professional as yet new to Modelica, Dymola, and/or CAE software in general, interested in reading text files while running Dymola models.

Why Read In Files

There are a number of motivations for wanting to read text files.

  • The most obvious is that there is some data in a file, and you want access to it.
  • This is may be easy when the file is the right format, and can be read “natively” by your software, but this may not always be the case.
  • A text file is legible to you, the user. You can amend it casually (occasionally I receive an email asking whether Modelica is “acasual” rather than “acausal”) & rerun your script while debugging.

Reading Text from CAE Software

Often, engineering software has a convenient facility to read a selection of file types. It is also routine as many readers will well know, to use “translator” modules which read (for instance) one CAD format into an alternate CAD software, or structural analysis system.

  • In the case of Dymola, a “native” file would be a .mat file, because the software has been designed to conform to that industry standard.
  • In essence a .mat file is a binary file. You need to create an application to read it, or use a general purpose numerical analysis system such as the open-source Octave – learn more or even participate at:
  • When it comes to CAE software, translator modules can be costly, and add considerably to the overhead of using the software.

Often, it’s useful to be able to read a file that was written using general purpose software, or which you just typed out yourself, if need be. Such files are often text files. There is certainly not always facility to read these, because CAE software is usually more concerned with results.

There are many great advantages to text files. One also notes that the simulation logs, and input scripts for FEA software are also often simply text files. Better still these are often written automatically in a fixed format with various headers and sections which can be “found” by your models & functions, using some logical, albeit cumbersome string manipulation. It can be invaluable to be able to check data against these kinds of files.

Other advantages include:

  • You can read a text file visually. This means you can test that code is working as you write it, to be certain that terms, especially ones which can’t (yet) be plotted, are as you expect.
  • Such code checking is incredibly useful, whether programming a proprietary parametric design language, Modelica, Python, or anything else, and there are circumstances where the model might not be working properly, but functions you’ve made can be called separately to make sure they’re doing what they’re meant to, writing files full of helpful intermediate information.

Reader Functions

The purpose of this article is to illustrate the uses of, and syntax for a handful of key functions included in the Modelica Standard Library:



This function uses external code to count the lines in a file. It is useful because it provides an avenue by which to size an array to hold the content of the file in a way which suits the user.


Below an example is shown of an array being sized by a call to this function. Note that this will only work in the context of another function, rather than within a model.

Modelica Code Notes
String holdTxt[

The countlines function is used here to dimension an array.



This function reads the characters stored in a text file into a String array. Every line becomes an entry in the array. You need to define an array ahead of time as usual. It can be seen here that the array is set up with unknown dimensionality. Assigning it the value of the function output determines the dimension. However, one cannot do this within a model.


Below a function is printed which goes to a location on the machine & reads a text file. The result of this is a vector of strings, each entry of which is one of the lines of the file.

Modelica Code Notes
function reader

 input String pName = "sourcefile.txt";
 input String pPath = "";
 input Integer n=1;
 input String dumpFile="reader_out.txt";
 output String dump="";
Filename has a default Command path defaults to null. An input which tells the function which line should be the output from the function. In a function, setting a variable value on declaration acts as specification of a default.

Not so in model.

parameter String f_ = "f_.txt";
parameter String fs2 = "/";

 String holdTxt[:];
 String cmdPth="";
Stroke in a string. Its function as a comment marker causes problems in composing strings. In a function (exclusively), the
output of a function can become the sole source of the information
for the dimension of an array.

cmdPth:= pPath+fs2+pName;

A command path is composed.Remove() deletes any file of identical name.
Modelica.Utilities.Streams.print(cmdPth,f_); Modelica.Utilities.Streams.print(
      "line "+
      " was output to file "+
The file is printed. You can read this text file.

end reader;
The output for the function is assigned the value, choosing the line specified in the input.

The reader file listed above is written with several arguments. Note especially the integer signifying which line of the file to output.

Modelica.Utilities.Strings.scanReal / scanInteger / scanBoolean


These functions are very useful. While we’re used to writing out numbers as strings, for example, into a text file (see article) these let us “read” some text not only in the sense of reading & registering the characters but in the sense of “understanding” that they signify a numerical value.


Below the model is provided with which the function already shown can be called. Within this model there are several items which could just as easily have been included in the function. We have a reminder here that the equation section will be calculated at every time-step, and therefore any command to read scan a string and/or write it down in a text file will yield a result at each step. This could well be what is intended, and indeed, a main reason to put the scanReal() part in your model, not in the function, but here we’ve restricted it to the last time-step to more easily see what comes out, using when terminal() then.

Modelica Code Notes
model  caller_ext
parameter String chkFile = "f_.txt";
String my_str ;
Integer my_Int ;
Real my_Rea ;
Integer my_Int2 ;
Real my_Rea2 ;

Integer tail_1;
Integer tail_2;
Integer tail_3;
Integer tail_4;
Note that this is the same filename as the function uses to write its data to. The name is the same, but the variable that holds it has a different name in the model & the file is accessed separately.
my_str=reader("target2_file.txt", "F:\TESTER",3);

The variable is assigned the result of the function.
Notice the filename for reading by the function, the path & which line to output from the function, are inputs entered in the same order they’re declared in, inside the reading function.
Here, the my_Int receives whatever integer
is read by scanInteger. The tail variable receives the integer index of the first character in the string the machine cannot read as part of the integer. Similarly the real scanner.
when terminal() then
level = AssertionLevel.error);

“assert” will throw an error if the condition is not met. The error text is an argument. Here “oops”. In this case the condition is the existence of the file.
" "+

" "+

" "+

" "+

end when;

end caller_ext;

These longwinded lines serve simply to write out a concatenation of strings, to the chkFile.txt file, for the user to examine. Note that these files will be written to the working directory, despite the path that was given to find the source file. These are distinct concepts!


If the above model & function are run, we can get information in text form to be read & understood by Dymola file reading functions. Try using a file of your own, and filling it with some data, such as several rows of numbers, and reading it in. Experiment with using Dymola to pick them up from the text and for example, add them together, having used scanReal to have the machine actually interpret the data.

Ensure the command path and file names correspond to the ones you’re using.


We have seen how the reading of text files in Dymola can help in the checking of the workings of models or functions. We have also seen some examples of how to handle the strings that result, and functions which convert the strings of characters into meaningful values.

Several functions exist that inspect the metadata of text files, extract the content, and process the information carried therein, to convert it back into numbers from a string of characters. Using these you can read data, and obtain information.

If you’re a student interested in using the Dymola software for your college coursework, or if you want to learn more about programming parametric engineering models in Modelica, then contact Claytex support (

Written by: Sas Harrison – Systems Engineer

Please get in touch if you have any questions or have got a topic in mind that you would like us to write about. You can submit your questions / topics via: Tech Blog Questions / Topic Suggestion


Got a question? Just fill in this form and send it to us and we'll get back to you shortly.


© Copyright 2010-2024 Claytex Services Ltd All Rights Reserved

Log in with your credentials

Forgot your details?