电网网络边缘负载计算功能实现求助（附测试用例及未完成代码）

各位大佬好，我现在在实现一个电网网络的边缘负载计算功能，卡在带connection类型节点的网络场景上了，目前的代码只能通过前几个简单的测试用例，复杂场景完全搞不定，求各位帮忙看看问题出在哪，或者给个实现思路！

数据结构定义 #

export type Network = {
  readonly nodes: readonly Node[];
  readonly edges: readonly Edge[];
}

export type Node = {
  readonly id: string;
  readonly displayName: string;
  readonly type: NodeType;
  readonly isGreenProduction: boolean;
  readonly hasFixedProduction: boolean;
  readonly maxProduction: number;
  production: number;
  readonly requiresGreenConsumption: boolean;
  readonly hasFixedConsumption: boolean;
  readonly maxConsumption: number;
  consumption: number;
}

export type NodeType = "participant" | "connection";

export type Edge = {
  readonly nodes: [Node, Node];
  readonly capacity: number;
  readonly maxCapacity: number;
}

测试用例（预期结果已标注） #

这些测试用例定义了各种场景下的预期边缘负载值，我的代码目前只能通过前几个简单场景，带connection节点的复杂场景都不对：

const defaultNode: Node = {
  id: "testNode",
  displayName: "testNode",
  type: "participant",
  production: 0,
  maxProduction: 0,
  isGreenProduction: false,
  hasFixedProduction: false,
  consumption: 0,
  maxConsumption: 0,
  requiresGreenConsumption: false,
  hasFixedConsumption: false,
};

const defaultEdge: Edge = {
  nodes: [defaultNode, defaultNode],
  capacity: 0,
  maxCapacity: 0,
};

describe("Edge calculation", () => {
  /**
   * Producer(100) --- Consumer(100)
   */
  it("simple", () => {
    const producer: Node = { ...defaultNode, production: 100 };
    const consumer: Node = { ...defaultNode, consumption: 100 };
    const edge: Edge = { ...defaultEdge, nodes: [producer, consumer] };
    const network: Network = { nodes: [producer, consumer], edges: [edge] };
    calculateEdges(network);
    expect(edge.capacity).toBe(100);
  });

  /**
   * Producer(150) --- Consumer(100)
   *     |
   * Consumer(50)
   */
  it("simple split consumer", () => {
    const producer: Node = { ...defaultNode, production: 150 };
    const consumer: Node = { ...defaultNode, consumption: 100 };
    const consumer2: Node = { ...defaultNode, consumption: 50 };
    const edge1: Edge = { ...defaultEdge, nodes: [producer, consumer] };
    const edge2: Edge = { ...defaultEdge, nodes: [producer, consumer2] };
    const network: Network = { nodes: [producer, consumer, consumer2], edges: [edge1, edge2] };
    calculateEdges(network);
    expect(edge1.capacity).toBe(100);
    expect(edge2.capacity).toBe(50);
  });

  /**
   * Producer(150) --- Consumer(200)
   *                 /
   *     Producer(50)
   */
  it("simple split producer", () => {
    const producer: Node = { ...defaultNode, production: 150 };
    const producer2: Node = { ...defaultNode, production: 50 };
    const consumer: Node = { ...defaultNode, consumption: 200 };
    const edge1: Edge = { ...defaultEdge, nodes: [producer, consumer] };
    const edge2: Edge = { ...defaultEdge, nodes: [producer2, consumer] };
    const network: Network = { nodes: [producer, producer2, consumer], edges: [edge1, edge2] };
    calculateEdges(network);
    expect(edge1.capacity).toBe(150);
    expect(edge2.capacity).toBe(50);
  });

  /**
   * Producer(100) --- Connection --- Consumer(100)
   */
  it("simple connection", () => {
    const producer: Node = { ...defaultNode, production: 100 };
    const consumer: Node = { ...defaultNode, consumption: 100 };
    const connection: Node = { ...defaultNode, type: "connection" };
    const edge1: Edge = { ...defaultEdge, nodes: [producer, connection] };
    const edge2: Edge = { ...defaultEdge, nodes: [connection, consumer] };
    const network: Network = { nodes: [producer, consumer, connection], edges: [edge1, edge2] };
    calculateEdges(network);
    expect(edge1.capacity).toBe(100);
    expect(edge2.capacity).toBe(100);
  });

  /**
   * Producer(100) --- Connection --- Connection --- Consumer(100)
   */
  it("simple double connection", () => {
    const producer: Node = { ...defaultNode, production: 100 };
    const consumer: Node = { ...defaultNode, consumption: 100 };
    const connection: Node = { ...defaultNode, type: "connection" };
    const connection2: Node = { ...defaultNode, type: "connection" };
    const edge1: Edge = { ...defaultEdge, nodes: [producer, connection] };
    const edge2: Edge = { ...defaultEdge, nodes: [connection, connection2] };
    const edge3: Edge = { ...defaultEdge, nodes: [connection2, consumer] };
    const network: Network = {
      nodes: [producer, consumer, connection, connection2],
      edges: [edge1, edge2, edge3],
    };
    calculateEdges(network);
    expect(edge1.capacity).toBe(100);
    expect(edge2.capacity).toBe(100);
    expect(edge2.capacity).toBe(100);
  });

  /**
   *                              / Consumer(50)
   * Producer(100) --- Connection
   *                              \ Consumer(50)
   */
  it("simple connection with split", () => {
    const producer: Node = { ...defaultNode, production: 100 };
    const consumer: Node = { ...defaultNode, consumption: 50 };
    const consumer2: Node = { ...defaultNode, consumption: 50 };
    const connection: Node = { ...defaultNode, type: "connection" };
    const edge1: Edge = { ...defaultEdge, nodes: [producer, connection] };
    const edge2: Edge = { ...defaultEdge, nodes: [connection, consumer] };
    const edge3: Edge = { ...defaultEdge, nodes: [connection, consumer2] };
    const network: Network = {
      nodes: [producer, consumer, consumer2, connection],
      edges: [edge1, edge2, edge3],
    };
    calculateEdges(network);
    expect(edge1.capacity).toBe(100);
    expect(edge2.capacity).toBe(50);
    expect(edge3.capacity).toBe(50);
  });

  /**
   *
   * Producer(100) --- Connection --- Consumer(150)
   *                       |
   *                  Producer(50)
   */
  it("double producer", () => {
    const producer: Node = { ...defaultNode, production: 100 };
    const producer2: Node = { ...defaultNode, production: 50 };
    const consumer: Node = { ...defaultNode, consumption: 150 };
    const connection: Node = { ...defaultNode, type: "connection" };
    const edge1: Edge = { ...defaultEdge, nodes: [producer, connection] };
    const edge2: Edge = { ...defaultEdge, nodes: [producer2, connection] };
    const edge3: Edge = { ...defaultEdge, nodes: [connection, consumer] };
    const network: Network = {
      nodes: [producer, producer2, consumer, connection],
      edges: [edge1, edge2, edge3],
    };
    calculateEdges(network);
    expect(edge1.capacity).toBe(100);
    expect(edge2.capacity).toBe(50);
    expect(edge3.capacity).toBe(150);
  });

  /**
   *
   * Producer(100green) --- Connection --- Consumer(100green)
   *                            |
   *                       Producer(50)
   */
  it("double producer green prefered", () => {
    const producer: Node = { ...defaultNode, production: 100, isGreenProduction: true };
    const producer2: Node = { ...defaultNode, production: 50 };
    const consumer: Node = { ...defaultNode, consumption: 100, requiresGreenConsumption: true };
    const connection: Node = { ...defaultNode, type: "connection" };
    const edge1: Edge = { ...defaultEdge, nodes: [producer, connection] };
    const edge2: Edge = { ...defaultEdge, nodes: [producer2, connection] };
    const edge3: Edge = { ...defaultEdge, nodes: [connection, consumer] };
    const network: Network = {
      nodes: [producer, producer2, consumer, connection],
      edges: [edge1, edge2, edge3],
    };
    calculateEdges(network);
    expect(edge1.capacity).toBe(100);
    expect(edge2.capacity).toBe(0);
    expect(edge3.capacity).toBe(100);
  });

  /**
   *
   * Producer(100green) --- Connection --- Consumer(150green)
   *                            |
   *                       Producer(50)
   */
  it("double producer green prefered grey fillup", () => {
    const producer: Node = { ...defaultNode, production: 100, isGreenProduction: true };
    const producer2: Node = { ...defaultNode, production: 50 };
    const consumer: Node = { ...defaultNode, consumption: 150, requiresGreenConsumption: true };
    const connection: Node = { ...defaultNode, type: "connection" };
    const edge1: Edge = { ...defaultEdge, nodes: [producer, connection] };
    const edge2: Edge = { ...defaultEdge, nodes: [producer2, connection] };
    const edge3: Edge = { ...defaultEdge, nodes: [connection, consumer] };
    const network: Network = {
      nodes: [producer, producer2, consumer, connection],
      edges: [edge1, edge2, edge3],
    };
    calculateEdges(network);
    expect(edge1.capacity).toBe(100);
    expect(edge2.capacity).toBe(50);
    expect(edge3.capacity).toBe(150);
  });

  /**
   *
   *                        Consumer(50)
   *                            |
   * Producer(100green) --- Connection --- Connection --- Consumer(150green)
   *                            |         |
   *                        Connection ---
   *                            |
   *                        Producer(100)
   */
  it("simple circle", () => {
    const producer: Node = { ...defaultNode, production: 100, isGreenProduction: true };
    const producer2: Node = { ...defaultNode, production: 100 };
    const consumer: Node = { ...defaultNode, consumption: 150, requiresGreenConsumption: true };
    const consumer2: Node = { ...defaultNode, consumption: 50 };
    const connection: Node = { ...defaultNode, type: "connection" };
    const connection2: Node = { ...defaultNode, type: "connection" };
    const connection3: Node = { ...defaultNode, type: "connection" };
    const edge1: Edge = { ...defaultEdge, nodes: [producer, connection] };
    const edge2: Edge = { ...defaultEdge, nodes: [producer2, connection2] };
    const edge3: Edge = { ...defaultEdge, nodes: [connection, connection2] };
    const edge4: Edge = { ...defaultEdge, nodes: [connection, consumer2] };
    const edge5: Edge = { ...defaultEdge, nodes: [connection, connection3] };
    const edge6: Edge = { ...defaultEdge, nodes: [connection2, connection3] };
    const edge7: Edge = { ...defaultEdge, nodes: [connection3, consumer] };
    const network: Network = {
      nodes: [producer, producer2, consumer, consumer2, connection, connection2, connection3],
      edges: [edge1, edge2, edge3, edge4, edge5, edge6, edge7],
    };
    calculateEdges(network);
    expect(edge1.capacity).toBe(100);
    expect(edge2.capacity).toBe(50);
    expect(edge3.capacity).toBe(50);
    expect(edge4.capacity).toBe(50);
    expect(edge5.capacity).toBe(100);
    expect(edge6.capacity).toBe(50);
    expect(edge7.capacity).toBe(150);
  });
});

我目前的未完成代码 #

我尝试用CalcNode来记录每个节点的供需情况，但connection节点的处理逻辑明显有问题，现在的代码只能处理简单的直连场景，复杂的连接节点转发、绿色能源优先的场景都处理不了：

type CalcNode = {
  giving: number;
  requesting: number;
  realNode: Node;
};

export function calculateEdges(network: Network): void {
  const calcNodes: CalcNode[] = network.nodes.map((node) => {
    const calcNode: CalcNode = { giving: 0, requesting: 0, realNode: node };
    if (node.type === "connection") {
      network.edges
        .filter((edge) => edge.nodes[0] === node || edge.nodes[1] === node)
        .forEach((edge) => {
          // TODO add
          if (edge.nodes[0] === node) {
            calcNode.giving = Math.max(calcNode.giving, edge.nodes[1].production);
            calcNode.requesting = Math.max(
              calcNode.requesting,
              edge.nodes[1].consumption,
            );
          } else if (edge.nodes[1] === node) {
            calcNode.giving = Math.max(calcNode.giving, edge.nodes[0].production);
            calcNode.requesting = Math.max(
              calcNode.requesting,
              edge.nodes[0].consumption,
            );
          }
        });
    } else {
      calcNode.giving = node.production;
      calcNode.requesting = node.consumption;
    }
    return calcNode;
  });

  calcNodes.forEach((node) => console.log(node));

  network.edges.forEach((edge) => {
    const node1 = calcNodes.find((calcNode) => calcNode.realNode === edge.nodes[0])!;
    const node2 = calcNodes.find((calcNode) => calcNode.realNode === edge.nodes[1])!;
    if (node1.requesting == 0) {
      edge.capacity = Math.max(node1.giving, node2.giving, node2.requesting);
    }
  });
}

核心问题 #

我现在的主要困惑是：

• connection节点本身没有生产和消费，它只是起到中转作用，怎么正确计算它的供需，进而算出连接它的每条边的负载？
• 绿色能源优先的规则（需要绿色消费的节点优先用绿色生产的能源）怎么融入到计算逻辑里？
• 环形网络这种复杂拓扑的负载怎么正确分配？

希望各位大佬能给点思路，或者帮我修正代码，谢谢大家！

备注：内容来源于stack exchange，提问作者Reborok