Look into PyStar

[jngrad]

Source code: alexander.d.kazakov/pystar

Installation: pip3 install simlearn

Running PyStar:

import espressomd
from simlearn import PyStar
PyStar.run()

At the time of writing, this requires ESPResSo 4.1.4 (4.2-dev doesn't work out-of-the-box).

Most of the GUI python code was automatically generated from .ui files with pyuic5.

Tasks for the coding day:

• determine which simulation ensembles are supported for a simple LJ fluid (NpT, NVT)
• compare features to the ESPResSo OpenGL visualizer:
  • particle bonds drawing
  • shape-based constraints drawing
  • LB boundary geometry drawing
  • LB velocity field drawing
  • user interaction with the system via the mouse or keyboard

[RudolfWeeber]

More generally, it needs to be determined, what exactly can be tought using the program, and if/how this could/should tie in with our other Espresso teaching activities.

[RiccardoFrenner]

I will look into it tomorrow.

[RiccardoFrenner]

Visualization

• Uses espressomd.visualization_opengl.OpenGLLive and creates a separate window and thread for it once the user starts the simulation.
• That means that there are no differences in the display of particle bonds, etc. from the ESPResSo OpenGL visualizer.

Usage

As teacher

Use predefined example systems or create own systems to

• display a window which allows for the initialization of system parameters and interactive control over parameters via e.g. sliders
• create live plots
• save data to files while simulation is running

  As student

• Play with the GUI created by the teacher to see the effects in the OpenGL visualizer or the live plots.
• Analyze the data provided by the teacher

Predefined example systems

LJ fluid 2D/3D

• Particles with LJ interaction
• Interactive control over
  • number of particles
  • thermostat (on/off, temperature),
  • gravity (on/off, strength),
  • particle type (LJ sigma and eps) with some presets (Argon, Oxygen)
  • live plots of energies, pressure and radial distribution function (RDF)
• Teaching:
  • Could be integrated in a lecture about ideal gases and pressure since one can see clearly the effect on the pressure when changing some parameters like temperature
  • Some parameters also influence the RDF in interesting ways which helps in the understanding of it
  • Changing the LJ parameters does not provide any insights IMO and would therefore not really fit into a LJ (fluid) lecture

    p(V) dependence

• Interface is basically the same as above but with fewer parameters.
• Teaching:
  • Data could be used to let students plot the p(V) dependence (p ~ 1/V). Maybe in a "Physik auf dem Computer" lecture?
  • Also, particle amount could be increased to do some error estimation.

Create own systems

• Inherit from base class and override/implement some methods
• Requires knowledge about ESPResSo and about the internals of simlearn

Conclusion

• There are many unsupported features that would require from little up to a lot of "hacking" to use them. For example
  • NPT ensemble
  • LB
  • Constraint plotting
  • Visualizer interaction
• Changing the predefined examples is easier but limiting
• The predefined examples are mainly useful for beginner lectures in gas theory or programming but not so much for simulation lectures since they do not provide any insights to the simulation part
• Has the advantage that you don't have to work with so much GUI code if you e.g. just want to have some simple sliders.

[RudolfWeeber]

Thanks, Riccardo.

Peter, maybe you can add on how you are using it.

How difficult is it, to modify the gui (as I understand it, a generator is used)

Would it be difficult to adapt to the current Python developr branch?

Would it be possible with reasonable effort (short of remote-controlling the gui) to automatically test one of the simple systems?

[RiccardoFrenner]

PyQt5 allows for automated testing with the QTest module. Here is a small example which automatically starts the LJ fluid example of the PyStar application:

import sys
import unittest as ut

from PyQt5 import QtCore
from PyQt5.QtTest import QTest
from PyQt5.QtWidgets import QApplication

from pystar.application.simlearn import PyStar

class TestLJ2D(ut.TestCase):
    def setUp(self):
        self.app = QApplication(sys.argv)
        self.main_window = PyStar.WelcomeWindow()

    def tearDown(self):
        self.app.exec_()

    def test(self):
        LEFT_MB = QtCore.Qt.MouseButton.LeftButton
        QTest.mouseClick(self.main_window.LJ2D_button, LEFT_MB)
        QTest.mouseClick(self.main_window.current_task.uim.run_button, LEFT_MB)

if __name__ == '__main__':
    ut.main()

However, if I don't call self.app.exec_() in tearDown() the application crashes after test finishes executing. But calling self.app.exec_() causes the app to be launched as a user would do, which is not ideal. I am sure there is a way around that but I am not familiar with Qt at all. So I think it is relatively simple to test a system.

[RiccardoFrenner]

Changing the GUI should also be easy. The .ui files can be generated with QTCreator and editing the files by hand is also possible.

Regarding the port to develop, I don't know what has changed since 4.14, so I am not sure how much work it is. Each PyStar example system uses some Espresso calls directly, more complex routines, like warming up the system, are wrapped in functions and need less work. If I had to guess I would say it's equivalent to porting two Espresso scripts with each 300 lines of code.