praktikum-holons/src/holeg/HolegGateway.java

package holeg;

import classes.AbstractCanvasObject;
import classes.HolonObject;
import classes.Node;
import holeg.model.*;
import holeg.power_flow.ComplexNumber;
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.controller.SingletonControl;
import ui.model.*;
import ui.view.GUI;

import javax.swing.*;
import java.awt.*;
import java.util.*;
import java.util.List;
import java.util.stream.Collectors;

public class HolegGateway {
    private static ThreadLocal<Boolean> onlyUpdateVisual = new ThreadLocal<Boolean>();

    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);
            double reactivePower = object.getReactiveEnergyAtTimeStep(iteration);
            SimpleGridNode node;

            // Create house or generator
            if (power <= 0)
                node = gridBuilder.addHouse(new ComplexNumber(-power, reactivePower));
            else
                node = gridBuilder.addGenerator(new ComplexNumber(power, reactivePower));
            node.tag = object;

            // Find type by design
            if (object.getElements().stream().anyMatch(e -> e.getEleName().equalsIgnoreCase("SLACK")))
                node.typeByDesign = NodeType.Slack;
            else if (object.getElements().stream().anyMatch(e -> e.getEleName().equalsIgnoreCase("TRANSFORMER")))
                node.typeByDesign = NodeType.Transformer;
            else
                node.typeByDesign = NodeType.Bus;
            canvasToGrid.put(object, node);
        }
        // Add all switches and nodes
        for (AbstractCanvasObject object : network.getNodeAndSwitches()) {
            SimpleGridNode node = gridBuilder.addHouse(new ComplexNumber(0, 0));
            node.tag = object;
            node.typeByDesign = NodeType.Bus;
            canvasToGrid.put(object, node);
        }

        // Add all cables
        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, Math.max(1, cable.getModel().getRealLength()));
            edge.overrideImpedance = new ComplexNumber(cable.getModel().getOverrideResistance(), cable.getModel().getOverrideReactance());
            edge.overrideShuntSusceptance = cable.getModel().getOverrideShuntSusceptance();
            edge.tag = cable;
        }
        return gridBuilder.getGrid();
    }

    private static void decorateNetwork(MinimumNetwork network, int iteration, FlexManager flexManager, DecoratedNetwork decoratedNetwork, Grid grid) {
        synchronized (decoratedNetwork.getLockObject()) {
            decoratedNetwork.clear();

            // Convert all nodes
            for (GridNode node : grid.getNodes()) {
                SimpleGridNode simpleNode = (SimpleGridNode) node;

                // Create supplier, consumer or passiv object
                if (node.getPowerGeneration().lenSquared() > 0)
                    decoratedNetwork.getSupplierList().add(new Supplier((HolonObject) simpleNode.tag, (float) node.getPowerGeneration().real, 0, simpleNode.getVoltage(), simpleNode.phaseDegrees, simpleNode.getTypeByDesign() == NodeType.Slack));
                else if (node.getPowerConsumption().lenSquared() > 0)
                    decoratedNetwork.getConsumerList().add(new Consumer((HolonObject) simpleNode.tag, (float) node.getPowerConsumption().real, simpleNode.getVoltage(), simpleNode.phaseDegrees, Math.cos(simpleNode.getPowerConsumption().angle()), simpleNode.getTypeByDesign() == NodeType.Slack));
                else if (simpleNode.tag instanceof HolonObject)
                    decoratedNetwork.getPassivNoEnergyList().add(new Passiv((HolonObject) simpleNode.tag));
            }

            // Convert all edges
            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,
                                (float) simpleGridEdge.loss.real));
            }
            decoratedNetwork.calculateStates();
        }
    }

    private static synchronized Set<HolegPowerFlowContext> getAllContextFromHolonObjects(List<HolonObject> objects) {
        HashSet<HolegPowerFlowContext> contextSet = new HashSet<>();

        for (AbstractCanvasObject object : objects)
            if (object.tag instanceof HolegPowerFlowContext)
                contextSet.add((HolegPowerFlowContext) object.tag);

        return contextSet;
    }

    public static synchronized Set<HolegPowerFlowContext> getALlContext() {
        return HolegGateway.getAllContextFromHolonObjects(SingletonControl.getInstance().getControl().getModel().getAllHolonObjectsOnCanvas());
    }

    private static synchronized HolegPowerFlowContext getContextFromHolonObjects(List<HolonObject> objects) {
        if (objects.size() == 0)
            return null;

        HolegPowerFlowContext context = null;
        for (AbstractCanvasObject object : objects) {
            if (object.tag instanceof HolegPowerFlowContext) {
                if (context == null)
                    context = (HolegPowerFlowContext) object.tag;
                else {
                    context.stopSolver();
                    object.tag = null;
                }
            }
        }

        if (context == null) {
            context = new HolegPowerFlowContext();
            objects.get(0).tag = context;
        }

        return context;
    }

    public static void solve(PowerFlowSettings settings, MinimumNetwork minimumNetwork, int iteration, FlexManager flexManager, DecoratedNetwork network) {
        Thread solverWrapper = new Thread(() -> {
            try {
                solveInternal(settings, minimumNetwork, iteration, flexManager, network);
            } catch (Exception e) {
                SolveResultMessageBox.showInternalError(e);
            }
        });
        try {
            solverWrapper.setName("Solver Wrapper " + Long.toHexString(solverWrapper.getId()));
            solverWrapper.start();
            solverWrapper.join(4000);
            if (solverWrapper.isAlive()) {
                solverWrapper.stop();
                SolveResultMessageBox.showSolverTookTooLongToStart();
            }
        } catch (Exception e) {
            SolveResultMessageBox.showInternalError(e);
        }
    }

    private static void solveInternal(PowerFlowSettings settings, MinimumNetwork minimumNetwork, int iteration, FlexManager flexManager, DecoratedNetwork network) {
        // Find context
        HolegPowerFlowContext context = getContextFromHolonObjects(minimumNetwork.getHolonObjectList());
        if (context == null)
            return;

        // Solve with context
        solve(settings, context, minimumNetwork, iteration, flexManager, network);
    }

    private static void solve(PowerFlowSettings settings, HolegPowerFlowContext context, MinimumNetwork minimumNetwork, int iteration, FlexManager flexManager, DecoratedNetwork network) {
        if (settings == null)
            throw new IllegalArgumentException("settings is null");
        if (context == null)
            throw new IllegalArgumentException("context is null");
        if (minimumNetwork == null)
            throw new IllegalArgumentException("minimumNetwork is null");
        if (network == null)
            throw new IllegalArgumentException("network is null");

        // If we should show this solved grid
        if (context.showGridForVisual != null) {
            decorateNetwork(minimumNetwork, iteration, flexManager, network, context.showGridForVisual);
            context.showGridForVisual = null;
            return;
        }

        synchronized (context.lock) {
            boolean solve = !PowerFlowAnalysisMenu.getInstance().areUpdatesDisabled();
            Grid grid = convert(minimumNetwork, iteration, flexManager);

            // Check if the grid is equal to one already solved
            if (settings.onlyUpdateGridWhenChanged) {
                for (Grid lastSolved : context.lastSolvedGrids) {
                    if (GridComparator.isEqual(lastSolved, grid)) {
                        decorateNetwork(minimumNetwork, iteration, flexManager, network, lastSolved);
                        return;
                    }
                }

                // Only remember grid when solving
                if (solve) {
                    // Keep size constrained to 32 saved grids
                    if (context.lastSolvedGrids.size() >= 32)
                        context.lastSolvedGrids.remove(0);

                    // Grid is updated by solver directly, so we can save the reference to the grid
                    context.lastSolvedGrids.add(grid);
                }
            }

            // We got no solution for this grid
            if (onlyUpdateVisual.get() != null && onlyUpdateVisual.get()) {
                decorateNetwork(minimumNetwork, iteration, flexManager, network, grid);
                return;
            }

            // Stop old solver
            context.stopSolver();

            // Create solver job
            Thread solverJob = new Thread(() -> {
                try {
                    long start = System.nanoTime();
                    GridSolverResult result = null;

                    // Starting solving when requested
                    if (solve) {
                        HolegPowerFlow powerFlow = new HolegPowerFlow();
                        result = powerFlow.solve(grid, settings);
                    }

                    // Decorate network
                    decorateNetwork(minimumNetwork, iteration, flexManager, network, grid);
                    context.solverTimeMilliseconds = (System.nanoTime() - start) / 1e6f;

                    // Update canvas and other visuals
                    context.showGridForVisual = grid;
                    onlyUpdateVisual.set(true);
                    SingletonControl.getInstance().getControl().calculateStateAndVisualForCurrentTimeStep();
                    onlyUpdateVisual.set(false);

                    // Show result message box
                    if (result != null && PowerFlowAnalysisMenu.getInstance().shouldShowResult())
                        SolveResultMessageBox.show(result);
                }
                catch(Exception e) {
                    SolveResultMessageBox.showInternalError(e);
                }
            });
            solverJob.setName("Solver 0x" + Integer.toHexString(context.hashCode()));


            // Wait or save solver job
            try {
                if (settings.waitForSolverJob) {
                    // Start and wait till solver job is finished
                    solverJob.start();
                    solverJob.join();
                } else {
                    // Render the non-solved grid and start the real solver job
                    decorateNetwork(minimumNetwork, iteration, flexManager, network, grid);
                    context.solverJob = solverJob;
                    solverJob.start();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}