praktikum-holons/src/classes/resistanceCalculator.java

package classes;

import com.google.gson.annotations.Expose;

public class resistanceCalculator {
    @Expose
    private int lowVoltage;

    @Expose
    private int highVoltage;

    @Expose
    private int diameter;

    @Expose
    private double specificMaterialResistance;

    public resistanceCalculator(int lowVoltage, int highVoltage, int diameter, double specificMaterialResistance){
        this.lowVoltage = lowVoltage;
        this.highVoltage = highVoltage;
        this.diameter = diameter;
        this.specificMaterialResistance = specificMaterialResistance;
    }

    public void setDistancesToCalcResistance(HolonObject powerPlant) {
        if (powerPlant != null) {
            // travers
            if (powerPlant.getConnectedTo().size() > 0) {
                for (CpsEdge edge : powerPlant.getConnectedTo()) {
                    if (powerPlant.getId() == edge.getA().getId()) {
                        traversEdges(edge.getB(), powerPlant, calcEdgeLength(edge), 0);
                    } else {
                        traversEdges(edge.getA(), powerPlant, calcEdgeLength(edge), 0);
                    }
                }
            } else {
                System.out.println("Nothing connected to powerplant");
            }
        } else {
            System.out.println("No powerplant connected");
        }
    }

    private void traversEdges(AbstractCpsObject currentObject, AbstractCpsObject last, double distance, double lastDistance) {
        if (currentObject.getConnectedTo().size() > 1) { // recursive call for all edges
            for (CpsEdge edge : currentObject.getConnectedTo()) {
                double newDistance = calcEdgeLength(edge);
                if (currentObject.getId() == edge.getA().getId()) { // look at which way the edge points
                    if (last.getId() != edge.getB().getId()) {
                        traversEdges(edge.getB(), currentObject, distance + newDistance, newDistance);
                    }
                } else {
                    if (last.getId() != edge.getA().getId()) {
                        traversEdges(edge.getA(), currentObject, distance + newDistance, newDistance);
                    }
                }
            }
        } else { // at leaf
            for (HolonElement ele : ((HolonObject) currentObject).getElements()) {
                ele.setHighDistance(distance - lastDistance);
                ele.setLowDistance(lastDistance);
            }
        }
    }

    private double calcEdgeLength(CpsEdge edge) {
        Position aPos = edge.getA().getPosition();
        Position bPos = edge.getB().getPosition();
        double xDiff = Math.abs(aPos.x - bPos.x);
        double yDiff = Math.abs(aPos.y - bPos.y);
        return Math.sqrt(Math.pow(xDiff, 2) + Math.pow(yDiff, 2));
    }

    float calcEnergyAfterResistance(float currentEnergy, double lowDistance, double highDistance, float energyRequiredForPowerplantBlackstart){
        double energyAfterLowVoltage = calcEnergyAfterPartOfGrid(currentEnergy, lowVoltage, lowDistance, energyRequiredForPowerplantBlackstart);
        energyAfterLowVoltage = (0.98 * energyAfterLowVoltage); //transfomer loses
        return (float) calcEnergyAfterPartOfGrid(energyAfterLowVoltage, highVoltage, highDistance, energyRequiredForPowerplantBlackstart);
    }

    private double calcEnergyAfterPartOfGrid(double currentEnergy, int voltage, double distance, float energyRequiredForPowerplantBlackstart){
        double blackstartResistance = blackstartResistance(voltage, energyRequiredForPowerplantBlackstart);
        double cableResistance = cableResistance(specificMaterialResistance, distance, diameter);
        return (1 - (cableResistance / (cableResistance + blackstartResistance))) * currentEnergy;
    }

    private double blackstartResistance(int voltage, float energyRequiredForPowerplantBlackstart){
        return Math.pow(voltage, 2) / energyRequiredForPowerplantBlackstart;
    }

    private double cableResistance(double specificMaterialResistance, double distance, int diameter){
        return specificMaterialResistance * (distance / (0.25 * Math.PI * Math.pow(diameter, 2)));
    }

    float calcEnergyNeededForCertainEnergyAfterResistance(float energyWanted, double lowDistance, double highDistance, float energyRequiredForPowerplantBlackstart){
        double energyBeforeHighVoltage = calcEnergyNeededBeforePartOfGrid(energyWanted, highVoltage, highDistance,energyRequiredForPowerplantBlackstart);
        energyBeforeHighVoltage = 1.02 * energyBeforeHighVoltage;
        return (float) calcEnergyNeededBeforePartOfGrid(energyBeforeHighVoltage, lowVoltage, lowDistance, energyRequiredForPowerplantBlackstart);
    }

    private double calcEnergyNeededBeforePartOfGrid(double energyWanted, int voltage, double distance, float energyRequiredForPowerplantBlackstart){
        double blackstartResistance = blackstartResistance(voltage, energyRequiredForPowerplantBlackstart);
        double cableResistance = cableResistance(specificMaterialResistance, distance, diameter);
        return (energyWanted / (1 - (cableResistance / (cableResistance + blackstartResistance))));
    }
}