An automatic marshalling generation method based on communication type and liaison relationship

Abstract

The application relates to the field of communication ad hoc networks and command control technology, and provides an automatic grouping generation method based on communication types and communication relations, which comprises data preparation, link relation network generation, filtering sub-set and filtering parent set, and relation space generation. The automatic grouping generation method based on communication types and communication relations provided by the application gives the rules of automatic grouping generation, realizes filtering and elimination of repeated network formation through network fusion, network sub-set judgment and network parent set judgment. Since the method of the application does not need operations such as super parameter adjustment, has the advantages of strong adaptability and low demand for computing resources, and can be independently formed into a module for modular integration.

Description

Technical Field

[0001] This invention relates to the fields of communication ad hoc networks and command and control technology, specifically to a group generation method based on communication type and communication relationship. Background Technology

[0002] Multi-agent collaboration depends not only on the type of controlled agent, but also on the type of communication equipment and communication connections of the controlled agents to determine whether collaboration is possible. For example, in mobile communication, 4G devices support downloading large files, watching high-definition videos, and playing online games, while 5G devices support low-latency real-time applications such as remote surgery and autonomous driving. Therefore, automatically forming groups based on communication type and connections is crucial for multi-agent policy generation and control.

[0003] The patent application "A Formation Method and System for Collaborative Inspection of Multiple Unmanned Aerial Vehicles" (Publication No. CN112947556A) filed by the State Grid Corporation of China provides a formation method based on equipment equipped with communication and control systems, and elaborates on its implementation process. However, this method only considers the formation method and system implementation under a single device.

[0004] The patent application "An Automatic Planning Method and System for Mobile Communication Network Structure Based on Particle Swarm Optimization" (PSO) filed by the National University of Defense Technology of the Chinese People's Liberation Army, with publication number CN116684273A, provides an automatic planning method for communication network based on a metaheuristic algorithm. It improves upon the particle swarm optimization algorithm, enabling automatic network structure planning in a short time. Compared to manual planning methods, it achieves higher network planning accuracy and faster convergence. However, since this method is based on the particle swarm optimization algorithm, it requires iterative updates to the planning method. The setting of its iteration termination conditions is relatively complex, and the model weakens the influence of connectivity factors.

[0005] In their paper "Earth Station Network Planning Method for Heterogeneous Communication Satellites," the Command and Control Engineering College of the Army Engineering University proposed a two-stage heuristic network planning method. This method outperforms typical genetic optimization algorithms and demonstrates high timeliness in large-scale channel unit network planning. However, this scheme still suffers from the drawbacks of metaheuristic algorithms, namely, the need for multiple rounds of optimization, which places certain demands on the computing power of the equipment.

[0006] The Command and Control Engineering College of the Army Engineering University proposed a network planning algorithm based on a roll-to-roll search in their paper "Low-Latency Network Planning Method for Micro UAV Swarms," ​​focusing on solving the multi-hop problem in UAV information transmission. This scheme overcomes the shortcomings of metaheuristic algorithms and effectively reduces time latency. However, it emphasizes the transmission latency of a single device. Summary of the Invention

[0007] This invention proposes an automated grouping generation method based on communication type and connectivity relationships, taking into account the different performance requirements of communication equipment for various collaborative capabilities in current communication technologies. First, the interconnection relationships between individual controlled entities are constructed; then, the interconnection relationships between different controlled entities are merged to automatically form network type groups.

[0008] The technical solution adopted in this invention is as follows:

[0009] An automated group generation method based on communication type and connection relationship includes the following steps:

[0010] Step 1: Prepare the data by building a node list and a network type list, and generate a network relationship dictionary and build a node grouping space based on the communication information;

[0011] Step 2: Obtain a network name from the network type list, and obtain the list of nodes contained in the corresponding network type from the node grouping space. From the perspective of each communication node, generate a link relationship network based on the network relationship dictionary and the node grouping space.

[0012] Step 3: Filter the subsets and parent sets in the link network;

[0013] Step 4: Return to step 2 until all network types have been traversed, and generate a relationship space based on the filtered link relationship network.

[0014] Furthermore, the specific implementation method in step 1 is as follows:

[0015] Step 1-1: Construct a network relationship dictionary, point_dict, as a dictionary, initially empty;

[0016] Step 1-2: Construct a node list named point_list, store the node names in point_list, and construct a node position dictionary. Use the node name as the key and the node position information as the value in the node position dictionary. The node position information is a dictionary, and the value is the two-dimensional position of the node in the scene.

[0017] Steps 1-3: Construct a net_list of net types and store the net names in net_list;

[0018] Steps 1-4: Using the node name as the key, store the corresponding node connection information into the network relationship dictionary point_dict; where the node connection information is a dictionary, the key is the network pattern name, and the value corresponding to the key is a list, which is used to store the nodes that are connected to the current node by a certain network pattern;

[0019] Steps 1-5: Traverse each node in the node list and all network types, and obtain the connection node information of the network type in the network relationship dictionary point_dict corresponding to the current node. This is called the connection node information list. If the current connection node information list is not empty, store the node name in the corresponding network type list, named the network type containing node list. Then, store the network type list in the node grouping space net_list_space according to the network type order, forming a local connectivity relationship from the perspective of each node. The stored content is other nodes directly connected to each node.

[0020] Furthermore, the specific implementation method of step 2 is as follows:

[0021] Step 2-1: Obtain a network name temp_net from the network list net_list, and obtain the node list temp_net_list contained in the corresponding network from the node grouping space net_list_space;

[0022] Step 2-2: Construct a list of links, named relation_net, initially empty;

[0023] Steps 2-3: Iterate through all elements in temp_net_list and obtain a node named x;

[0024] Steps 2-4: Construct a temporary network structure space temp_relation_net of type list, and store node x in it;

[0025] Steps 2-5: Iterate through all elements in temp_net_list to obtain a node p;

[0026] Step 2-6: Determine whether the temp_net space of node p is empty from the point_dict dictionary. If it is not empty, traverse the elements in the temp_net space of node p in the point_dict dictionary to obtain node d, and execute step 2-7; if it is empty, return to step 2-5.

[0027] Step 2-7: Determine whether node d is in the temporary network structure space temp_relation_net. If node d is in the temporary network structure space temp_relation_net, then store p in temp_relation_net and execute step 2-8; otherwise, execute step 2-8 directly.

[0028] Step 2-8: If node d has not completed traversing the elements in the temp_net mesh space, then obtain new elements sequentially from the temp_net mesh space of node p and return to step 2-7; if the traversal is complete, then execute step 2-9.

[0029] Step 2-9: If node p has not completed traversing all elements in temp_net_list, return to step 2-5 to retrieve new elements in sequence; if the traversal is complete, proceed to step 2-10.

[0030] Step 2-10: If node x has not completed traversing all elements in temp_net_list, return to step 2-3 to retrieve new elements in sequence; if the traversal is complete, proceed to step 2-11.

[0031] Step 2-11: Remove duplicate elements from the list temp_relation_net and save the deduplicated list in the relation_net.

[0032] Furthermore, the specific implementation of filtering subsets in the link relationship network in step 3 is as follows:

[0033] Step 3-1-1: Obtain the dimensions of the relation_net list;

[0034] Step 3-1-2: Set variable i = 0;

[0035] Step 3-1-3: Set variable j = i + 1;

[0036] Step 3-1-4: If j is less than or equal to the dimension of the relation_net list, determine whether the j-th element in the relation_net list is a subset of the i-th element. If they are subsets, delete the j-th element. If j is greater than the dimension of the relation_net list, then i = i + 1, and return to step 3-1-3. When i is greater than the dimension of the relation_net list, the subset filtering is complete.

[0037] Furthermore, the filtering of parent sets in the link relationship network in step 3 is specifically implemented as follows:

[0038] Step 3-2-1: Obtain the dimensions of the relation_net list;

[0039] Step 3-2-2: Set variable i = 0;

[0040] Step 3-2-3: Set variable j = i + 1;

[0041] Step 3-2-4: If j is less than or equal to the dimension of the relation_net list, then determine whether the j-th element in the relation_net list is the parent set of the i-th element. If they are parent sets, then delete the i-th element. If j is greater than the dimension of the relation_net list, then i = i + 1, and return to step 3-2-3. When i is greater than the dimension of the relation_net list, the parent set filtering is completed.

[0042] Furthermore, the specific implementation method of step 4 is as follows:

[0043] Step 4-1: Construct the result storage space result_space, with the attribute being a list;

[0044] Step 4-2: Repeat steps 2-4 for different network types in turn until all network types have been traversed, and obtain a list of relation_nets for the corresponding network type name;

[0045] Step 4-4: Store the relation_net list into the storage space result_space.

[0046] The advantages of this invention compared to the prior art are:

[0047] This invention provides an automated group generation method based on communication type and connection relationship. The process is simple, computationally inefficient, and easy to implement. Attached Figure Description

[0048] Figure 1 This is a flowchart of a method according to an embodiment of the present invention.

[0049] Figure 2 This is the grouping result based on the net1 network type in this embodiment of the invention.

[0050] Figure 3 This is the grouping result based on the net2 network type in this embodiment of the invention.

[0051] Figure 4 This is the grouping result based on the net3 network type in this embodiment of the invention. Detailed Implementation

[0052] The present invention will be further described below with reference to the accompanying drawings and specific embodiments.

[0053] An automated group generation method based on communication type and connection relationship, the overall process of which is as follows: Figure 1 As shown, the specific steps include the following:

[0054] Step 1: Data preparation, specifically:

[0055] Step 1-1: Construct a network relationship dictionary.

[0056] Construct a network relationship dictionary named point_dict using a dictionary type, initially empty.

[0057] Step 1-2: Build the node list.

[0058] Construct a list of nodes named point_list, and store the node names in point_list;

[0059] point_list=['A','B','C','D','E','F','G','H','I','J','K']

[0060] In addition, a node location dictionary is constructed, using the node name as the key to store the node's location information. The node's location information is a dictionary, with values ​​x and y representing its two-dimensional position in the scene.

[0061] position_dict['A']={'x':0,'y':3}

[0062] position_dict['B']={'x':1,'y':4}

[0063] position_dict['C']={'x':2,'y':3}

[0064] position_dict['D']={'x':3,'y':1}

[0065] position_dict['E']={'x':4,'y':0}

[0066] position_dict['F']={'x':6,'y':1}

[0067] position_dict['G']={'x':5,'y':2}

[0068] position_dict['H']={'x':4,'y':4}

[0069] position_dict['I']={'x':5,'y':5}

[0070] position_dict['J']={'x':6,'y':4}

[0071] position_dict['K']={'x':6,'y':6}

[0072] Steps 1-3: Construct a list of network types.

[0073] Construct a list of network types named net_list, and store the network type names in net_list.

[0074] net_list=['net1','net2','net3']

[0075] Steps 1-4: Generate a network relationship dictionary based on communication information.

[0076] Using the node name as the key, the corresponding node connection information is stored in the network relationship dictionary point_dict. The node connection information is a dictionary, where the key is the network pattern name and the value corresponding to the key is a list, which is used to store the nodes that are connected to the current node by a certain network pattern.

[0077] point_dict['A']={'net1':['B','D'],'net2':[],'net3':[]}

[0078] point_dict['B']={'net1':['A','C','H'],'net2':[],'net3':[]}

[0079] point_dict['C']={'net1':['B','D'],'net2':[],'net3':[]}

[0080] point_dict['D']={'net1':['A','C','H','G','E'],'net2':['H','G','E'],'net3':[]}

[0081] point_dict['E']={'net1':['D','F'],'net2':[],'net3':['F']}

[0082] point_dict['F']={'net1':['E','G'],'net2':['G'],'net3':['E']}

[0083] point_dict['G']={'net1':['D','H','F'],'net2':['D','H','F'],'net3':['E']}

[0084] point_dict['H']={'net1':['B','D','G','I'],'net2':['D','G'],'net3':[]}

[0085] point_dict['I']={'net1':['H','K'],'net2':[],'net3':['K']}

[0086] point_dict['J']={'net1':['H','K'],'net2':[],'net3':['K']}

[0087] point_dict['K']={'net1':['I','J'],'net2':[],'net3':['I','J']}

[0088] Steps 1-5: Construct the node grouping space

[0089] Iterate through each node in the node list and all network types, retrieving the connection node information of the network type in the network relationship dictionary `point_dict` corresponding to the current node. This information is a list, called the connection node information list. If the current connection node information list is not empty, store the node name in the corresponding network type list, named the network type containing node list. Then, store the network type lists in the node grouping space `net_list_space` according to the network type order, forming a local connectivity relationship from the perspective of each node. The stored content consists of other nodes directly connected to each node. The result is:

[0090] ['A','B','C','D','E','F','G','H','I','J','K']['D','F','G','H']['E','F','G','I','J','K']

[0091] Step 2: Obtain a network name from the network type list and a list of nodes containing the corresponding network type from the node grouping space. Then, from the perspective of each communication node, generate a link network based on the network relationship dictionary and the node grouping space. The specific implementation method is as follows:

[0092] Step 2-1: Obtain a network name temp_net from the network list net_list, and obtain the node list temp_net_list contained in the corresponding network from the node grouping space net_list_space;

[0093] Step 2-2: Construct a list of links, named relation_net, initially empty;

[0094] Steps 2-3: Iterate through all elements in temp_net_list and obtain a node named x;

[0095] Steps 2-4: Construct a temporary network structure space temp_relation_net of type list, and store node x in it;

[0096] Steps 2-5: Iterate through all elements in temp_net_list to obtain a node p;

[0097] Step 2-6: Determine if the temp_net space of node p is empty from the point_dict dictionary. If it is not empty, iterate through the elements in the temp_net space of node p in the point_dict dictionary to obtain node d, and execute step 2-7; if it is empty, return to step 2-5.

[0098] Step 2-7: Determine whether node d is in the temporary network structure space temp_relation_net. If node d is in the temporary network structure space temp_relation_net, then store p in temp_relation_net and execute step 2-8; otherwise, execute step 2-8 directly.

[0099] Step 2-8: If node d has not completed traversing the elements in the temp_net mesh space, then obtain new elements sequentially from the temp_net mesh space of node p and return to step 2-7; if the traversal is complete, then execute step 2-9.

[0100] Step 2-9: If node p has not completed traversing all elements in temp_net_list, return to step 2-5 to retrieve new elements in sequence; if the traversal is complete, proceed to step 2-10.

[0101] Step 2-10: If node x has not completed traversing all elements in temp_net_list, return to step 2-3 to retrieve new elements in sequence; if the traversal is complete, proceed to step 2-11.

[0102] Step 2-11: Remove duplicate elements from the list temp_relation_net and save the deduplicated list in the relation_net.

[0103] Step 3: Filter the subsets and parent sets in the link network;

[0104] The specific implementation of filtering subsets in a link relationship network is as follows:

[0105] Step 3-1-1: Obtain the dimensions of the relation_net list;

[0106] Step 3-1-2: Set variable i = 0;

[0107] Step 3-1-3: Set variable j = i + 1;

[0108] Step 3-1-4: If j is less than or equal to the dimension of the relation_net list, determine whether the j-th element in the relation_net list is a subset of the i-th element. If they are subsets, delete the j-th element. If j is greater than the dimension of the relation_net list, then i = i + 1, and return to step 3-1-3. When i is greater than the dimension of the relation_net list, the subset filtering is complete.

[0109] The specific implementation of filtering the parent set in the link relationship network is as follows:

[0110] Step 3-2-1: Obtain the dimensions of the relation_net list;

[0111] Step 3-2-2: Set variable i = 0;

[0112] Step 3-2-3: Set variable j = i + 1;

[0113] Step 3-2-4: If j is less than or equal to the dimension of the relation_net list, then determine whether the j-th element in the relation_net list is the parent set of the i-th element. If they are parent sets, then delete the i-th element. If j is greater than the dimension of the relation_net list, then i = i + 1, and return to step 3-2-3. When i is greater than the dimension of the relation_net list, the parent set filtering is completed.

[0114] Step 4: Return to Step 2 until all network types have been traversed, and generate a relationship space based on the filtered link network; the specific implementation method is as follows:

[0115] Step 4-1: Construct the result storage space result_space, with the attribute being a list;

[0116] Step 4-2: Repeat steps 2-4 for different network types in turn until all network types have been traversed, and obtain a list of relation_nets for the corresponding network type name;

[0117] Step 4-4: Store the relation_net list into the result_space storage space to obtain the grouping result:

[0118] [[['A','B','C','D','E','F','G','H','I','J','K']],[['G','D','F','H']],[['E','F','G'],['K','I','J']]]

[0119] In this embodiment of the invention, the grouping results based on net1, net2, and net3 network types correspond to the following respectively: Figure 2 , Figure 3 and Figure 4 As shown.

[0120] In summary, the method of the present invention can achieve automated grouping based on communication type and communication relationship.

Claims

1. An automated group generation method based on communication type and connection relationship, characterized in that, Includes the following steps: Step 1: Prepare the data by building a node list and a network type list, and generate a network relationship dictionary and build a node grouping space based on the communication information; Step 2: Obtain a network name from the network type list, and obtain the list of nodes contained in the corresponding network type from the node grouping space. From the perspective of each communication node, generate a link relationship network based on the network relationship dictionary and the node grouping space. Step 3: Filter the subsets and parent sets in the link network; Step 4: Return to Step 2 until all network types have been traversed, and generate a relationship space based on the filtered link relationship network; The specific implementation method in step 1 is as follows: Step 1-1: Construct a network relationship dictionary, point_dict, as a dictionary, initially empty; Step 1-2: Construct a node list named point_list, store the node names in point_list, and construct a node position dictionary. Use the node name as the key and the node position information as the value in the node position dictionary. The node position information is a dictionary, and the value is the two-dimensional position of the node in the scene. Steps 1-3: Construct a net_list of net types and store the net names in net_list; Steps 1-4: Using the node name as the key, store the corresponding node connection information into the network relationship dictionary point_dict; where the node connection information is a dictionary, the key is the network pattern name, and the value corresponding to the key is a list, which is used to store the nodes that are connected to the current node by a certain network pattern; Steps 1-5: Traverse each node in the node list and all network types, and obtain the connection node information of the network type in the network relationship dictionary point_dict corresponding to the current node. This is called the connection node information list. If the current connection node information list is not empty, store the node name in the corresponding network type list, named the network type containing node list. Then, store the network type list in the node grouping space net_list_space according to the network type order, forming a local connectivity relationship from the perspective of each node. The stored content is other nodes directly connected to each node. The specific implementation method of step 2 is as follows: Step 2-1: Obtain a network name temp_net from the network list net_list, and obtain the node list temp_net_list contained in the corresponding network from the node grouping space net_list_space; Step 2-2: Construct a list of links, named relation_net, initially empty; Steps 2-3: Iterate through all elements in temp_net_list and obtain a node named x; Steps 2-4: Construct a temporary network structure space temp_relation_net of type list, and store node x in it; Steps 2-5: Iterate through all elements in temp_net_list to obtain a node p; Step 2-6: Determine whether the temp_net space of node p is empty from the point_dict dictionary. If it is not empty, traverse the elements in the temp_net space of node p in the point_dict dictionary to obtain node d, and execute step 2-7; if it is empty, return to step 2-5. Step 2-7: Determine whether node d is in the temporary network structure space temp_relation_net. If node d is in the temporary network structure space temp_relation_net, then store p in temp_relation_net and execute step 2-8; otherwise, execute step 2-8 directly. Step 2-8: If node d has not completed traversing the elements in the temp_net mesh space, then obtain new elements sequentially from the temp_net mesh space of node p and return to step 2-7; if the traversal is complete, then execute step 2-9. Step 2-9: If node p has not completed traversing all elements in temp_net_list, return to step 2-5 to retrieve new elements in sequence; if the traversal is complete, proceed to step 2-10. Step 2-10: If node x has not completed traversing all elements in temp_net_list, return to step 2-3 to retrieve new elements in sequence; if the traversal is complete, proceed to step 2-11. Step 2-11: Remove duplicate elements from the list temp_relation_net and save the deduplicated list in the relation_net.

2. The automated grouping generation method based on communication type and connection relationship according to claim 1, characterized in that, Step 3 involves filtering subsets within the link network, specifically implemented as follows: Step 3-1-1: Obtain the dimensions of the relation_net list; Step 3-1-2: Set variable i = 0; Step 3-1-3: Set variable j = i + 1; Step 3-1-4: If j is less than or equal to the dimension of the relation_net list, determine whether the j-th element in the relation_net list is a subset of the i-th element. If they are subsets, delete the j-th element. If j is greater than the dimension of the relation_net list, then i = i + 1 and return to step 3-1-3. When i is greater than the dimension of the relation_net list, the subset filtering is complete.

3. The automated grouping generation method based on communication type and connection relationship according to claim 1, characterized in that, Step 3 involves filtering the parent set in the link relationship network. The specific implementation method is as follows: Step 3-2-1: Obtain the dimensions of the relation_net list; Step 3-2-2: Set variable i = 0; Step 3-2-3: Set variable j = i + 1; Step 3-2-4: If j is less than or equal to the dimension of the relation_net list, then determine whether the j-th element in the relation_net list is the parent set of the i-th element. If they are parent sets, then delete the i-th element. If j is greater than the dimension of the relation_net list, then i = i + 1, and return to step 3-2-3. When i is greater than the dimension of the relation_net list, the parent set filtering is completed.

4. The automated grouping generation method based on communication type and connection relationship according to claim 1, characterized in that, The specific implementation method of step 4 is as follows: Step 4-1: Construct the result storage space result_space, with the attribute being a list; Step 4-2: Repeat steps 2-4 for different network types in turn until all network types have been traversed, and obtain a list of relation_nets for the corresponding network type name; Step 4-4: Store the relation_net list into the storage space result_space.

Images