Entity network distributed physical simulation method, device and equipment and storage medium

Abstract

The application discloses an entity network distributed physical simulation method, device, equipment and storage medium. The method comprises the following steps: performing dynamic grid division on an entity network; deploying a node server in each grid, and performing parallel calculation on physical simulation data on different grids according to the node server; connecting the node server with one or more aggregation servers, storing the physical simulation data in the aggregation server, and sending the physical simulation data to a client through the aggregation server. According to the entity network distributed simulation method provided by the application, the problem of unlimited expansion of the entity network can be solved, the physical simulation data can be synchronized between different terminals, the physical simulation data is sent to the client through the aggregation server, frequent connection switching between the client and the node server is avoided, and the physical simulation data can be stably fed back to the client in real time.

Description

Technical Field

[0001] This invention relates to the fields of distributed computing and industrial simulation technology, and in particular to a method, apparatus, device and storage medium for distributed physical simulation of physical networks. Background Technology

[0002] Existing physical simulation methods typically divide the physical data to be simulated into "first-class data" and "second-class data". The physical simulation data related to the virtual character is defined as first-class data and simulated locally, while other physical simulation data is defined as second-class data and simulated by multiple remote devices.

[0003] However, the data classification methods in existing technologies are not the core challenge of distributed physical settlement. The core challenge lies in how to synchronize and correct data sent to multiple remote devices for simulation in real time, while ensuring a stable frame rate. The reason why distributed physical simulation has not yet achieved a breakthrough is not related to how the data is divided, but rather to how to synchronize physical information among multiple terminals and ensure a fixed frame rate and simulation stability. Summary of the Invention

[0004] This application provides a method, apparatus, device, and storage medium for distributed physical simulation of physical networks. To provide a basic understanding of some aspects of the disclosed embodiments, a brief summary is given below. This summary is not intended as a general description, nor is it intended to identify key / important components or describe the scope of protection of these embodiments. Its sole purpose is to present some concepts in a simple form as a prelude to the detailed description that follows.

[0005] In a first aspect, embodiments of this application provide a distributed physical simulation method for physical networks, including:

[0006] Dynamically mesh the entity network;

[0007] Node servers are deployed within each grid, and physical simulation data on different grids are computed in parallel by the node servers.

[0008] The node server is connected to one or more aggregation servers, the physical simulation data is stored in the aggregation server, and then sent to the client through the aggregation server.

[0009] In an optional embodiment, dynamic mesh partitioning of the entity network includes:

[0010] Obtain the physical network;

[0011] The entity network is divided into multiple grids according to the preset grid division parameters, and the computational load in each grid is less than or equal to the preset load threshold.

[0012] When the load in a grid exceeds a preset load threshold, the grid with the load exceeding the preset load threshold will be further divided into multiple grids until the load in each grid is less than or equal to the preset load threshold.

[0013] In an optional embodiment, node servers are deployed within each grid, and physical simulation data for different grids is calculated based on the node servers, including:

[0014] The position of objects within the mesh is calculated using node servers and object constraint information to obtain first position calculation information. The first position calculation information is then broadcast to neighboring node servers. The system waits for second position calculation information to be returned from neighboring node servers and then merges the first and second position calculation information to obtain third position calculation information.

[0015] The velocity of objects within the mesh is calculated using node servers and object constraint information to obtain first velocity calculation information. This first velocity calculation information is then broadcast to neighboring node servers. The system waits for second velocity calculation information to be returned from neighboring node servers, and then merges the first and second velocity calculation information to obtain third velocity calculation information.

[0016] Based on the third position and third velocity calculation information, a new mesh is determined to which the object and its constraint information belong. The physical simulation data of the object is then recalculated based on the node servers in the new mesh.

[0017] In an optional embodiment, determining the new mesh to which the object belongs based on the third position solution information and the third velocity solution information includes:

[0018] Based on the third position calculation information and the third velocity calculation information, the object's migration information is determined;

[0019] Based on the migration information, the object's current mesh is obtained, and the object is added to all node servers with intersecting meshes.

[0020] In an optional embodiment, determining the new mesh to which the object's constraint information belongs based on the third position solution information and the third velocity solution information includes:

[0021] Based on the third position solution information and the third velocity solution information, determine the objects that have constraint information with the object;

[0022] When there is constraint information between objects, find the node server that is common to the objects with constraint information.

[0023] Add the constraint information to the shared node server.

[0024] In an optional embodiment, adding constraint information to the shared node server includes:

[0025] When there are multiple shared node servers, the shared node servers are sorted from smallest to largest according to the preset number.

[0026] Add the constraint information to the shared node server with the smallest number.

[0027] In an optional embodiment, after determining the new mesh to which the object and its constraint information belong, the method further includes:

[0028] Broadcast new mesh information, including object and constraint information, to neighboring node servers.

[0029] Secondly, embodiments of this application provide a distributed physical simulation device for physical networks, comprising:

[0030] The mesh generation module is used to dynamically mesh entities.

[0031] The parallel computing module is used to deploy node servers within each grid and perform parallel computing of physical simulation data on different grids based on the node servers.

[0032] The data sending module is used to connect the node server to one or more aggregation servers, store the physical simulation data in the aggregation server, and send it to the client through the aggregation server.

[0033] Thirdly, embodiments of this application provide an electronic device, including a processor and a memory storing program instructions, wherein the processor is configured to execute a distributed physical simulation method for physical networks provided in the above embodiments when executing the program instructions.

[0034] Fourthly, embodiments of this application provide a computer-readable medium storing computer-readable instructions, which are executed by a processor to implement a distributed physical simulation method for physical networks provided in the above embodiments.

[0035] The technical solutions provided in this application embodiment may include the following beneficial effects:

[0036] The distributed physical simulation method for physical networks provided in this application divides the physical network into multiple grids. As the load within a grid increases, the number of grids can be dynamically changed, solving the problem of infinite expansion of ultra-large-scale physical networks. By deploying node servers within each grid, simulation data is computed in parallel by multiple node servers, enabling synchronized physical simulation data across different terminals. Furthermore, an architecture separating data and computation is adopted, with an aggregation server storing simulation data from different nodes. This avoids frequent connection switching between clients and node servers, ensuring that clients can stably obtain physical simulation data.

[0037] It should be understood that the above general description and the following detailed description are exemplary and explanatory only, and are not intended to limit the invention. Attached Figure Description

[0038] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with the invention and, together with the description, serve to explain the principles of the invention.

[0039] Figure 1 This is a flowchart illustrating a distributed physical simulation method for an entity network according to an exemplary embodiment;

[0040] Figure 2 This is a schematic diagram illustrating a process of parallel computing performed by a node server according to an exemplary embodiment;

[0041] Figure 3 This is a schematic diagram illustrating the determination of object ownership according to an exemplary embodiment;

[0042] Figure 4 This is a schematic diagram illustrating a connection between a node server and an aggregation server according to an exemplary embodiment;

[0043] Figure 5 This is a schematic diagram of the structure of a distributed physical simulation device for a physical network according to an exemplary embodiment;

[0044] Figure 6 This is a schematic diagram of the structure of an electronic device according to an exemplary embodiment;

[0045] Figure 7 A schematic diagram of a computer storage medium according to an exemplary embodiment. Detailed Implementation

[0046] The following description and accompanying drawings fully illustrate specific embodiments of the invention to enable those skilled in the art to practice them.

[0047] It should be understood that the described embodiments are merely some, not all, of the embodiments of the present invention. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without inventive effort are within the scope of protection of the present invention.

[0048] In the following description, when referring to the accompanying drawings, the same numbers in different drawings denote the same or similar elements unless otherwise indicated. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with the present invention. Rather, they are merely examples of systems and methods consistent with some aspects of the invention as detailed in the appended claims.

[0049] The reason why distributed physics simulation has not yet made a breakthrough is not related to how the data is divided, but rather to how to synchronize physical information across multiple terminals and ensure a fixed frame rate and simulation stability.

[0050] Based on this, this application provides a distributed physical simulation method for physical networks. It uses distributed physical simulation technology to solve the physical simulation of infinitely expandable ultra-large-scale virtual worlds, synchronizes physical simulation data between different terminals, and ensures the correctness and stability of the simulation. It integrates the data obtained from simulation between different terminals and provides real-time and stable feedback to the client.

[0051] The following will be combined with the appendix Figure 1 This application provides a detailed description of the distributed physical simulation method for physical networks provided in its embodiments. See also... Figure 1 The method specifically includes the following steps.

[0052] S101 performs dynamic mesh generation on the entity network.

[0053] In one possible implementation, the entity network is obtained and divided into multiple grids according to preset grid partitioning parameters, with the computational load in each grid being less than or equal to a preset load threshold.

[0054] Specifically, the virtual world composed of the physical network is divided into grids, with each grid corresponding to a computing server, called a node server. It is crucial to ensure that the size of each grid cell is larger than the scale of the largest rigid body among all objects in the physical network, to avoid large rigid bodies spanning an entire node server area.

[0055] When performing mesh generation, various shapes can be used, such as square meshes, rectangular meshes, planar quadrilateral meshes, and rhombus meshes. This application embodiment does not impose specific limitations. Mesh generation parameters are obtained based on the shape and size of the generated mesh, and the entity network is then meshed according to these parameters. It is ensured that the computational load within each mesh is below a preset load threshold. This preset load threshold can be set according to actual conditions.

[0056] Each grid has a limited size. When the local load is too high and there are too many physical constraints, the number of grids can be dynamically adjusted to ensure a balanced computational load. When the load within a grid exceeds a preset load threshold, the grid exceeding the preset load threshold is further divided into multiple grids until the load within each grid is less than or equal to the preset load threshold. Therefore, as the network expands, the communication and computational load of each node server will not increase; only new node servers need to be added. Thus, this scheme can perform physical simulations on infinitely expanding, ultra-large-scale worlds.

[0057] According to this step, large-scale entity networks can be expanded by performing dynamic mesh partitioning.

[0058] S102 deploys node servers within each grid, and performs parallel computation of physical simulation data on different grids based on the node servers.

[0059] In one possible implementation, each grid contains a node server that calculates the physical simulation data within the grid. In an exemplary embodiment, the grid is square, and since objects in each grid are subject to constraints from at most neighboring grids, each node server only needs to communicate bidirectionally with the node servers in its eight surrounding grids.

[0060] Along with the above technical solution, two new problems have emerged. First, this solution requires different nodes to process physical world constraints simultaneously. Traditional constraint iterative algorithms have strict dependencies, making it difficult to split them into different nodes for parallel computation. To address this, this application employs a new iterative algorithm that allows physical constraints to be processed in parallel, with each grid performing calculations simultaneously and synchronizing the calculated physical simulation data among surrounding grids.

[0061] In one embodiment, the physical simulation data on different grids is computed in parallel by the node server, including: calculating the position of the object in the grid by using the node server and object constraint information to obtain the first position calculation information, broadcasting the first position calculation information to the surrounding neighboring node servers, waiting for the second position calculation information returned by the surrounding neighboring node servers, and merging the first position calculation information and the second position calculation information to obtain the third position calculation information.

[0062] The velocity of objects within the mesh is calculated using node servers and object constraint information to obtain first velocity information. This first velocity information is then broadcast to neighboring node servers. The system waits for second velocity information to be returned from neighboring node servers, and then merges the first and second velocity information to obtain third velocity information.

[0063] Based on the third position and third velocity calculation information, a new mesh is determined to which the object and its constraints belong. The physical simulation data of the object is then recalculated using the node servers in this new mesh. This yields the real-time simulation data of the object.

[0064] Specifically, iterative calculations are performed using a sub-stepping + Jacobi scheme, such as... Figure 2 As shown, the node server within the current mesh predicts the position of objects in the next frame based on its current position. Based on the predicted position, it generates constraints for the current node server, solves all constraints within the server, including collision constraints and constraints between objects, and obtains the first position information. It then broadcasts this first position information to neighboring node servers and waits for the solution results from these neighboring node servers. Finally, it merges all the solutions from the neighboring node servers to obtain new position information.

[0065] Furthermore, the speed update result of the local node server is calculated, the speed update result is broadcast to the surrounding node servers, and the speed solution results returned by the surrounding node servers are waited for. All speed solution information is merged to obtain new speed information.

[0066] Furthermore, based on the new velocity and position information, the mesh affiliation of objects and their constraints is redefined, and the affiliation information of objects and their constraints is updated with the surrounding node servers. The entire process involves three waiting periods: position calculation synchronization, velocity calculation synchronization, and object migration information synchronization.

[0067] The process of determining the new mesh to which the object belongs based on the third position solution information and the third velocity solution information includes: determining the migration information of the object based on the third position solution information and the third velocity solution information, obtaining the mesh to which the object currently belongs based on the migration information, and adding the object to the node server of all intersecting node meshes.

[0068] In one embodiment, based on the object's new velocity and position information, potential migrations of the object are determined, and the object's mesh affiliation is redefined based on the migration information. The object is bounded by a rectangle in the coordinate system, and the intersection of the object's bounding box with the grid is calculated and added to all intersecting node servers. Figure 3 This is a schematic diagram illustrating the determination of object ownership according to an exemplary embodiment, such as... Figure 3 As shown, object A intersects with grids 1, 2, 4 and 5, and will belong to four node servers: 1, 2, 4 and 5.

[0069] Based on the third position solution information and the third velocity solution information, determine the new mesh to which the constraint information of the object belongs, including: based on the third position solution information and the third velocity solution information, determine the objects with constraint information. When there is constraint information between objects, find the common node server between the objects with constraint information and add the constraint information to the common node server.

[0070] In an optional embodiment, when there are multiple shared node servers, the multiple shared node servers are sorted from smallest to largest according to a preset number, and the constraint information is added to the shared node server with the smallest number.

[0071] For example, suppose there is a constraint k between objects A and B. The node servers where A and B coexist are located, and these servers are sorted by their numbers. The node server with the smallest number is responsible for solving constraint k. For instance, if there is only node server number 2 where objects A and B coexist, then constraint k belongs to node server number 2. If there are node servers numbered 4, 5, and 6 where objects A and C coexist, then according to the sorting rules, the constraint belongs to node server number 4. The node server numbers can be pre-configured by those skilled in the art.

[0072] In one possible implementation, constraints are divided into permanent constraints and temporary constraints. Permanent constraints are pre-configured constraints that migrate synchronously as objects move between servers. Temporary constraints, such as collision constraints, are generated entirely by each node server in its own computation step, and therefore do not require consideration of migration. However, their ownership should still belong to only one node server.

[0073] The calculation results from different node servers are combined to form the calculation results of the entire physical network. According to this step, multiple node servers calculate physical simulation data in parallel and propagate the calculated simulation data between different node servers to achieve synchronous physical simulation data between different terminals.

[0074] S103 connects the node server to one or more aggregation servers, stores the physical simulation data in the aggregation server, and sends it to the client through the aggregation server.

[0075] In one possible implementation, the object character can move and migrate within the entity network. Since the network is divided into different grids, and different grids are composed of different nodes, there may be frequent jumps between different nodes. When data is transmitted from the node server to the client, it will cause frequent reconnections between the client and the node server, which may affect the stability of the client's frame rate.

[0076] To address this issue, this application adopts a data and computation separation architecture, establishing separate node servers and aggregation servers. The computation results of the node servers are stored in the aggregation servers, and each aggregation server is responsible for multiple node servers. There may be node overlap between aggregation servers, and the client only needs to connect to the aggregation server, thus avoiding the problem of the client frequently switching connections.

[0077] Figure 4 This is a schematic diagram illustrating a connection between a node server and an aggregation server according to an exemplary embodiment.

[0078] like Figure 4 As shown in the figure, this application embodiment designs an aggregation server to store the calculation results of multiple node servers. The calculation result of one node server can be stored by multiple aggregation servers. For example, the data of node server 1 in the figure is stored in both aggregation server 0 and aggregation server 1. The client only needs to switch connections when leaving the aggregation server.

[0079] In an exemplary scenario, consider the following user behavior path: a user starts from node 0, passes through node 1, walks to node 2, and then returns along the same path. The path may experience fluctuations during this journey. Without an aggregation server, when the user crosses a server boundary (e.g., 0-1), they would need to frequently switch between the 0 and 1 node servers to obtain the correct data, leading to data instability.

[0080] When designing an aggregation server, users only need to switch aggregation servers once when leaving aggregation server 1 and going to aggregation server 2, and once when returning from aggregation server 1 to aggregation server 0. This avoids connection instability.

[0081] This application connects to the client via an aggregation server, enabling the transmission of stable physical simulation data, such as the object's velocity and position, to the client.

[0082] The distributed physical simulation method for physical networks provided in this application supports ultra-large-scale physical simulations through dynamic mesh partitioning and transmits simulation results to clients in real time. This scheme dynamically partitions a large-scale physical world using different node servers to handle physical simulations on different meshes. A set of rules for constraints and object attribution is designed for physical simulations between meshes. Distributed computation of physical constraints within the same physical world is achieved, ensuring data synchronization across multiple clients.

[0083] In addition, this application embodiment also designs an aggregation server to store simulation data from different node servers, avoiding frequent connection switching between the client and the node server, and ensuring that the client can stably obtain physical simulation data.

[0084] This application also provides a physical network distributed physical simulation device, which is used to execute the physical network distributed physical simulation method of the above embodiments, such as... Figure 5 As shown, the device includes:

[0085] Mesh generation module 501 is used to dynamically mesh the entity network;

[0086] Parallel computing module 502 is used to deploy node servers in each grid and perform parallel computing of physical simulation data on different grids based on the node servers;

[0087] The data sending module 503 is used to connect the node server to one or more aggregation servers, store the physical simulation data in the aggregation server, and send it to the client through the aggregation server.

[0088] It should be noted that the physical network distributed physical simulation device provided in the above embodiments is only illustrated by the division of the above functional modules when executing the physical network distributed physical simulation method. In practical applications, the above functions can be assigned to different functional modules as needed, that is, the internal structure of the device can be divided into different functional modules to complete all or part of the functions described above. In addition, the physical network distributed physical simulation device and the physical network distributed physical simulation method embodiments provided in the above embodiments belong to the same concept, and the implementation process is detailed in the method embodiments, which will not be repeated here.

[0089] This application also provides an electronic device corresponding to the physical network distributed physical simulation method provided in the foregoing embodiments, to execute the above-described physical network distributed physical simulation method.

[0090] Please refer to Figure 6 This illustrates a schematic diagram of an electronic device provided by some embodiments of this application. For example... Figure 6 As shown, the electronic device includes: a processor 600, a memory 601, a bus 602, and a communication interface 603. The processor 600, the communication interface 603, and the memory 601 are connected via the bus 602. The memory 601 stores a computer program that can run on the processor 600. When the processor 600 runs the computer program, it executes the physical network distributed physical simulation method provided in any of the foregoing embodiments of this application.

[0091] The memory 601 may include high-speed random access memory (RAM) or non-volatile memory, such as at least one disk storage device. Communication between this system network element and at least one other network element is achieved through at least one communication interface 603 (which can be wired or wireless), such as the Internet, wide area network, local area network, or metropolitan area network.

[0092] Bus 602 can be an ISA bus, PCI bus, or EISA bus, etc. Buses can be divided into address buses, data buses, control buses, etc. Memory 601 is used to store programs. After receiving execution instructions, processor 600 executes the program. The distributed physical simulation method for physical networks disclosed in any of the aforementioned embodiments of this application can be applied to processor 600, or implemented by processor 600.

[0093] The processor 600 may be an integrated circuit chip with signal processing capabilities. In implementation, each step of the above method can be completed by the integrated logic circuitry in the hardware of the processor 600 or by instructions in software form. The processor 600 may be a general-purpose processor, including a central processing unit (CPU), a network processor (NP), etc.; it may also be a digital signal processor (DSP), an application-specific integrated circuit (ASIC), an off-the-shelf programmable gate array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. It can implement or execute the methods, steps, and logic block diagrams disclosed in the embodiments of this application. The general-purpose processor may be a microprocessor or any conventional processor. The steps of the methods disclosed in the embodiments of this application can be directly embodied in the execution of a hardware decoding processor, or executed by a combination of hardware and software modules in the decoding processor. The software modules may reside in random access memory, flash memory, read-only memory, programmable read-only memory, electrically erasable programmable memory, registers, or other mature storage media in the art. The storage medium is located in memory 601. Processor 600 reads the information in memory 601 and, in conjunction with its hardware, completes the steps of the above method.

[0094] The electronic device provided in this application embodiment and the physical network distributed physical simulation method provided in this application embodiment are based on the same inventive concept and have the same beneficial effects as the methods they adopt, operate or implement.

[0095] This application also provides a computer-readable storage medium corresponding to the distributed physical simulation method for physical networks provided in the foregoing embodiments. Please refer to... Figure 7 The computer-readable storage medium shown is an optical disc 700, on which a computer program (i.e., a program product) is stored. When the computer program is run by a processor, it executes the physical network distributed physical simulation method provided in any of the foregoing embodiments.

[0096] It should be noted that examples of computer-readable storage media may also include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other optical and magnetic storage media, which will not be elaborated here.

[0097] The computer-readable storage medium provided in the above embodiments of this application and the physical network distributed physical simulation method provided in the embodiments of this application are based on the same inventive concept and have the same beneficial effects as the methods adopted, run or implemented by the applications stored therein.

[0098] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0099] The above embodiments merely illustrate several implementation methods of the present invention, and their descriptions are relatively specific and detailed, but they should not be construed as limiting the scope of the present invention. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of the present invention, and these all fall within the protection scope of the present invention. Therefore, the protection scope of this patent should be determined by the appended claims.

Claims

1. A distributed physical simulation method for physical networks, characterized in that, include: Dynamic mesh partitioning of an entity network includes: acquiring the entity network; dividing the entity network into multiple meshes according to preset mesh partitioning parameters, wherein the computational load in each mesh is less than or equal to a preset load threshold; when the load in a mesh is greater than the preset load threshold, further dividing the mesh into multiple meshes until the load in each mesh is less than or equal to the preset load threshold. Node servers are deployed within each grid, and physical simulation data on different grids are calculated in parallel based on the node servers. This includes: calculating the position of objects within their respective grids using the node servers and object constraint information to obtain first position information; broadcasting the first position information to neighboring node servers; waiting for second position information from neighboring node servers; merging the first and second position information to obtain third position information; calculating the velocity of objects within their respective grids using the node servers and object constraint information to obtain first velocity information; broadcasting the first velocity information to neighboring node servers; waiting for second velocity information from neighboring node servers; merging the first and second velocity information to obtain third velocity information; and determining the new grid to which the object and its constraint information belong based on the third position and third velocity information, and recalculating the physical simulation data of the object using the node servers in the new grid. The node server is connected to one or more aggregation servers, the physical simulation data is stored in the aggregation server, and then sent to the client through the aggregation server.

2. The method according to claim 1, characterized in that, Based on the third position calculation information and the third velocity calculation information, the new mesh to which the object belongs is determined, including: Based on the third position calculation information and the third velocity calculation information, the migration information of the object is determined; Based on the migration information, the object's current mesh is obtained, and the object is added to all node servers with intersecting meshes.

3. The method according to claim 1, characterized in that, Based on the third position solution information and the third velocity solution information, determine the new mesh to which the object's constraint information belongs, including: Based on the third position calculation information and the third velocity calculation information, determine the object that has constraint information with the object; When there is constraint information between objects, find the node server that is common to the objects with constraint information. The constraint information is added to the shared node server.

4. The method according to claim 3, characterized in that, Adding the constraint information to the shared node server includes: When there are multiple shared node servers, the shared node servers are sorted from smallest to largest according to the preset number. The constraint information is added to the shared node server with the smallest number.

5. The method according to claim 1, characterized in that, After determining the new mesh to which the object and its constraints belong, the following steps are also included: Broadcast new mesh information, including object and constraint information, to neighboring node servers.

6. A distributed physical simulation device for physical networks, characterized in that, include: A mesh partitioning module is used to dynamically partition an entity network; including: acquiring the entity network; dividing the entity network into multiple meshes according to preset mesh partitioning parameters, wherein the computational load in each mesh is less than or equal to a preset load threshold; when the load in the mesh is greater than the preset load threshold, the mesh that is greater than the preset load threshold is further divided into multiple meshes until the load in each mesh is less than or equal to the preset load threshold. A parallel computing module is used to deploy node servers within each grid and perform parallel computation of physical simulation data on different grids based on the node servers. This includes: calculating the position of objects within their respective grids using the node servers and object constraint information to obtain first position information; broadcasting the first position information to neighboring node servers; waiting for second position information returned by neighboring node servers; merging the first and second position information to obtain third position information; calculating the velocity of objects within their respective grids using the node servers and object constraint information to obtain first velocity information; broadcasting the first velocity information to neighboring node servers; waiting for second velocity information returned by neighboring node servers; merging the first and second velocity information to obtain third velocity information; and determining the new grid to which the object and its constraint information belong based on the third position and third velocity information, and recalculating the physical simulation data of the object based on the node servers in the new grid. The data sending module is used to connect the node server to one or more aggregation servers, store the physical simulation data in the aggregation server, and send it to the client through the aggregation server.

7. An electronic device, characterized in that, It includes a processor and a memory storing program instructions, the processor being configured to execute, when executing the program instructions, a distributed physical simulation method for physical networks as described in any one of claims 1 to 5.

8. A computer-readable medium, characterized in that, It stores computer-readable instructions that are executed by a processor to implement a distributed physical simulation method for physical networks as described in any one of claims 1 to 5.

Images