如何使用 omnet++ 从两个节点之间的“Link”中读取值

Question

我正在尝试使用 C++ 在 omnet++ 中实现 Ford Fulkerson 算法。我从这个 article 中获取了 c++ class 但是我无法从网络中读取应该来自 Links

的值

我的class算法：

// C++ program for implementation of Ford Fulkerson algorithm
#include <iostream>
#include <limits.h>
#include <string.h>
#include <queue>
using namespace std;

// Number of vertices in given graph
#define V 6

class Node : public cSimpleModule
{
  protected:
    // The following redefined virtual function holds the algorithm.
    virtual void initialize();
    virtual void handleMessage(cMessage *msg);
};

Define_Module(Node);

void Node::initialize()
{
    // These values should come from Links
    int graph[V][V] = { {0, 16, 13, 0, 0, 0},
                            {0, 0, 10, 12, 0, 0},
                            {0, 4, 0, 0, 14, 0},
                            {0, 0, 9, 0, 0, 20},
                            {0, 0, 0, 7, 0, 4},
                            {0, 0, 0, 0, 0, 0}
                          };
    fordFulkerson(graph, 0, 5);
}

void Node::handleMessage(cMessage *msg)
{
    send(msg, "out");
}

/* Returns true if there is a path from source 's' to sink 't' in
  residual graph. Also fills parent[] to store the path */
bool bfs(int rGraph[V][V], int s, int t, int parent[])
{
    // Create a visited array and mark all vertices as not visited
    bool visited[V];
    memset(visited, 0, sizeof(visited));

    // Create a queue, enqueue source vertex and mark source vertex
    // as visited
    queue <int> q;
    q.push(s);
    visited[s] = true;
    parent[s] = -1;

    // Standard BFS Loop
    while (!q.empty())
    {
        int u = q.front();
        q.pop();

        for (int v=0; v<V; v++)
        {
            if (visited[v]==false && rGraph[u][v] > 0)
            {
                q.push(v);
                parent[v] = u;
                visited[v] = true;
            }
        }
    }

    // If we reached sink in BFS starting from source, then return
    // true, else false
    return (visited[t] == true);
}

// Returns tne maximum flow from s to t in the given graph
int fordFulkerson(int graph[V][V], int s, int t)
{
    int u, v;

    // Create a residual graph and fill the residual graph with
    // given capacities in the original graph as residual capacities
    // in residual graph
    int rGraph[V][V]; // Residual graph where rGraph[i][j] indicates
                     // residual capacity of edge from i to j (if there
                     // is an edge. If rGraph[i][j] is 0, then there is not)
    for (u = 0; u < V; u++)
        for (v = 0; v < V; v++)
             rGraph[u][v] = graph[u][v];

    int parent[V];  // This array is filled by BFS and to store path

    int max_flow = 0;  // There is no flow initially

    // Augment the flow while tere is path from source to sink
    while (bfs(rGraph, s, t, parent))
    {
        // Find minimum residual capacity of the edhes along the
        // path filled by BFS. Or we can say find the maximum flow
        // through the path found.
        int path_flow = INT_MAX;
        for (v=t; v!=s; v=parent[v])
        {
            u = parent[v];
            path_flow = min(path_flow, rGraph[u][v]);
        }

        // update residual capacities of the edges and reverse edges
        // along the path
        for (v=t; v != s; v=parent[v])
        {
            u = parent[v];
            rGraph[u][v] -= path_flow;
            rGraph[v][u] += path_flow;
        }

        // Add path flow to overall flow
        max_flow += path_flow;
    }

    // Return the overall flow
    return max_flow;
}

网络：

/
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see http://www.gnu.org/licenses/.
// 

import Node;

import Link;

//
// Generated network with random topology (6 nodes, 8 edges, seed=100).
//
network Network
{
    @display("bgb=478,329");
    submodules:
        S: Node {
            @display("p=19,87;is=s");
        }
        n1: Node {
            @display("p=130,142;is=s");
        }
        n2: Node {
            @display("p=130,36;is=s");
        }
        n3: Node {
            @display("p=262,142;is=s");
        }
        n4: Node {
            @display("p=262,36;is=s");
        }
        T: Node {
            @display("p=364,87;is=s");
        }
    connections:
        S.g++ <--> Link { @display("t=13"); cost = 13; } <--> n1.g++;
        S.g++ <--> Link {  cost = 16;@display("t=16"); } <--> n2.g++;
        n1.g++ <--> Link {  cost = 1;@display("t=1"); } <--> n2.g++;
        n1.g++ <--> Link {  cost = 14;@display("t=14"); } <--> n3.g++;
        n1.g++ <--> Link {  cost = 9;@display("t=9"); } <--> n4.g++;
        n2.g++ <--> Link {  cost = 12;@display("t=12"); } <--> n4.g++;
        n4.g++ <--> Link {  cost = 20;@display("t=20"); } <--> T.g++;
        n3.g++ <--> Link {  cost = 4;@display("t=4"); } <--> T.g++;
        n3.g++ <--> Link {  cost = 7;@display("t=7"); } <--> n4.g++;
}

Answer 1

您似乎正在使用一个名为 Link 的自定义模块作为您的频道，您似乎已经为它提供了一个 cost 参数。从 Node 获取此 cost 参数需要三个步骤：

要获取哪些 Link 通道将 Node 连接到它的邻居，您需要首先使用 OMNeT++ API 查询节点的 Connections。有关详细信息，请参阅用户手册中的 访问门和连接 部分。对于每个连接，您可以使用 getChannel 方法获取指向关联通道（您的 Link 模块）的指针。

使用指向您的 Link 模块的指针，您可以使用 OMNet++ 的 par() 方法查询其参数值。

我看到您还设置了 Link 模块的 Display String（特别是 t 标记来注释某些文本）。有关如何读取（或写入）此标签的信息，请参阅用户手册中有关 Display Strings 的章节。

如何使用 omnet++ 从两个节点之间的“Link”中读取值

How to read value from `Link` between two nodes using omnet++

c++

algorithm

omnet++