MuPhyN - MultiPhysical Nexus
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Number of Parts | 542 | |
| Author | ||
| License | CC Attribution 2.0 Belgium: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/61908 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
FOSDEM 2023426 / 542
2
5
10
14
15
16
22
24
27
29
31
36
43
48
56
63
74
78
83
87
89
95
96
99
104
106
107
117
119
121
122
125
126
128
130
132
134
135
136
141
143
146
148
152
155
157
159
161
165
166
168
170
173
176
180
181
185
191
194
196
197
198
199
206
207
209
210
211
212
216
219
220
227
228
229
231
232
233
236
250
252
256
258
260
263
264
267
271
273
275
276
278
282
286
292
293
298
299
300
302
312
316
321
322
324
339
341
342
343
344
351
352
354
355
356
357
359
369
370
372
373
376
378
379
380
382
383
387
390
394
395
401
405
406
410
411
413
415
416
421
426
430
437
438
440
441
443
444
445
446
448
449
450
451
458
464
468
472
475
476
479
481
493
494
498
499
502
509
513
516
517
520
522
524
525
531
534
535
537
538
541
00:00
MultiplicationSystem programmingComputer simulationPhysicsSimulationChainMechatronicsCollaborationismForschungszentrum RossendorfGraphical user interfaceComputer simulationSoftwareProjective planePhysical systemChainSoftware developerDiagramLecture/Conference
00:53
SimulationMultiplicationSoftwarePhysicsDifferent (Kate Ryan album)Open setComputer simulationPhysical systemVariable (mathematics)Projective planeDifferent (Kate Ryan album)Local ringType theoryComputer animation
01:45
SimulationPoint (geometry)Computer simulationPhysical systemAnalogyData conversionNumerical analysisScale (map)Moment of inertiaMereologyMultiplicationComputer simulationMoment of inertiaPhysical systemPoint (geometry)Reduction of orderMultiplication signMereologyDifferent (Kate Ryan album)Square numberAdaptive behaviorLecture/Conference
04:06
Physical systemMoment of inertiaMereologyPoint (geometry)Scale (map)PhysicsSoftwareSimulationMultiplicationComputer simulationAdaptive behaviorData structureOpen sourceClosed setCurve fittingSystem programmingMathematicsWell-formed formulaBinary multiplierPower (physics)Logical constantView (database)Computer fileDirected graphGraph (mathematics)NoiseSawtooth waveSineSquare numberGreen's functionGraphical user interfaceSoftwareUsabilityComputer simulationRegulator geneFunctional (mathematics)ResultantProjective planeCartesian coordinate systemOpen sourceCuboidDrop (liquid)Physical systemDrag (physics)Power (physics)Graph (mathematics)Multiplication signClosed setNumbering schemeCondition numberComputer animation
06:49
SimulationGraph (mathematics)Default (computer science)Library (computing)SoftwareProcess (computing)CuboidProcess (computing)Cartesian coordinate systemComputer simulationDefault (computer science)Graph (mathematics)Lecture/Conference
07:22
Graph (mathematics)SimulationLibrary (computing)Default (computer science)Process (computing)SoftwareMathematicsOpen sourceMultiplicationAdditionHeat transferFunction (mathematics)Square numberNoiseGoogle Street ViewDerivation (linguistics)Digital filterComputer simulationCartesian coordinate systemDefault (computer science)CuboidMoving averageGraph (mathematics)Heat transferSignal processingOpen setOrder (biology)Computer animationLecture/Conference
07:54
Default (computer science)MathematicsOpen sourceFunction (mathematics)Heat transferDigital filterDerivation (linguistics)AdditionMultiplicationSquare numberNoiseGraph (mathematics)Library (computing)SoftwareComputer fileCuboidCartesian coordinate systemLibrary (computing)Lecture/Conference
08:17
Computer fileSoftwareCodePlot (narrative)Electronic visual displayGraph (mathematics)Multiplication signCuboidCondition numberComputer filePlotterCodeDescriptive statisticsGraph (mathematics)Computer animation
09:27
SoftwareElectronic visual displaySimulationPlot (narrative)Open sourceGraph (mathematics)InformationRevision controlLibrary (computing)Directed graphComputer fileCharacteristic polynomialLibrary (computing)CuboidMetadataDefault (computer science)Cartesian coordinate systemParameter (computer programming)Function (mathematics)Characteristic polynomialType theoryLecture/ConferenceComputer animation
10:25
Graph (mathematics)Characteristic polynomialParameter (computer programming)SoftwareString (computer science)outputNumberChi-squared distributionDefault (computer science)CountingDefault (computer science)outputNumberRange (statistics)Parameter (computer programming)Lecture/ConferenceComputer animation
11:17
Characteristic polynomialParameter (computer programming)NumberoutputDefault (computer science)String (computer science)Graph (mathematics)SoftwareComputer fileComputer fileLecture/Conference
11:40
Graph (mathematics)SoftwareSimulationClefPlot (narrative)Functional (mathematics)PlotterCuboidProcess (computing)Lecture/ConferenceComputer animation
12:31
SimulationPlot (narrative)Computer fileGraph (mathematics)SoftwareData structureComputer fileDescriptive statisticsPlotterCodeCuboidLibrary (computing)Functional (mathematics)Lecture/ConferenceComputer animation
13:15
Library (computing)Data structureSoftwareLibrary (computing)CuboidLecture/Conference
13:37
Library (computing)Computer fileData structureSoftwareIntegrated development environmentVariable (mathematics)Parameter (computer programming)Variable (mathematics)Computer simulationIntegrated development environmentInteractive televisionParameter (computer programming)Computer animation
14:23
Integrated development environmentVariable (mathematics)Parameter (computer programming)SoftwareSystem dynamicsComputer simulationCartesian coordinate systemVariable (mathematics)Lecture/Conference
14:53
Variable (mathematics)Parameter (computer programming)System dynamicsIntegrated development environmentSoftwareExtension (kinesiology)Computer animation
15:14
Variable (mathematics)CodeView (database)Clique-widthAngleParameter (computer programming)Pulse (signal processing)Computer fileInformationThread (computing)SynchronizationOpen sourceGeometryMaxima and minimaoutputGraph (mathematics)Asynchronous Transfer ModeDirected graphComputer simulationBeta functionParameter (computer programming)Cartesian coordinate systemInformationComputer simulationComputer animation
16:12
Maxima and minimaVariable (mathematics)Computer fontSummierbarkeitView (database)CodeInformationThread (computing)SynchronizationPulse (signal processing)SineGeometryAngleParameter (computer programming)Phase transitionBeta functionComputer simulationMoore's lawOpen sourceComputer fileClique-width2 (number)Game controllerComputer animation
16:48
Structural loadControl flowSoftwareCuboidFilm editingProjective planeComputer animation
17:13
SoftwareProcess (computing)SimulationPhysicsMultiplicationScheduling (computing)Integrated development environmentFormal languageProcess (computing)Integrated development environmentComputer simulationServer (computing)Power (physics)CuboidCartesian coordinate systemMultiplication signFormal languageExterior algebraLecture/Conference
18:42
Revision controlSoftwareSoftware developerJava appletInformationInstallation artCartesian coordinate systemLink (knot theory)UsabilityProjective planeOpen sourceInteractive televisionElectronic mailing listGroup actionComputer animation
19:42
SoftwareVariable (mathematics)Moment of inertiaMultiplication signWellenwiderstand <Strömungsmechanik>Scheduling (computing)BitAnalogyFunctional (mathematics)Projective planeMereologyInterface (computing)Function (mathematics)MathematicsSoftwareComputer simulationPhysical systemCartesian coordinate systemCuboidPhysicalismLocal ringRight angleStress (mechanics)Set (mathematics)Process (computing)Point (geometry)Computer animationLecture/Conference
26:18
Program flowchart
Transcript: English(auto-generated)
00:06
Hello, everyone. I'm Dylan Fieve, and I'm a research engineer at the Seraf Technik Research Center in Mons in Belgium. Today I will present to you the software Muffin, which is a graphical tool for modeling and simulating multiphysics systems. So
00:26
the project started with a research project. It is a collaboration with Thales Alenia Space. It's a research project funded by the Wallonia, so a public fund of Belgium.
00:45
And the goal of the project is the development of a simulation method to assist in the design of mechatronic chains with a complete multiphysics model. So in other terms, what are the goals of the project? It exists different kinds of multiphysics simulation
01:07
software. The global variable simulation type, like Open Modelica, which simulates a system by item like a motor, etc. And we have a local variable simulation, like Finite Element
01:24
Simulation System, Finite Element Simulation for Multiphysics System. And both types of simulation are not compatible with each other, so the research project tried to find another
01:41
way to simulate a multiphysics model with using electrical analogous modeling. So the method we want to develop is a simulation in three points. So the first step is to
02:02
convert physical system to electrical analogous system. The second step is to convert those electrical analogous model to numerical model. And the last step is reducing numerical model with evaluating the influence of each part of the system to the other, to the rest of the
02:26
system. And a second point, a more important point for our research is a time-squared adaptive model reduction. So how to explain that? In a system, we have a low inertia part in the
02:44
system and high inertia, so low inertia part of the system are a part of the system that evolve quickly in the time and high inertia evolve slowly with the time. So
03:13
when we make a simulation, a physical simulation, we have to find an optimal step size. If we have
03:26
a too large step size, the accuracy will decrease. And if we have a smaller step size, we will have a sufficient accuracy. But if the step size is too much small, the time
03:44
to execute the simulation will be increased for a little gain of accuracy. So we have a multiple inertia part in a multiphysics system and we want to find a way to optimize
04:03
the simulation by using different time squares in the system. So for the project, we have some requirements when we will choose the simulation software. We need a multiphysics
04:24
simulation software. This one must be adaptable. It must be able to adapt the model as a function of the condition of simulation, like the time, et cetera. And last but not least,
04:48
the application must be user friendly. So we have Simulink with Matlab or X-Cost with Scilab. That would be a very, very good application for the project. But Simulink
05:08
is expensive. It's a closed source software and not exactly adapted to our requirement. And it's a closed source software, so we couldn't modify Matlab like we wanted. And for X-Cost,
05:29
it's not user friendly. And like Matlab, it doesn't exactly fit with the project requirement. So we decided to develop our own software that leverages existing powerful Python libraries.
05:46
Here is an overview of our application. It has been used in a regulation system, and here we have an example of results for this regulation system. So the software,
06:05
it's a graphical tool for modeling and simulating multiphysics systems. Here is a quick demonstration of how to use the application. So to build the simulation graph, it's just a drag
06:24
and drop from box libraries to a scheme drawing. And then once the simulation graph is done, you can easily launch the simulation. We can use multiple projects at the same time.
06:42
Save and load a project, et cetera. So what is the application? The application is a simulation graph builder. We have provided some default libraries to use the application if you install
07:02
it on your computer. But you can easily add your own process boxes and can solve all the simulation you've been building in the application. We have implemented some default
07:23
simulation solver, but you can also add your custom simulation solver. So here is a list of default boxes in the application. We have a mat application like addition, multiplication,
07:44
derivative, et cetera, signal processing with transfer function, et cetera, sources, an order like a graph displayer, and also open modeling, simulation embedder, et cetera.
08:01
So if you want to install the application on your PC and want to create your own library of boxes, if we want to create our own box, we have to know that a box is defined by two files.
08:25
The first one is a description file written in YAML. The second one is a code file written in Python. And there is one condition to make it as a box. It's that both files must share the same
08:44
base file name. So how to create a box? I will take an example. I will create a box that is able to display graphic data in a graph. So the goal of the box is to display data
09:06
in a two-axis plot. In the X-axis, the time and the Y-axis, the value. The box must be able to display data from one or more sources.
09:23
And the graph must be displayed at the end of the simulation. There is how the box must behave during the simulation and at the end of the simulation. So how to create the box? The first step is to define the metadata of the box with the box name, the library name,
09:47
version, author, and creation date. It's just a metadata of the box. Then we will define the characteristic of the box. What I mean by characteristic is all the inputs, all the outputs of the box, and the parameters.
10:07
So for the box, for the graphical box, we need three parameters. The title, the label for Y-axis, and the label for X-axis. We must define the type of the parameter,
10:23
and we can define a default value. For the outputs, the box doesn't require any outputs. And for the inputs, we have three conditions. The first one, we have defined a default count
10:42
of inputs to one. So the box, by default, will have one input. The number of inputs must be unlimited. So we must write the parameter is infinite to true.
11:02
And the number of inputs must be not limited. And that means we can define a range of number of inputs. So we can limit, for example, the number of inputs from one to five, for example. But in this case,
11:21
we won't define any limit. The next step is to define a behavior. So how to define the behavior of the box? We write a Python file we write a Python file. When we write a Python file, we can use all of the available Python
11:47
libraries. We have to define three functions. The first one, an init function.
12:06
Sorry, an init function. In our case, this function will init the plot. The second one is during the simulation. What will the box do? What is the process inside the box during the simulation? In our case, it's saving data.
12:25
And what will the box will do after the simulation? And in our case, it's plot the data. Then the next step is to connect the description file and the code file, the
12:41
Python file. To connect both, you only have to write the name of the associated function. Then we have created a box. Now we want to add it in a library. So a library is just
13:02
a collection of boxes. In practical, a library is just a folder containing a YAML file and Python file. For now, a library is a folder that doesn't accept subdirectories. At the time,
13:24
we can't put our file in subdirectories. It won't be recognized. So we have our folder. We add our first box with our two files, the second one, etc. And it's how we make a library.
13:51
Another feature we added to muffin is an IPython interaction. So muffin can be run in an IPython session. It means that muffin can access all the
14:08
IPython variables, all variables declared in the IPython environment. We can use all these variables as simulation parameters. And the access variable is dynamic. It means that
14:25
we can launch the application at the beginning of the session, declare variables in the IPython and use it dynamically. So if I launch a first simulation with some parameters,
14:43
I update it after one simulation. If I launch a second simulation, the second simulation will take the new value into account for the new simulation. How to use it in an IPython session?
15:04
The first step is to load the muffin extension with the command loadext. And then just run the muffin command. There is a demonstration of how it works. So we have firstly declared our
15:24
parameter in a notebook. We will create a simulation with two signed signals. And then we will configure all the parameters.
15:54
We have implemented some information for the user. When he writes a wrong
16:04
variable name, the application will give the information to the user. So here we have all of both signals. The first one at 10 hertz with an amplitude of 10.
16:30
And the second one at 5 hertz with an amplitude of 7. I will launch the demonstration. Then we will update the value of the second signal, the amplitude of the second signal
16:46
only. And we have a signal with the new values. We have implemented other control features like saving and loading projects, working with multiple projects at the same time,
17:04
copying past boxes and cut also, deleting blocks, then cancel action, etc. So in conclusion, we have developed our own multi-physics simulation software.
17:30
The advantages of this application is that the application is entirely coded in Python. So we have access to many powerful libraries like NumPy, SciPy, etc.
17:42
for the application and for the custom processing boxes and simulation servers. The application is very adaptive. What I mean by that is that you can easily implement your own custom boxes and custom simulation server.
18:04
And the application can be associated to an IPython environment. So Muffin offers a Python alternative to MATLAB plus Simulink.
18:20
These advantages of the application, it's written in a scripting language. So we have higher solving times. It's a young application at the time, so we need more time to offer a lot of features. And we need more users to improve the experience.
18:45
So what's next? We will have to work on compatibility. We want to make the transition from PyQT 5 to PyQT 6. And we want to add more interactivity with the user to improve the user-friendliness
19:05
of the application. Here is a list of the contributors of the project. And here are the links of the project. If you want to read all the source code,
19:24
you have the link to the GitLab. And if you want to try the application, we have a package available on pipe. If you want to try to install it directly in your Python, you can use pip install Muffin.
19:44
So thank you for your attention. If you have some questions.
20:10
Electrical analogy to make the calculation, you use the electrical equation, right? Can you repeat? I will repeat after.
20:22
At the beginning of the presentation, you said you come from physical... Yes, we want to make mechatronics simulation. And we want to convert all the part of the system to electrical analogues.
20:43
Why did you choose electrical simulation? We don't choose any... At the time, we don't choose any software like... Sorry, I'm a bit stressed. Electrical simulation, I don't remember the name. But
21:09
the point with those software is that the model is not dynamic. We can't try a lot of sets easily. But the aim of our application is to, with the time, make a box to
21:30
create an interface to other multi-physics applications. We don't want to replace those applications. We just want to create an interface to those applications to use it in our research
21:44
project. If I can rebound on that, because it's an important project. The idea is a lot of process can be simulated with impedance like thinking, like thermal stuff, mechanical stuff. You had already between the physical aspect and the electrical impedance step.
22:07
So my question was, how do you use electrical equations, because they are simpler to solve, according to the physical equation? Sorry guys, there is a stream, people watching on the web, you have to go through the mic. Maybe you can go
22:22
instead and use the mic if you want to answer that question. Oh, you can repeat, maybe. Yeah, that would be great, if you could at least summarize. The goal is for the user to understand better the problem. Okay, the goal of the project, of the application, is to improve the comprehension of the system.
22:42
Is it time to make it real-time to accelerate the wide process? Sorry, I don't have heard. Can we in the future make a value in the entrance, like the boxes,
23:07
and change directly the value and see the output directly with the hit play button? Sorry, I don't have heard the question. I'm a bit deaf.
23:27
The question was, can you do a real-time simulation? No, the simulation, can we do a real-time simulation? For now, it's not possible. We want to implement that in the future.
23:44
For now, the application, we just run the initialization function, then run the simulation function and the ending function, and all the functions are run in one time.
24:00
At the time, we don't have implemented a real-time overview of the simulation, but we plan in the future to add this feature.
24:21
So, in the beginning, you talked about the slow paths, and the high inertia and lower inertia paths of your simulations. Yes. And you said that your software was designed to deal with local variable solutions and global variable simulations.
24:44
How does that translate into what you've shown us? Where is the global variable part? So, I'll repeat the question. I've said that we have in a system a low inertia part and high inertia part,
25:02
and also local variable simulation software and global variable software. How does this translate into what you've shown us? Or does it implement it in the application?
25:23
Yeah, where is it in the application? How did this concept translate into the application you've shown us? At the time, it's not implemented. It's the background of the project.
25:41
All right. But it leads to a scheduler problem. So, the idea is we want to have two schedulers, and then, at this time, we wait to keep for the three. Discussion can go on in the whole course.
26:01
That's a great part of the first time. So, go on with the discussion. We should switch speakers now. Thank you.