praktikum-holons/src/holeg/HolegGateway.java

package holeg;

import classes.AbstractCanvasObject;
import classes.HolonObject;
import holeg.model.Grid;
import holeg.model.GridEdge;
import holeg.model.GridNode;
import holeg.power_flow.ComplexNumber;
import holeg.power_flow.SolverSettings;
import holeg.simple_grid.SimpleGridBuilder;
import holeg.simple_grid.SimpleGridEdge;
import holeg.simple_grid.SimpleGridNode;
import holeg.ui.PowerFlowAnalysisMenu;
import holeg.ui.SolveResultMessageBox;
import ui.controller.FlexManager;
import ui.model.*;

import java.util.HashMap;

public class HolegGateway {
    private static Grid convert(MinimumNetwork network, int iteration, FlexManager flexManager) {
        SimpleGridBuilder gridBuilder = new SimpleGridBuilder();
        HashMap<AbstractCanvasObject, SimpleGridNode> canvasToGrid = new HashMap<>();
        for (HolonObject object : network.getHolonObjectList()) {
            double power = object.getEnergyAtTimeStep(iteration);
            SimpleGridNode node;
            if (power <= 0)
                node = gridBuilder.addHouse(new ComplexNumber(-power, 0));
            else
                node = gridBuilder.addGenerator(new ComplexNumber(power, 0));
            node.tag = object;
            canvasToGrid.put(object, node);
        }
        for (AbstractCanvasObject object : network.getNodeAndSwitches()) {
            SimpleGridNode node = gridBuilder.addHouse(new ComplexNumber(0, 0));
            node.tag = object;
            canvasToGrid.put(object, node);
        }
        for (IntermediateCableWithState cable : network.getEdgeList()) {
            SimpleGridNode a = canvasToGrid.get(cable.getModel().getA());
            SimpleGridNode b = canvasToGrid.get(cable.getModel().getB());
            if (a == null || b == null)
                continue;
            SimpleGridEdge edge = gridBuilder.connect(a, b, 1);
            edge.tag = cable;
        }
        return gridBuilder.getGrid();
    }

    private static void decorateNetwork(MinimumNetwork network, int iteration, FlexManager flexManager, DecoratedNetwork decoratedNetwork, Grid grid) {
        for (GridNode node : grid.getNodes()) {
            SimpleGridNode simpleNode = (SimpleGridNode) node;
            if (node.getPowerGeneration().lenSquared() > 0)
                decoratedNetwork.getSupplierList().add(new Supplier((HolonObject) simpleNode.tag, (float) node.getPowerGeneration().real, 0));
            else if (node.getPowerConsumption().lenSquared() < 0)
                decoratedNetwork.getConsumerList().add(new Consumer((HolonObject) simpleNode.tag));
            else
                decoratedNetwork.getPassivNoEnergyList().add(new Passiv((HolonObject) simpleNode.tag));
        }
        for (GridEdge edge : grid.getEdges()) {
            SimpleGridEdge simpleGridEdge = (SimpleGridEdge) edge;
            decoratedNetwork.getDecoratedCableList().add(
                    new DecoratedCable(
                            ((IntermediateCableWithState)simpleGridEdge.tag).getModel(),
                            DecoratedCable.CableState.Working,
                            (float)simpleGridEdge.power.real));
        }
    }

    public static void solve(MinimumNetwork minimumNetwork, int iteration, FlexManager flexManager, DecoratedNetwork network) {
        Grid grid = convert(minimumNetwork, iteration, flexManager);

        HolegPowerFlow powerFlow = new HolegPowerFlow();
        GridSolverResult result = powerFlow.solve(grid);
        decorateNetwork(minimumNetwork, iteration, flexManager, network, grid);

        if (PowerFlowAnalysisMenu.getInstance().shouldShowResult())
            SolveResultMessageBox.show(result);
    }
}