Modeling long-term or large-scale processes is associated with a significant investment of researchers' time, as well as computer time. In this regard, it can be effective to make adjustments to the model directly in the process of modeling. This article discusses the design and implementation of a web client that acts as an administration system (panel) for a platform for multi-agent modeling of movements and interactions of actors within a city map area. All modeling logic in this platform is implemented directly in modules, while the modeling platform only calls it for specific, connected modules. The modeling platform is implemented on the ASP.NET Core 5.0 framework. For the implementation of the web client, the Angular 11 framework was chosen with the Ant Design UI components.
+ + +
The target component of this work is an application that is a client-server platform for modeling
the movements and interactions of actors within a city map section [
Modules contain all the logic and modeling rules. Initially, the modules are not supplied as part of this software package, each of them is a separate class library. However, the modules are directly involved in the operation of the software package in the case of connecting one or more of them. For example, the module for managing data about objects on an online city map parses data from a file with OSM XML format and converts them to the necessary structure for storing in the list of objects of the main program and further using them by other modules.
The developed administration system is required to execute various modeling scenarios in real
time with an extensible property list of the model itself and actors and plug-in components to answer
the multiple "what if" question [
In this regard, the purpose of the work is to develop a system for distributed administration of the behavior of actors and properties of the city model in real time. At the same time, as a key component of the concept of creating such a system, it was decided to focus on enabling the user to influence the course of modeling by changing the properties of models and actors in real time.
The existing application models the movement of actors on the basis of modules, however, it has a number of drawbacks and limitations, some of which must be eliminated in the created administration system.
The object of this research is the process of administration of modeling and obtaining results.
The subject of the research is the methods of distributed administration of the behavior of actors and properties of the city model in real time.
The business process diagram (“BPMN AS IS”) in the case using the application is shown in Figure 1.
One of the problems of current modeling administration systems is the lack of approaches to processing and representing the state of actors in real time. The systems display the simulation result without the ability to pause the simulation or restart it during the current simulation with different modules and / or properties.
In some modeling systems, such as Ant Road Planner, it is not possible to dynamically change any properties of the model in general and actors in particular in real time after the initial setting of the modeling properties and the launch of the modeling. The simulation can be restarted on the changed properties only after the simulation has been worked out and the results are obtained.
In this regard, the task was set to develop a system of distributed administration of the behavior of actors and properties of the city model in real time, allowing the user to change the course of modeling by changing the properties of models and actors.
To implement the web client, the Angular framework [
The platform architecture takes into account all the needs of the updated processes. The platform architecture is shown in Figure 2.
To solve the problem with the development of an approach to processing and representing the state
of actors in real time, the proto3 [
Based on the API, there are several methods that will be needed to process and represent the state of the actors. One of these methods is to divide actors by their type (from the type_full_name field) into groups that represent layers. Splitting into layers opens up a number of possibilities, one of which is the ability to turn off the display of certain types of actors, if necessary.
Another important feature, as well as the next used method, opened by using layers, is the ability to apply specific styles to individual layers (from the open_layers_style field). This style is javascript code that must be executed before an object of the Style class is obtained.
The method for displaying actors in specific coordinates should be based on the GeoJSON format
[
To solve the problem with the development of an approach to representing and changing the properties of the model in general and actors in particular in real time, a number of methods from the REST API of the modeling platform can be used. For example, the State group of methods allows the user to manage the life cycle of a simulation, which can be started, temporarily paused, and stopped. The Assemblies method provides the ability to add new assemblies with modules and module dependencies to the application, and the Modules method group allows the user to get the entire list of modules obtained from the added assemblies, and also provides the ability to manage the list of modules participating in the modeling process (specific modules from the general list can be activate and deactivate for the model). In addition, there are a number of methods for working with the list of properties of specific actors.
Thus, a brief description of the methods that will be used in the research when creating a targeted method for distributed administration of the behavior of actors and properties of the city model in real time is given.
It was customary to add the entire generated infrastructure along the src/app/generated path, so this path was added to the standard .gitignore file.
The modeling platform route /swagger/v1/swagger.json is called to get the swagger.json file used for generation. This route is created automatically using the Swashbuckle.AspNetCore library. Then this file is added to the root of the project.
The npm module ng-openapi-gen is used to generate the API infrastructure.
To generate the javascript gRPC-web infrastructure [
After that, a script is created in the package.json file to generate the infrastructure based on map.proto;
The generated client does not require DI and can be obtained directly from the grpc namespace. 5.2.
Assemblies are managed in AssemblyCompositorComponent, a child of AssemblyComponent. The NzUploadModule component and AssembliesService are used to upload files.
The view of the final component is shown in Figure 4. When the component button is pressed, a file system window opens with a proposal to select one or more assembly files. After selection, assemblies are immediately uploaded to the server.
Modules are managed in the ModuleManagerComponent, a child of the ModuleComponent. For this, ModulesService is used.
The view of the resulting component is shown in Figure 5. Each of the component buttons can be active or inactive, depending on the current state of the model.
Model state is managed in ModelStateManagerComponent, a child of ModelComponent. The StateService is used for this.
The view of the resulting component is shown in Figure 6. This component supports multiple choice of modules for the model.
After selecting or deselecting one of the modules, the changes are immediately sent to the server.
Getting the current metadata occurs when the map component is initialized. To get metadata, the contract method GetMapFeaturesMetadata is used, which returns a stream of objects of type MapFeaturesMetadata.
Each of the obtained objects is transferred both to the component of the map browser (to create a
new layer [
The map browser component uses the type (type_full_name) as the name of the layer to create and the style (open_layers_style) as the layer style. This component does not work with observable properties.
The map properties component uses the type (type_full_name) to classify actors into various tables. The list of observable properties is used by this component to create the table infrastructure. So, if the “editable” flag of the observed property is “true”, then the corresponding cell in the table can be edited. The value type (value_type) is used for correct conversion from gRPC types to javascript / typescript types and vice versa.
After the method for obtaining metadata has finished its work, subscribes to the method for updating the metadata GetMapFeaturesMetadataUpdates, which returns objects of the same type, which are processed in the same way. This subscription exists until one of the applications (modeling platform or administration system) stops working. 6.2.
Getting the current list of actors occurs after getting the list of metadata. This is necessary in order for the resulting actors to be correctly placed on a previously created map layer. The list of actors is obtained using the GetMapFeatures method, after which a subscription to updates is performed using the GetMapFeaturesUpdates method (using an approach similar to working with metadata). Both methods return an object of type MapFeature.
The resulting object from any of the methods is sent to the map browser component, where it is converted from GeoJson (geo_json) to the OpenLayers library format, from which the actor ID is obtained. An actor obtained from the GeoJson format is placed on a layer that has the corresponding type, the same as the type of the resulting actor (type_full_name). If an actor with such an identifier already exists in the corresponding layer, then it is previously removed from the layer.
After the initial receipt of the actors, there is also a subscription to the GetRemoveMapFeatureEventsUpdates method, which provides a stream of events for removing actors, objects of type RemoveMapFeatureEvent.
When objects are received from this stream, objects with parameters corresponding to the type (type_full_name) and identifier (id) of the received event are removed from both the map browser component and the map properties component. 6.3.
The retrieval of the current list of the observable properties of the actors occurs after the retrieval of the list of metadata. The retrieval of the current list of the watched properties of the actors occurs after the retrieval of the list of metadata. The list of actor observable properties is obtained using the GetMapFeaturesObservableProperties method, after which a subscription to updates is performed using the GetMapFeaturesObservablePropertiesUpdates method (using an approach similar to working with metadata and with actors). Both methods return an object of type MapFeatureObservableProperty.
After receiving this object, it is added to the map properties component, in which it is displayed in the table, in accordance with its metadata. The type of the observable property (type_full_name) affects the table in which the object will be placed. The identifier (id) groups several different properties by one actor, the verbal title of the property (title) defines the column in the table, and the value (value) defines the current value of the column.
In addition to displaying the properties of actors, there is also the ability to edit them. After finishing editing the cell that has the corresponding property, the updated value is sent to the modeling platform, to the SetMapFeatureObservableProperty method, as a MapFeatureObservableProperty object.
To test the results, a modeling platform with a connected test module is used.
The test module adds several actors to the map: 1. Point (PointActor) 2. Line string (LineStringActor) 3. Polygon (PolygonActor) 4. Airplane 1 with an initial speed of 1000 by "Boeing" (Airplane, actor class created in the module) 5. Airplane 2 with an initial speed of 0 by "Airbus" (Airplane, an actor class created in the module)
The Airplane class inherits from the PointActor class and has several additional observable properties. 7.2.
Metadata is displayed regardless of the status of the modeling process; it is always displayed in the map properties component for all types of actors that have at least one observable property. Figure 8 shows the mapping of actor property metadata for Airplane type actors. Since the modeling process is stopped and there are no actors at the moment, the table has only columns indicating the properties being viewed and has no rows.
The metadata responsible for displaying styles can be seen when displaying actors in the map browser component (see Figure 9), displaying occurs only when the modeling process is running or paused, since only at this moment there can be actors on the map.
There are two Airplane type actors on the map (lower left corner), displayed as small purple dots, a line string actor (in the center of the map), a point actor (at one of the ends of the line string actor), and a polygon actor (upper left corner). Of all the listed objects, only Airplane objects have a changed style. 7.3.
Actors are displayed both when the administration system is connected to the modeling platform with simulation already running, and when modeling is started from the administration system with the same result.
At the same time, updates to actors are correctly displayed by the administration system over time (see Figure 10).
When the modeling process is stopped, the Map Browser component is cleared of actors.
When the simulation is run, the map browser component displays the browseable properties according to the table layout and metadata (see Figure 11, a).
If the observable properties on the modeling platform change (for example, the speed of one of the Airplanes increases over time), the changes will be reflected in the administration system, without the need to reload the page (see Figure 11, b). 7.5.
When the cursor is hovering over a row that contains editable observable properties, the editable property cells will be highlighted (see Figure 12, a). Clicking on one of these cells will open the editing element (see Figure 12, b)
If the property value is changed and the edit dialog is closed, this property will be changed on the modeling platform, as well as in the current and all other connected administration systems (see Figure 12, c).
To interact with the platform for modeling the movements and interactions of actors within the city map section, a web client was developed that plays the role of an administration system and provides: Custom display of real-time actors with specific styles based on actor types Ability for the user to manage the list of model modules Ability to the user to manage the life cycle of the simulation The ability for the user to influence the course of modeling by changing the properties of the model and actors
Compared to existing solutions, this administration system is distinguished by the ability to work with a specific modeling platform, which in turn offers a number of advantages over other modeling solutions, such as: Cross-platform Open source Extensibility of functionality using modules
Thus, the developed administration system makes the modeling platform more accessible for interaction with the end user by providing a graphical user interface instead of a software one (REST and gRPC API).
This work has been supported by the Russian Science Foundation (RSF) grant (project No. 20-7110087). The authors express gratitude to colleagues from the Urban Computing Laboratory (UCLab) and the Department of Digital Technologies for Urban Studies, Architecture and Civil Engineering, VSTU involved in the development of Live.UrbanBasis.com project.