Explore the contents of this article with a free Wolfram SystemModeler trial. Today we are proud to announce the release of Wolfram SystemModeler 4.

For SystemModeler 4, we have expanded the supported model libraries to cover many new areas. We’ve also improved workflows for everything from learning the software to developing models to analyzing and deploying them.

People have been using SystemModeler in an astonishing variety of areas. Many of those have been well supported by built-in libraries, but many are totally new domains where models typically need to be built from scratch.

For most applications, using existing model libraries gives a real boost to productivity, but developing a good library takes a lot of effort. There are many aspects to think of: the best structure for easy modeling, the right level of detail, the interfaces to other components, which components to include, documentation, etc. And you may very well have to refactor the library more than once before you’re done. Reusing components and interfaces from already tested and documented libraries not only speeds up development and learning, but also improves quality.

So we’ve made SystemModeler‘s already broad collection of built-in libraries even larger. For instance, we’ve added Digital, for digital electronics following the VHDL multivalued logic standard; QuasiStationary, for efficient approximate modeling of large analog circuits; and FundamentalWave, for modeling multiphase electrical machines. There are also many improvements to existing libraries, such as support for thermal ports in the Rotational and Translational mechanics libraries so that heat losses can be captured.

But we also wanted to make it easy to access all the other great existing and future model libraries. So we decided to create a marketplace for both free and paid libraries, the SystemModeler Library Store. With the Library Store you get easy download and automatic installation, and we are even working with the Modelica Association to get a new standard accepted for such library bundles to enable this simple workflow more generally. All the libraries in the store are verified to work with SystemModeler 4, and we are working with developers to bring you new and updated libraries on an ongoing basis.

So what sorts of modeling libraries can you already find in the Library Store? Well, they cover a variety of areas—for example, Hydraulic, for hydraulic actuators and circuits as in an excavator arm or flight controls; BioChem, for biochemical systems as in compartmental or pathway models; SmartCooling, for cooling circuits such as battery stacks or combustion engines; SystemDynamics, for sociotechnical models such as energy markets, disease propagation, and logistics; and PlanarMechanics for constrained 2D mechanical systems such as revolute joints in robots.

The world of modeling libraries and areas covered by SystemModeler just got bigger. And with the Library Store we expect to expand on the available libraries continuously. Interestingly, we’ve interacted with many R&D groups that have in-depth knowledge of different areas—from tire modeling for off-road machinery, to chemical reactors, to classes of disease pathways, etc.—for which libraries don’t yet exist. With the SystemModeler Library Store, there is an actual marketplace where such knowledge—if made into a library—can readily be made available. There really is no limit to the areas that can be made accessible with well-designed model libraries.

So, with more built-in libraries and a dedicated Library Store, you have a more powerful modeling tool. But how do you find out what is in one of these libraries? And how do you learn to use the software? How do you learn to model in the first place? With SystemModeler 4 we have created a new Documentation Center (online and in-product) as the hub from which questions like these can be answered.

The Documentation Center makes it easy to browse and search all product and library documentation, which includes video and text tutorials as well as the more-structured library pages. But it also provides access to additional resources, such as free online training courses, other SystemModeler users in the Wolfram Community, technical support, and technical consulting.

The documentation is extensively cross-linked so that when you, for instance, look up a component, you will immediately find links to connectors, parameters, subcomponents, and—particularly useful—a list of examples that make use of that component. And for simulatable models, you will find links to all components that they use, as well as the ability to directly simulate the models from the documentation in SystemModeler.

So learning about libraries and how to use them has become much easier. But what do you do when there is no library? SystemModeler is set up to also support modeling from the ground up using the Modelica language. For SystemModeler 3 we pointed people to the Modelica book by Michael Tiller as the most accessible resource. But the book was getting out of date with recent developments, and fortuitously Michael came to us with the idea of producing an updated Creative Commons version of the book. A little later he launched a Kickstarter project, which we’re happy to say we were one of the first gold sponsors for. The project got funded and the first version became available this spring, and we are now including this book, Modelica by Example, as part of the Documentation Center in SystemModeler. This is a great resource for when you want to learn more about the Modelica language.

Model libraries are all about reusing and connecting component models in SystemModeler. But is there a way that you can reuse models outside of SystemModeler in other software? SystemModeler provides a standalone executable for simulatable models that can be called using a TCP/IP-based API. This means it can be integrated into most software systems by using the appropriate API calls.

But for simulation software we can make this easier and do away with programming. Functional Mockup Interface (FMI) is an industry standard that we and other modeling and simulation companies have been developing for this very purpose. The idea is that by standardizing the interfaces we can enable model exchange without the user needing to do any programming. This means there can be complementary tools that make use of these models, including things like system integration tools that integrate both software and hardware modules. SystemModeler 4 now supports FMI export, which can be used in several dozen other software systems immediately and in many more to come.

So SystemModeler on its own is a very powerful system, but when used together with Mathematica you open up a whole new world of uses, including programmatic control of most tasks in SystemModeler; support for model calibration, linearization, and control design; access to the world’s largest web of algorithms and data; interactive notebooks; cloud integration; and more.

The integration between SystemModeler and Mathematica has been improved throughout, so things are generally faster and smoother. One noticeable change is that any model is now displayed using its diagram or icon, which you can even use as input to other functions.

In the plot above, the model is compiled and simulated automatically. And with SystemModeler 4, you can now perform real-time simulation and visualization of models. You can even use input controls such as sliders, joysticks, and so on to affect the simulation model in real time, and you can conveniently use gauges and other real-time visualizations to display simulation states. This means you can easily build a mockup of a system using inexpensive input devices and have the system react like the real thing, whether for a virtual lab, an actual intended product, or whatever.

In SystemModeler 4, you can now create models automatically from differential equations in Mathematica without writing the detailed Modelica code. You can also create components, which are models with interfaces so they can be connected to other components. This makes it simple to derive a key component in Mathematica and then rely on SystemModeler for other parts of the overall model. In fact, you can even connect components programmatically from Mathematica, making it easy to explore whole worlds of modeling alternatives, for instance replacing one or several components with ones that have different failure behaviors.

One particularly interesting type of model that is algorithmically derived from others is a control system. In the real-time simulation above, a human can directly interact with a model through input control devices. But many “smart” systems don’t have a human in the loop, but rather a controller that automatically decides inputs for the model based on measurements and an internal model, just like the familiar cruise control for a car, or autopilot for a plane. An important task in many system designs is to derive such a control algorithm. Mathematica has a full suite of control design algorithms with many new capabilities added in Mathematica 9 and 10, including automated PID tuning, support for descriptor, delay, and nonlinear systems. So in SystemModeler 4 you can now design the controller, create the corresponding model component, connect it to the rest of the system, and simulate the closed-loop system at full fidelity.

This is just a sampling of the myriad ways SystemModeler and Mathematica can be used together. Some of the uses we’ve seen include deriving and testing model equations, performing more advanced analysis of models (like sensitivity analysis or computing aggregate measures of performance or efficiency for different subsystems), and creating informative visualizations, animations, and manipulations, as well as presentation material to communicate designs to students, managers, and customers. Many of our users have already adopted this way of working, and of course we use it extensively in developing SystemModeler.

For more on what’s new in SystemModeler 4 as well as examples, free courses, and trial software, check out the SystemModeler website.