## 7 Ground-Segment Optimization Aspects
### Applicable Optimization Methods for Ground Segment
#### 7.2.2 Long Short-Term Memory (LSTM)
#### 8.3.2 Search Methods

Search methods are optimization calculations or algorithms that are employed to solve a search problem to varying degrees of optimality. There are a vast number of such methods, but we will do our best to give overviews for the commonly used ones with respect to the user segment problems seen in Table 2.7

We start with some brute-force methods. Continuing with the satellite selection problem, an 'optimal' brute-force method would be to look at all possible combinations of \(k\) out of \(n\) satellites to determine the best performance. Such brute-force methods are optimal in terms of returning the best possible outcome but are distinctly non-optimal in terms of overhead, i.e., computational cost and time. If there were \(n\) healthy satellites above the mask, a receiver with \(k\) channels would have to evaluate \(N_{opt}\) geometries, where \(N_{opt}\) is given by a simple combination, as shown in Equation (43). However, it is easy to see that the number of geometries to evaluate can quickly become infeasible as \(n\) and \(k\) change. Table 2.8

Another brute-force approach is to utilize a greedy heuristic to make the combination more feasible. This 'Greedy Search' method is similar to the optimal, but the difference is that instead of calculating all possible combinations, the search focuses on the best subset of a chosen satellite, iterating over all the satellites. For an example, if we take an initial case with \(n=10\) satellites, all subsets continuing 9 satellites are calculated first, and then the one with the best metric is selected to continue evaluating another subset of eight satellites. This results in an improved speed over the straightforward combination calculation, but it runs the risk of missing the global optimum. In addition, the overhead may still remain non-optimal. More sophisticated search methods are typically employed to solve problems related to network routing optimization, which can be formulated as shortest path problems. The first algorithm we would like to introduce is the well-known 'Dijkstra's Algorithm', originally introduced in [46] to find the shortest path between two given nodes. Nowadays, the common variant finds the shortest path from a'source' node to all the other nodes in the network. We provide the steps in Algorithm 6. This algorithm can be seen as a brute-search type of algorithm as it typically ends when the entire network is known (therefore, the overhead remains at the non-optimal levels). However, it can also be coupled with models depending on the available information about the network and how accurate its cost calculation and dynamic model is. ```
Step 1: Initialization  Given the network graph, assign a cost value to every node in the network; the cost value of a node is the total cost value of the shortest path discovered so far between that node and the source node. Initially, this means 0 for the source node and inf for all other nodes. Furthermore, create a list for unvisited nodes and initialize it with all the nodes in the network. Set the current node as the source node. Step 2: Calculate Cost to Neighbors  For the current node, consider all of its unvisited neighbors and calculate their cost values through the current node. Compare the newly calculated cost to the current assigned value and assign the smaller one. Step 3: Update Current Node  Remove the current node from the unvisited list and assign the neighbor with lowest cost as the current node that is in the unvisited list (a visited node will never be checked again). Step 4: Termination  Repeat steps 2-4 until a termination criterion is met (i.e., destination node is found, all routes in the network are known, etc.). ```

**Algorithm 6** Dijkstra's Algorithm

Another well-known algorithm is the 'A* Search Algorithm', which is a very similar algorithm to Dijkstra, except it includes a heuristic while selecting which nodes to explore next. As we have shown in Algorithm 6, [PERSON] decides which node to explore next based on the path cost.