From f1f3cf6c861f17a82206c09f25e9253552b64ea8 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Sat, 25 Oct 2014 16:43:03 +0200 Subject: [PATCH 01/24] Eigenes Projekt in DNA-Strukturen eingebunden --- .classpath | 31 +- .../generators/traffic/CardinalDirection.java | 5 + .../graph/generators/traffic/Crossroad.java | 102 ++ .../generators/traffic/CrossroadWeight.java | 81 + src/dna/graph/generators/traffic/DB.java | 1368 +++++++++++++++++ .../generators/traffic/EdgeContainer.java | 33 + .../graph/generators/traffic/InputWay.java | 27 + .../traffic/InputWayConnection.java | 22 + src/dna/graph/generators/traffic/Sensor.java | 51 + .../generators/traffic/SensorModelNode.java | 69 + .../TrafficCrossroadGraphGenerator.java | 132 ++ .../TrafficInputWayGraphGenerator.java | 131 ++ .../traffic/TrafficSensorGraphGenerator.java | 142 ++ .../generators/traffic/TrafficUpdate.java | 72 + src/dna/graph/weights/Double3dWeight.java | 11 + .../centrality/BetweennessCentrality.java | 3 +- .../metrics/degree/DegreeDistribution.java | 11 +- .../paths/AllPairsShortestPathsDouble.java | 69 + .../DoubleWeightedAllPairsShortestPaths.java | 43 + .../DoubleWeightedAllPairsShortestPathsR.java | 130 ++ src/dna/metrics/weights/NodeWeights.java | 5 +- src/dna/metrics/weights/Weights.java | 3 + src/dna/series/data/DistributionDouble.java | 15 + src/dna/updates/generators/traffic/Days.java | 9 + .../updates/generators/traffic/Helpers.java | 43 + .../TrafficCrossroadBatchGenerator.java | 151 ++ .../TrafficInputWayBatchGenerator.java | 223 +++ .../traffic/TrafficSensorBatchGenerator.java | 253 +++ 28 files changed, 3216 insertions(+), 19 deletions(-) create mode 100644 src/dna/graph/generators/traffic/CardinalDirection.java create mode 100644 src/dna/graph/generators/traffic/Crossroad.java create mode 100644 src/dna/graph/generators/traffic/CrossroadWeight.java create mode 100644 src/dna/graph/generators/traffic/DB.java create mode 100644 src/dna/graph/generators/traffic/EdgeContainer.java create mode 100644 src/dna/graph/generators/traffic/InputWay.java create mode 100644 src/dna/graph/generators/traffic/InputWayConnection.java create mode 100644 src/dna/graph/generators/traffic/Sensor.java create mode 100644 src/dna/graph/generators/traffic/SensorModelNode.java create mode 100644 src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java create mode 100644 src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java create mode 100644 src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java create mode 100644 src/dna/graph/generators/traffic/TrafficUpdate.java create mode 100644 src/dna/metrics/paths/AllPairsShortestPathsDouble.java create mode 100644 src/dna/metrics/paths/DoubleWeightedAllPairsShortestPaths.java create mode 100644 src/dna/metrics/paths/DoubleWeightedAllPairsShortestPathsR.java create mode 100644 src/dna/updates/generators/traffic/Days.java create mode 100644 src/dna/updates/generators/traffic/Helpers.java create mode 100644 src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java create mode 100644 src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java create mode 100644 src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java diff --git a/.classpath b/.classpath index fd645472..7ddb00d1 100644 --- a/.classpath +++ b/.classpath @@ -1,15 +1,16 @@ - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + diff --git a/src/dna/graph/generators/traffic/CardinalDirection.java b/src/dna/graph/generators/traffic/CardinalDirection.java new file mode 100644 index 00000000..e70ab2ed --- /dev/null +++ b/src/dna/graph/generators/traffic/CardinalDirection.java @@ -0,0 +1,5 @@ +package dna.graph.generators.traffic; + +public enum CardinalDirection { +NORTH, EAST,SOUTH,WEST +} diff --git a/src/dna/graph/generators/traffic/Crossroad.java b/src/dna/graph/generators/traffic/Crossroad.java new file mode 100644 index 00000000..c3a2013c --- /dev/null +++ b/src/dna/graph/generators/traffic/Crossroad.java @@ -0,0 +1,102 @@ +package dna.graph.generators.traffic; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + + +public class Crossroad { + HashMap inputWays; + HashMap outputWays; + HashMap> inputToOutput; + HashMap outputToInput; + int crossroadID; + DB db; + + public Crossroad(int crossroadID, DB db){ + inputToOutput=new HashMap<>(); + this.crossroadID=crossroadID; + this.db=db; + outputToInput = new HashMap<>(); + } + + public boolean setInputWays(HashMap newInputWays) { + boolean wasNull = inputWays==null; + inputWays=newInputWays; + return wasNull; + } + + public boolean setOutputWays(HashMap newOutputWays) { + boolean wasNull = outputWays==null; + outputWays=newOutputWays; + return wasNull; + } + + public boolean setOutputWay(CardinalDirection inDir, CardinalDirection outDir){ + if(!inputToOutput.containsKey(inDir)){ + inputToOutput.put(inDir, new HashSet()); + } + return inputToOutput.get(inDir).add(outDir); + } + + public Integer getWay(CardinalDirection direction, int type) { + if(type==0) + return (inputWays.containsKey(direction)) ? inputWays.get(direction) : -1; + else + return (outputWays.containsKey(direction)) ? outputWays.get(direction) : -1; + } + + public void connectWays () { + for (CardinalDirection outDir : outputWays.keySet()) { + List connectedWays = db.getConnectedInputWays(getWay(outDir,1), crossroadID); + for (InputWay integers : connectedWays) { + if(integers!=null) { + outputToInput.put(outDir, integers); + } + } + } + } + + public Set getConnections(){ + Set connectedOutputways; + Set connectedCrossroads = new HashSet<>(); + InputWay connection; + for (Map.Entry> innerConnection : inputToOutput.entrySet()) { + connectedOutputways = innerConnection.getValue(); + for (CardinalDirection outputDirection : connectedOutputways) { + if(outputToInput.containsKey(outputDirection)) { + connection = outputToInput.get(outputDirection); + connectedCrossroads.add(new InputWayConnection(this.crossroadID, inputWays.get(innerConnection.getKey()),innerConnection.getKey(), connection.wayID , connection.crossroadID,outputDirection)); + } + } + } + return connectedCrossroads; + } + + public void printInputWays(){ + System.out.println("InputWays von:\t"+this.crossroadID); + for (Map.Entry inputWay : inputWays.entrySet()) { + System.out.println(inputWay.getKey() +"\t"+inputWay.getValue()); + } + } + + public void printInput2Output(){ + System.out.println("Input2Output von:\t"+this.crossroadID); + for (Map.Entry> inputWay : inputToOutput.entrySet()) { + System.out.println(inputWay.getKey()); + for (CardinalDirection outputWay : inputWay.getValue()) { + System.out.println("\t"+outputWay); + } + } + } + + public void printOutputWays(){ + System.out.println("OutputWays von:\t"+this.crossroadID); + for (Map.Entry outputWay : outputWays.entrySet()) { + System.out.println(outputWay.getKey() +"\t"+outputWay.getValue()); + } + } +} diff --git a/src/dna/graph/generators/traffic/CrossroadWeight.java b/src/dna/graph/generators/traffic/CrossroadWeight.java new file mode 100644 index 00000000..d8047bc0 --- /dev/null +++ b/src/dna/graph/generators/traffic/CrossroadWeight.java @@ -0,0 +1,81 @@ +package dna.graph.generators.traffic; + +import java.util.HashMap; +import java.util.Map; + +public class CrossroadWeight { + public int crossroadID; + public String crossroadName; + public HashMap inputWayWeights; + public HashMap inputWayMaxWeights; + public double maxCount; + public double maxLoad; + private double threshold; + private int timestamp; + + public CrossroadWeight(int crossroadID,String crossroadName, double treshold){ + this.crossroadID = crossroadID; + this.crossroadName = crossroadName; + inputWayWeights = new HashMap<>(); + inputWayMaxWeights = new HashMap<>(); + this.threshold = treshold; + this.timestamp=0; + } + + public void addWeightWay(int osmWayID, double[] weights) { + inputWayWeights.put(osmWayID, weights); + } + + public void setMaxWeightWay(int osmWayID, double[] maxWeights) { + inputWayMaxWeights.put(osmWayID, maxWeights); + } + + public void setTimestamp(int timestamp){ + this.timestamp = timestamp; + } + public int getTimestamp(){ + return timestamp; + } + + public void setMaxWeight(double[] maxWeights) { + this.maxCount=maxWeights[0]; + this.maxLoad=maxWeights[1]; + } + + public void resetInputWayWeight(double count, double load){ + double numOfInputWays = inputWayWeights.keySet().size(); + double count_value = count/numOfInputWays; + double load_value = load/numOfInputWays; + for (Map.Entry entry : inputWayWeights.entrySet()) { + entry.setValue(new double[]{count_value,load_value,(count_value/inputWayMaxWeights.get(entry.getKey())[0])*100}); + } + } + + /** + * calculates and returns the weight of a crossroad. + * Index 0 - count + * Index 1 - load + * Index 2 - count/maxcount + * @return 3D-double + */ + public double[] getWeight(){ + double[] sum = new double[3]; + for (double[] entry : inputWayWeights.values()) { + sum[0]+=entry[0]; + sum[1]+=entry[1]; + } + int numOfinputWays = inputWayWeights.size(); + sum[2]=(sum[0]/maxCount)*100; + return sum; + } + + public HashMap getOverladedEdges() { + HashMap result = new HashMap<>(); + for (Map.Entry inputWay : inputWayWeights.entrySet()) { + if(inputWay.getValue()[2] >threshold){ + result.put(inputWay.getKey(), inputWay.getValue()); + } + } + return result; + } +} diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java new file mode 100644 index 00000000..04ec09ac --- /dev/null +++ b/src/dna/graph/generators/traffic/DB.java @@ -0,0 +1,1368 @@ +package dna.graph.generators.traffic; + + +import java.io.BufferedReader; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.sql.Timestamp; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Random; +import java.util.Set; + +import org.joda.time.DateTime; + +import sun.security.action.GetIntegerAction; +import dna.graph.datastructures.DataStructure.ListType; +import dna.graph.datastructures.GraphDataStructure; +import dna.graph.edges.Edge; +import dna.graph.nodes.DirectedWeightedNode; +import dna.graph.nodes.INode; +import dna.graph.nodes.Node; +import dna.graph.weights.Double3dWeight; + +public class DB { + private static Connection con = null; + private static String dbHost = "127.0.0.1"; // Hostname + private static String dbPort = "3306"; // Port -- Standard: 3306 + private static String dbName = "dbName"; // Datenbankname + private static String dbUser = "dbUser"; // Datenbankuser + private static String dbPass = "dbPass"; // Datenbankpasswort + + + private GraphDataStructure gds; + private int stepSize; + public DateTime initDateTime; + private HashMap maxValuesCrossroad; + private HashMap maxValuesInputWays; + private HashMap maxValuesSensors; + private HashMap sensorModelNodes; + private HashMap crossroadModelNodes; + public HashMap inputWays; + public HashMap inputWaysToID; + public HashMap> inputWayConnections; //Key: ToCrossroad,ToWay - Value: List + public boolean[] days; + public int timeRange; + private double treshold; + private TrafficUpdate trafficUpdate; + private HashMap disabledEdges; + private HashMap> disabledEdgesInputWay; + private boolean dummyMax; + + + /** + * Konstruktor für die Nutzung der Datenbank ohne + * @param stepSize + * @param initTDateTime + * @param days + * @param timeRange + * @param treshold + * @param trafficUpdate + * @param dummyMax + */ + public DB(GraphDataStructure gds, DateTime initTDateTime, int stepSize, boolean[] days , int timeRange, double treshold,TrafficUpdate trafficUpdate,boolean dummyMax) { + try { + FileReader fr = new FileReader("db.txt"); + BufferedReader br = new BufferedReader(fr); + String line = br.readLine(); + String[] values; + while (line != null) { + values = line.split(" "); + if(values.length != 2) + System.out.println("Falsche Anzahl an Parametern"); + switch (values[0]) { + case "dbHost": + dbHost = values[1]; + break; + case "dbPort": + dbPort = values[1]; + break; + case "dbName": + dbName = values[1]; + break; + case "dbUser": + dbUser = values[1]; + break; + case "dbPass": + dbPass = values[1]; + break; + default: + break; + } + line = br.readLine(); + } + br.close(); + System.out.println("Datenbank-Logindaten aus Datei gelesen"); + } catch (FileNotFoundException e1) { + System.out.println("Keine Daten für Datenbank gefunden - verwende Dummy-Daten"); + } catch (IOException e) { + e.printStackTrace(); + } + try { + System.out.println("Versuche zur Datenbank zu verbinden"); + Class.forName("com.mysql.jdbc.Driver"); + con = DriverManager.getConnection("jdbc:mysql://"+dbHost+":"+dbPort+"/"+dbName,dbUser,dbPass); + } catch (ClassNotFoundException e) { + System.out.println("Treiber nicht gefunden"); + } catch (SQLException e) { + System.out.println("Verbindung nicht moglich"); + System.out.println("SQLException: " + e.getMessage()); + System.out.println("SQLState: " + e.getSQLState()); + System.out.println("VendorError: " + e.getErrorCode()); + } + this.gds = gds; + this.stepSize=stepSize; + this.initDateTime = initTDateTime; + this.days = days; + this.timeRange = timeRange; + this.maxValuesInputWays = new HashMap<>(); + this.maxValuesCrossroad = new HashMap<>(); + this.maxValuesSensors = new HashMap<>(); + this.sensorModelNodes = new HashMap<>(); + this.crossroadModelNodes = new HashMap<>(); + this.inputWayConnections = new HashMap<>(); + this.inputWaysToID = new HashMap<>(); + this.inputWays= new HashMap<>(); + this.treshold = treshold; + this.trafficUpdate = trafficUpdate; + this.disabledEdges = new HashMap<>(); + this.disabledEdgesInputWay = new HashMap<>(); + this.dummyMax = dummyMax; + getInputWays(); + getMaximalWeightCrossroad(); + getMaximalWeightInputWay(); + getMaximalWeightSensor(); + loadFromWays(); + + } + + public double[] writeMaximalWeightsCrossroad(int crossroadID) { + System.out.println("Prüfe ID " +crossroadID); + if(crossroadID==43 || crossroadID == 44 || crossroadID == 63 || crossroadID == 99 || crossroadID == 147 || crossroadID == 93) { + return new double[]{0.0,0.0}; + } + String crossroadName = getCrossroadName(crossroadID); + double count = 0; + double load = 0; + ResultSet rs; + String selectStmt = null; + try { + selectStmt = "SELECT * FROM (SELECT SUM(COUNT_VALUE) AS ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG, DATETIME,CROSSROAD_ID, CROSSROAD_NAME FROM (SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM (SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM (SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID="+crossroadID+") SENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays SW WHERE crossroadID = "+crossroadID+" AND wayID IS NOT NULL) SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN (SELECT DATETIME,ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET FROM jee_trafficlight_rawevents RE WHERE CROSSROAD = '"+crossroadName+"') EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET) CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID) RESULT WHERE FRONT_BACK = 0 GROUP BY DATETIME ORDER BY ANZAHL DESC LIMIT 1) GROUPED"; + + // COUNT + if(crossroadID==1) + System.out.println(selectStmt); + Statement stmt = con.createStatement(); + rs= stmt.executeQuery(selectStmt); + if(rs.first() && rs.getTime("DATETIME")!=null){ + String inserTableSQL = "REPLACE INTO mw_MaxValues_Crossroad VALUES (?,?,?,?,?,?,DEFAULT)"; + PreparedStatement insertStmt = con.prepareStatement(inserTableSQL); + insertStmt.setInt(1, rs.getInt("CROSSROAD_ID")); + insertStmt.setString(2, rs.getString("CROSSROAD_NAME")); + insertStmt.setInt(3, rs.getInt("ANZAHL")); + insertStmt.setInt(4, rs.getInt("BELEGUNG")); + insertStmt.setTimestamp(5, rs.getTimestamp("DATETIME")); + insertStmt.setInt(6, 0); + System.out.println(insertStmt); + insertStmt.executeUpdate(); + count = rs.getDouble("ANZAHL"); + //LOAD + //TODO: LOAD + /* + selectStmt = "SELECT * FROM (SELECT SUM(COUNT_VALUE) AS ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG, DATETIME,CROSSROAD_ID, CROSSROAD_NAME FROM (SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM (SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM (SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID="+crossroadID+") SENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays SW WHERE crossroadID = "+crossroadID+" AND wayID IS NOT NULL) SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN (SELECT DATETIME,ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET FROM jee_trafficlight_rawevents RE WHERE CROSSROAD = '"+crossroadName+"') EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET) CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID) RESULT WHERE FRONT_BACK = 0 GROUP BY DATETIME ORDER BY BELEGUNG DESC LIMIT 1) GROUPED"; + // COUNT + + if(crossroadID==10) + System.out.println(selectStmt); + stmt = con.createStatement(); + rs = null; + rs= stmt.executeQuery(selectStmt); + rs.first(); + inserTableSQL = "REPLACE INTO mw_MaxValues_Crossroad VALUES (?,?,?,?,?,?,DEFAULT)"; + insertStmt = con.prepareStatement(inserTableSQL); + System.out.println(rs.getInt("CROSSROAD_ID")); + insertStmt.setInt(1, rs.getInt("CROSSROAD_ID")); + insertStmt.setString(2, rs.getString("CROSSROAD_NAME")); + insertStmt.setInt(3, rs.getInt("ANZAHL")); + insertStmt.setInt(4, rs.getInt("BELEGUNG")); + insertStmt.setTimestamp(5, rs.getTimestamp("DATETIME")); + insertStmt.setInt(6, 1); + System.out.println(insertStmt); + insertStmt.executeUpdate();*/ + return new double[]{count,0.0}; + } + } catch (SQLException e) { + e.printStackTrace(); + System.out.println(crossroadID+"\t\t"+selectStmt); + } + return new double[]{0.0,0.0}; + } + + public double[] writeMaximalWeightsInputWays_5Minutes(int inputwayID) { + System.out.println("Prüfe ID " +inputwayID); + double count = 0; + ResultSet rs; + int[] inputData = inputWays.get(inputwayID); + if(inputData==null) + return new double[]{0,0}; + int crossroadID = inputData[1]; + System.out.println("InputWay:\t"+inputwayID+"CrossroadID:\t"+crossroadID); + String selectStmt = null; + try { + //selectStmt = "SELECT SUM(cr_count) as ANZAHL,SUM(cr_load)/COUNT(cr_load) AS BELEGUNG, DATETIME,SENSORS_ON_WAY.* FROM (SELECT * FROM (SELECT ID AS SENSOR_ID, REALNAME AS SENSOR_NAME, CSVOFFSET, wayID AS WAY_ID, CROSSROAD_ID, crossroadName AS CROSSROAD_NAME FROM (SELECT ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') GLOBALSENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays WHERE crossroadID = '"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON GLOBALSENSORS.ID = SENSORS_MAPPED.sensorID) SENSORS JOIN (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID = '"+inputwayID+"') INPUT_WAYS ON SENSORS.WAY_ID = INPUT_WAYS.wayID) SENSORS_ON_WAY LEFT JOIN jee_trafficlight_rawevents RE ON RE.CSVOFFSET = SENSORS_ON_WAY.CSVOFFSET AND RE.CROSSROAD = SENSORS_ON_WAY.CROSSROAD_NAME GROUP BY DATETIME ORDER BY ANZAHL DESC LIMIT 1"; + selectStmt = "SELECT MAX(ANZAHL_5) as MAX_ANZAHL FROM (SELECT SUM(ANZAHL)/COUNT(DATETIME) as ANZAHL_5,COUNT(DATETIME) as MINUTES ,DATETIME FROM (SELECT SUM(cr_count) as ANZAHL,COUNT(DATETIME) as MINUTES ,SUM(cr_load)/COUNT(cr_load) AS BELEGUNG, DATETIME,SENSORS_ON_WAY.* FROM (SELECT * FROM (SELECT ID AS SENSOR_ID, REALNAME AS SENSOR_NAME, CSVOFFSET, wayID AS WAY_ID, CROSSROAD_ID, crossroadName AS CROSSROAD_NAME FROM (SELECT ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') GLOBALSENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays WHERE crossroadID = '"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON GLOBALSENSORS.ID = SENSORS_MAPPED.sensorID) SENSORS JOIN (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID = '"+inputwayID+"') INPUT_WAYS ON SENSORS.WAY_ID = INPUT_WAYS.wayID) SENSORS_ON_WAY LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents LIMIT 1000000) RE ON RE.CSVOFFSET = SENSORS_ON_WAY.CSVOFFSET AND RE.CROSSROAD = SENSORS_ON_WAY.CROSSROAD_NAME GROUP BY DATETIME) FOR_MINUTES GROUP BY (UNIX_TIMESTAMP(DATETIME) DIV 300)) MAXIMA"; + System.out.println("WEIGHT\t\t"+selectStmt); + // COUNT + Statement stmt = con.createStatement(); + rs= stmt.executeQuery(selectStmt); + if(rs.first()){ + count = rs.getDouble("MAX_ANZAHL"); + String inserTableSQL = "REPLACE INTO mw_MaxValues_InputWay_5 VALUES (?,?)"; + java.sql.PreparedStatement insertStmt = con.prepareStatement(inserTableSQL); + insertStmt.setInt(1,inputwayID); + insertStmt.setDouble(2, count); + insertStmt.executeUpdate(); + + + //TODO: LOAD + //LOAD + /* + selectStmt = "SELECT SUM(cr_count) as ANZAHL,SUM(cr_load) AS BELEGUNG, DATETIME,SENSORS_ON_WAY.* FROM (SELECT * FROM (SELECT ID AS SENSOR_ID, REALNAME AS SENSOR_NAME, CSVOFFSET, wayID AS WAY_ID, CROSSROAD_ID, crossroadName AS CROSSROAD_NAME FROM (SELECT ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') GLOBALSENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays WHERE crossroadID = '"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON GLOBALSENSORS.ID = SENSORS_MAPPED.sensorID) SENSORS JOIN (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID = '"+inputwayID+"') INPUT_WAYS ON SENSORS.WAY_ID = INPUT_WAYS.wayID) SENSORS_ON_WAY LEFT JOIN jee_trafficlight_rawevents RE ON RE.CSVOFFSET = SENSORS_ON_WAY.CSVOFFSET AND RE.CROSSROAD = SENSORS_ON_WAY.CROSSROAD_NAME GROUP BY DATETIME ORDER BY BELEGUNG DESC LIMIT 1"; + + // COUNT + + if(inputwayID==10) + System.out.println(selectStmt); + stmt = con.createStatement(); + rs = null; + rs= stmt.executeQuery(selectStmt); + rs.first(); + inserTableSQL = "REPLACE INTO mw_MaxValues_InputWays VALUES (?,?,?,?,?,?,?,DEFAULT)"; + insertStmt = con.prepareStatement(inserTableSQL); + insertStmt.setInt(1,inputwayID); + insertStmt.setInt(2, rs.getInt("CROSSROAD_ID")); + insertStmt.setString(3, rs.getString("CROSSROAD_NAME")); + insertStmt.setInt(4, rs.getInt("ANZAHL")); + insertStmt.setInt(5, rs.getInt("BELEGUNG")); + insertStmt.setTimestamp(6, rs.getTimestamp("DATETIME")); + insertStmt.setInt(7, 1); + System.out.println(insertStmt); + insertStmt.executeUpdate();*/ + return new double[]{count,0}; + } + } catch (SQLException e) { + e.printStackTrace(); + System.out.println(inputwayID+"\t\t"+selectStmt); + } + return new double[]{0,0}; + } + + public void writeMaximalWeightsCrossroadsRandom(int crossroadID,double random){ + java.sql.PreparedStatement stmt; + try { + String inserTableSQL = "REPLACE INTO mw_MaxValues_Crossroad_Random VALUES (?,?)"; + stmt = con.prepareStatement(inserTableSQL); + stmt.setInt(1, crossroadID); + stmt.setDouble(2, random); + stmt.execute(); + } catch (Exception e) { + e.printStackTrace(); + } + } + + public double[] writeMaximalWeightsInputWays(int inputwayID) { + System.out.println("Prüfe ID " +inputwayID); + int count = 0; + ResultSet rs; + int[] inputData = inputWays.get(inputwayID); + int crossroadID = inputData[1]; + System.out.println("InputWay:\t"+inputwayID+"CrossroadID:\t"+crossroadID); + String selectStmt = null; + try { + selectStmt = "SELECT SUM(cr_count) as ANZAHL,SUM(cr_load)/COUNT(cr_load) AS BELEGUNG, DATETIME,SENSORS_ON_WAY.* FROM (SELECT * FROM (SELECT ID AS SENSOR_ID, REALNAME AS SENSOR_NAME, CSVOFFSET, wayID AS WAY_ID, CROSSROAD_ID, crossroadName AS CROSSROAD_NAME FROM (SELECT ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') GLOBALSENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays WHERE crossroadID = '"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON GLOBALSENSORS.ID = SENSORS_MAPPED.sensorID) SENSORS JOIN (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID = '"+inputwayID+"') INPUT_WAYS ON SENSORS.WAY_ID = INPUT_WAYS.wayID) SENSORS_ON_WAY LEFT JOIN jee_trafficlight_rawevents RE ON RE.CSVOFFSET = SENSORS_ON_WAY.CSVOFFSET AND RE.CROSSROAD = SENSORS_ON_WAY.CROSSROAD_NAME GROUP BY DATETIME ORDER BY ANZAHL DESC LIMIT 1"; + System.out.println("WEIGHT\t\t"+selectStmt); + // COUNT + Statement stmt = con.createStatement(); + rs= stmt.executeQuery(selectStmt); + if(rs.first() && rs.getTime("DATETIME")!=null){ + String inserTableSQL = "REPLACE INTO mw_MaxValues_InputWays VALUES (?,?,?,?,?,?,?,DEFAULT)"; + java.sql.PreparedStatement insertStmt = con.prepareStatement(inserTableSQL); + insertStmt.setInt(1,inputwayID); + insertStmt.setInt(2, rs.getInt("CROSSROAD_ID")); + insertStmt.setString(3, rs.getString("CROSSROAD_NAME")); + insertStmt.setInt(4, rs.getInt("ANZAHL")); + insertStmt.setInt(5, rs.getInt("BELEGUNG")); + insertStmt.setTimestamp(6, rs.getTimestamp("DATETIME")); + insertStmt.setInt(7, 0); + System.out.println(insertStmt); + insertStmt.executeUpdate(); + count = rs.getInt("ANZAHL"); + + //TODO: LOAD + //LOAD + /* + selectStmt = "SELECT SUM(cr_count) as ANZAHL,SUM(cr_load) AS BELEGUNG, DATETIME,SENSORS_ON_WAY.* FROM (SELECT * FROM (SELECT ID AS SENSOR_ID, REALNAME AS SENSOR_NAME, CSVOFFSET, wayID AS WAY_ID, CROSSROAD_ID, crossroadName AS CROSSROAD_NAME FROM (SELECT ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') GLOBALSENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays WHERE crossroadID = '"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON GLOBALSENSORS.ID = SENSORS_MAPPED.sensorID) SENSORS JOIN (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID = '"+inputwayID+"') INPUT_WAYS ON SENSORS.WAY_ID = INPUT_WAYS.wayID) SENSORS_ON_WAY LEFT JOIN jee_trafficlight_rawevents RE ON RE.CSVOFFSET = SENSORS_ON_WAY.CSVOFFSET AND RE.CROSSROAD = SENSORS_ON_WAY.CROSSROAD_NAME GROUP BY DATETIME ORDER BY BELEGUNG DESC LIMIT 1"; + + // COUNT + + if(inputwayID==10) + System.out.println(selectStmt); + stmt = con.createStatement(); + rs = null; + rs= stmt.executeQuery(selectStmt); + rs.first(); + inserTableSQL = "REPLACE INTO mw_MaxValues_InputWays VALUES (?,?,?,?,?,?,?,DEFAULT)"; + insertStmt = con.prepareStatement(inserTableSQL); + insertStmt.setInt(1,inputwayID); + insertStmt.setInt(2, rs.getInt("CROSSROAD_ID")); + insertStmt.setString(3, rs.getString("CROSSROAD_NAME")); + insertStmt.setInt(4, rs.getInt("ANZAHL")); + insertStmt.setInt(5, rs.getInt("BELEGUNG")); + insertStmt.setTimestamp(6, rs.getTimestamp("DATETIME")); + insertStmt.setInt(7, 1); + System.out.println(insertStmt); + insertStmt.executeUpdate();*/ + return new double[]{count,0}; + } + } catch (SQLException e) { + e.printStackTrace(); + System.out.println(inputwayID+"\t\t"+selectStmt); + } + return new double[]{0,0}; + } + + public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTime to,int timestamp) { + String crossroadName = getCrossroadName(crossroadID); + if(!maxValuesCrossroad.containsKey(crossroadID)){ + maxValuesCrossroad.put(crossroadID, getMaximalWeightCrossroad(crossroadID) ); + } + CrossroadWeight crw = new CrossroadWeight(crossroadID, crossroadName,treshold); + try { + String selectStmt = "SELECT SUM(COUNT_VALUE)/COUNT(COUNT_VALUE) as ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG ,FROM_DIRECTION, OSMWAY_ID FROM (SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM (SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM (SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') SENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays SW WHERE crossroadID ='"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN (SELECT ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET,DATETIME FROM jee_trafficlight_rawevents RE WHERE RE.DATETIME >= '"+toSql(from)+"'AND RE.DATETIME < '"+toSql(to)+"' AND CROSSROAD = '"+crossroadName+"') EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET) CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID) RESULT LEFT JOIN (SELECT * FROM mw_CrossroadWays WHERE TYPE = '0')CRW on RESULT.FROM_DIRECTION = CRW.DIRECTION AND RESULT.CROSSROAD_ID = CRW.CROSSROAD_ID WHERE FRONT_BACK = 0 GROUP BY OSMWAY_ID"; + Statement stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery(selectStmt); + while (rs.next()) { + int wayID = rs.getInt("OSMWAY_ID"); + double[] maxValue = getMaximalWeightInputWayFromMap(wayID,crossroadID); //Index 0 = MaxCount, Index 1 = MaxLoad + if(maxValue == null){ + maxValue = new double[]{Double.MAX_VALUE,Double.MAX_VALUE}; + } + crw.setMaxWeightWay(wayID, maxValue); + crw.addWeightWay(wayID, new double[]{rs.getDouble("ANZAHL"),rs.getDouble("BELEGUNG"),(rs.getDouble("ANZAHL")/maxValue[0])*100}); + crw.setTimestamp(timestamp); + + } + } catch (SQLException e) { + e.printStackTrace(); + } + crw.setMaxWeight(maxValuesCrossroad.get(crossroadID)); + crossroadModelNodes.put(crossroadID, crw); + return crw; + } + + public CrossroadWeight getCrossroadWeightStaticInit(int crossroadID,DateTime from, DateTime to, int timestamp,TrafficUpdate trafficUpdate) { + CrossroadWeight crw = getCrossroadWeight(crossroadID, from, to,timestamp); + crw.resetInputWayWeight(trafficUpdate.getInitCount(), trafficUpdate.getInitLoad()); + return crw; + } + public CrossroadWeight getCrossroadWeightStaticBatch(int crossroadID,TrafficUpdate update) { + CrossroadWeight crw = crossroadModelNodes.get(crossroadID); + crw.setTimestamp(crw.getTimestamp()+1); + if(update.isAffected(crossroadID)){ + crw.resetInputWayWeight((update.getSleepTillUpdate()*update.getInitCount()+update.getUpdateCount())/(update.getSleepTillUpdate()+1), (update.getSleepTillUpdate()*update.getInitLoad()+update.getUpdateLoad())/(update.getSleepTillUpdate()+1)); + } + return crw; + } + + public double[] getMaximalWeightCrossroad(int crossroadID) { + try { + String selectStmt = "SELECT * FROM mw_MaxValues_Crossroad WHERE CROSSROAD_ID = "+crossroadID+" AND COUNT_OR_LOAD =0"; + Statement stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery(selectStmt); + if(rs.first()){ + return new double[]{rs.getDouble("COUNT"),0}; + } + else + return writeMaximalWeightsCrossroad(crossroadID); + } catch (SQLException e) { + e.printStackTrace(); + } + return null; + } + + private double[] getMaximalWeightInputWayFromMap(int wayID,int crossroadID){ + int inputWayID = getInputWay(crossroadID, wayID); + double[] result = maxValuesInputWays.get(inputWayID); + return result; + } + + /** + * liest den Maximalwert für einen Einfahrtsweg direkt aus der Datenbank + * @param osmWayID + * @param crossroadRoad + * @return + */ + private double[] getMaximalWeightInputWay(int inputWayID) { + try { + String selectStmt = "SELECT * FROM mw_MaxValues_InputWays WHERE INPUT_WAY_ID = "+inputWayID+" AND COUNT_OR_LOAD =0"; + Statement stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery(selectStmt); + if(rs.first()){ + return new double[]{rs.getDouble("COUNT"),0}; + } + else + return writeMaximalWeightsInputWays(inputWayID); + } catch (SQLException e) { + e.printStackTrace(); + } + return null; + } + + /** + * liest den Maximalwert für einen Einfahrtsweg direkt aus der Datenbank + * @param osmWayID + * @param crossroadRoad + * @return + */ + private double[] getMaximalWeightInputWay(int osmWayID, int crossroadRoad) { + try { + String selectStmt = "SELECT IW.*,wayID FROM mw_MaxValues_InputWays IW LEFT JOIN mw_InputWaysGlobal IWG ON IW.INPUT_WAY_ID = IWG.ID WHERE wayID ='"+osmWayID+"' AND CROSSROAD_ID ="+crossroadRoad; + Statement stmt = con.createStatement(); + if(crossroadRoad == 8) + System.out.println(selectStmt); + ResultSet rs = stmt.executeQuery(selectStmt); + if(rs.first()){ + return new double[]{rs.getDouble("COUNT"),0}; + } + else + return new double[]{100,100}; //TODO mit osmWay und Crossroad + } catch (SQLException e) { + e.printStackTrace(); + } + return null; + } + + public void getMaximalWeightInputWay() { + Random rand = new Random(); + try { + String selectStmt = null; + if(!dummyMax) + selectStmt = "SELECT * FROM mw_MaxValues_InputWays WHERE COUNT_OR_LOAD =0"; + else + selectStmt = "SELECT * FROM mw_MaxValues_InputWay_Random JOIN mw_InputWaysGlobal on INPUTWAY_ID = ID"; + Statement stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery(selectStmt); + while(rs.next()) { + if(!dummyMax) + maxValuesInputWays.put(rs.getInt(1), new double[]{rs.getDouble("COUNT"),rs.getDouble("LOAD")}); + else{ + maxValuesInputWays.put(rs.getInt("INPUTWAY_ID"), new double[]{rs.getDouble("MAX_COUNT"),0}); + } + } + } catch (SQLException e) { + e.printStackTrace(); + } + } + /** + * schreibt Maximale Werte für die Einfahrtswege einer Kreuzung, die Werte orientieren sich dabei an den Maximalwerten der Kreuzung + */ + public void writeMaximalWeightInputWayRandom() { + Random rand = new Random(); + try { + String selectStmt = "SELECT ID, crossroadID,MAX_COUNT as MAX_COUNT_CROSSROAD FROM mw_InputWaysGlobal IWG LEFT JOIN mw_MaxValues_Crossroad_Random MAX_C_RANDOM ON IWG.crossroadID = MAX_C_RANDOM.CROSSROAD_ID"; + Statement stmt = con.createStatement(); + String insertString = "REPLACE INTO mw_MaxValues_InputWay_Random VALUES (?,?)"; + java.sql.PreparedStatement insertStmt = con.prepareStatement(insertString); + ResultSet rs = stmt.executeQuery(selectStmt); + while(rs.next()) { + double randMax = rand.nextDouble()*(rs.getDouble("MAX_COUNT_CROSSROAD")/2)+rs.getDouble("MAX_COUNT_CROSSROAD")/4; + insertStmt.setInt(1, rs.getInt("ID")); + insertStmt.setDouble(2, randMax); + insertStmt.addBatch(); + } + insertStmt.executeBatch(); + } catch (SQLException e) { + e.printStackTrace(); + } + + } + + /** + * schreibt Maximale Werte für die realen Sensoren in die Datenbank, welche sich grob an den Werten für den passenden virtuellen Sensor orientieren + */ + public void writeMaximalWeightSensorRandom() { + Random rand = new Random(); + try { + String selectStmt = "SELECT NODE_ID as REALSENSOR_INDEX , R2.* FROM (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 0) R3 LEFT JOIN (SELECT R1.*,MAX_COUNT FROM (SELECT INPUTWAY_INDEX, ANZAHL_SENSORS,WAY_ID,CROSSROAD_ID,DIRECTION, ID as INPUTWAY_ID_GLOBAL FROM (SELECT NODE_ID as INPUTWAY_INDEX, COUNT(VS) as ANZAHL_SENSORS,WAY_ID,CROSSROAD_ID,DIRECTION FROM (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 1) WAYS LEFT JOIN (SELECT SG2.NODE_ID as VS, SG1.NODE_ID as RS FROM (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 0) SG1 JOIN (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 1) SG2 ON SG1.WAY_ID = SG2.WAY_ID AND SG1.CROSSROAD_ID = SG2.CROSSROAD_ID AND SG1.DIRECTION = SG2.DIRECTION) VS_TO_RS ON WAYS.NODE_ID = VS_TO_RS.VS GROUP BY VS) ANZAHL LEFT JOIN mw_InputWaysGlobal IWG ON ANZAHL.WAY_ID = IWG.wayID AND ANZAHL.CROSSROAD_ID = IWG.crossroadID) R1 LEFT JOIN mw_MaxValues_InputWay_Random MWIWR ON R1.INPUTWAY_ID_GLOBAL=MWIWR.INPUTWAY_ID) R2 ON R3.WAY_ID = R2.WAY_ID AND R3.CROSSROAD_ID = R2.CROSSROAD_ID AND R3.DIRECTIOn = R2.DIRECTION"; + Statement stmt = con.createStatement(); + String insertString = "REPLACE INTO mw_MaxValues_Sensor_Random VALUES (?,?)"; + java.sql.PreparedStatement insertStmt = con.prepareStatement(insertString); + ResultSet rs = stmt.executeQuery(selectStmt); + while(rs.next()) { + double randMax = rand.nextDouble()*(rs.getDouble("MAX_COUNT")/rs.getDouble("ANZAHL_SENSORS"))+2; + if(rs.getDouble("MAX_COUNT")==0) + randMax = rand.nextDouble()*5+2; + insertStmt.setInt(1, rs.getInt("REALSENSOR_INDEX")); + insertStmt.setDouble(2, randMax); + insertStmt.addBatch(); + } + insertStmt.executeBatch(); + } catch (SQLException e) { + e.printStackTrace(); + } + + } + /** + * liest die maximalen Werte, welche für einen Kreuzung gemessen wurden - über dummyMax können einmalig zufällig generierte Werte geladen werden + */ + public void getMaximalWeightCrossroad() { + Random rand = new Random(); + try { + String selectStmt = "SELECT * FROM mw_MaxValues_Crossroad WHERE COUNT_OR_LOAD =0"; + if(dummyMax) + selectStmt = "SELECT * FROM mw_MaxValues_Crossroad_Random"; + Statement stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery(selectStmt); + while(rs.next()){ + if(!dummyMax) + maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getInt("COUNT"),0}); + else{ + maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getDouble("MAX_COUNT"),0}); + } + } + } catch (SQLException e) { + e.printStackTrace(); + } + } + /** + * liest die maximalen Werte, welche für einen realen Sensor gemessen wurden - über dummyMax können einmalig zufällig generierte Werte geladen werden + */ + public void getMaximalWeightSensor() { + Random rand = new Random(); + try { + String selectStmt = "SELECT * FROM mw_MaxValues_Sensor_Random"; + Statement stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery(selectStmt); + while(rs.next()){ + maxValuesSensors.put(rs.getInt("SENSOR_ID"), new double[] {rs.getDouble("MAX_COUNT"),0}); + } + } catch (SQLException e) { + e.printStackTrace(); + } + } + + + + public int setFromID(int id) { + return setID(id,"from"); + } + public int setToID(int id) { + return setID(id,"to"); + } + public int setID(int id,String mode) { + + try { + String selectStmtString = "SELECT * FROM mw_InputWaysGlobal WHERE ID = "+ id; + Statement selectStmt = con.createStatement(); + ResultSet rs = selectStmt.executeQuery(selectStmtString); + rs.first(); + String updateString = "UPDATE mw_InputWayConnection A SET "+mode+"ID = "+id+" WHERE A."+mode+"Way = "+rs.getInt(2) +" AND A."+mode+"Crossroad = " +rs.getInt(3); + Statement updateStmt = con.createStatement(); + return updateStmt.executeUpdate(updateString); + + } catch (SQLException e) { + e.printStackTrace(); + } + return 0; + } + + + public List getCrossroadConnection() { + List connection = new ArrayList<>(); + try { + String selectStmt = "SELECT FROM_CROSSROAD,TO_CROSSROAD FROM mw_CrossroadConnection"; + Statement stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery(selectStmt); + int c = 0; + while(rs.next()) { + connection.add(new EdgeContainer(rs.getInt(1),rs.getInt(2))); + } + } catch (SQLException e) { + e.printStackTrace(); + } + return connection; + } + + /** + * alle InputWays einer Kreuzung + * @param crossroadID + * @return + */ + public HashMap getInputWays(int crossroadID) { + return getWays(crossroadID,0); + } + + /** + * liefert eine Liste von Ausfahrtswegen, vonden der übergebene Einfahrtsweg direkt zu erreichen ist + * @param crossroadID + * @param toWay + * @return + */ + public List getFromWays(int crossroadID, int toWay) { + return inputWayConnections.get(new InputWay(toWay, crossroadID)); + + } + public void loadFromWays(){ + InputWay key; + int[] value; + try { + String selectStmt = "SELECT FROM_CROSSROAD,FROM_WAY,TO_CROSSROAD,TO_WAY FROM mw_CrossroadConnection"; + Statement stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery(selectStmt); + while(rs.next()) { + key = new InputWay(rs.getInt("TO_WAY"),rs.getInt("TO_CROSSROAD")); + value = new int[]{rs.getInt("FROM_CROSSROAD"), rs.getInt("FROM_WAY")}; + if(!this.inputWayConnections.containsKey(key)){ + this.inputWayConnections.put(key,new ArrayList()); + } + this.inputWayConnections.get(key).add(value); + } + } catch (SQLException e) { + e.printStackTrace(); + } + } + + /** + * alle Output-Ways einer Kreuzung + * @param crossroadID + * @return + */ + public HashMap getOutputWays(int crossroadID) { + return getWays(crossroadID,1); + } + + private HashMap getWays(int crossroadID, int type) { + HashMap ways = new HashMap<>(); + try { + Statement stmt = con.createStatement(); + String statementString = "SELECT DIRECTION , OSMWAY_ID FROM mw_CrossroadWays WHERE CROSSROAD_ID ="+crossroadID+" AND TYPE =" +type; + ResultSet rs = stmt.executeQuery(statementString); + while(rs.next()){ + ways.put(CardinalDirection.valueOf(rs.getString("DIRECTION")), rs.getInt("OSMWAY_ID")); + } + } catch (SQLException e) { + e.printStackTrace(); + } + return ways; + } + + public List getSensors(int crossroadID, int wayID) { + List sensors = new ArrayList<>(); + try { + Statement stmt = con.createStatement(); + String statementString = "SELECT * FROM mw_SensorWays WHERE crossroadID ="+crossroadID+" AND wayID =" +wayID; + ResultSet rs = stmt.executeQuery(statementString); + while(rs.next()){ + sensors.add(new Sensor(rs.getInt(1),rs.getString(2),rs.getInt(3),rs.getString(4),rs.getInt(5))); + } + } catch (SQLException e) { + e.printStackTrace(); + } + return sensors; + } + public Sensor getSensor(int sensorID) { + Set directions= new HashSet<>(); + try { + Statement stmt = con.createStatement(); + String statementString = "SELECT * FROM mw_SensorConnection WHERE SENSOR_ID = "+sensorID; + ResultSet rs = stmt.executeQuery(statementString); + if(rs.first()) { + if(rs.getString("TO_LEFT")!=null) { + directions.add(CardinalDirection.valueOf(rs.getString("TO_LEFT"))); + } + if(rs.getString("TO_STRAIGHT")!=null) { + directions.add(CardinalDirection.valueOf(rs.getString("TO_STRAIGHT"))); + } + if(rs.getString("TO_RIGHT")!=null) { + directions.add(CardinalDirection.valueOf(rs.getString("TO_RIGHT"))); + } + return new Sensor(rs.getInt(1), rs.getString(2), rs.getInt(3), rs.getString(4), rs.getInt(5),directions); + } + } catch (SQLException e) { + e.printStackTrace(); + } + return null; + } + + /** + * liefert alle Outputways zu einem Sensor + * @param sensorID + * @param crossroadID + * @return + */ + public HashMap getOutputWays(int sensorID, int crossroadID) { + HashMap outputDirection = new HashMap<>(); + try { + String[] direction = new String[] {"LEFT","STRAIGHT", "RIGHT"}; + Statement stmt = con.createStatement(); + int wayID; + String statementString; + for (int i = 0; i < direction.length; i++) { + statementString = "SELECT SC.CROSSROAD_ID, SC.CROSSROAD_NAME, SC.SENSOR_ID, SC.SENSOR_NAME, SC.FROM_WAY, SC.FROM_DIRECTION, SC.TO_LEFT, CW.OSMWAY_ID as OUT_WAYID, CW.DIRECTION as OUTDIRECTION FROM mw_SensorConnection SC , mw_CrossroadWays CW WHERE SC.CROSSROAD_ID = CW.CROSSROAD_ID AND SC.TO_"+direction[i]+" = CW.DIRECTION AND SC.CROSSROAD_ID = "+crossroadID+" AND CW.TYPE=1 AND SC.SENSOR_ID = "+sensorID; + ResultSet rs = stmt.executeQuery(statementString); + while(rs.next() ) { + wayID = rs.getInt("OUT_WAYID"); + if( wayID >0 ) + outputDirection.put(direction[i],wayID); + } + } + } catch (SQLException e) { + e.printStackTrace(); + } + return outputDirection; + } + + public List getConnectedInputWays(int outputOSM, int outputCrossroad) { + List connections = new ArrayList<>(); + try { + Statement stmt = con.createStatement(); + int wayID; + String statementString; + statementString = "SELECT TO_CROSSROAD,TO_WAY FROM mw_CrossroadConnection CC WHERE CC.FROM_WAY = "+outputOSM+" AND CC.FROM_CROSSROAD = " +outputCrossroad; + ResultSet rs = stmt.executeQuery(statementString); + while(rs.next() ) { + wayID = rs.getInt("TO_WAY"); + if( wayID >0 ) { + connections.add(new InputWay(rs.getInt(1), rs.getInt(2))); + } + } + } catch (SQLException e) { + e.printStackTrace(); + } + return connections; + } + + public List getSensorIDs(int crossroadID) { + List sensors = new ArrayList<>(); + try { + Statement stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery("SELECT SENSOR_ID FROM mw_SensorConnection WHERE CROSSROAD_ID = "+crossroadID); + while(rs.next()) { + sensors.add(rs.getInt(1)); + } + } catch (SQLException e) { + e.printStackTrace(); + } + return sensors; + } + + public void getInputWays(){ + try { + Statement stmt = con.createStatement(); + String statementString; + statementString = "SELECT * FROM mw_InputWaysGlobal"; + ResultSet rs = stmt.executeQuery(statementString); + while(rs.next() ) { + int wayID = rs.getInt("wayID"); + int crossroadID = rs.getInt("crossroadID"); + inputWays.put(rs.getInt("ID"), new int[]{wayID,crossroadID}); + inputWaysToID.put(new InputWay(wayID,crossroadID), rs.getInt(1)); + } + } catch (SQLException e) { + e.printStackTrace(); + } + } + //TODO: Datenbankabfrage ändern + public int getInputWay(int crossroadID,int wayID){ + InputWay key = new InputWay(wayID, crossroadID); + if(inputWaysToID.containsKey(key)){ + return inputWaysToID.get(key); + } + else{ + return -1; + } + } + /** + * + * @return + */ + public List getInputWaysForDNA(int modus) { + List nodes = new ArrayList(); + Node currentWeighted = null; + try { + Statement stmt = con.createStatement(); + String statementString; + statementString = "SELECT * FROM mw_InputWaysGlobal"; + ResultSet rs = stmt.executeQuery(statementString); + while(rs.next() ) { + currentWeighted = gds.newNodeInstance(rs.getInt(1)); + nodes.add(currentWeighted); + } + } catch (SQLException e) { + e.printStackTrace(); + } + return nodes; + } + + public List getInputWaysConnectionForDNA() { + List edges = new ArrayList<>(); + try { + Statement stmt = con.createStatement(); + String statementString; + statementString = "SELECT fromID, fromWay,toID, toWay FROM mw_InputWayConnection"; + ResultSet rs = stmt.executeQuery(statementString); + while(rs.next() ) { + edges.add(new EdgeContainer(rs.getInt(1),rs.getInt(3))); + } + } catch (SQLException e) { + e.printStackTrace(); + } + return edges; + } + + + /** + * liest alle Kreuzunen aus der Datenbank, das Gewicht wird gemäß dem Modus bestimmt + * @param modus 0 = Voraussage mit Stepsize, 1 = Rückblick für Tagesvergleich + * @return + */ + public List getCrossroadsForDNA(int modus) { + if(modus == 1) { + if(timeRange==0){ + System.out.println("TimeRange ist 0, setze auf 1"); + timeRange=1; + } + } + + List nodes = new ArrayList(); + Node current = null; + + try { + System.out.println("Lade Kreuzungen aus Datenbank..."); + Statement stmt = con.createStatement(); + String statementString; + statementString = "SELECT * FROM ((SELECT DISTINCT FROM_CROSSROAD as CROSSROAD FROM mw_CrossroadConnection) UNION (SELECT DISTINCT TO_CROSSROAD as CROSSROAD FROM mw_CrossroadConnection)) V"; + ResultSet rs = stmt.executeQuery(statementString); + + while(rs.next() ) { + int label = rs.getInt(1); + current= gds.newNodeInstance(label); + nodes.add(current); + } + + } catch (SQLException e) { + e.printStackTrace(); + } + return nodes; + } + /* + public List getCrossroadsForDNA_Mode1() { + + List nodes = new ArrayList(); + Node current = null; + DirectedWeightedNode currentWeighted = null; + try { + System.out.println("Lade Kreuzungen aus Datenbank..."); + Statement stmt = con.createStatement(); + String statementString; + statementString = "SELECT * FROM ((SELECT DISTINCT FROM_CROSSROAD as CROSSROAD FROM mw_CrossroadConnection) UNION (SELECT DISTINCT TO_CROSSROAD as CROSSROAD FROM mw_CrossroadConnection)) V"; + ResultSet rs = stmt.executeQuery(statementString); + while(rs.next() ) { + int label = rs.getInt(1); + double[] weight = getCrossroadWeight(rs.getInt(1),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange)).getWeight(); + //System.out.println("Füge Knoten " +label +" mit Gewicht " +weight[0]+"/"+weight[1] + " hinzu "); + current = gds.newNodeInstance(label); + currentWeighted = (current instanceof DirectedWeightedNode) ? (DirectedWeightedNode) current : null; + if(currentWeighted!=null) { + currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); + nodes.add(currentWeighted); + } + } + } catch (SQLException e) { + e.printStackTrace(); + } + return nodes; + }*/ + + public int writeConnections(Set connections) { + java.sql.PreparedStatement stmt; + try { + String inserTableSQL = "INSERT IGNORE INTO mw_InputWayConnection VALUES (?,?,?,?,?,?,DEFAULT)"; + stmt = con.prepareStatement(inserTableSQL); + for (InputWayConnection connection : connections) { + stmt.setInt(1, connection.fromWayID); + stmt.setInt(2, connection.fromCrossroad); + stmt.setString(3, getCrossroadName(connection.fromCrossroad)); + stmt.setInt(4, connection.toWayID); + stmt.setInt(5, connection.toCrossroad); + stmt.setString(6, getCrossroadName(connection.toCrossroad)); + stmt.addBatch(); + }//System.out.println(strInsertIntoMyTable); + stmt.executeBatch(); + } catch (Exception e) { + e.printStackTrace(); + } + return connections.size(); + } + + + public Crossroad innerconnectionForCrossroad(int crossroadID){ + HashMap inputWays = getInputWays(crossroadID); + if(inputWays.size()==0){ + System.out.println("Keine Einfahrtswege"); + return null; + } + Crossroad crossroad = new Crossroad(crossroadID,this); + crossroad.setInputWays(inputWays); + HashMap outPut = getOutputWays(crossroadID); + crossroad.setOutputWays(outPut); + HashMap outputWays; + + for (Map.Entry way : inputWays.entrySet()) { + outputWays = getConnectedOutputWays(crossroadID, way.getValue(), way.getKey()); + if(outputWays==null) { + continue; + } + for (Map.Entry outputWay : outputWays.entrySet()) { + crossroad.setOutputWay(way.getKey(), outputWay.getKey()); + } + } + return crossroad; + } + + /** + * liefert für einen InputWay alle OuputWays die innerhalb der Kreuzung zu erreichen sind + * @param crossroadID + * @param wayID + * @param wayDirection + * @return + */ + public HashMap getConnectedOutputWays(int crossroadID, int wayID, CardinalDirection wayDirection) { + List sensors = getSensors(crossroadID, wayID); + HashMap outputWaysCrossroad = new HashMap<>(); + HashMap outputWaysSensor; + CardinalDirection cd; + for (Sensor sensor : sensors) { + outputWaysSensor = getOutputWays(sensor.sensorID, crossroadID); + for (Map.Entry integer : outputWaysSensor.entrySet()) { + cd = transposeDirection(wayDirection, integer.getKey()); + if(!outputWaysCrossroad.containsKey(cd)) + outputWaysCrossroad.put(cd, integer.getValue()); + } + } + return (outputWaysCrossroad.size()>0) ? outputWaysCrossroad : null; + } + + /** + * übersetzt InputWay-Direction und Richtung, in eine OutputWay-Direction + * @param inDir + * @param goDir + * @return + */ + public CardinalDirection transposeDirection (CardinalDirection inDir, String goDir) { + String[] directions = new String[]{"LEFT","STRAIGHT"}; + switch (inDir) { + case NORTH: + if(goDir.equals(directions[0])) + return CardinalDirection.EAST; + else if(goDir.equals(directions[1])) + return CardinalDirection.SOUTH; + else + return CardinalDirection.WEST; + case EAST: + if(goDir.equals(directions[0])) + return CardinalDirection.SOUTH; + else if(goDir.equals(directions[1])) + return CardinalDirection.WEST; + else + return CardinalDirection.NORTH; + case SOUTH: + if(goDir.equals(directions[0])) + return CardinalDirection.WEST; + else if(goDir.equals(directions[1])) + return CardinalDirection.NORTH; + else + return CardinalDirection.EAST; + default: + if(goDir.equals(directions[0])) + return CardinalDirection.NORTH; + else if(goDir.equals(directions[1])) + return CardinalDirection.EAST; + else + return CardinalDirection.SOUTH; + } + } + + /** + * liefert den Name den Kreuzung mit übergebener ID in der Datenbank + * @param crossroadID + * @return + */ + public String getCrossroadName(int crossroadID) { + String selectStmt = "SELECT REALNAME FROM jee_crmodel_CrossroadDim WHERE ID = " + crossroadID; + Statement stmt; + try { + stmt = con.createStatement(); + ResultSet rs = stmt.executeQuery(selectStmt); + while(rs.next()){ + return rs.getString("REALNAME"); + } + } catch (SQLException e) { + e.printStackTrace(); + } + return "Not Found"; + } + + /** + * wandelt ein DateTime in eine SQL-konforme Stringrepräsentation um. + * @param dateTime + * @return + */ + public static String toSql(DateTime dateTime) { + return new Timestamp( dateTime.getMillis() ).toString(); + } + + /** + * schließt die Verbindung zur Datenbank + */ + public void disconnect() { + try { + con.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } + + /** + * liefert die Knoten für das SensorModell + * @return + */ + public List getSensorsForDNA() { + System.out.println("Erstelle den Graph ... "); + List nodes = new ArrayList(); + try { + Statement stmt = con.createStatement(); + String statementString; + statementString = "SELECT SG.*, ID as INPUT_WAY_ID FROM (SELECT * FROM mw_SensorGlobal) SG LEFT JOIN (SELECT * FROM mw_InputWaysGlobal) IWG ON SG.WAY_ID = IWG.wayID AND SG.CROSSROAD_ID = IWG.crossroadID"; + ResultSet rs = stmt.executeQuery(statementString); + int label; + while (rs.next()) { + label = rs.getInt("NODE_ID"); + nodes.add(gds.newNodeInstance(label)); + sensorModelNodes.put(label, new SensorModelNode(label, !rs.getBoolean("SENSOR_TYPE"),rs.getInt("INPUT_WAY_ID"),CardinalDirection.valueOf(rs.getString("DIRECTION")))); + } + /*double[] weight = null; + DateTime from = null; + DateTime to = null; + if(modus==0){ + from = initDateTime; + to = initDateTime.plusMinutes(stepSize); + } + else if (modus == 1){ + from = initDateTime.minusMinutes(timeRange); + to = initDateTime.plusMinutes(timeRange); + } + getSensorWeights(from, to,0); + while(rs.next() ) { + int label = rs.getInt("NODE_ID"); + if(rs.getBoolean("SENSOR_TYPE")){ + int id = getInputWay(rs.getInt("CROSSROAD_ID"),rs.getInt("WAY_ID")); + if(id>0){ + weight = getInputWayWeight(id,initDateTime, initDateTime.plusMinutes(stepSize)); + } + else { + weight = new double[]{-2,-2,-2}; + } + sensorModelNodes.put(label, new SensorModelNode(label,false, weight, 0,id)); + } + else { + weight = getSensorNodeWeight(label,0,from,to); + } + current = gds.newNodeInstance(label); + currentWeighted = (current instanceof DirectedWeightedNode) ? (DirectedWeightedNode) current : null; + if(currentWeighted!=null) { + currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); + nodes.add(currentWeighted); + } + }*/ + } catch (SQLException e) { + e.printStackTrace(); + } + return nodes; + } + + public double[] getSensorModelWeight(int nodeID,DateTime from, DateTime to,int timestemp){ + if(sensorModelNodes.containsKey(nodeID)){ + SensorModelNode sensorModelNode = sensorModelNodes.get(nodeID); + if(sensorModelNode.isReal()){ + if(sensorModelNode.getTimestep()==timestemp){ + return sensorModelNode.getWeight(); + } + else{ + System.out.println("Not found"); + double[] weight = new double[]{0,0,0}; + sensorModelNode.setWeight(weight, timestemp); + return weight; + } + } + else { + int inputWayID = sensorModelNode.getInputWayID(); + if(inputWayID>0){ + double[] weight = getInputWayWeight(inputWayID, from, to); + sensorModelNode.setWeight(weight, timestemp); + return weight; + } + return new double[]{0,0,0}; + } + } + else + return new double[]{0,0,0}; + } + + /** + * liefert die Gewichte für den Einfahrtsweg + * @param inputWayID + * @param timestamp + * @return Index 0: count/maxCount, Index 1: load + */ + public double[] getInputWayWeight(int inputWayID, DateTime timestamp) { + return getInputWayWeight(inputWayID, timestamp, timestamp.plusMinutes(5)); + } + + /** + * liefert die Gewichte für den Einfahrtsweg + * @param inputWayID + * @param timestamp + * @return Index 0: count/maxCount, Index 1: load + */ + public double[] getInputWayWeight(int inputWayID, DateTime from, DateTime to) { + if(from.equals(to)){ + to = from.plusMinutes(1); + } + double count =0; + double load = 0; + if(!maxValuesInputWays.containsKey(inputWayID)){ + maxValuesInputWays.put(inputWayID, getMaximalWeightInputWay(inputWayID) ); + } + String statementString = null; + try { + int[] inputData = inputWays.get(inputWayID); + int crossroadID = inputData[1]; + Statement stmt = con.createStatement(); + statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID as INPUTWAY_ID, IWG.wayID as OSMWAY_ID, IWG.crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME, sensorID as SENSOR_ID, sensorName as SENSOR_NAME FROM (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID ="+inputWayID+") IWG LEFT JOIN mw_SensorWays SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ="+crossroadID+") S2 ON S1.SENSOR_ID = S2.ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; + ResultSet rs = stmt.executeQuery(statementString); + if(rs.first()){ + count=rs.getDouble(1); + load=rs.getDouble(2); + } + else + System.out.println("ERROR - " +statementString); + if(count == 0 && load == 0){ + System.out.println("InputWayWeight ist 0/0/0"); + } + } catch (SQLException e) { + e.printStackTrace(); + } + double savedMax = maxValuesInputWays.get(inputWayID)[0]; + double countNorm = savedMax> 0 ? count/savedMax : 0; + return new double[]{count,load,countNorm*100}; + } + + + + /** + * liefert das Knotengewicht für einer der tatsächlichen Sensoren + * @param to + * @param from + * @param sensorID + * @param timeStamp + * @return + */ + + // ALT + public double[] getSensorNodeWeight(int nodeID, int timestamp, DateTime from, DateTime to){ + if(sensorModelNodes.containsKey(nodeID)){ + SensorModelNode node = sensorModelNodes.get(nodeID); + if(node.getTimestep()==timestamp) + return node.getWeight(); + else { //Outdated Data + if(node.isReal()){ + getSensorWeights(from, to, timestamp); + return getSensorNodeWeight(nodeID, timestamp, from, to); + } + else{ + double[] weight = (node.getInputWayID()>0)?getInputWayWeight(node.getInputWayID(), from, to):new double[]{-2,-2,-2}; + node.setWeight(weight, timestamp); + return weight; + } + } + } + else{ + System.out.println("Nicht drin " +nodeID); + return new double[]{0,0,0}; + } + } + /** + * Liefer TRUE, wenn es sich um einen realen Sensor handel, sonst FALSE + * @param nodeID + * @return + */ + public boolean getSensorType(int nodeID){ + return sensorModelNodes.get(nodeID).isReal(); + } + /** + * liefert die Werte für alle tatsächlichen Sensoren + * @param from + * @param to + * @return + */ + public double[] getSensorWeights(DateTime from, DateTime to,int timestemp){ + try { + Statement stmt = con.createStatement(); + String statementString; + statementString = "SELECT NODE_ID,SUM(cr_count)/COUNT(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, SENSOR_ID,SENSOR_NAME,WAY_ID,CROSSROAD_ID,CROSSROAD_NAME,SENSOR_TYPE,CSVOFFSET FROM (SELECT NODE_ID,SENSOR_ID,SENSOR_NAME,WAY_ID,CROSSROAD_ID,CROSSROAD_NAME,SENSOR_TYPE,SENSORS.CSVOFFSET,cr_count,DATETIME,cr_load FROM (SELECT NODES.*,CSVOFFSET FROM (SELECT * FROM mw_SensorGlobal SG WHERE SG.SENSOR_TYPE=0) NODES JOIN jee_crmodel_SensorDim SD ON NODES.SENSOR_ID = SD.ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME >= '"+toSql(from)+"') RE ON SENSORS.CSVOFFSET = RE.CSVOFFSET AND SENSORS.CROSSROAD_NAME = RE.CROSSROAD) RESULT GROUP BY NODE_ID "; + ResultSet rs = stmt.executeQuery(statementString); + while(rs.next()){ + if(!rs.getBoolean("SENSOR_TYPE")){ + double[] max = maxValuesSensors.get(rs.getInt("NODE_ID")); + if(max == null) + max = new double[]{10,0}; + sensorModelNodes.put(rs.getInt("NODE_ID"), new SensorModelNode(rs.getInt("NODE_ID"),true,new double[]{rs.getDouble("ANZAHL"), rs.getDouble("BELEGUNG"),(rs.getDouble("ANZAHL")/max[0])*100},timestemp)); + } + } + } catch (SQLException e) { + e.printStackTrace(); + } + return new double[]{0,0,0}; + } + + + public List getSensorConnectionForDNA() { + List edges = new ArrayList<>(); + try { + Statement vStmt = con.createStatement(); + String statementString; + // Virtual Sensor -> Real Sensor + statementString = "SELECT VS.NODE_ID AS V_NODE_ID, VS.WAY_ID as V_WAY_ID, VS.CROSSROAD_ID as V_CROSSROAD, RS.NODE_ID as R_NODE_ID, RS.WAY_ID as R_WAY_ID, RS.CROSSROAD_ID as R_CROSSROAD_ID FROM (SELECT * FROM mw_SensorGlobal SG1 WHERE SENSOR_TYPE = 1) VS LEFT JOIN (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 0) RS ON VS.WAY_ID = RS.WAY_ID AND VS.CROSSROAD_ID = RS.CROSSROAD_ID"; + ResultSet v2r = vStmt.executeQuery(statementString); + while(v2r.next() ) { + edges.add(new EdgeContainer(v2r.getInt("V_NODE_ID"), v2r.getInt("R_NODE_ID"))); + } + + // Real Sensor -> Virtual Sensor + Statement rStmt = con.createStatement(); + statementString = "SELECT DISTINCT R_NODE_ID,V_NODE_ID FROM (SELECT R_NODE.*,V_NODE.NODE_ID as V_NODE_ID FROM (SELECT FROM_NODE.*, TO_WAY,TO_CROSSROAD FROM (SELECT NODE_ID as R_NODE_ID,SENSOR_ID,SENSOR_NAME,WAY_ID as INNER_FROM_WAY,FROM_SENSOR.CROSSROAD_ID, FROM_SENSOR.CROSSROAD_NAME, FROM_SENSOR.DIRECTION as INNER_FROM_DIRECTION, TO_LEFT, OSMWAY_ID as INNER_TO_WAY,TO_WAY.DIRECTION as INNER_TO_DIRECTION FROM (SELECT NODE_ID,SC.SENSOR_ID,SC.SENSOR_NAME,SG.WAY_ID,SC.CROSSROAD_ID,SC.CROSSROAD_NAME,DIRECTION,TO_LEFT,TO_STRAIGHT,TO_RIGHT FROM (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 0) SG JOIN (SELECT * FROM mw_SensorConnection WHERE FRONT_BACK = 0) SC ON SG.SENSOR_ID = SC.SENSOR_ID) FROM_SENSOR JOIN (SELECT * FROM mw_CrossroadWays CRW WHERE TYPE = 1) TO_WAY ON FROM_SENSOR.TO_LEFT = TO_WAY.DIRECTION AND FROM_SENSOR.CROSSROAD_ID = TO_WAY.CROSSROAD_ID) FROM_NODE JOIN (SELECT * FROM mw_CrossroadConnection) CC ON FROM_NODE.CROSSROAD_ID = CC.FROM_CROSSROAD AND INNER_TO_WAY = CC.FROM_WAY) R_NODE JOIN (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 1) V_NODE ON R_NODE.TO_WAY = V_NODE.WAY_ID AND R_NODE.TO_CROSSROAD = V_NODE.CROSSROAD_ID) RESULT1 UNION SELECT DISTINCT R_NODE_ID, V_NODE_ID FROM (SELECT R_NODE.*, V_NODE.NODE_ID AS V_NODE_ID FROM (SELECT FROM_NODE.*, TO_WAY, TO_CROSSROAD FROM (SELECT NODE_ID AS R_NODE_ID, SENSOR_ID, SENSOR_NAME, WAY_ID AS INNER_FROM_WAY, FROM_SENSOR.CROSSROAD_ID, FROM_SENSOR.CROSSROAD_NAME, FROM_SENSOR.DIRECTION AS INNER_FROM_DIRECTION, TO_STRAIGHT, OSMWAY_ID AS INNER_TO_WAY, TO_WAY.DIRECTION AS INNER_TO_DIRECTION FROM (SELECT NODE_ID, SC.SENSOR_ID, SC.SENSOR_NAME, SG.WAY_ID, SC.CROSSROAD_ID, SC.CROSSROAD_NAME, DIRECTION, TO_LEFT, TO_STRAIGHT, TO_RIGHT FROM (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 0) SG JOIN (SELECT * FROM mw_SensorConnection WHERE FRONT_BACK = 0) SC ON SG.SENSOR_ID = SC.SENSOR_ID) FROM_SENSOR JOIN (SELECT * FROM mw_CrossroadWays CRW WHERE TYPE = 1) TO_WAY ON FROM_SENSOR.TO_STRAIGHT = TO_WAY.DIRECTION AND FROM_SENSOR.CROSSROAD_ID = TO_WAY.CROSSROAD_ID) FROM_NODE JOIN (SELECT * FROM mw_CrossroadConnection) CC ON FROM_NODE.CROSSROAD_ID = CC.FROM_CROSSROAD AND INNER_TO_WAY = CC.FROM_WAY) R_NODE JOIN (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 1) V_NODE ON R_NODE.TO_WAY = V_NODE.WAY_ID AND R_NODE.TO_CROSSROAD = V_NODE.CROSSROAD_ID) RESULT2 UNION SELECT DISTINCT R_NODE_ID, V_NODE_ID FROM (SELECT R_NODE.*, V_NODE.NODE_ID AS V_NODE_ID FROM (SELECT FROM_NODE.*, TO_WAY, TO_CROSSROAD FROM (SELECT NODE_ID AS R_NODE_ID, SENSOR_ID, SENSOR_NAME, WAY_ID AS INNER_FROM_WAY, FROM_SENSOR.CROSSROAD_ID, FROM_SENSOR.CROSSROAD_NAME, FROM_SENSOR.DIRECTION AS INNER_FROM_DIRECTION, TO_RIGHT, OSMWAY_ID AS INNER_TO_WAY, TO_WAY.DIRECTION AS INNER_TO_DIRECTION FROM (SELECT NODE_ID, SC.SENSOR_ID, SC.SENSOR_NAME, SG.WAY_ID, SC.CROSSROAD_ID, SC.CROSSROAD_NAME, DIRECTION, TO_LEFT, TO_STRAIGHT, TO_RIGHT FROM (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 0) SG JOIN (SELECT * FROM mw_SensorConnection WHERE FRONT_BACK = 0) SC ON SG.SENSOR_ID = SC.SENSOR_ID) FROM_SENSOR JOIN (SELECT * FROM mw_CrossroadWays CRW WHERE TYPE = 1) TO_WAY ON FROM_SENSOR.TO_RIGHT = TO_WAY.DIRECTION AND FROM_SENSOR.CROSSROAD_ID = TO_WAY.CROSSROAD_ID) FROM_NODE JOIN (SELECT * FROM mw_CrossroadConnection) CC ON FROM_NODE.CROSSROAD_ID = CC.FROM_CROSSROAD AND INNER_TO_WAY = CC.FROM_WAY) R_NODE JOIN (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 1) V_NODE ON R_NODE.TO_WAY = V_NODE.WAY_ID AND R_NODE.TO_CROSSROAD = V_NODE.CROSSROAD_ID) RESULT3"; + ResultSet r2v = rStmt.executeQuery(statementString); + while(r2v.next() ) { + edges.add(new EdgeContainer(r2v.getInt("R_NODE_ID"), r2v.getInt("V_NODE_ID"))); + } + } catch (SQLException e) { + e.printStackTrace(); + } + return edges; + } + + public void writeSensorConnection(Sensor s) { + try { + Statement stmt = con.createStatement(); + String insertString; + for (InputWay connectedInputWay : s.connections.values()) { + insertString="INSERT IGNORE INTO mw_SensorGlobalConnection SELECT * FROM (SELECT NODE_ID as FROM_NODE_ID FROM mw_SensorGlobal WHERE mw_SensorGlobal.SENSOR_ID ='"+s.sensorID+"' AND CROSSROAD_ID = '"+s.crossroadID+"') A , (SELECT NODE_ID as TO_NODE_ID FROM mw_SensorGlobal SG WHERE SG.SENSOR_TYPE=1 AND SG.CROSSROAD_ID = '"+connectedInputWay.wayID+"' AND SG.WAY_ID = '"+connectedInputWay.crossroadID+"') B "; + stmt.executeUpdate(insertString); + } + } catch (SQLException e) { + e.printStackTrace(); + } + + } + + + + public void setDisabledEdges(HashMap disabledEdges){ + this.disabledEdges=disabledEdges; + } + public void setDisabledEdgesInputWay(HashMap> disabledEdges){ + this.disabledEdgesInputWay=disabledEdges; + } + public HashMap getDisabledEdges(){ + return disabledEdges; + } + public HashMap> getDisabledEdgesInputWay(){ + return disabledEdgesInputWay; + } + + + public double[] getInputWayWeightStaticInit(int index,TrafficUpdate trafficUpdate) { + double count = trafficUpdate.getInitCount(); + double load = trafficUpdate.getInitLoad(); + double savedMax = (maxValuesInputWays.containsKey(index)) ?(double) maxValuesInputWays.get(index)[0] : 0; + double countNorm = savedMax> 0 ? Double.valueOf(count)/savedMax : 0; + return new double[]{count,load,countNorm*100}; + } + public double[] getInputWayWeightStaticBatch(int index,TrafficUpdate trafficUpdate) { + double count = (trafficUpdate.getSleepTillUpdate()*trafficUpdate.getInitCount()+trafficUpdate.getUpdateCount())/(trafficUpdate.getSleepTillUpdate()+1); + double load = (trafficUpdate.getSleepTillUpdate()*trafficUpdate.getInitLoad()+trafficUpdate.getUpdateLoad())/(trafficUpdate.getSleepTillUpdate()+1); + double savedMax = (maxValuesInputWays.containsKey(index)) ? maxValuesInputWays.get(index)[0] : 0; + double countNorm = savedMax> 0 ? count/savedMax : 0; + return new double[]{count,load,countNorm*100}; + } + public double[] getSensorModelWeightStaticInit(int index,TrafficUpdate trafficUpdate) { + if(trafficUpdate.getModus()==0){ + if(sensorModelNodes.containsKey(index)){ + SensorModelNode sensorModelNode = sensorModelNodes.get(index); + double count = trafficUpdate.getInitCount(); + double load = trafficUpdate.getInitLoad(); + double countNorm; + if(getSensorType(index)){ + if(maxValuesSensors.containsKey(index)) + countNorm = (count/maxValuesSensors.get(index)[0]); + else + countNorm = (count/50); + } + else{ + double savedMax = (maxValuesInputWays.containsKey(sensorModelNode.getInputWayID())) ? maxValuesInputWays.get(sensorModelNode.getInputWayID())[0] : 0; + countNorm = savedMax> 0 ? count/savedMax : 0; + } + return new double[]{count,load,countNorm*100}; + } + else + return new double[]{0,0,0}; + } + else{ + return new double[]{-1,-1,trafficUpdate.getInitUtilization()*100}; + } + } + public double[] getSensorModelWeightStaticBatch(int index,TrafficUpdate trafficUpdate) { + if(trafficUpdate.getModus()==0){ + if(sensorModelNodes.containsKey(index)){ + SensorModelNode sensorModelNode = sensorModelNodes.get(index); + if(sensorModelNode.isReal()){ + double count = (trafficUpdate.getSleepTillUpdate()*trafficUpdate.getInitCount()+trafficUpdate.getUpdateCount())/(trafficUpdate.getSleepTillUpdate()+1); + double load = (trafficUpdate.getSleepTillUpdate()*trafficUpdate.getInitLoad()+trafficUpdate.getUpdateLoad())/(trafficUpdate.getSleepTillUpdate()+1); + double savedMax = maxValuesSensors.get(sensorModelNode.getNodeID())[0]; + double countNorm = savedMax> 0 ? count/savedMax : 0; + return new double[]{count,load,countNorm*100}; + } + else + return getInputWayWeightStaticBatch(sensorModelNode.getInputWayID(), trafficUpdate); + } + else + return new double[]{0,0,0}; + } + else{ + return new double[]{-1,-1,trafficUpdate.getUpdateUtilization()*100}; + } + } + +} diff --git a/src/dna/graph/generators/traffic/EdgeContainer.java b/src/dna/graph/generators/traffic/EdgeContainer.java new file mode 100644 index 00000000..6bf1f5ad --- /dev/null +++ b/src/dna/graph/generators/traffic/EdgeContainer.java @@ -0,0 +1,33 @@ +package dna.graph.generators.traffic; + +import java.util.Arrays; + +public class EdgeContainer { + int from; + int to; + + public EdgeContainer(int from, int to){ + this.from = from; + this.to = to; + } + + public int hashCode(){ + return Arrays.hashCode(new int[]{from,to}); + } + + public boolean equals(Object obj) { + EdgeContainer ec = (EdgeContainer) obj; + return Arrays.equals(new int[]{from, to},new int[]{ec.from,ec.to}); + } + public String toString(){ + return "FROM:"+from+"\tTO:"+to; + } + + public int getFrom(){ + return from; + } + + public int getTo(){ + return to; + } +} diff --git a/src/dna/graph/generators/traffic/InputWay.java b/src/dna/graph/generators/traffic/InputWay.java new file mode 100644 index 00000000..60fa7781 --- /dev/null +++ b/src/dna/graph/generators/traffic/InputWay.java @@ -0,0 +1,27 @@ +package dna.graph.generators.traffic; + +import java.util.Arrays; + +public class InputWay { + int wayID; + int crossroadID; + + public InputWay(int wayID, int crossroadID) { + this.wayID=wayID; + this.crossroadID=crossroadID; + } + + public String toString(){ + return String.valueOf(wayID) + "\t"+crossroadID; + } + + public int hashCode(){ + return Arrays.hashCode(new int[]{wayID,crossroadID}); + } + + public boolean equals(Object obj) { + InputWay inputWay = (InputWay) obj; + return Arrays.equals(new int[]{wayID,crossroadID}, new int[]{inputWay.wayID,inputWay.crossroadID}); + } + +} diff --git a/src/dna/graph/generators/traffic/InputWayConnection.java b/src/dna/graph/generators/traffic/InputWayConnection.java new file mode 100644 index 00000000..92c39161 --- /dev/null +++ b/src/dna/graph/generators/traffic/InputWayConnection.java @@ -0,0 +1,22 @@ +package dna.graph.generators.traffic; + + +public class InputWayConnection { + int fromCrossroad; + int fromWayID; + CardinalDirection fromWayDirection; + int toCrossroad; + int toWayID; + CardinalDirection toWayDirection; + + public InputWayConnection(int fromCrossroad, int fromWayID,CardinalDirection fromWayDirection, int toCrossroad, int toWayID,CardinalDirection toWayDirection) { + this.fromCrossroad=fromCrossroad; + this.fromWayID=fromWayID; + this.toCrossroad=toCrossroad; + this.toWayID=toWayID; + } + + public String toString() { + return "Connected " + fromWayID + " on " +fromCrossroad + " with " +toWayID + " on " + toCrossroad; + } +} diff --git a/src/dna/graph/generators/traffic/Sensor.java b/src/dna/graph/generators/traffic/Sensor.java new file mode 100644 index 00000000..10ef32ba --- /dev/null +++ b/src/dna/graph/generators/traffic/Sensor.java @@ -0,0 +1,51 @@ +package dna.graph.generators.traffic; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Map; +import java.util.Set; + + +public class Sensor { + int sensorID; + String sensorName; + int crossroadID; + String crossroadName; + int wayID; + Set outputDiretions; + HashMap connections; + + public Sensor(int sensorID, String sensorName, int crossroadID, String crossroadName, int wayID,Set outputDirections){ + this.sensorID=sensorID; + this.sensorName=sensorName; + this.crossroadID=crossroadID; + this.crossroadName=crossroadName; + this.wayID=wayID; + this.outputDiretions=outputDirections; + } + public Sensor(int sensorID, String sensorName, int crossroadID, String crossroadName, int wayID){ + this.sensorID=sensorID; + this.sensorName=sensorName; + this.crossroadID=crossroadID; + this.crossroadName=crossroadName; + this.wayID=wayID; + } + public HashMap getConnection(HashMap outputConnection) { + HashMap connections = new HashMap<>(); + for (CardinalDirection output : outputDiretions) { + if(outputConnection.containsKey(output)) + connections.put(output, outputConnection.get(output)); + } + this.connections=connections; + return connections; + } + public void printConnection() { + System.out.println("Verbindungen von:\t"+sensorID+"("+sensorName+") on " +crossroadID+"("+crossroadName+")"); + for (Map.Entry connection : connections.entrySet()) { + System.out.println("\t\t"+connection.getKey()+"\t"+connection.getValue()); + } + + } + + +} diff --git a/src/dna/graph/generators/traffic/SensorModelNode.java b/src/dna/graph/generators/traffic/SensorModelNode.java new file mode 100644 index 00000000..5d5659a3 --- /dev/null +++ b/src/dna/graph/generators/traffic/SensorModelNode.java @@ -0,0 +1,69 @@ +package dna.graph.generators.traffic; + + +public class SensorModelNode { + private double[] weight; + private boolean isReal; + private int nodeID; + private int timestep; + private int inputWayID; + private CardinalDirection direction; + + public SensorModelNode(int nodeID, boolean isReal){ + this.nodeID=nodeID; + this.isReal=isReal; + this.timestep=-1; + } + + public SensorModelNode(int nodeID, boolean isReal,double[] weight,int timestep){ + this.nodeID=nodeID; + this.isReal=isReal; + this.weight=weight; + this.timestep=timestep; + } + + public SensorModelNode(int nodeID, boolean isReal,double[] weight,int timestep,int inputWayID){ + this.nodeID=nodeID; + this.isReal=isReal; + this.weight=weight; + this.timestep=timestep; + this.inputWayID = inputWayID; + } + + public SensorModelNode(int nodeID, boolean isReal,int inputWayID, CardinalDirection direction){ + this.nodeID=nodeID; + this.isReal=isReal; + this.inputWayID = inputWayID; + this.direction = direction; + this.timestep=-1; + } + + public double[] getWeight(){ + return weight; + } + + public void setWeight(double[] weight, int timestep){ + this.weight=weight; + this.timestep=timestep; + } + + public boolean isReal(){ + return isReal; + } + + public int getNodeID(){ + return nodeID; + } + + public int getTimestep(){ + return timestep; + } + + public int getInputWayID(){ + return inputWayID; + } + + public CardinalDirection getDirection(){ + return direction; + } +} diff --git a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java new file mode 100644 index 00000000..827c4d64 --- /dev/null +++ b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java @@ -0,0 +1,132 @@ +package dna.graph.generators.traffic; + +import java.io.IOException; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; + +import org.joda.time.DateTime; + +import dna.graph.Graph; +import dna.graph.IElement; +import dna.graph.datastructures.GraphDataStructure; +import dna.graph.edges.DirectedEdge; +import dna.graph.edges.Edge; +import dna.graph.generators.GraphGenerator; +import dna.graph.generators.random.IRandomGenerator; +import dna.graph.nodes.DirectedNode; +import dna.graph.nodes.DirectedWeightedNode; +import dna.graph.nodes.INode; +import dna.graph.nodes.Node; +import dna.graph.weights.Double3dWeight; +import dna.io.GraphReader; +import dna.io.GraphWriter; +import dna.updates.update.EdgeRemoval; +import dna.util.ArrayUtils; +import dna.util.parameters.IntParameter; +import dna.util.parameters.Parameter; + +public class TrafficCrossroadGraphGenerator extends GraphGenerator{ + + List nodeslist; + private DB db; + private int modus; + private DateTime initDateTime; + private int stepsize; + private int timeRange; + private TrafficUpdate trafficUpdate; + + public TrafficCrossroadGraphGenerator(String name, GraphDataStructure gds, DB db,long timeStampInit,int modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate) { + this(name, null, gds,timeStampInit, 0, 0,db,modus,initDateTime,stepsize,timeRange,trafficupdate); + } + + public TrafficCrossroadGraphGenerator(String name, Parameter[] params, + GraphDataStructure gds, long timestampInit, int nodesInit, + int edgesInit,DB db,int modus,DateTime initDateTime,int stepsize,int timeRange,TrafficUpdate trafficUpdate) { + super(name, params, gds, timestampInit, nodesInit, edgesInit); + this.db= db; + this.modus=modus; + this.initDateTime=initDateTime; + this.stepsize = stepsize; + this.timeRange = timeRange; + this.trafficUpdate = trafficUpdate; + } + + @Override + public Graph generate() { + System.out.println("Generiere den Graph"); + db.getMaximalWeightInputWay(); + db.getMaximalWeightCrossroad(); + Graph g = this.newGraphInstance(); + List nodes = null; + HashMap disabledEdges = new HashMap<>(); + + // Nodes + nodes = db.getCrossroadsForDNA(modus); + CrossroadWeight crossroadWeight = null; + Node currentNode = null; + DirectedWeightedNode currentWeighted = null; + for (int i = 0; i < nodes.size(); i++) { + + currentNode = (Node) nodes.get(i); + if(currentNode instanceof DirectedWeightedNode) + currentWeighted = (DirectedWeightedNode) currentNode; + else{ + continue; + } + + switch (modus) { + case 0: + crossroadWeight = db.getCrossroadWeight(currentWeighted.getIndex(),initDateTime,initDateTime.plusMinutes(stepsize),0); + break; + case 1: + crossroadWeight = db.getCrossroadWeight(currentWeighted.getIndex(),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange),0); + break; + case 2: + crossroadWeight = db.getCrossroadWeightStaticInit(currentWeighted.getIndex(),initDateTime,initDateTime.plusMinutes(1),0,trafficUpdate); + break; + default: + System.out.println("error - Modus nicht definiert"); + break; + } + + double[] weight = crossroadWeight.getWeight(); + currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); + g.addNode(currentWeighted); + + EdgeContainer ec = null; + for (Integer wayId : crossroadWeight.getOverladedEdges().keySet()) { + List edgesToRemove = db.getFromWays(currentWeighted.getIndex(), wayId); + if(edgesToRemove != null){ + for (int[] way : edgesToRemove) { + ec = new EdgeContainer(way[0], currentNode.getIndex()); + disabledEdges.put(ec, null); + } + } + } + } + + + + //Edges + List connection = db.getCrossroadConnection(); + EdgeContainer current = null; + for (int i = 0; i < connection.size(); i++) { + current = connection.get(i); + Edge e = gds.newEdgeInstance(g.getNode(current.getFrom()), g.getNode(current.getTo())); + + if(disabledEdges.containsKey(current)){ + disabledEdges.put(current, e); + } + else{ + e.connectToNodes(); + g.addEdge(e); + } + + } + + db.setDisabledEdges(disabledEdges); + return g; + } + +} diff --git a/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java new file mode 100644 index 00000000..537ae62e --- /dev/null +++ b/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java @@ -0,0 +1,131 @@ +package dna.graph.generators.traffic; + + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import org.joda.time.DateTime; + +import dna.graph.Graph; +import dna.graph.datastructures.GraphDataStructure; +import dna.graph.edges.Edge; +import dna.graph.generators.GraphGenerator; +import dna.graph.nodes.DirectedWeightedNode; +import dna.graph.nodes.INode; +import dna.graph.nodes.Node; +import dna.graph.weights.Double3dWeight; +import dna.io.GraphWriter; +import dna.util.parameters.Parameter; + +public class TrafficInputWayGraphGenerator extends GraphGenerator{ + + List nodeslist; + private DB db; + private DateTime initTime; + private int modus; + private DateTime initDateTime; + private int stepsize; + private int timeRange; + private TrafficUpdate trafficUpdate; + private double treshold; + private HashMap> disabledEdges = new HashMap<>(); + + public TrafficInputWayGraphGenerator(String name, GraphDataStructure gds, DB db, long timeStamp, int modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold) { + this(name, null, gds,timeStamp, 0, 0,db, modus,initDateTime,stepsize,timeRange,trafficupdate,treshold); + } + + public TrafficInputWayGraphGenerator(String name, Parameter[] params, + GraphDataStructure gds, long timestampInit, int nodesInit, + int edgesInit,DB db,int modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold) { + super(name, params, gds, timestampInit, nodesInit, edgesInit); + this.db= db; + this.modus = modus; + this.initDateTime = initDateTime; + this.stepsize = stepsize; + this.timeRange = timeRange; + this.trafficUpdate = trafficupdate; + this.treshold = treshold; + } + + @Override + public Graph generate() { + Graph g = this.newGraphInstance(); + + + List nodes = null; + Set overloaded = new HashSet<>(); + + // Nodes + nodes = db.getInputWaysForDNA(modus); + + Node currentNode = null; + DirectedWeightedNode currentWeighted = null; + double[] weight = null; + for (int i = 0; i < nodes.size(); i++) { + currentNode = (Node) nodes.get(i); + if(currentNode instanceof DirectedWeightedNode) + currentWeighted = (DirectedWeightedNode) currentNode; + else{ + continue; + } + + switch (modus) { + case 0: + weight = db.getInputWayWeight(currentWeighted.getIndex(), initDateTime, initDateTime.plusMinutes(stepsize)); + break; + case 1: + weight = db.getInputWayWeight(currentWeighted.getIndex(),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange)); + break; + case 2: + weight = db.getInputWayWeightStaticInit(currentWeighted.getIndex(),trafficUpdate); + break; + default: + System.out.println("error - Modus nicht definiert"); + break; + } + if(weight[2] > treshold){ + overloaded.add(currentWeighted.getIndex()); + } + + currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); + g.addNode(currentWeighted); + + } + + List connection = db.getInputWaysConnectionForDNA(); + DirectedWeightedNode fromNode = null; + DirectedWeightedNode toNode = null; + Edge e = null; + EdgeContainer ec = null; + for (int i = 0; i < connection.size(); i++) { + ec = connection.get(i); + fromNode = (DirectedWeightedNode) g.getNode(ec.getFrom()); + toNode = (DirectedWeightedNode) g.getNode(ec.getTo()); + e = gds.newEdgeInstance(fromNode,toNode); + if(overloaded.contains(fromNode.getIndex()) || overloaded.contains((toNode.getIndex()))){ + addEdge(fromNode.getIndex(),ec,e); + addEdge(toNode.getIndex(),ec,e); + } + else{ + g.addEdge(e); + e.connectToNodes(); + } + } + db.setDisabledEdgesInputWay(disabledEdges); + return g; + } + + public void addEdge(int index,EdgeContainer ec, Edge e){ + if(disabledEdges.containsKey(index)) + disabledEdges.get(index).put(ec,e); + else{ + HashMap newEdgeList = new HashMap<>(); + newEdgeList.put(ec,e); + disabledEdges.put(index,newEdgeList); + } + } + +} diff --git a/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java new file mode 100644 index 00000000..8363896a --- /dev/null +++ b/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java @@ -0,0 +1,142 @@ +package dna.graph.generators.traffic; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import org.joda.time.DateTime; + +import dna.graph.Graph; +import dna.graph.IElement; +import dna.graph.datastructures.GraphDataStructure; +import dna.graph.edges.Edge; +import dna.graph.generators.GraphGenerator; +import dna.graph.generators.random.IRandomGenerator; +import dna.graph.nodes.DirectedWeightedNode; +import dna.graph.nodes.INode; +import dna.graph.nodes.Node; +import dna.graph.weights.Double3dWeight; +import dna.util.ArrayUtils; +import dna.util.parameters.IntParameter; +import dna.util.parameters.Parameter; + +public class TrafficSensorGraphGenerator extends GraphGenerator{ + + List nodeslist; + private DB db; + private int modus; + private DateTime initDateTime; + private int stepsize; + private int timeRange; + private TrafficUpdate trafficUpdate; + private double treshold; + private HashMap> disabledEdges = new HashMap<>(); + + public TrafficSensorGraphGenerator(String name, GraphDataStructure gds, DB db,long timeStamp,int modus,DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold) { + this(name, null, gds,timeStamp, 0, 0,db,modus,initDateTime,stepsize,timeRange,trafficupdate,treshold); + } + + public TrafficSensorGraphGenerator(String name, Parameter[] params, + GraphDataStructure gds, long timestampInit, int nodesInit, + int edgesInit,DB db, int modus,DateTime initDateTime,int stepsize,int timeRange,TrafficUpdate trafficUpdate,double treshold) { + super(name, params, gds, timestampInit, nodesInit, edgesInit); + this.db= db; + this.modus = modus; + this.initDateTime=initDateTime; + this.stepsize = stepsize; + this.timeRange = timeRange; + this.trafficUpdate = trafficUpdate; + this.treshold = treshold; + } + + @Override + public Graph generate() { + Graph g = this.newGraphInstance(); + Set overloaded = new HashSet<>(); + + List nodes = db.getSensorsForDNA(); + double[] weight = null; + Node currentNode = null; + DirectedWeightedNode currentWeighted = null; + switch (modus) { + case 0: + db.getSensorWeights(initDateTime, initDateTime.plusMinutes(stepsize), 0); + break; + case 1: + db.getSensorWeights(initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange),0); + break; + + default: + break; + } + + // Knoten + for (int i = 0; i < nodes.size(); i++) { + currentNode = (Node) nodes.get(i); + if(currentNode instanceof DirectedWeightedNode) + currentWeighted = (DirectedWeightedNode) currentNode; + else{ + System.out.println("Continue"); + continue; + } + switch (modus) { + case 0: + weight = db.getSensorModelWeight(currentWeighted.getIndex(),initDateTime,initDateTime.plusMinutes(stepsize),0); + break; + case 1: + weight = db.getSensorModelWeight(currentWeighted.getIndex(),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange),0); + break; + case 2: + weight = db.getSensorModelWeightStaticInit(currentWeighted.getIndex(),trafficUpdate); + break; + default: + System.out.println("error - Modus nicht definiert"); + break; + } + if(weight== null){ + weight = new double[]{0,0,0}; + } + if(weight[2] > treshold){ + System.out.println("Overloaded " +currentWeighted.getIndex()); + overloaded.add(currentWeighted.getIndex()); + } + currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); + g.addNode(currentWeighted); + } + + // Kanten + List connection = db.getSensorConnectionForDNA(); + DirectedWeightedNode fromNode; + DirectedWeightedNode toNode; + Edge e = null; + EdgeContainer ec = null; + for (int i = 0; i < connection.size(); i++) { + ec = connection.get(i); + fromNode = (DirectedWeightedNode) g.getNode(ec.getFrom()); + toNode = (DirectedWeightedNode) g.getNode(ec.getTo()); + e = gds.newEdgeInstance(fromNode,toNode); + if(overloaded.contains(fromNode.getIndex()) || overloaded.contains((toNode.getIndex()))){ + addEdge(fromNode.getIndex(),ec,e); + addEdge(toNode.getIndex(),ec,e); + } + else{ + g.addEdge(e); + e.connectToNodes(); + } + + } + db.setDisabledEdgesInputWay(disabledEdges); + return g; + } + public void addEdge(int index,EdgeContainer ec, Edge e){ + if(disabledEdges.containsKey(index)) + disabledEdges.get(index).put(ec,e); + else{ + HashMap newEdgeList = new HashMap<>(); + newEdgeList.put(ec,e); + disabledEdges.put(index,newEdgeList); + } + } + +} diff --git a/src/dna/graph/generators/traffic/TrafficUpdate.java b/src/dna/graph/generators/traffic/TrafficUpdate.java new file mode 100644 index 00000000..b60f2550 --- /dev/null +++ b/src/dna/graph/generators/traffic/TrafficUpdate.java @@ -0,0 +1,72 @@ +package dna.graph.generators.traffic; + +import java.util.List; + +public class TrafficUpdate { + private double initCount; + private double initLoad; + private double initUtilization; + private double updateCount; + private double updateLoad; + private double updateUtilization; + private List nodesToUpdate; + + private int modus; + private int sleeptillUpdate; + + public TrafficUpdate(double initCount,double initLoad,double updateCount,double updateLoad,int sleeptillUpdate, List affectedNodes){ + this.initCount=initCount; + this.initLoad=initLoad; + this.updateCount=updateCount; + this.updateLoad=updateLoad; + this.nodesToUpdate = affectedNodes; + this.modus=0; + this.sleeptillUpdate = sleeptillUpdate; + } + + public TrafficUpdate(double initUtilization, double updateUtilization,int sleepTilleTimestamp,List affectedNodes){ + this.initUtilization = initUtilization; + this.updateUtilization = updateUtilization; + this.nodesToUpdate = affectedNodes; + this.modus=1; + } + + public int getModus(){ + return modus; + } + + public double getInitCount(){ + return initCount; + } + + public double getInitLoad(){ + return initLoad; + } + + public double getUpdateCount(){ + return updateCount; + } + + public double getUpdateLoad(){ + return updateLoad; + } + + public boolean isAffected(int nodeID){ + return nodesToUpdate.contains(nodeID); + } + public boolean changeToUpdate(int timeStamp){ + return sleeptillUpdate<=timeStamp; + } + + public double getInitUtilization(){ + return initUtilization; + } + + public double getUpdateUtilization(){ + return updateUtilization; + } + + public double getSleepTillUpdate(){ + return sleeptillUpdate; + } +} diff --git a/src/dna/graph/weights/Double3dWeight.java b/src/dna/graph/weights/Double3dWeight.java index a311cb4c..49701820 100644 --- a/src/dna/graph/weights/Double3dWeight.java +++ b/src/dna/graph/weights/Double3dWeight.java @@ -65,5 +65,16 @@ public String asString() { return this.x + Weight.WeightSeparator + this.y + Weight.WeightSeparator + this.z; } + + + public boolean equals(Object o){ + if (o == null) + return false; + if (!(o instanceof Double3dWeight)) + return false; + + Double3dWeight oCasted = (Double3dWeight) o; + return this.x == oCasted.getX() && this.y == oCasted.getY() && this.z == oCasted.getZ(); + } } diff --git a/src/dna/metrics/centrality/BetweennessCentrality.java b/src/dna/metrics/centrality/BetweennessCentrality.java index 72e204de..bd959c2d 100644 --- a/src/dna/metrics/centrality/BetweennessCentrality.java +++ b/src/dna/metrics/centrality/BetweennessCentrality.java @@ -46,7 +46,8 @@ public BetweennessCentrality(String name) { public Value[] getValues() { // Value v1 = new Value("median", getMedian()); Value v2 = new Value("avg_bc", bCSum / (double) g.getNodeCount()); - return new Value[] { v2 }; + Value v3 = new Value("sum_of_path", sumShortestPaths); + return new Value[] { v2,v3 }; } @Override diff --git a/src/dna/metrics/degree/DegreeDistribution.java b/src/dna/metrics/degree/DegreeDistribution.java index 9d33bd9b..7901b713 100644 --- a/src/dna/metrics/degree/DegreeDistribution.java +++ b/src/dna/metrics/degree/DegreeDistribution.java @@ -27,7 +27,16 @@ public DegreeDistribution(String name, Parameter... p) { @Override public Value[] getValues() { - return new Value[0]; + Value degree_average = new Value("degree_average", degree.computeAverage()); + Value degree_maxValue = new Value("degree_maxValue", degree.getMax()); + Value degree_minValue = new Value("degree_minValue", degree.getMin()); + Value indegree_average = new Value("indegree_average", inDegree.computeAverage()); + Value indegree_maxValue = new Value("indegree_maxValue", inDegree.getMax()); + Value indegree_minValue = new Value("indegree_minValue", inDegree.getMin()); + Value outdegree_average = new Value("outdegree_average", outDegree.computeAverage()); + Value outdegree_maxValue = new Value("outdegree_maxValue", outDegree.getMax()); + Value outdegree_minValue = new Value("outdegree_minValue",outDegree.getMin()); + return new Value[]{degree_average,degree_maxValue,degree_minValue,indegree_average,indegree_maxValue,indegree_minValue,outdegree_average,outdegree_maxValue,outdegree_minValue}; } @Override diff --git a/src/dna/metrics/paths/AllPairsShortestPathsDouble.java b/src/dna/metrics/paths/AllPairsShortestPathsDouble.java new file mode 100644 index 00000000..d09c87b4 --- /dev/null +++ b/src/dna/metrics/paths/AllPairsShortestPathsDouble.java @@ -0,0 +1,69 @@ +package dna.metrics.paths; + +import dna.metrics.IMetric; +import dna.metrics.Metric; +import dna.series.data.BinnedDistributionDouble; +import dna.series.data.Distribution; +import dna.series.data.DistributionLong; +import dna.series.data.NodeNodeValueList; +import dna.series.data.NodeValueList; +import dna.series.data.Value; +import dna.util.ArrayUtils; + +/** + * works nearly similar to AllPairsShortestPathsDouble except it + * uses BinnedDistributionDouble instead of DistributionLong + * + * maybe this can be combined with the parent class distribution + * @author barracuda317 (Maurice Wendt) + * @date 25.10.2014 + */ +public abstract class AllPairsShortestPathsDouble extends Metric { + + // TODO INIT!!! + // this.apsp = new DistributionLong("APSP"); + + protected BinnedDistributionDouble apsp; + + public AllPairsShortestPathsDouble(String name) { + super(name); + } + + @Override + public Value[] getValues() { + this.apsp.truncate(); + + Value v1 = new Value("existingPaths", this.apsp.getDenominator()); + Value v2 = new Value("possiblePaths", this.g.getNodeCount() + * (this.g.getNodeCount() - 1)); + Value v3 = new Value("characteristicPathLength", + this.apsp.computeAverage()); + Value v4 = new Value("diameter", this.apsp.getMax()); + + return new Value[] { v1, v2, v3, v4 }; + } + + @Override + public Distribution[] getDistributions() { + return new Distribution[] { this.apsp }; + } + + @Override + public NodeValueList[] getNodeValueLists() { + return new NodeValueList[] {}; + } + + @Override + public NodeNodeValueList[] getNodeNodeValueLists() { + return new NodeNodeValueList[] {}; + } + + @Override + public boolean equals(IMetric m) { + return this.isComparableTo(m) + && ArrayUtils.equals(this.apsp.getDoubleValues(), + ((AllPairsShortestPathsDouble) m).apsp.getDoubleValues(), + "APSP"); + } + +} diff --git a/src/dna/metrics/paths/DoubleWeightedAllPairsShortestPaths.java b/src/dna/metrics/paths/DoubleWeightedAllPairsShortestPaths.java new file mode 100644 index 00000000..79a2fd3f --- /dev/null +++ b/src/dna/metrics/paths/DoubleWeightedAllPairsShortestPaths.java @@ -0,0 +1,43 @@ +package dna.metrics.paths; + +import dna.graph.Graph; +import dna.graph.weights.Double3dWeight; +import dna.graph.weights.IWeightedEdge; +import dna.graph.weights.IWeightedNode; +import dna.graph.weights.IntWeight; +import dna.metrics.IMetric; +import dna.updates.batch.Batch; +/** + * + * Adaption of IntWeightedAllPairsShortestPath + * + * using NodeWeights and DoubleValues + * + * @author barracuda317 (Maurice Wendt) + * @date 25.10.2014 + */ +public abstract class DoubleWeightedAllPairsShortestPaths extends + AllPairsShortestPathsDouble { + + public DoubleWeightedAllPairsShortestPaths(String name) { + super(name); + } + + @Override + public boolean isComparableTo(IMetric m) { + return m != null && m instanceof DoubleWeightedAllPairsShortestPaths; + } + + @Override + public boolean isApplicable(Graph g) { + return g.getGraphDatastructures().isNodeType(IWeightedNode.class) + && g.getGraphDatastructures().isNodeWeightType(Double3dWeight.class); //TODO fragt den Z-Wert von Double3dWeight ab + } + + @Override + public boolean isApplicable(Batch b) { + return b.getGraphDatastructures().isNodeType(IWeightedNode.class) + && b.getGraphDatastructures().isNodeWeightType(Double3dWeight.class); //TODO fragt den Z-Wert von Double3dWeight ab + } + +} diff --git a/src/dna/metrics/paths/DoubleWeightedAllPairsShortestPathsR.java b/src/dna/metrics/paths/DoubleWeightedAllPairsShortestPathsR.java new file mode 100644 index 00000000..7eb5b2ba --- /dev/null +++ b/src/dna/metrics/paths/DoubleWeightedAllPairsShortestPathsR.java @@ -0,0 +1,130 @@ +package dna.metrics.paths; + +import java.util.Comparator; +import java.util.PriorityQueue; + +import dna.graph.IElement; +import dna.graph.edges.DirectedEdge; +import dna.graph.edges.UndirectedEdge; +import dna.graph.nodes.DirectedNode; +import dna.graph.nodes.Node; +import dna.graph.nodes.UndirectedNode; +import dna.graph.weights.Double3dWeight; +import dna.graph.weights.IWeighted; +import dna.graph.weights.IntWeight; +import dna.metrics.algorithms.IRecomputation; +import dna.series.data.BinnedDistributionDouble; +import dna.series.data.DistributionLong; +/** + * + * Adaption of IntWeightedAllPairsShortestPathR + * + * using NodeWeights and DoubleValues + * + * @author barracuda317 (Maurice Wendt) + * @date 25.10.2014 + */ +public class DoubleWeightedAllPairsShortestPathsR extends + DoubleWeightedAllPairsShortestPaths implements IRecomputation { + + double binsize; + + public DoubleWeightedAllPairsShortestPathsR(double binsize) { + super("DoubleWeightedAllPairsShortestPathsR"); + this.binsize=binsize; + } + + @Override + public boolean recompute() { + this.apsp = new BinnedDistributionDouble("APSP", binsize); + for (IElement source_ : this.g.getNodes()) { + Node source = (Node) source_; + + double[] dist = this.getInitialDist(this.g.getMaxNodeIndex() + 1); + Node[] previous = new Node[this.g.getMaxNodeIndex() + 1]; + boolean[] visited = new boolean[g.getMaxNodeIndex() + 1]; + PriorityQueue Q = new PriorityQueue(g.getNodeCount(), + new DistComparator(dist)); + + dist[source.getIndex()] = 0; + Q.add(source); + + while (!Q.isEmpty()) { + Node current = (Node) Q.remove(); + + if (visited[current.getIndex()]) { + continue; + } + visited[current.getIndex()] = true; + + if (current instanceof DirectedNode) { + for (IElement e : ((DirectedNode) current) + .getOutgoingEdges()) { + Node n = ((DirectedEdge) e).getDst(); + Double3dWeight w = (Double3dWeight) ((IWeighted) n).getWeight(); + this.process(source, current, n, w.getZ(), + dist, previous, visited, Q); + } + } else if (current instanceof UndirectedNode) { + for (IElement e : ((UndirectedNode) current).getEdges()) { + Node n = ((UndirectedEdge) e).getDifferingNode(current); + Double3dWeight w = (Double3dWeight) ((IWeighted) e).getWeight(); + this.process(source, current, n, w.getZ(), + dist, previous, visited, Q); + } + } + } + + for (double d : dist) { + if (d > 0 && d != Integer.MAX_VALUE) { + this.apsp.incr(d); + } + } + } + + return true; + } + + protected class DistComparator implements Comparator { + + private double[] dist; + + public DistComparator(double[] dist) { + this.dist = dist; + } + + @Override + public int compare(Node o1, Node o2) { + double diff = this.dist[o1.getIndex()] - this.dist[o2.getIndex()]; + if(diff > 0) + return 1; + else if (diff < 0) + return -1; + else + return 0; + } + } + + protected void process(Node source, Node current, Node n, double weight, + double[] dist, Node[] previous, boolean[] visited, + PriorityQueue Q) { + if (n.getIndex() == source.getIndex()) { + return; + } + double newDist = dist[current.getIndex()] + weight; + if (previous[n.getIndex()] == null || newDist < dist[n.getIndex()]) { + dist[n.getIndex()] = newDist; + previous[n.getIndex()] = current; + Q.add(n); + } + } + + protected double[] getInitialDist(int size) { + double[] dist = new double[size]; + for (int i = 0; i < dist.length; i++) { + dist[i] = Integer.MAX_VALUE; + } + return dist; + } + +} diff --git a/src/dna/metrics/weights/NodeWeights.java b/src/dna/metrics/weights/NodeWeights.java index 8329d708..bca0b896 100644 --- a/src/dna/metrics/weights/NodeWeights.java +++ b/src/dna/metrics/weights/NodeWeights.java @@ -3,6 +3,7 @@ import dna.graph.Graph; import dna.graph.IElement; import dna.graph.nodes.INode; +import dna.graph.weights.Double3dWeight; import dna.graph.weights.DoubleWeight; import dna.graph.weights.IWeightedNode; import dna.graph.weights.IntWeight; @@ -34,14 +35,14 @@ public boolean isComparableTo(IMetric m) { public boolean isApplicable(Graph g) { return g.getGraphDatastructures().isNodeType(IWeightedNode.class) && g.getGraphDatastructures().isNodeWeightType(IntWeight.class, - DoubleWeight.class); + DoubleWeight.class,Double3dWeight.class); } @Override public boolean isApplicable(Batch b) { return b.getGraphDatastructures().isNodeType(IWeightedNode.class) && b.getGraphDatastructures().isNodeWeightType(IntWeight.class, - DoubleWeight.class); + DoubleWeight.class,Double3dWeight.class); } protected double getWeight(INode n) { diff --git a/src/dna/metrics/weights/Weights.java b/src/dna/metrics/weights/Weights.java index b824a1f9..f442af59 100644 --- a/src/dna/metrics/weights/Weights.java +++ b/src/dna/metrics/weights/Weights.java @@ -1,5 +1,6 @@ package dna.metrics.weights; +import dna.graph.weights.Double3dWeight; import dna.graph.weights.DoubleWeight; import dna.graph.weights.IntWeight; import dna.graph.weights.Weight; @@ -62,6 +63,8 @@ protected double getWeight(Weight w) { return (double) ((IntWeight) w).getWeight(); } else if (w instanceof DoubleWeight) { return ((DoubleWeight) w).getWeight(); + } else if (w instanceof Double3dWeight) { + return ((Double3dWeight) w).getZ(); } else { return Double.NaN; } diff --git a/src/dna/series/data/DistributionDouble.java b/src/dna/series/data/DistributionDouble.java index d866a3f2..5e9b5846 100644 --- a/src/dna/series/data/DistributionDouble.java +++ b/src/dna/series/data/DistributionDouble.java @@ -21,6 +21,7 @@ public class DistributionDouble extends Distribution { // member variables private double[] values; + private long denominator; // values for comparison private double comparedSum; @@ -105,6 +106,7 @@ public double getComparedAvg() { */ public void incr(int index) { this.values = ArrayUtils.incr(this.values, index); + this.denominator++; } /** @@ -115,6 +117,7 @@ public void incr(int index) { */ public void decr(int index) { this.values = ArrayUtils.decr(this.values, index); + this.denominator--; } /** @@ -213,5 +216,17 @@ public static DistributionDouble read(String dir, String filename, public static boolean equals(DistributionDouble d1, DistributionDouble d2) { return ArrayUtils.equals(d1.getDoubleValues(), d2.getDoubleValues()); } + + public double getDenominator() { + return denominator; + } + + public double computeAverage() { + double avg = 0; + for (int i = 0; i < this.values.length; i++) { + avg += i * this.values[i]; + } + return avg / this.denominator; + } } diff --git a/src/dna/updates/generators/traffic/Days.java b/src/dna/updates/generators/traffic/Days.java new file mode 100644 index 00000000..193ba2f5 --- /dev/null +++ b/src/dna/updates/generators/traffic/Days.java @@ -0,0 +1,9 @@ +package dna.updates.generators.traffic; + +public enum Days { + MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY; + + static Days getDay(int i){ + return values()[i-1]; + } +} \ No newline at end of file diff --git a/src/dna/updates/generators/traffic/Helpers.java b/src/dna/updates/generators/traffic/Helpers.java new file mode 100644 index 00000000..c1ce1b57 --- /dev/null +++ b/src/dna/updates/generators/traffic/Helpers.java @@ -0,0 +1,43 @@ +package dna.updates.generators.traffic; + + +import org.joda.time.DateTime; +import org.joda.time.DateTimeConstants; +import org.joda.time.JodaTimePermission; + +public class Helpers { + public static boolean isWorkDay(Days d) { + return !(d == Days.SATURDAY || d==Days.SUNDAY); + } + + public static DateTime calculateNextWorkDay(DateTime start,long l){ + return calculateNextDay(start, l, new boolean[]{true,true,true,true,true,false,false},null); + } + + public static DateTime calculateNextDay(DateTime end, long l, boolean[] daySelection,DateTime ignoreTo){ + DateTime current = end; + int count = 0; + while(count <= l) { + current = current.minusDays(1); + if(daySelection[current.getDayOfWeek()-1] && current.isBefore(ignoreTo)){ + count++; + } + } + return current; + } + /** + * Wandelt die Beobachtungswochen in die Beobachtungstage um (=#Batches) + * @param weeks, Wochen die beobachtet werden sollen + * @param daySelection , Tage die in einer Woche beobachtet werden sollen + * @return + */ + public static int weekToDay(int weeks, boolean[] daySelection){ + int i =0; + for (int j = 0; j < daySelection.length; j++) { + if(daySelection[j]) + i++; + } + return i*weeks; + } + +} diff --git a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java new file mode 100644 index 00000000..bc9aeb01 --- /dev/null +++ b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java @@ -0,0 +1,151 @@ +package dna.updates.generators.traffic; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Random; +import java.util.Set; + +import org.joda.time.DateTime; + +import dna.graph.Graph; +import dna.graph.IElement; +import dna.graph.datastructures.INodeListDatastructure; +import dna.graph.edges.Edge; +import dna.graph.generators.traffic.CrossroadWeight; +import dna.graph.generators.traffic.DB; +import dna.graph.generators.traffic.EdgeContainer; +import dna.graph.generators.traffic.TrafficUpdate; +import dna.graph.nodes.DirectedNode; +import dna.graph.nodes.DirectedWeightedNode; +import dna.graph.nodes.Node; +import dna.graph.weights.Double2dWeight; +import dna.graph.weights.Double3dWeight; +import dna.graph.weights.Int2dWeight; +import dna.graph.weights.IntWeight; +import dna.io.GraphWriter; +import dna.updates.batch.Batch; +import dna.updates.generators.BatchGenerator; +import dna.updates.update.EdgeAddition; +import dna.updates.update.EdgeRemoval; +import dna.updates.update.NodeWeight; +import dna.updates.update.Update; +import dna.util.Rand; +import dna.util.parameters.IntParameter; +import dna.util.parameters.ObjectParameter; +import dna.util.parameters.Parameter; + +public class TrafficCrossroadBatchGenerator extends BatchGenerator{ + DB db; + DateTime initDateTime; + int stepSize; + int run=0; + private int modus; + DateTime holidayStart; + boolean[] daySelection; + HashMap disabledEdges = new HashMap<>(); + private TrafficUpdate trafficUpdate; + + public TrafficCrossroadBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, int modus, DateTime holidayStart, boolean [] daySelection,TrafficUpdate trafficUpdate) { + super(name, new IntParameter("NA", 0), new IntParameter("NR", + 0), new IntParameter("NW", 0), + new ObjectParameter("NWS", 0), new IntParameter("EA", 0), + new IntParameter("ER", 0)); + this.db = db; + this.initDateTime = initDateTime; + this.stepSize = stepSize; + this.modus = modus; + this.holidayStart = holidayStart; + this.daySelection = daySelection; + this.trafficUpdate = trafficUpdate; + } + + @Override + public Batch generate(Graph g) { + GraphWriter.write(g, "CrossroadGraph/", "batch"+run+++".txt"); + Batch b = new Batch(g.getGraphDatastructures(), g.getTimestamp(), + g.getTimestamp() + 1, 0, 0, 0, 0, + 0, 0); + if(g.getTimestamp()==0){ + disabledEdges = db.getDisabledEdges(); + } + HashMap newDisabled = new HashMap<>(); + Iterable nodes = g.getNodes(); + CrossroadWeight crossroadWeight = null; + DateTime time = null; + if(modus == 1 || modus == 2){ + time = initDateTime; + time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart); + } + int newTimeStamp = (int) g.getTimestamp() + 1; + System.out.println("Neuer Batch am : \t" +time); + for (IElement currentNode : nodes) { + DirectedWeightedNode n = (DirectedWeightedNode) currentNode; + double[] update = null; + + // Gewichts-Update + + if(modus==0){ // Vergleich in Schritten der Größe Stepsize + crossroadWeight =db.getCrossroadWeight(n.getIndex(), initDateTime.plusMinutes((int) (g.getTimestamp()*stepSize)),initDateTime.plusMinutes((int) (g.getTimestamp()+stepSize)*stepSize),newTimeStamp); + } + else if (modus == 1 ){ // Vergleich für Zeiträume der Länge timeRange an Tagen aus Dayselection + crossroadWeight = db.getCrossroadWeight(n.getIndex(),time.minusMinutes(db.timeRange),time.plusMinutes(db.timeRange),newTimeStamp); + } + else if (modus == 2){ // Statische Verkehrsanalyse + crossroadWeight = db.getCrossroadWeightStaticBatch(n.getIndex(),trafficUpdate); + } + update = crossroadWeight.getWeight(); + Double3dWeight oldWeight = (Double3dWeight) n.getWeight(); + Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); + if(!oldWeight.equals(newWeight)) + b.add(new NodeWeight((dna.graph.weights.IWeightedNode) currentNode,newWeight)); + + //Edge-Removal + Edge disabledEdge = null; + for (Integer wayId : crossroadWeight.getOverladedEdges().keySet()) { + List edgesToRemove = db.getFromWays(n.getIndex(), wayId); + if(edgesToRemove != null){ + for (int[] edge : edgesToRemove) { + disabledEdge = g.getEdge(g.getNode(edge[0]), n); + EdgeContainer ec = new EdgeContainer(edge[0], n.getIndex()); + if(disabledEdge==null){ + disabledEdge = disabledEdges.remove(ec); + if(disabledEdge==null){ + for (EdgeContainer e : disabledEdges.keySet()) { + System.out.println(e); + } + } + } + else + b.add(new EdgeRemoval(disabledEdge)); + newDisabled.put(ec, disabledEdge); + } + } + } + } + + //Edge-Addition, falls diese wieder frei sind + for (Map.Entry oldDeletedEdge : disabledEdges.entrySet()) { + b.add(new EdgeAddition(oldDeletedEdge.getValue())); + } + disabledEdges=newDisabled; + + return b; + } + + @Override + public void reset() { + // TODO Auto-generated method stub + + } + + @Override + public boolean isFurtherBatchPossible(Graph g) { + // TODO Auto-generated method stub + return true; + } + +} diff --git a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java new file mode 100644 index 00000000..a9e321c8 --- /dev/null +++ b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java @@ -0,0 +1,223 @@ +package dna.updates.generators.traffic; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; + +import org.joda.time.DateTime; + +import dna.graph.Graph; +import dna.graph.IElement; +import dna.graph.datastructures.INodeListDatastructure; +import dna.graph.edges.Edge; +import dna.graph.generators.traffic.DB; +import dna.graph.generators.traffic.EdgeContainer; +import dna.graph.generators.traffic.TrafficUpdate; +import dna.graph.nodes.DirectedNode; +import dna.graph.nodes.DirectedWeightedNode; +import dna.graph.nodes.Node; +import dna.graph.weights.Double3dWeight; +import dna.io.GraphWriter; +import dna.updates.batch.Batch; +import dna.updates.generators.BatchGenerator; +import dna.updates.update.EdgeAddition; +import dna.updates.update.EdgeRemoval; +import dna.updates.update.NodeWeight; +import dna.updates.update.Update; +import dna.util.parameters.IntParameter; +import dna.util.parameters.ObjectParameter; +import dna.util.parameters.Parameter; + +public class TrafficInputWayBatchGenerator extends BatchGenerator{ + DB db; + DateTime initDateTime; + int stepSize; + int step=0; + int modus; + private DateTime holidayStart; + private boolean[] daySelection; + private HashMap> disabledEdges = new HashMap<>(); + private HashMap> newDisabledEdges = new HashMap<>(); + private double treshold; + private TrafficUpdate trafficUpdate; + + + public TrafficInputWayBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, int modus, DateTime holidayStart, boolean [] daySelection, double treshold,TrafficUpdate trafficUpdate) { + super(name, new IntParameter("NA", 0), new IntParameter("NR", + 0), new IntParameter("NW", 10), + new ObjectParameter("NWS", 0), new IntParameter("EA", 0), + new IntParameter("ER", 0)); + this.db = db; + this.initDateTime = initDateTime; + this.stepSize = stepSize; + this.modus = modus; + this.holidayStart = holidayStart; + this.daySelection = daySelection; + this.treshold = treshold; + this.trafficUpdate = trafficUpdate; + } + + @Override + public Batch generate(Graph g) { + Batch b = new Batch(g.getGraphDatastructures(), g.getTimestamp(), + g.getTimestamp() + 1, 0, 0, 0, 0, + 0, 0); + if(g.getTimestamp()==0){ + disabledEdges=db.getDisabledEdgesInputWay(); + } + Set toDisable = new HashSet<>(); + GraphWriter.write(g, "InputWayGraph/", "batch"+step+++".txt"); + Iterable nodes = g.getNodes(); + DateTime time = null; + Edge edge = null; + Integer newKey = null; + if(modus == 1){ + time = initDateTime; + time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart); + System.out.println("Neuer Batch am : \t" +time); + } + newDisabledEdges = new HashMap<>(); + for (IElement currentNode : nodes) { + DirectedWeightedNode n = (DirectedWeightedNode) currentNode; + double[] update =null; + + //WeightUpdate + switch (modus) { + case 0: + update = db.getInputWayWeight(n.getIndex(),initDateTime.plusMinutes((int) (g.getTimestamp()+1)*stepSize),initDateTime.plusMinutes((int) (g.getTimestamp()+2)*stepSize)); + break; + case 1: + update = db.getInputWayWeight(n.getIndex(),time.minusMinutes(db.timeRange),time.plusMinutes(db.timeRange)); + break; + case 2: + update = (trafficUpdate.isAffected(n.getIndex()))? db.getInputWayWeightStaticBatch(n.getIndex(),trafficUpdate) : null; + break; + + default: + System.out.println("Modus nicht definiert"); + break; + } + Double3dWeight oldWeight = (Double3dWeight) n.getWeight(); + if(update!=null){ + Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); + if(!oldWeight.equals(newWeight)) + b.add(new NodeWeight((dna.graph.weights.IWeightedNode) currentNode,new Double3dWeight(update[0],update[1],update[2]))); + } + else{ + update = new double[]{oldWeight.getX(),oldWeight.getY(),oldWeight.getZ()}; + } + EdgeContainer ec = null; + if(update[2] > treshold) { + newKey = n.getIndex(); + int from; + int to; + // Verhindere das Hinzufügen bereits gelöschter Kante + if(disabledEdges.containsKey(newKey)){ + HashMap oldMap = disabledEdges.get(newKey); + for (Entry entry : oldMap.entrySet()) { + EdgeContainer key = entry.getKey(); + Edge value = entry.getValue(); + if(key.getFrom()==newKey){ + removeEdge(key.getTo(),key,value); + addEdge(key.getTo(), key, value); + } + else{ + removeEdge(key.getFrom(),key,value); + addEdge(key.getFrom(),key,value); + } + } + disabledEdges.remove(newKey); + } + + // Lösche neue Kanten + for (IElement elem : n.getEdges()) { + edge = (Edge) elem; + from = edge.getN1Index(); + to = edge.getN2Index(); + ec = new EdgeContainer(from, to); + removeEdge(from,ec,edge); + removeEdge(to, ec, edge); + addEdge(from,ec,edge); + addEdge(to, ec, edge); + toDisable.add(edge); + } + } + + + + /* + //EdgeRemoval + if(update[2] > treshold){ //Knoten ist überlastet + key = n.getIndex(); + if(!disabledEdges.containsKey(key)){ + List edges= new ArrayList<>(); + for (IElement e : n.getEdges()) { + if(e instanceof Edge){ + edge = (Edge) e; + b.add(new EdgeRemoval(edge)); + } + } + newDisabledEdges.put(key, edges); + } + else{ + newDisabledEdges.put(key, disabledEdges.get(key)); + } + disabledEdges.remove(key); + }*/ + } + //TODO: War in der Schleife, prüfen + for (Edge e : toDisable) { + b.add(new EdgeRemoval(e)); + } + + for (Entry> freeEdges : disabledEdges.entrySet()) { + int node = freeEdges.getKey(); + for (Entry elem : freeEdges.getValue().entrySet()) { + if(node == elem.getKey().getFrom()) + b.add(new EdgeAddition(elem.getValue())); + } + } + + disabledEdges=newDisabledEdges; + + return b; + } + + @Override + public void reset() { + // TODO Auto-generated method stub + } + + @Override + public boolean isFurtherBatchPossible(Graph g) { + // TODO Auto-generated method stub + return true; + } + + public void removeEdge(int index, EdgeContainer ec, Edge e){ + if(disabledEdges.containsKey(index)){ + HashMap oldMap = disabledEdges.get(index); + oldMap.remove(ec); + if(oldMap.isEmpty()){ + disabledEdges.remove(index); + } + } + } + public void addEdge(int index, EdgeContainer ec, Edge e){ + if(newDisabledEdges.containsKey(index)){ + HashMap oldMap = newDisabledEdges.get(index); + oldMap.put(ec, e); + } + else { + HashMap newMap = new HashMap<>(); + newMap.put(ec, e); + newDisabledEdges.put(index,newMap); + } + } + + +} diff --git a/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java new file mode 100644 index 00000000..23fc7e14 --- /dev/null +++ b/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java @@ -0,0 +1,253 @@ +package dna.updates.generators.traffic; + +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Random; +import java.util.Set; +import java.util.Map.Entry; + +import org.joda.time.DateTime; + +import dna.graph.Graph; +import dna.graph.IElement; +import dna.graph.datastructures.INodeListDatastructure; +import dna.graph.edges.Edge; +import dna.graph.generators.traffic.DB; +import dna.graph.generators.traffic.EdgeContainer; +import dna.graph.generators.traffic.TrafficUpdate; +import dna.graph.nodes.DirectedNode; +import dna.graph.nodes.DirectedWeightedNode; +import dna.graph.nodes.Node; +import dna.graph.weights.Double3dWeight; +import dna.graph.weights.IWeightedNode; +import dna.graph.weights.Int2dWeight; +import dna.graph.weights.IntWeight; +import dna.io.GraphWriter; +import dna.updates.batch.Batch; +import dna.updates.generators.BatchGenerator; +import dna.updates.update.EdgeAddition; +import dna.updates.update.EdgeRemoval; +import dna.updates.update.NodeWeight; +import dna.updates.update.Update; +import dna.util.Rand; +import dna.util.parameters.IntParameter; +import dna.util.parameters.ObjectParameter; +import dna.util.parameters.Parameter; + +public class TrafficSensorBatchGenerator extends BatchGenerator{ + DB db; + DateTime initDateTime; + int stepSize; + int step=0; + int modus; + private DateTime holidayStart; + private boolean[] daySelection; + private double treshold; + private int timeRange; + + private HashMap> disabledEdges; + private HashMap> newDisabledEdges; + private TrafficUpdate trafficUpdate; + + public TrafficSensorBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, int modus, DateTime holidayStart, boolean [] daySelection, double treshold,int timeRange,TrafficUpdate trafficUpdate) { + super(name, new IntParameter("NA", 0), new IntParameter("NR", + 0), new IntParameter("NW", 0), + new ObjectParameter("NWS", 0), new IntParameter("EA", 0), + new IntParameter("ER", 0)); + this.db = db; + this.initDateTime = initDateTime; + this.stepSize = stepSize; + this.modus=modus; + this.holidayStart=holidayStart; + this.daySelection = daySelection; + this.treshold = treshold; + this.timeRange = timeRange; + this.trafficUpdate = trafficUpdate; + disabledEdges=new HashMap<>(); + newDisabledEdges = new HashMap<>(); + } + + @Override + public Batch generate(Graph g) { + Batch b = new Batch(g.getGraphDatastructures(), g.getTimestamp(), + g.getTimestamp() + 1, 0, 0, 0, 0, + 0, 0); + if(g.getTimestamp()==0){ + disabledEdges = db.getDisabledEdgesInputWay(); + } + GraphWriter.write(g, "SensorGraph/", "batch"+step+++".txt"); + Integer newKey = null; + int newTimestamp = (int)g.getTimestamp() + 1; + + DateTime time = initDateTime; + time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart); + DateTime fromTime = null; + DateTime toTime = null; + + Set toDisable = new HashSet<>(); + Edge edge = null; + + if(modus == 0){ + fromTime = initDateTime.plusMinutes((int) (g.getTimestamp()+1)*stepSize); + toTime = initDateTime.plusMinutes((int) (g.getTimestamp()+2)*stepSize); + } + else if(modus == 1){ + + time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart); + fromTime = time.minusMinutes(db.timeRange); + toTime = time.plusMinutes(db.timeRange); + } + switch (modus) { + case 0: + fromTime = initDateTime.plusMinutes((int) (g.getTimestamp()+1)*stepSize); + toTime = initDateTime.plusMinutes((int) (g.getTimestamp()+2)*stepSize); + break; + case 1: + time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart); + fromTime = time.minusMinutes(db.timeRange); + toTime = time.plusMinutes(db.timeRange); + break; + + default: + break; + } + // Vorabberechnung aller Gewichte der Realen Sensoren + if(modus == 0 || modus == 1){ + db.getSensorWeights(fromTime,toTime, newTimestamp); + } + + double[] update = null; + for (IElement currentNode : g.getNodes()) { + + // Get Node + DirectedWeightedNode currentWeighted = null; + if(currentNode instanceof DirectedWeightedNode) + currentWeighted= (DirectedWeightedNode) currentNode; + else + continue; + + // Get Weight + switch (modus) { + case 0: + update = db.getSensorModelWeight(currentWeighted.getIndex(),fromTime,toTime,newTimestamp); + break; + case 1: + update = db.getSensorModelWeight(currentWeighted.getIndex(),fromTime,toTime,newTimestamp); + break; + case 2: + update = trafficUpdate.isAffected(currentWeighted.getIndex()) ? db.getSensorModelWeightStaticBatch(currentWeighted.getIndex(),trafficUpdate) : null; + break; + default: + System.out.println("error - Modus nicht definiert"); + break; + } + Double3dWeight oldWeight = (Double3dWeight) currentWeighted.getWeight(); + if(update!=null){ + Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); + + // Set Weight + if(!oldWeight.equals(newWeight)) + b.add(new NodeWeight((dna.graph.weights.IWeightedNode) currentNode,newWeight)); + } + else{ + update = new double[]{oldWeight.getX(),oldWeight.getY(),oldWeight.getZ()}; + } + + + // Edge Removal + EdgeContainer ec = null; + if(update[2] > treshold) { + newKey = currentWeighted.getIndex(); + int from; + int to; + // Verhindere das Hinzufügen bereits gelöschter Kante + if(disabledEdges.containsKey(newKey)){ + HashMap oldMap = disabledEdges.get(newKey); + for (Entry entry : oldMap.entrySet()) { + EdgeContainer key = entry.getKey(); + Edge value = entry.getValue(); + removeEdge(key.getTo(),key,value); + addEdge(key.getTo(), key, value); + removeEdge(key.getFrom(),key,value); + addEdge(key.getFrom(),key,value); + } + disabledEdges.remove(newKey); + } + + // Lösche neue Kanten + for (IElement elem : currentWeighted.getEdges()) { + edge = (Edge) elem; + from = edge.getN1Index(); + to = edge.getN2Index(); + ec = new EdgeContainer(from, to); + removeEdge(from,ec,edge); + removeEdge(to, ec, edge); + addEdge(from,ec,edge); + addEdge(to, ec, edge); + toDisable.add(edge); + } + } + } + + for (Edge e : toDisable) { + b.add(new EdgeRemoval(e)); + } + + for (Entry> freeEdges : disabledEdges.entrySet()) { + int node = freeEdges.getKey(); + for (Entry elem : freeEdges.getValue().entrySet()) { + if(node == elem.getKey().getFrom()) + b.add(new EdgeAddition(elem.getValue())); + } + } + disabledEdges=newDisabledEdges; + /* + int node = 0; + //NodeWeight + db.getSensorWeights(from, to, newTimestamp); + for (IElement currentNode : g.getNodes()) { + Node n = (DirectedWeightedNode) currentNode; + double[] update = db.getSensorModelWeight(n.getIndex(), from, to, newTimestamp); + b.add(new NodeWeight((IWeightedNode) currentNode,new Double3dWeight(update[0],update[1],update[2]))); + System.out.println("Updated: "+node++); + } + */ + return b; + } + + @Override + public void reset() { + // TODO Auto-generated method stub + + } + + @Override + public boolean isFurtherBatchPossible(Graph g) { + // TODO Auto-generated method stub + return true; + } + + public void removeEdge(int index, EdgeContainer ec, Edge e){ + if(disabledEdges.containsKey(index)){ + HashMap oldMap = disabledEdges.get(index); + oldMap.remove(ec); + if(oldMap.isEmpty()){ + disabledEdges.remove(index); + } + } + } + public void addEdge(int index, EdgeContainer ec, Edge e){ + if(newDisabledEdges.containsKey(index)){ + HashMap oldMap = newDisabledEdges.get(index); + oldMap.put(ec, e); + } + else { + HashMap newMap = new HashMap<>(); + newMap.put(ec, e); + newDisabledEdges.put(index,newMap); + } + } + +} From decc3d2095ce08c2f14d329a0018a0de929f6e25 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Fri, 7 Nov 2014 09:45:24 +0100 Subject: [PATCH 02/24] =?UTF-8?q?Grad=207=20entfernt,=20Components-Titel?= =?UTF-8?q?=20ge=C3=A4ndert,=20Modus=203=20(Vergleich=20der=20Werktage)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .classpath | 2 +- .../generators/traffic/CrossroadWeight.java | 52 ++++++++++++++++++- src/dna/graph/generators/traffic/DB.java | 9 ++-- .../TrafficCrossroadGraphGenerator.java | 2 +- .../connectivity/StrongConnectivity.java | 2 +- .../traffic/CrossroadWeightList.java | 51 ++++++++++++++++++ .../TrafficCrossroadBatchGenerator.java | 33 +++++++++++- 7 files changed, 141 insertions(+), 10 deletions(-) create mode 100644 src/dna/updates/generators/traffic/CrossroadWeightList.java diff --git a/.classpath b/.classpath index 7ddb00d1..fb2341ef 100644 --- a/.classpath +++ b/.classpath @@ -11,6 +11,6 @@ - + diff --git a/src/dna/graph/generators/traffic/CrossroadWeight.java b/src/dna/graph/generators/traffic/CrossroadWeight.java index d8047bc0..e05d0abc 100644 --- a/src/dna/graph/generators/traffic/CrossroadWeight.java +++ b/src/dna/graph/generators/traffic/CrossroadWeight.java @@ -1,6 +1,7 @@ package dna.graph.generators.traffic; import java.util.HashMap; +import java.util.List; import java.util.Map; public class CrossroadWeight { @@ -22,6 +23,10 @@ public CrossroadWeight(int crossroadID,String crossroadName, double treshold){ this.timestamp=0; } + public double getThreshold(){ + return threshold; + } + public void addWeightWay(int osmWayID, double[] weights) { inputWayWeights.put(osmWayID, weights); } @@ -30,9 +35,14 @@ public void setMaxWeightWay(int osmWayID, double[] maxWeights) { inputWayMaxWeights.put(osmWayID, maxWeights); } + public double[] getMaxWeightWay(int osmWayID) { + return inputWayMaxWeights.get(osmWayID); + } + public void setTimestamp(int timestamp){ this.timestamp = timestamp; } + public int getTimestamp(){ return timestamp; } @@ -41,6 +51,9 @@ public void setMaxWeight(double[] maxWeights) { this.maxCount=maxWeights[0]; this.maxLoad=maxWeights[1]; } + public double[] getMaxWeight() { + return new double[] {maxCount,maxLoad}; + } public void resetInputWayWeight(double count, double load){ double numOfInputWays = inputWayWeights.keySet().size(); @@ -65,7 +78,10 @@ public double[] getWeight(){ sum[1]+=entry[1]; } int numOfinputWays = inputWayWeights.size(); - sum[2]=(sum[0]/maxCount)*100; + if(maxCount>0) + sum[2]=(sum[0]/maxCount)*100; + else + sum[2]=0; return sum; } @@ -78,4 +94,38 @@ public HashMap getOverladedEdges() { } return result; } + + public HashMap getWayWeights(){ + return inputWayWeights; + + } + + public boolean addWeights(HashMap wayWeights){ + for (Integer keys : wayWeights.keySet()) { + if(!inputWayWeights.containsKey(keys)) + return false; + } + for (Map.Entry entry : wayWeights.entrySet()) { + double[] value = inputWayWeights.get(entry.getKey()); + double[] newValue = entry.getValue(); + for (int i = 0; i < value.length; i++) { + value[i]+=newValue[i]; + } + inputWayWeights.put(entry.getKey(), value); + } + return true; + } + + public void divWays(int divisor){ + if(divisor>0){ + for (Map.Entry entry : inputWayWeights.entrySet()) { + double[] value = entry.getValue(); + for (int i = 0; i < value.length; i++) { + value[i] = value[i]/divisor; + } + inputWayWeights.put(entry.getKey(), value); + } + } + } + } diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index 04ec09ac..d8bcceec 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -282,7 +282,7 @@ public void writeMaximalWeightsCrossroadsRandom(int crossroadID,double random){ } public double[] writeMaximalWeightsInputWays(int inputwayID) { - System.out.println("Prüfe ID " +inputwayID); + System.out.println("Prüfe ID MaximalWeightsInputWays " +inputwayID); int count = 0; ResultSet rs; int[] inputData = inputWays.get(inputwayID); @@ -820,10 +820,10 @@ public List getInputWaysConnectionForDNA() { try { Statement stmt = con.createStatement(); String statementString; - statementString = "SELECT fromID, fromWay,toID, toWay FROM mw_InputWayConnection"; + statementString = "SELECT fromID , toID FROM mw_InputWayConnection"; ResultSet rs = stmt.executeQuery(statementString); while(rs.next() ) { - edges.add(new EdgeContainer(rs.getInt(1),rs.getInt(3))); + edges.add(new EdgeContainer(rs.getInt("fromID"),rs.getInt("toID"))); } } catch (SQLException e) { e.printStackTrace(); @@ -1160,7 +1160,8 @@ public double[] getInputWayWeight(int inputWayID, DateTime from, DateTime to) { int[] inputData = inputWays.get(inputWayID); int crossroadID = inputData[1]; Statement stmt = con.createStatement(); - statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID as INPUTWAY_ID, IWG.wayID as OSMWAY_ID, IWG.crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME, sensorID as SENSOR_ID, sensorName as SENSOR_NAME FROM (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID ="+inputWayID+") IWG LEFT JOIN mw_SensorWays SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ="+crossroadID+") S2 ON S1.SENSOR_ID = S2.ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; + statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID as INPUTWAY_ID, IWG.wayID as OSMWAY_ID, IWG.crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME, sensorID as SENSOR_ID, sensorName as SENSOR_NAME,IWG.direction as DIRECTION FROM (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID ="+inputWayID+") IWG LEFT JOIN mw_SensorWays SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID AND IWG.direction = SW.direction) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ="+crossroadID+") S2 ON S1.SENSOR_ID = S2.ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; + System.out.println(statementString); ResultSet rs = stmt.executeQuery(statementString); if(rs.first()){ count=rs.getDouble(1); diff --git a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java index 827c4d64..7547f423 100644 --- a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java @@ -79,7 +79,7 @@ public Graph generate() { case 0: crossroadWeight = db.getCrossroadWeight(currentWeighted.getIndex(),initDateTime,initDateTime.plusMinutes(stepsize),0); break; - case 1: + case 1:case 3: crossroadWeight = db.getCrossroadWeight(currentWeighted.getIndex(),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange),0); break; case 2: diff --git a/src/dna/metrics/connectivity/StrongConnectivity.java b/src/dna/metrics/connectivity/StrongConnectivity.java index b1b636de..0b446d6e 100644 --- a/src/dna/metrics/connectivity/StrongConnectivity.java +++ b/src/dna/metrics/connectivity/StrongConnectivity.java @@ -121,7 +121,7 @@ protected int lookup(DirectedNode n) { @Override public Value[] getValues() { Value v1 = new Value("NumberofComponents", countComponents()); - Value v2 = new Value("average size", getaverageSize()); + Value v2 = new Value("averagesize", getaverageSize()); return new Value[] { v1, v2 }; } diff --git a/src/dna/updates/generators/traffic/CrossroadWeightList.java b/src/dna/updates/generators/traffic/CrossroadWeightList.java new file mode 100644 index 00000000..7b797296 --- /dev/null +++ b/src/dna/updates/generators/traffic/CrossroadWeightList.java @@ -0,0 +1,51 @@ +package dna.updates.generators.traffic; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +import dna.graph.generators.traffic.CrossroadWeight; + +public class CrossroadWeightList { + int crossroadID; + String crossroadName; + double threshold; + List objects; + List weights; + CrossroadWeight sum; + + public CrossroadWeightList(int index, String crossroadName, double threshold){ + this.crossroadID=index; + this.crossroadName=crossroadName; + this.threshold = threshold; + this.objects = new ArrayList<>(); + this.weights = new ArrayList<>(); + } + + public boolean add(CrossroadWeight crw){ + if(crw.crossroadID != crossroadID || !crw.crossroadName.equals(crossroadName) ) + return false; + else{ + if(sum==null){ + sum = new CrossroadWeight(crossroadID, crossroadName, threshold); + for (Map.Entry entry : crw.getWayWeights().entrySet()) { + sum.addWeightWay(entry.getKey(), entry.getValue()); + sum.setMaxWeightWay(entry.getKey(), crw.getMaxWeightWay(entry.getKey())); + } + sum.setMaxWeight(crw.getMaxWeight()); + } + else{ + sum.addWeights(crw.inputWayWeights); + } + objects.add(crw); + weights.add(crw.getWeight()[2]); + return true; + } + } + + public CrossroadWeight getAverage(){ + sum.divWays(objects.size()); + return sum; + } +} diff --git a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java index bc9aeb01..24cc7d5b 100644 --- a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java @@ -43,13 +43,15 @@ public class TrafficCrossroadBatchGenerator extends BatchGenerator{ DateTime initDateTime; int stepSize; int run=0; + int observationDays; private int modus; DateTime holidayStart; boolean[] daySelection; HashMap disabledEdges = new HashMap<>(); private TrafficUpdate trafficUpdate; + HashMap nodeHistory; - public TrafficCrossroadBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, int modus, DateTime holidayStart, boolean [] daySelection,TrafficUpdate trafficUpdate) { + public TrafficCrossroadBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, int modus, DateTime holidayStart, boolean [] daySelection,TrafficUpdate trafficUpdate, int observationDays) { super(name, new IntParameter("NA", 0), new IntParameter("NR", 0), new IntParameter("NW", 0), new ObjectParameter("NWS", 0), new IntParameter("EA", 0), @@ -61,6 +63,7 @@ public TrafficCrossroadBatchGenerator(String name,DB db, DateTime initDateTime, this.holidayStart = holidayStart; this.daySelection = daySelection; this.trafficUpdate = trafficUpdate; + this.observationDays = observationDays; } @Override @@ -77,11 +80,16 @@ public Batch generate(Graph g) { CrossroadWeight crossroadWeight = null; DateTime time = null; if(modus == 1 || modus == 2){ + System.out.println("Alter Batch am : \t" +initDateTime); time = initDateTime; time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart); + System.out.println("Neuer Batch am : \t" +time); + } + if(modus == 3){ + nodeHistory = new HashMap<>(); } int newTimeStamp = (int) g.getTimestamp() + 1; - System.out.println("Neuer Batch am : \t" +time); + for (IElement currentNode : nodes) { DirectedWeightedNode n = (DirectedWeightedNode) currentNode; double[] update = null; @@ -97,9 +105,30 @@ else if (modus == 1 ){ // Vergleich für Zeiträume der Länge timeRange an Tage else if (modus == 2){ // Statische Verkehrsanalyse crossroadWeight = db.getCrossroadWeightStaticBatch(n.getIndex(),trafficUpdate); } + else if (modus == 3){ + time = initDateTime; + int index = n.getIndex(); + for (int i = 0; i < observationDays; i++) { + time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart); + CrossroadWeight weightOfDay = db.getCrossroadWeight(n.getIndex(),time.minusMinutes(db.timeRange*2),time.plusMinutes(db.timeRange*2),newTimeStamp); + if(nodeHistory.containsKey(index)){ + nodeHistory.get(index).add(weightOfDay); + } + else{ + CrossroadWeightList weightList = new CrossroadWeightList(weightOfDay.crossroadID,weightOfDay.crossroadName,weightOfDay.getThreshold()); + weightList.add(weightOfDay); + nodeHistory.put(index, weightList); + } + //System.out.println("Alter Batch am "+initDateTime); + //System.out.println("Update auf Knoten mit Index " +index +" am " + time); + } + crossroadWeight = nodeHistory.get(index).getAverage(); + + } update = crossroadWeight.getWeight(); Double3dWeight oldWeight = (Double3dWeight) n.getWeight(); Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); + System.out.println("Index: \t"+n.getIndex()+"\tOldWeight: "+oldWeight.asString()+"\tNewWeight:"+newWeight.asString()); if(!oldWeight.equals(newWeight)) b.add(new NodeWeight((dna.graph.weights.IWeightedNode) currentNode,newWeight)); From 4a4b07e175ff3fb261bdd0008983f09ade9484ba Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Mon, 10 Nov 2014 11:42:28 +0100 Subject: [PATCH 03/24] Bugfixes --- .classpath | 2 +- config/plotting/gnuplot.properties | 2 +- .../generators/traffic/CrossroadWeight.java | 3 + src/dna/graph/generators/traffic/DB.java | 57 +++++++++++++++---- .../traffic/TrafficSensorGraphGenerator.java | 7 ++- .../paths/AllPairsShortestPathsDouble.java | 9 ++- .../DoubleWeightedAllPairsShortestPaths.java | 4 +- .../DoubleWeightedAllPairsShortestPathsR.java | 4 +- .../updates/generators/traffic/Helpers.java | 10 ++-- .../TrafficCrossroadBatchGenerator.java | 11 ++-- .../TrafficInputWayBatchGenerator.java | 2 +- .../traffic/TrafficSensorBatchGenerator.java | 14 +---- 12 files changed, 81 insertions(+), 44 deletions(-) diff --git a/.classpath b/.classpath index fb2341ef..7ddb00d1 100644 --- a/.classpath +++ b/.classpath @@ -11,6 +11,6 @@ - + diff --git a/config/plotting/gnuplot.properties b/config/plotting/gnuplot.properties index 9ba68a59..4b5e1967 100644 --- a/config/plotting/gnuplot.properties +++ b/config/plotting/gnuplot.properties @@ -1,5 +1,5 @@ ## GENERAL PLOT SETTINGS ############### -GNUPLOT_PATH = /usr/bin/gnuplot +GNUPLOT_PATH = C:\\Users\\Maurice\\gnuplot\\bin\\gnuplot.exe GNUPLOT_TERMINAL = png large GNUPLOT_EXTENSION = png GNUPLOT_DIR = null diff --git a/src/dna/graph/generators/traffic/CrossroadWeight.java b/src/dna/graph/generators/traffic/CrossroadWeight.java index e05d0abc..b423aba3 100644 --- a/src/dna/graph/generators/traffic/CrossroadWeight.java +++ b/src/dna/graph/generators/traffic/CrossroadWeight.java @@ -78,6 +78,9 @@ public double[] getWeight(){ sum[1]+=entry[1]; } int numOfinputWays = inputWayWeights.size(); + if(numOfinputWays>0){ + sum[1]/=numOfinputWays; + } if(maxCount>0) sum[2]=(sum[0]/maxCount)*100; else diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index d8bcceec..c5fbd1a9 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -59,7 +59,7 @@ public class DB { private HashMap disabledEdges; private HashMap> disabledEdgesInputWay; private boolean dummyMax; - + private boolean backupWays = false; /** * Konstruktor für die Nutzung der Datenbank ohne @@ -350,6 +350,8 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi CrossroadWeight crw = new CrossroadWeight(crossroadID, crossroadName,treshold); try { String selectStmt = "SELECT SUM(COUNT_VALUE)/COUNT(COUNT_VALUE) as ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG ,FROM_DIRECTION, OSMWAY_ID FROM (SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM (SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM (SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') SENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays SW WHERE crossroadID ='"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN (SELECT ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET,DATETIME FROM jee_trafficlight_rawevents RE WHERE RE.DATETIME >= '"+toSql(from)+"'AND RE.DATETIME < '"+toSql(to)+"' AND CROSSROAD = '"+crossroadName+"') EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET) CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID) RESULT LEFT JOIN (SELECT * FROM mw_CrossroadWays WHERE TYPE = '0')CRW on RESULT.FROM_DIRECTION = CRW.DIRECTION AND RESULT.CROSSROAD_ID = CRW.CROSSROAD_ID WHERE FRONT_BACK = 0 GROUP BY OSMWAY_ID"; + if(crossroadID == 83) + System.out.println(selectStmt); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); while (rs.next()) { @@ -437,7 +439,11 @@ private double[] getMaximalWeightInputWay(int inputWayID) { */ private double[] getMaximalWeightInputWay(int osmWayID, int crossroadRoad) { try { - String selectStmt = "SELECT IW.*,wayID FROM mw_MaxValues_InputWays IW LEFT JOIN mw_InputWaysGlobal IWG ON IW.INPUT_WAY_ID = IWG.ID WHERE wayID ='"+osmWayID+"' AND CROSSROAD_ID ="+crossroadRoad; + String selectStmt = null; + if(backupWays) + selectStmt = "SELECT IW.*,wayID FROM mw_MaxValues_InputWays IW LEFT JOIN mw_InputWaysGlobal_bak2 IWG ON IW.INPUT_WAY_ID = IWG.ID WHERE wayID ='"+osmWayID+"' AND CROSSROAD_ID ="+crossroadRoad; + else + selectStmt = "SELECT IW.*,wayID FROM mw_MaxValues_InputWays IW LEFT JOIN mw_InputWaysGlobal IWG ON IW.INPUT_WAY_ID = IWG.ID WHERE wayID ='"+osmWayID+"' AND CROSSROAD_ID ="+crossroadRoad; Statement stmt = con.createStatement(); if(crossroadRoad == 8) System.out.println(selectStmt); @@ -459,8 +465,12 @@ public void getMaximalWeightInputWay() { String selectStmt = null; if(!dummyMax) selectStmt = "SELECT * FROM mw_MaxValues_InputWays WHERE COUNT_OR_LOAD =0"; - else - selectStmt = "SELECT * FROM mw_MaxValues_InputWay_Random JOIN mw_InputWaysGlobal on INPUTWAY_ID = ID"; + else { + if(backupWays) + selectStmt = "SELECT * FROM mw_MaxValues_InputWay_Random JOIN mw_InputWaysGlobal_bak2 on INPUTWAY_ID = ID"; + else + selectStmt = "SELECT * FROM mw_MaxValues_InputWay_Random JOIN mw_InputWaysGlobal on INPUTWAY_ID = ID"; + } Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); while(rs.next()) { @@ -536,7 +546,7 @@ public void getMaximalWeightCrossroad() { ResultSet rs = stmt.executeQuery(selectStmt); while(rs.next()){ if(!dummyMax) - maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getInt("COUNT"),0}); + maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getInt("COUNT")+20,0}); else{ maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getDouble("MAX_COUNT"),0}); } @@ -771,7 +781,10 @@ public void getInputWays(){ try { Statement stmt = con.createStatement(); String statementString; - statementString = "SELECT * FROM mw_InputWaysGlobal"; + if(backupWays) + statementString = "SELECT * FROM mw_InputWaysGlobal_bak2"; + else + statementString = "SELECT * FROM mw_InputWaysGlobal"; ResultSet rs = stmt.executeQuery(statementString); while(rs.next() ) { int wayID = rs.getInt("wayID"); @@ -803,9 +816,14 @@ public List getInputWaysForDNA(int modus) { try { Statement stmt = con.createStatement(); String statementString; - statementString = "SELECT * FROM mw_InputWaysGlobal"; + if(backupWays) + statementString = "SELECT * FROM mw_InputWaysGlobal_bak2"; + else + statementString = "SELECT * FROM mw_InputWaysGlobal"; ResultSet rs = stmt.executeQuery(statementString); + int i = 0; while(rs.next() ) { + System.out.println("Added Node:"+i++); currentWeighted = gds.newNodeInstance(rs.getInt(1)); nodes.add(currentWeighted); } @@ -820,9 +838,14 @@ public List getInputWaysConnectionForDNA() { try { Statement stmt = con.createStatement(); String statementString; - statementString = "SELECT fromID , toID FROM mw_InputWayConnection"; + if(backupWays) + statementString = "SELECT fromID , toID FROM mw_InputWayConnection_bak"; + else + statementString = "SELECT fromID , toID FROM mw_InputWayConnection_bak3"; ResultSet rs = stmt.executeQuery(statementString); + int i = 0; while(rs.next() ) { + System.out.println("Added " +i++); edges.add(new EdgeContainer(rs.getInt("fromID"),rs.getInt("toID"))); } } catch (SQLException e) { @@ -1054,7 +1077,7 @@ public List getSensorsForDNA() { try { Statement stmt = con.createStatement(); String statementString; - statementString = "SELECT SG.*, ID as INPUT_WAY_ID FROM (SELECT * FROM mw_SensorGlobal) SG LEFT JOIN (SELECT * FROM mw_InputWaysGlobal) IWG ON SG.WAY_ID = IWG.wayID AND SG.CROSSROAD_ID = IWG.crossroadID"; + statementString = "SELECT SG.*, ID as INPUT_WAY_ID FROM (SELECT * FROM mw_SensorGlobal_bak) SG LEFT JOIN (SELECT * FROM mw_InputWaysGlobal) IWG ON SG.WAY_ID = IWG.wayID AND SG.CROSSROAD_ID = IWG.crossroadID"; ResultSet rs = stmt.executeQuery(statementString); int label; while (rs.next()) { @@ -1160,8 +1183,11 @@ public double[] getInputWayWeight(int inputWayID, DateTime from, DateTime to) { int[] inputData = inputWays.get(inputWayID); int crossroadID = inputData[1]; Statement stmt = con.createStatement(); - statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID as INPUTWAY_ID, IWG.wayID as OSMWAY_ID, IWG.crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME, sensorID as SENSOR_ID, sensorName as SENSOR_NAME,IWG.direction as DIRECTION FROM (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID ="+inputWayID+") IWG LEFT JOIN mw_SensorWays SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID AND IWG.direction = SW.direction) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ="+crossroadID+") S2 ON S1.SENSOR_ID = S2.ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; - System.out.println(statementString); + if(backupWays) + statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID as INPUTWAY_ID, IWG.wayID as OSMWAY_ID, IWG.crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME, sensorID as SENSOR_ID, sensorName as SENSOR_NAME,IWG.direction as DIRECTION FROM (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID ="+inputWayID+") IWG LEFT JOIN mw_SensorWays SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID AND IWG.direction = SW.direction) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ="+crossroadID+") S2 ON S1.SENSOR_ID = S2.ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; + else + statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID as INPUTWAY_ID, IWG.wayID as OSMWAY_ID, IWG.crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME, sensorID as SENSOR_ID, sensorName as SENSOR_NAME FROM (SELECT * FROM mw_InputWaysGlobal_bak2 IWG WHERE IWG.ID ="+inputWayID+") IWG LEFT JOIN mw_SensorWays_bak SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ="+crossroadID+") S2 ON S1.SENSOR_ID = S2.ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; + ResultSet rs = stmt.executeQuery(statementString); if(rs.first()){ count=rs.getDouble(1); @@ -1254,8 +1280,10 @@ public List getSensorConnectionForDNA() { try { Statement vStmt = con.createStatement(); String statementString; + /* // Virtual Sensor -> Real Sensor - statementString = "SELECT VS.NODE_ID AS V_NODE_ID, VS.WAY_ID as V_WAY_ID, VS.CROSSROAD_ID as V_CROSSROAD, RS.NODE_ID as R_NODE_ID, RS.WAY_ID as R_WAY_ID, RS.CROSSROAD_ID as R_CROSSROAD_ID FROM (SELECT * FROM mw_SensorGlobal SG1 WHERE SENSOR_TYPE = 1) VS LEFT JOIN (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 0) RS ON VS.WAY_ID = RS.WAY_ID AND VS.CROSSROAD_ID = RS.CROSSROAD_ID"; + // alle Sensoren statementString = "SELECT VS.NODE_ID AS V_NODE_ID, VS.WAY_ID as V_WAY_ID, VS.CROSSROAD_ID as V_CROSSROAD, RS.NODE_ID as R_NODE_ID, RS.WAY_ID as R_WAY_ID, RS.CROSSROAD_ID as R_CROSSROAD_ID FROM (SELECT * FROM mw_SensorGlobal SG1 WHERE SENSOR_TYPE = 1) VS LEFT JOIN (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 0) RS ON VS.WAY_ID = RS.WAY_ID AND VS.CROSSROAD_ID = RS.CROSSROAD_ID WHERE RS.NODE_ID IS NOT NULL"; + statementString = "SELECT VS.NODE_ID AS V_NODE_ID, VS.WAY_ID as V_WAY_ID, VS.CROSSROAD_ID as V_CROSSROAD, RS.NODE_ID as R_NODE_ID, RS.WAY_ID as R_WAY_ID, RS.CROSSROAD_ID as R_CROSSROAD_ID FROM (SELECT * FROM mw_SensorGlobal SG1 WHERE SENSOR_TYPE = 1) VS LEFT JOIN (SELECT REAL_SENSORS.* FROM (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 0) REAL_SENSORS JOIN (SELECT * FROM mw_SensorConnection WHERE FRONT_BACK = 0) FRONT_SENSORS ON REAL_SENSORS.SENSOR_ID = FRONT_SENSORS.SENSOR_ID) RS ON VS.WAY_ID = RS.WAY_ID AND VS.CROSSROAD_ID = RS.CROSSROAD_ID WHERE RS.NODE_ID IS NOT NULL"; ResultSet v2r = vStmt.executeQuery(statementString); while(v2r.next() ) { edges.add(new EdgeContainer(v2r.getInt("V_NODE_ID"), v2r.getInt("R_NODE_ID"))); @@ -1267,6 +1295,11 @@ public List getSensorConnectionForDNA() { ResultSet r2v = rStmt.executeQuery(statementString); while(r2v.next() ) { edges.add(new EdgeContainer(r2v.getInt("R_NODE_ID"), r2v.getInt("V_NODE_ID"))); + }*/ + statementString = "SELECT * FROM mw_SensorConnection_Global"; + ResultSet sensor_con = vStmt.executeQuery(statementString); + while(sensor_con.next() ) { + edges.add(new EdgeContainer(sensor_con.getInt("FROM_NODE"), sensor_con.getInt("TO_NODE"))); } } catch (SQLException e) { e.printStackTrace(); diff --git a/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java index 8363896a..b546f8c2 100644 --- a/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java @@ -115,7 +115,12 @@ public Graph generate() { ec = connection.get(i); fromNode = (DirectedWeightedNode) g.getNode(ec.getFrom()); toNode = (DirectedWeightedNode) g.getNode(ec.getTo()); - e = gds.newEdgeInstance(fromNode,toNode); + try { + e = gds.newEdgeInstance(fromNode,toNode); + } catch (Exception e2) { + System.out.println("Problem: \t" +ec.getFrom()+"\t"+ec.getTo()); + } + if(overloaded.contains(fromNode.getIndex()) || overloaded.contains((toNode.getIndex()))){ addEdge(fromNode.getIndex(),ec,e); addEdge(toNode.getIndex(),ec,e); diff --git a/src/dna/metrics/paths/AllPairsShortestPathsDouble.java b/src/dna/metrics/paths/AllPairsShortestPathsDouble.java index d09c87b4..3d5a27df 100644 --- a/src/dna/metrics/paths/AllPairsShortestPathsDouble.java +++ b/src/dna/metrics/paths/AllPairsShortestPathsDouble.java @@ -22,12 +22,17 @@ public abstract class AllPairsShortestPathsDouble extends Metric { // TODO INIT!!! // this.apsp = new DistributionLong("APSP"); + double binsize; protected BinnedDistributionDouble apsp; public AllPairsShortestPathsDouble(String name) { super(name); } + public AllPairsShortestPathsDouble(String name,double binsize) { + super(name); + this.binsize = binsize; + } @Override public Value[] getValues() { @@ -37,8 +42,8 @@ public Value[] getValues() { Value v2 = new Value("possiblePaths", this.g.getNodeCount() * (this.g.getNodeCount() - 1)); Value v3 = new Value("characteristicPathLength", - this.apsp.computeAverage()); - Value v4 = new Value("diameter", this.apsp.getMax()); + this.apsp.computeAverage()*binsize); + Value v4 = new Value("diameter", this.apsp.getMax()*binsize); return new Value[] { v1, v2, v3, v4 }; } diff --git a/src/dna/metrics/paths/DoubleWeightedAllPairsShortestPaths.java b/src/dna/metrics/paths/DoubleWeightedAllPairsShortestPaths.java index 79a2fd3f..f4fb3a4b 100644 --- a/src/dna/metrics/paths/DoubleWeightedAllPairsShortestPaths.java +++ b/src/dna/metrics/paths/DoubleWeightedAllPairsShortestPaths.java @@ -19,8 +19,8 @@ public abstract class DoubleWeightedAllPairsShortestPaths extends AllPairsShortestPathsDouble { - public DoubleWeightedAllPairsShortestPaths(String name) { - super(name); + public DoubleWeightedAllPairsShortestPaths(String name,double binsize) { + super(name,binsize); } @Override diff --git a/src/dna/metrics/paths/DoubleWeightedAllPairsShortestPathsR.java b/src/dna/metrics/paths/DoubleWeightedAllPairsShortestPathsR.java index 7eb5b2ba..979f3264 100644 --- a/src/dna/metrics/paths/DoubleWeightedAllPairsShortestPathsR.java +++ b/src/dna/metrics/paths/DoubleWeightedAllPairsShortestPathsR.java @@ -27,10 +27,10 @@ public class DoubleWeightedAllPairsShortestPathsR extends DoubleWeightedAllPairsShortestPaths implements IRecomputation { - double binsize; + public DoubleWeightedAllPairsShortestPathsR(double binsize) { - super("DoubleWeightedAllPairsShortestPathsR"); + super("DoubleWeightedAllPairsShortestPathsR", binsize); this.binsize=binsize; } diff --git a/src/dna/updates/generators/traffic/Helpers.java b/src/dna/updates/generators/traffic/Helpers.java index c1ce1b57..076b8d38 100644 --- a/src/dna/updates/generators/traffic/Helpers.java +++ b/src/dna/updates/generators/traffic/Helpers.java @@ -10,16 +10,16 @@ public static boolean isWorkDay(Days d) { return !(d == Days.SATURDAY || d==Days.SUNDAY); } - public static DateTime calculateNextWorkDay(DateTime start,long l){ - return calculateNextDay(start, l, new boolean[]{true,true,true,true,true,false,false},null); + public static DateTime calculateNextWorkDay(DateTime start,long l, boolean forward){ + return calculateNextDay(start, l, new boolean[]{true,true,true,true,true,false,false},null,forward); } - public static DateTime calculateNextDay(DateTime end, long l, boolean[] daySelection,DateTime ignoreTo){ + public static DateTime calculateNextDay(DateTime end, long l, boolean[] daySelection,DateTime ignoreTo, boolean forward){ DateTime current = end; int count = 0; while(count <= l) { - current = current.minusDays(1); - if(daySelection[current.getDayOfWeek()-1] && current.isBefore(ignoreTo)){ + current = forward ? current.plusDays(1) : current.minusDays(1); + if(daySelection[current.getDayOfWeek()-1] && (current.isBefore(ignoreTo) || forward)){ count++; } } diff --git a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java index 24cc7d5b..db7f979d 100644 --- a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java @@ -82,7 +82,7 @@ public Batch generate(Graph g) { if(modus == 1 || modus == 2){ System.out.println("Alter Batch am : \t" +initDateTime); time = initDateTime; - time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart); + time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart,true); System.out.println("Neuer Batch am : \t" +time); } if(modus == 3){ @@ -99,17 +99,17 @@ public Batch generate(Graph g) { if(modus==0){ // Vergleich in Schritten der Größe Stepsize crossroadWeight =db.getCrossroadWeight(n.getIndex(), initDateTime.plusMinutes((int) (g.getTimestamp()*stepSize)),initDateTime.plusMinutes((int) (g.getTimestamp()+stepSize)*stepSize),newTimeStamp); } - else if (modus == 1 ){ // Vergleich für Zeiträume der Länge timeRange an Tagen aus Dayselection + else if (modus == 1 ){ // Vergleich für Zeiträume der Länge timeRange an Tagen aus Dayselection, Geht in die Zukunft crossroadWeight = db.getCrossroadWeight(n.getIndex(),time.minusMinutes(db.timeRange),time.plusMinutes(db.timeRange),newTimeStamp); } else if (modus == 2){ // Statische Verkehrsanalyse crossroadWeight = db.getCrossroadWeightStaticBatch(n.getIndex(),trafficUpdate); } - else if (modus == 3){ + else if (modus == 3){ // Aggregiert die Weiter für einen Beobachtungszeitraum in der Vergangenheit time = initDateTime; int index = n.getIndex(); for (int i = 0; i < observationDays; i++) { - time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart); + time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart,false); CrossroadWeight weightOfDay = db.getCrossroadWeight(n.getIndex(),time.minusMinutes(db.timeRange*2),time.plusMinutes(db.timeRange*2),newTimeStamp); if(nodeHistory.containsKey(index)){ nodeHistory.get(index).add(weightOfDay); @@ -123,12 +123,13 @@ else if (modus == 3){ //System.out.println("Update auf Knoten mit Index " +index +" am " + time); } crossroadWeight = nodeHistory.get(index).getAverage(); - } update = crossroadWeight.getWeight(); Double3dWeight oldWeight = (Double3dWeight) n.getWeight(); Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); System.out.println("Index: \t"+n.getIndex()+"\tOldWeight: "+oldWeight.asString()+"\tNewWeight:"+newWeight.asString()); + if(Math.abs(oldWeight.getZ() - newWeight.getZ())>10 ) + System.out.println("Alarm."); if(!oldWeight.equals(newWeight)) b.add(new NodeWeight((dna.graph.weights.IWeightedNode) currentNode,newWeight)); diff --git a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java index a9e321c8..841d815f 100644 --- a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java @@ -77,7 +77,7 @@ public Batch generate(Graph g) { Integer newKey = null; if(modus == 1){ time = initDateTime; - time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart); + time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart,true); System.out.println("Neuer Batch am : \t" +time); } newDisabledEdges = new HashMap<>(); diff --git a/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java index 23fc7e14..7ad86e73 100644 --- a/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java @@ -82,30 +82,20 @@ public Batch generate(Graph g) { int newTimestamp = (int)g.getTimestamp() + 1; DateTime time = initDateTime; - time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart); + time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart,true); DateTime fromTime = null; DateTime toTime = null; Set toDisable = new HashSet<>(); Edge edge = null; - if(modus == 0){ - fromTime = initDateTime.plusMinutes((int) (g.getTimestamp()+1)*stepSize); - toTime = initDateTime.plusMinutes((int) (g.getTimestamp()+2)*stepSize); - } - else if(modus == 1){ - - time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart); - fromTime = time.minusMinutes(db.timeRange); - toTime = time.plusMinutes(db.timeRange); - } switch (modus) { case 0: fromTime = initDateTime.plusMinutes((int) (g.getTimestamp()+1)*stepSize); toTime = initDateTime.plusMinutes((int) (g.getTimestamp()+2)*stepSize); break; case 1: - time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart); + time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart,true); fromTime = time.minusMinutes(db.timeRange); toTime = time.plusMinutes(db.timeRange); break; From 62ffd73330f8f09fc9b606d23ffae605abf19104 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Mon, 10 Nov 2014 21:56:18 +0100 Subject: [PATCH 04/24] =?UTF-8?q?Gewichte=20ge=C3=A4ndert?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/dna/graph/generators/traffic/CrossroadWeight.java | 8 +++++--- src/dna/graph/generators/traffic/DB.java | 6 +++--- src/dna/updates/generators/traffic/Helpers.java | 4 ++-- .../traffic/TrafficCrossroadBatchGenerator.java | 7 +++++-- 4 files changed, 15 insertions(+), 10 deletions(-) diff --git a/src/dna/graph/generators/traffic/CrossroadWeight.java b/src/dna/graph/generators/traffic/CrossroadWeight.java index b423aba3..2a38eb66 100644 --- a/src/dna/graph/generators/traffic/CrossroadWeight.java +++ b/src/dna/graph/generators/traffic/CrossroadWeight.java @@ -81,17 +81,19 @@ public double[] getWeight(){ if(numOfinputWays>0){ sum[1]/=numOfinputWays; } - if(maxCount>0) + /*if(maxCount>0) sum[2]=(sum[0]/maxCount)*100; else - sum[2]=0; + sum[2]=0;*/ + if(sum[1]>0) + sum[2] = sum[1]; return sum; } public HashMap getOverladedEdges() { HashMap result = new HashMap<>(); for (Map.Entry inputWay : inputWayWeights.entrySet()) { - if(inputWay.getValue()[2] >threshold){ + if(inputWay.getValue()[1] >threshold){ result.put(inputWay.getKey(), inputWay.getValue()); } } diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index c5fbd1a9..098f7cff 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -350,8 +350,6 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi CrossroadWeight crw = new CrossroadWeight(crossroadID, crossroadName,treshold); try { String selectStmt = "SELECT SUM(COUNT_VALUE)/COUNT(COUNT_VALUE) as ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG ,FROM_DIRECTION, OSMWAY_ID FROM (SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM (SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM (SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') SENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays SW WHERE crossroadID ='"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN (SELECT ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET,DATETIME FROM jee_trafficlight_rawevents RE WHERE RE.DATETIME >= '"+toSql(from)+"'AND RE.DATETIME < '"+toSql(to)+"' AND CROSSROAD = '"+crossroadName+"') EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET) CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID) RESULT LEFT JOIN (SELECT * FROM mw_CrossroadWays WHERE TYPE = '0')CRW on RESULT.FROM_DIRECTION = CRW.DIRECTION AND RESULT.CROSSROAD_ID = CRW.CROSSROAD_ID WHERE FRONT_BACK = 0 GROUP BY OSMWAY_ID"; - if(crossroadID == 83) - System.out.println(selectStmt); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); while (rs.next()) { @@ -361,7 +359,9 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi maxValue = new double[]{Double.MAX_VALUE,Double.MAX_VALUE}; } crw.setMaxWeightWay(wayID, maxValue); - crw.addWeightWay(wayID, new double[]{rs.getDouble("ANZAHL"),rs.getDouble("BELEGUNG"),(rs.getDouble("ANZAHL")/maxValue[0])*100}); + double count = rs.getDouble("ANZAHL"); + double load = rs.getDouble("BELEGUNG"); + crw.addWeightWay(wayID, new double[]{count,load,(count/maxValue[0])*100}); crw.setTimestamp(timestamp); } diff --git a/src/dna/updates/generators/traffic/Helpers.java b/src/dna/updates/generators/traffic/Helpers.java index 076b8d38..0d6e84ac 100644 --- a/src/dna/updates/generators/traffic/Helpers.java +++ b/src/dna/updates/generators/traffic/Helpers.java @@ -14,10 +14,10 @@ public static DateTime calculateNextWorkDay(DateTime start,long l, boolean forwa return calculateNextDay(start, l, new boolean[]{true,true,true,true,true,false,false},null,forward); } - public static DateTime calculateNextDay(DateTime end, long l, boolean[] daySelection,DateTime ignoreTo, boolean forward){ + public static DateTime calculateNextDay(DateTime end, long timestamp, boolean[] daySelection,DateTime ignoreTo, boolean forward){ DateTime current = end; int count = 0; - while(count <= l) { + while(count <= timestamp) { current = forward ? current.plusDays(1) : current.minusDays(1); if(daySelection[current.getDayOfWeek()-1] && (current.isBefore(ignoreTo) || forward)){ count++; diff --git a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java index db7f979d..0a79461c 100644 --- a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java @@ -108,8 +108,9 @@ else if (modus == 2){ // Statische Verkehrsanalyse else if (modus == 3){ // Aggregiert die Weiter für einen Beobachtungszeitraum in der Vergangenheit time = initDateTime; int index = n.getIndex(); + long start = g.getTimestamp(); for (int i = 0; i < observationDays; i++) { - time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart,false); + time = Helpers.calculateNextDay(initDateTime, start++,daySelection,holidayStart,false); CrossroadWeight weightOfDay = db.getCrossroadWeight(n.getIndex(),time.minusMinutes(db.timeRange*2),time.plusMinutes(db.timeRange*2),newTimeStamp); if(nodeHistory.containsKey(index)){ nodeHistory.get(index).add(weightOfDay); @@ -119,15 +120,17 @@ else if (modus == 3){ // Aggregiert die Weiter für einen Beobachtungszeitraum i weightList.add(weightOfDay); nodeHistory.put(index, weightList); } + System.out.println("Aggreate: "+time); //System.out.println("Alter Batch am "+initDateTime); //System.out.println("Update auf Knoten mit Index " +index +" am " + time); } + crossroadWeight = nodeHistory.get(index).getAverage(); } update = crossroadWeight.getWeight(); Double3dWeight oldWeight = (Double3dWeight) n.getWeight(); Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); - System.out.println("Index: \t"+n.getIndex()+"\tOldWeight: "+oldWeight.asString()+"\tNewWeight:"+newWeight.asString()); + //System.out.println("Index: \t"+n.getIndex()+"\tOldWeight: "+oldWeight.asString()+"\tNewWeight:"+newWeight.asString()); if(Math.abs(oldWeight.getZ() - newWeight.getZ())>10 ) System.out.println("Alarm."); if(!oldWeight.equals(newWeight)) From fa964d3093a450a34b64df5bc838d66759e45574 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Thu, 13 Nov 2014 13:03:24 +0100 Subject: [PATCH 05/24] =?UTF-8?q?Gewichte=20ge=C3=A4ndert?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/dna/graph/generators/traffic/CrossroadWeight.java | 6 ++++-- src/dna/graph/generators/traffic/DB.java | 1 + 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/dna/graph/generators/traffic/CrossroadWeight.java b/src/dna/graph/generators/traffic/CrossroadWeight.java index 2a38eb66..39c5b610 100644 --- a/src/dna/graph/generators/traffic/CrossroadWeight.java +++ b/src/dna/graph/generators/traffic/CrossroadWeight.java @@ -85,8 +85,10 @@ public double[] getWeight(){ sum[2]=(sum[0]/maxCount)*100; else sum[2]=0;*/ - if(sum[1]>0) - sum[2] = sum[1]; + if(sum[0]>1) + sum[2] = sum[1]/(sum[0]*10)*10; + else + sum[2] = 0; return sum; } diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index 098f7cff..b54029ef 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -350,6 +350,7 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi CrossroadWeight crw = new CrossroadWeight(crossroadID, crossroadName,treshold); try { String selectStmt = "SELECT SUM(COUNT_VALUE)/COUNT(COUNT_VALUE) as ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG ,FROM_DIRECTION, OSMWAY_ID FROM (SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM (SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM (SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') SENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays SW WHERE crossroadID ='"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN (SELECT ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET,DATETIME FROM jee_trafficlight_rawevents RE WHERE RE.DATETIME >= '"+toSql(from)+"'AND RE.DATETIME < '"+toSql(to)+"' AND CROSSROAD = '"+crossroadName+"') EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET) CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID) RESULT LEFT JOIN (SELECT * FROM mw_CrossroadWays WHERE TYPE = '0')CRW on RESULT.FROM_DIRECTION = CRW.DIRECTION AND RESULT.CROSSROAD_ID = CRW.CROSSROAD_ID WHERE FRONT_BACK = 0 GROUP BY OSMWAY_ID"; + System.out.println(selectStmt); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); while (rs.next()) { From f032c02bb26659442aa9751bec711651fcaa4a85 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Thu, 27 Nov 2014 16:26:56 +0100 Subject: [PATCH 06/24] Minor Bugfixes --- .classpath | 2 +- .../generators/traffic/CrossroadWeight.java | 17 +++- src/dna/graph/generators/traffic/DB.java | 77 ++++++++++++++++--- .../TrafficCrossroadGraphGenerator.java | 2 + .../TrafficInputWayGraphGenerator.java | 6 +- .../TrafficCrossroadBatchGenerator.java | 1 + .../TrafficInputWayBatchGenerator.java | 36 ++++++++- 7 files changed, 123 insertions(+), 18 deletions(-) diff --git a/.classpath b/.classpath index 7ddb00d1..fb2341ef 100644 --- a/.classpath +++ b/.classpath @@ -11,6 +11,6 @@ - + diff --git a/src/dna/graph/generators/traffic/CrossroadWeight.java b/src/dna/graph/generators/traffic/CrossroadWeight.java index 39c5b610..67e6d1ba 100644 --- a/src/dna/graph/generators/traffic/CrossroadWeight.java +++ b/src/dna/graph/generators/traffic/CrossroadWeight.java @@ -81,22 +81,33 @@ public double[] getWeight(){ if(numOfinputWays>0){ sum[1]/=numOfinputWays; } - /*if(maxCount>0) + + // Normierte Werte + if(maxCount>0) sum[2]=(sum[0]/maxCount)*100; else - sum[2]=0;*/ + sum[2]=0; + + /* + // Load/Count if(sum[0]>1) sum[2] = sum[1]/(sum[0]*10)*10; else sum[2] = 0; + */ + /* + // Load-Wert + sum[2] = sum[1]; + */ return sum; } public HashMap getOverladedEdges() { HashMap result = new HashMap<>(); for (Map.Entry inputWay : inputWayWeights.entrySet()) { - if(inputWay.getValue()[1] >threshold){ + if(inputWay.getValue()[2] >threshold){ result.put(inputWay.getKey(), inputWay.getValue()); + System.out.println("Overloaded: " +inputWay.getKey() +"Crossroad " +crossroadID +"\t"+inputWay.getValue()[0]+"\tNorm:" +inputWay.getValue()[2]); } } return result; diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index b54029ef..1d31ce39 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -60,6 +60,7 @@ public class DB { private HashMap> disabledEdgesInputWay; private boolean dummyMax; private boolean backupWays = false; + private boolean improvedMax = true; /** * Konstruktor für die Nutzung der Datenbank ohne @@ -209,6 +210,42 @@ public double[] writeMaximalWeightsCrossroad(int crossroadID) { return new double[]{0.0,0.0}; } + public boolean setMaximalWeightsCrossroadImproved(int crossroadID, double count, double load, DateTime time, int timeRange){ + String inserTableSQL = "UPDATE mw_MaxValues_CrossroadImproved SET COUNT_VALUE = ?, LOAD_VALUE = ?, DATETIME = ?,timeRange = ? WHERE CROSSROAD_ID ="+crossroadID+" AND COUNT_VALUE<"+count; + + try { + PreparedStatement insertStmt = con.prepareStatement(inserTableSQL); + insertStmt.setDouble(1,count); + insertStmt.setDouble(2, load); + insertStmt.setTimestamp(3, Timestamp.valueOf(toSql(time))); + insertStmt.setInt(4, timeRange*2); + insertStmt.execute(); + } catch (SQLException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + return true; + } + public boolean setMaximalWeightsInputWayImproved(int inputWayID, double count, double load, DateTime time, int timeRange){ + if(true) + return true; + String inserTableSQL = "UPDATE mw_MaxValues_InputWaysImproved SET COUNT_VALUE = ?, LOAD_VALUE = ?, DATETIME = ?, timeRange = ? WHERE INPUT_WAY_ID ="+inputWayID+" AND COUNT_VALUE<"+count; + try { + PreparedStatement insertStmt = con.prepareStatement(inserTableSQL); + insertStmt.setDouble(1,count); + insertStmt.setDouble(2, load); + insertStmt.setTimestamp(3, Timestamp.valueOf(toSql(time))); + insertStmt.setInt(4, timeRange*2); + insertStmt.execute(); + } catch (SQLException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + return true; + } + + + public double[] writeMaximalWeightsInputWays_5Minutes(int inputwayID) { System.out.println("Prüfe ID " +inputwayID); double count = 0; @@ -349,8 +386,7 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi } CrossroadWeight crw = new CrossroadWeight(crossroadID, crossroadName,treshold); try { - String selectStmt = "SELECT SUM(COUNT_VALUE)/COUNT(COUNT_VALUE) as ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG ,FROM_DIRECTION, OSMWAY_ID FROM (SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM (SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM (SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') SENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays SW WHERE crossroadID ='"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN (SELECT ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET,DATETIME FROM jee_trafficlight_rawevents RE WHERE RE.DATETIME >= '"+toSql(from)+"'AND RE.DATETIME < '"+toSql(to)+"' AND CROSSROAD = '"+crossroadName+"') EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET) CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID) RESULT LEFT JOIN (SELECT * FROM mw_CrossroadWays WHERE TYPE = '0')CRW on RESULT.FROM_DIRECTION = CRW.DIRECTION AND RESULT.CROSSROAD_ID = CRW.CROSSROAD_ID WHERE FRONT_BACK = 0 GROUP BY OSMWAY_ID"; - System.out.println(selectStmt); + String selectStmt = "SELECT SUM(COUNT_VALUE)/COUNT(DISTINCT DATETIME) as ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG ,FROM_DIRECTION, OSMWAY_ID FROM (SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM (SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM (SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') SENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays SW WHERE crossroadID ='"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN (SELECT ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET,DATETIME FROM jee_trafficlight_rawevents RE WHERE RE.DATETIME >= '"+toSql(from)+"'AND RE.DATETIME < '"+toSql(to)+"' AND CROSSROAD = '"+crossroadName+"') EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET) CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID) RESULT LEFT JOIN (SELECT * FROM mw_CrossroadWays WHERE TYPE = '0')CRW on RESULT.FROM_DIRECTION = CRW.DIRECTION AND RESULT.CROSSROAD_ID = CRW.CROSSROAD_ID WHERE FRONT_BACK = 0 GROUP BY OSMWAY_ID"; Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); while (rs.next()) { @@ -362,6 +398,7 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi crw.setMaxWeightWay(wayID, maxValue); double count = rs.getDouble("ANZAHL"); double load = rs.getDouble("BELEGUNG"); + setMaximalWeightsInputWayImproved(getInputWay(crossroadID, wayID), count, load, from, timeRange); crw.addWeightWay(wayID, new double[]{count,load,(count/maxValue[0])*100}); crw.setTimestamp(timestamp); @@ -461,10 +498,12 @@ private double[] getMaximalWeightInputWay(int osmWayID, int crossroadRoad) { } public void getMaximalWeightInputWay() { - Random rand = new Random(); try { String selectStmt = null; - if(!dummyMax) + if(improvedMax){ + selectStmt = "SELECT * FROM mw_MaxValues_InputWaysImproved WHERE COUNT_OR_LOAD =0"; + } + else if(!dummyMax) selectStmt = "SELECT * FROM mw_MaxValues_InputWays WHERE COUNT_OR_LOAD =0"; else { if(backupWays) @@ -475,7 +514,13 @@ public void getMaximalWeightInputWay() { Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); while(rs.next()) { - if(!dummyMax) + if(improvedMax){ + double maxCount = rs.getDouble("COUNT_VALUE"); + if(maxCount <1) + maxCount= 1; + maxValuesInputWays.put(rs.getInt(1), new double[]{maxCount,rs.getDouble("LOAD_VALUE")}); + } + else if(!dummyMax) maxValuesInputWays.put(rs.getInt(1), new double[]{rs.getDouble("COUNT"),rs.getDouble("LOAD")}); else{ maxValuesInputWays.put(rs.getInt("INPUTWAY_ID"), new double[]{rs.getDouble("MAX_COUNT"),0}); @@ -534,20 +579,30 @@ public void writeMaximalWeightSensorRandom() { } } + + /** * liest die maximalen Werte, welche für einen Kreuzung gemessen wurden - über dummyMax können einmalig zufällig generierte Werte geladen werden */ public void getMaximalWeightCrossroad() { - Random rand = new Random(); try { String selectStmt = "SELECT * FROM mw_MaxValues_Crossroad WHERE COUNT_OR_LOAD =0"; if(dummyMax) selectStmt = "SELECT * FROM mw_MaxValues_Crossroad_Random"; + if(improvedMax) + selectStmt = "SELECT * FROM mw_MaxValues_CrossroadImproved"; Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); while(rs.next()){ - if(!dummyMax) - maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getInt("COUNT")+20,0}); + if(improvedMax){ + double maxCount = rs.getDouble("COUNT_VALUE"); + if(maxCount <1) + maxCount = 1; + maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {maxCount,rs.getDouble("LOAD_VALUE")}); + + } + else if(!dummyMax) + maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getInt("COUNT"),0}); else{ maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getDouble("MAX_COUNT"),0}); } @@ -824,7 +879,6 @@ public List getInputWaysForDNA(int modus) { ResultSet rs = stmt.executeQuery(statementString); int i = 0; while(rs.next() ) { - System.out.println("Added Node:"+i++); currentWeighted = gds.newNodeInstance(rs.getInt(1)); nodes.add(currentWeighted); } @@ -1186,9 +1240,10 @@ public double[] getInputWayWeight(int inputWayID, DateTime from, DateTime to) { Statement stmt = con.createStatement(); if(backupWays) statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID as INPUTWAY_ID, IWG.wayID as OSMWAY_ID, IWG.crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME, sensorID as SENSOR_ID, sensorName as SENSOR_NAME,IWG.direction as DIRECTION FROM (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID ="+inputWayID+") IWG LEFT JOIN mw_SensorWays SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID AND IWG.direction = SW.direction) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ="+crossroadID+") S2 ON S1.SENSOR_ID = S2.ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; - else + else{ statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID as INPUTWAY_ID, IWG.wayID as OSMWAY_ID, IWG.crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME, sensorID as SENSOR_ID, sensorName as SENSOR_NAME FROM (SELECT * FROM mw_InputWaysGlobal_bak2 IWG WHERE IWG.ID ="+inputWayID+") IWG LEFT JOIN mw_SensorWays_bak SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ="+crossroadID+") S2 ON S1.SENSOR_ID = S2.ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; - + statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT FRONT_AND_BACK.* FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID AS INPUTWAY_ID, IWG.wayID AS OSMWAY_ID, IWG.crossroadID AS CROSSROAD_ID, crossroadName AS CROSSROAD_NAME, sensorID AS SENSOR_ID, sensorName AS SENSOR_NAME FROM (SELECT * FROM mw_InputWaysGlobal_bak2 IWG WHERE IWG.ID ='"+inputWayID+"') IWG LEFT JOIN mw_SensorWays_bak SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ='"+crossroadID+"') S2 ON S1.SENSOR_ID = S2.ID) FRONT_AND_BACK JOIN (SELECT * FROM mw_SensorConnection_bak FR WHERE FR.FRONT_BACK = 0) ONLY_FRONT ON FRONT_AND_BACK.SENSOR_ID = ONLY_FRONT.SENSOR_ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; + } ResultSet rs = stmt.executeQuery(statementString); if(rs.first()){ count=rs.getDouble(1); diff --git a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java index 7547f423..bdcd729b 100644 --- a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java @@ -91,6 +91,8 @@ public Graph generate() { } double[] weight = crossroadWeight.getWeight(); + System.out.println("ID " +currentWeighted.getIndex() + "\tCount:" + weight[0] +"\tLoad:"+weight[1]+"\t"+"Norm:"+weight[2]); + db.setMaximalWeightsCrossroadImproved(currentWeighted.getIndex(), weight[0], weight[1], initDateTime,db.timeRange); currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); g.addNode(currentWeighted); diff --git a/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java index 537ae62e..50ec559c 100644 --- a/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java @@ -76,7 +76,7 @@ public Graph generate() { case 0: weight = db.getInputWayWeight(currentWeighted.getIndex(), initDateTime, initDateTime.plusMinutes(stepsize)); break; - case 1: + case 1: case 3: weight = db.getInputWayWeight(currentWeighted.getIndex(),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange)); break; case 2: @@ -92,7 +92,9 @@ public Graph generate() { currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); g.addNode(currentWeighted); - + if(weight[2]>96) + System.out.println("ID " +currentWeighted.getIndex() + "\tCount:" + weight[0] +"\tLoad:"+weight[1]+"\t"+"Norm:"+weight[2]); + } List connection = db.getInputWaysConnectionForDNA(); diff --git a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java index 0a79461c..914c03c6 100644 --- a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java @@ -131,6 +131,7 @@ else if (modus == 3){ // Aggregiert die Weiter für einen Beobachtungszeitraum i Double3dWeight oldWeight = (Double3dWeight) n.getWeight(); Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); //System.out.println("Index: \t"+n.getIndex()+"\tOldWeight: "+oldWeight.asString()+"\tNewWeight:"+newWeight.asString()); + db.setMaximalWeightsCrossroadImproved(n.getIndex(), update[0], update[1], time,db.timeRange); if(Math.abs(oldWeight.getZ() - newWeight.getZ())>10 ) System.out.println("Alarm."); if(!oldWeight.equals(newWeight)) diff --git a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java index 841d815f..da1b7a9f 100644 --- a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java @@ -9,6 +9,7 @@ import java.util.Set; import org.joda.time.DateTime; +import org.mockito.internal.util.collections.ListUtil; import dna.graph.Graph; import dna.graph.IElement; @@ -28,6 +29,7 @@ import dna.updates.update.EdgeRemoval; import dna.updates.update.NodeWeight; import dna.updates.update.Update; +import dna.util.ArrayUtils; import dna.util.parameters.IntParameter; import dna.util.parameters.ObjectParameter; import dna.util.parameters.Parameter; @@ -44,6 +46,7 @@ public class TrafficInputWayBatchGenerator extends BatchGenerator{ private HashMap> newDisabledEdges = new HashMap<>(); private double treshold; private TrafficUpdate trafficUpdate; + private HashMap> nodeHistory; public TrafficInputWayBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, int modus, DateTime holidayStart, boolean [] daySelection, double treshold,TrafficUpdate trafficUpdate) { @@ -59,6 +62,7 @@ public TrafficInputWayBatchGenerator(String name,DB db, DateTime initDateTime, i this.daySelection = daySelection; this.treshold = treshold; this.trafficUpdate = trafficUpdate; + this.nodeHistory = new HashMap<>(); } @Override @@ -96,7 +100,35 @@ public Batch generate(Graph g) { case 2: update = (trafficUpdate.isAffected(n.getIndex()))? db.getInputWayWeightStaticBatch(n.getIndex(),trafficUpdate) : null; break; - + case 3: + time = initDateTime; + int index = n.getIndex(); + long start = g.getTimestamp(); + double max = 0; + for (int i = 0; i < 5; i++) { + time = Helpers.calculateNextDay(initDateTime, start++, daySelection, holidayStart, false); + double[] weightOfDay = db.getInputWayWeight(n.getIndex(),time.minusMinutes(db.timeRange),time.plusMinutes(db.timeRange)); + if(nodeHistory.containsKey(index)){ + System.out.println(weightOfDay[2]); + nodeHistory.get(index).add(weightOfDay[2]); + } + else { + List weightList = new ArrayList<>(); + weightList.add(weightOfDay[2]); + nodeHistory.put(index, weightList); + } + //System.out.println("Aggregate " +time); + + } + double sum = 0; + List values = nodeHistory.get(index); + for (int i = 0; i < values.size(); i++) { + sum+=values.get(i); + } + double value = (values.isEmpty())? 0 : sum/values.size(); + update = new double[]{0,0,value}; + System.out.println("Avg: " + value); + break; default: System.out.println("Modus nicht definiert"); break; @@ -106,6 +138,8 @@ public Batch generate(Graph g) { Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); if(!oldWeight.equals(newWeight)) b.add(new NodeWeight((dna.graph.weights.IWeightedNode) currentNode,new Double3dWeight(update[0],update[1],update[2]))); + if(update[2]>95) + System.out.println("ID " +n.getIndex() + "\tCount:" + update[0] +"\tLoad:"+update[1]+"\t"+"Norm:"+update[2]); } else{ update = new double[]{oldWeight.getX(),oldWeight.getY(),oldWeight.getZ()}; From 9c909b8617c466197c7e2a0f6b697045b4c80eab Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Thu, 27 Nov 2014 16:26:56 +0100 Subject: [PATCH 07/24] Minor Bugfixes --- .classpath | 2 +- .../generators/traffic/CrossroadWeight.java | 17 +++- src/dna/graph/generators/traffic/DB.java | 77 ++++++++++++++++--- .../TrafficCrossroadGraphGenerator.java | 2 + .../TrafficInputWayGraphGenerator.java | 6 +- .../TrafficCrossroadBatchGenerator.java | 1 + .../TrafficInputWayBatchGenerator.java | 36 ++++++++- 7 files changed, 123 insertions(+), 18 deletions(-) diff --git a/.classpath b/.classpath index 7ddb00d1..fb2341ef 100644 --- a/.classpath +++ b/.classpath @@ -11,6 +11,6 @@ - + diff --git a/src/dna/graph/generators/traffic/CrossroadWeight.java b/src/dna/graph/generators/traffic/CrossroadWeight.java index 39c5b610..67e6d1ba 100644 --- a/src/dna/graph/generators/traffic/CrossroadWeight.java +++ b/src/dna/graph/generators/traffic/CrossroadWeight.java @@ -81,22 +81,33 @@ public double[] getWeight(){ if(numOfinputWays>0){ sum[1]/=numOfinputWays; } - /*if(maxCount>0) + + // Normierte Werte + if(maxCount>0) sum[2]=(sum[0]/maxCount)*100; else - sum[2]=0;*/ + sum[2]=0; + + /* + // Load/Count if(sum[0]>1) sum[2] = sum[1]/(sum[0]*10)*10; else sum[2] = 0; + */ + /* + // Load-Wert + sum[2] = sum[1]; + */ return sum; } public HashMap getOverladedEdges() { HashMap result = new HashMap<>(); for (Map.Entry inputWay : inputWayWeights.entrySet()) { - if(inputWay.getValue()[1] >threshold){ + if(inputWay.getValue()[2] >threshold){ result.put(inputWay.getKey(), inputWay.getValue()); + System.out.println("Overloaded: " +inputWay.getKey() +"Crossroad " +crossroadID +"\t"+inputWay.getValue()[0]+"\tNorm:" +inputWay.getValue()[2]); } } return result; diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index b54029ef..1d31ce39 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -60,6 +60,7 @@ public class DB { private HashMap> disabledEdgesInputWay; private boolean dummyMax; private boolean backupWays = false; + private boolean improvedMax = true; /** * Konstruktor für die Nutzung der Datenbank ohne @@ -209,6 +210,42 @@ public double[] writeMaximalWeightsCrossroad(int crossroadID) { return new double[]{0.0,0.0}; } + public boolean setMaximalWeightsCrossroadImproved(int crossroadID, double count, double load, DateTime time, int timeRange){ + String inserTableSQL = "UPDATE mw_MaxValues_CrossroadImproved SET COUNT_VALUE = ?, LOAD_VALUE = ?, DATETIME = ?,timeRange = ? WHERE CROSSROAD_ID ="+crossroadID+" AND COUNT_VALUE<"+count; + + try { + PreparedStatement insertStmt = con.prepareStatement(inserTableSQL); + insertStmt.setDouble(1,count); + insertStmt.setDouble(2, load); + insertStmt.setTimestamp(3, Timestamp.valueOf(toSql(time))); + insertStmt.setInt(4, timeRange*2); + insertStmt.execute(); + } catch (SQLException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + return true; + } + public boolean setMaximalWeightsInputWayImproved(int inputWayID, double count, double load, DateTime time, int timeRange){ + if(true) + return true; + String inserTableSQL = "UPDATE mw_MaxValues_InputWaysImproved SET COUNT_VALUE = ?, LOAD_VALUE = ?, DATETIME = ?, timeRange = ? WHERE INPUT_WAY_ID ="+inputWayID+" AND COUNT_VALUE<"+count; + try { + PreparedStatement insertStmt = con.prepareStatement(inserTableSQL); + insertStmt.setDouble(1,count); + insertStmt.setDouble(2, load); + insertStmt.setTimestamp(3, Timestamp.valueOf(toSql(time))); + insertStmt.setInt(4, timeRange*2); + insertStmt.execute(); + } catch (SQLException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + return true; + } + + + public double[] writeMaximalWeightsInputWays_5Minutes(int inputwayID) { System.out.println("Prüfe ID " +inputwayID); double count = 0; @@ -349,8 +386,7 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi } CrossroadWeight crw = new CrossroadWeight(crossroadID, crossroadName,treshold); try { - String selectStmt = "SELECT SUM(COUNT_VALUE)/COUNT(COUNT_VALUE) as ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG ,FROM_DIRECTION, OSMWAY_ID FROM (SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM (SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM (SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') SENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays SW WHERE crossroadID ='"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN (SELECT ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET,DATETIME FROM jee_trafficlight_rawevents RE WHERE RE.DATETIME >= '"+toSql(from)+"'AND RE.DATETIME < '"+toSql(to)+"' AND CROSSROAD = '"+crossroadName+"') EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET) CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID) RESULT LEFT JOIN (SELECT * FROM mw_CrossroadWays WHERE TYPE = '0')CRW on RESULT.FROM_DIRECTION = CRW.DIRECTION AND RESULT.CROSSROAD_ID = CRW.CROSSROAD_ID WHERE FRONT_BACK = 0 GROUP BY OSMWAY_ID"; - System.out.println(selectStmt); + String selectStmt = "SELECT SUM(COUNT_VALUE)/COUNT(DISTINCT DATETIME) as ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG ,FROM_DIRECTION, OSMWAY_ID FROM (SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM (SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM (SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') SENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays SW WHERE crossroadID ='"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN (SELECT ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET,DATETIME FROM jee_trafficlight_rawevents RE WHERE RE.DATETIME >= '"+toSql(from)+"'AND RE.DATETIME < '"+toSql(to)+"' AND CROSSROAD = '"+crossroadName+"') EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET) CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID) RESULT LEFT JOIN (SELECT * FROM mw_CrossroadWays WHERE TYPE = '0')CRW on RESULT.FROM_DIRECTION = CRW.DIRECTION AND RESULT.CROSSROAD_ID = CRW.CROSSROAD_ID WHERE FRONT_BACK = 0 GROUP BY OSMWAY_ID"; Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); while (rs.next()) { @@ -362,6 +398,7 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi crw.setMaxWeightWay(wayID, maxValue); double count = rs.getDouble("ANZAHL"); double load = rs.getDouble("BELEGUNG"); + setMaximalWeightsInputWayImproved(getInputWay(crossroadID, wayID), count, load, from, timeRange); crw.addWeightWay(wayID, new double[]{count,load,(count/maxValue[0])*100}); crw.setTimestamp(timestamp); @@ -461,10 +498,12 @@ private double[] getMaximalWeightInputWay(int osmWayID, int crossroadRoad) { } public void getMaximalWeightInputWay() { - Random rand = new Random(); try { String selectStmt = null; - if(!dummyMax) + if(improvedMax){ + selectStmt = "SELECT * FROM mw_MaxValues_InputWaysImproved WHERE COUNT_OR_LOAD =0"; + } + else if(!dummyMax) selectStmt = "SELECT * FROM mw_MaxValues_InputWays WHERE COUNT_OR_LOAD =0"; else { if(backupWays) @@ -475,7 +514,13 @@ public void getMaximalWeightInputWay() { Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); while(rs.next()) { - if(!dummyMax) + if(improvedMax){ + double maxCount = rs.getDouble("COUNT_VALUE"); + if(maxCount <1) + maxCount= 1; + maxValuesInputWays.put(rs.getInt(1), new double[]{maxCount,rs.getDouble("LOAD_VALUE")}); + } + else if(!dummyMax) maxValuesInputWays.put(rs.getInt(1), new double[]{rs.getDouble("COUNT"),rs.getDouble("LOAD")}); else{ maxValuesInputWays.put(rs.getInt("INPUTWAY_ID"), new double[]{rs.getDouble("MAX_COUNT"),0}); @@ -534,20 +579,30 @@ public void writeMaximalWeightSensorRandom() { } } + + /** * liest die maximalen Werte, welche für einen Kreuzung gemessen wurden - über dummyMax können einmalig zufällig generierte Werte geladen werden */ public void getMaximalWeightCrossroad() { - Random rand = new Random(); try { String selectStmt = "SELECT * FROM mw_MaxValues_Crossroad WHERE COUNT_OR_LOAD =0"; if(dummyMax) selectStmt = "SELECT * FROM mw_MaxValues_Crossroad_Random"; + if(improvedMax) + selectStmt = "SELECT * FROM mw_MaxValues_CrossroadImproved"; Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); while(rs.next()){ - if(!dummyMax) - maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getInt("COUNT")+20,0}); + if(improvedMax){ + double maxCount = rs.getDouble("COUNT_VALUE"); + if(maxCount <1) + maxCount = 1; + maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {maxCount,rs.getDouble("LOAD_VALUE")}); + + } + else if(!dummyMax) + maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getInt("COUNT"),0}); else{ maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getDouble("MAX_COUNT"),0}); } @@ -824,7 +879,6 @@ public List getInputWaysForDNA(int modus) { ResultSet rs = stmt.executeQuery(statementString); int i = 0; while(rs.next() ) { - System.out.println("Added Node:"+i++); currentWeighted = gds.newNodeInstance(rs.getInt(1)); nodes.add(currentWeighted); } @@ -1186,9 +1240,10 @@ public double[] getInputWayWeight(int inputWayID, DateTime from, DateTime to) { Statement stmt = con.createStatement(); if(backupWays) statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID as INPUTWAY_ID, IWG.wayID as OSMWAY_ID, IWG.crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME, sensorID as SENSOR_ID, sensorName as SENSOR_NAME,IWG.direction as DIRECTION FROM (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID ="+inputWayID+") IWG LEFT JOIN mw_SensorWays SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID AND IWG.direction = SW.direction) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ="+crossroadID+") S2 ON S1.SENSOR_ID = S2.ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; - else + else{ statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID as INPUTWAY_ID, IWG.wayID as OSMWAY_ID, IWG.crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME, sensorID as SENSOR_ID, sensorName as SENSOR_NAME FROM (SELECT * FROM mw_InputWaysGlobal_bak2 IWG WHERE IWG.ID ="+inputWayID+") IWG LEFT JOIN mw_SensorWays_bak SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ="+crossroadID+") S2 ON S1.SENSOR_ID = S2.ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; - + statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT FRONT_AND_BACK.* FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID AS INPUTWAY_ID, IWG.wayID AS OSMWAY_ID, IWG.crossroadID AS CROSSROAD_ID, crossroadName AS CROSSROAD_NAME, sensorID AS SENSOR_ID, sensorName AS SENSOR_NAME FROM (SELECT * FROM mw_InputWaysGlobal_bak2 IWG WHERE IWG.ID ='"+inputWayID+"') IWG LEFT JOIN mw_SensorWays_bak SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ='"+crossroadID+"') S2 ON S1.SENSOR_ID = S2.ID) FRONT_AND_BACK JOIN (SELECT * FROM mw_SensorConnection_bak FR WHERE FR.FRONT_BACK = 0) ONLY_FRONT ON FRONT_AND_BACK.SENSOR_ID = ONLY_FRONT.SENSOR_ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; + } ResultSet rs = stmt.executeQuery(statementString); if(rs.first()){ count=rs.getDouble(1); diff --git a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java index 7547f423..bdcd729b 100644 --- a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java @@ -91,6 +91,8 @@ public Graph generate() { } double[] weight = crossroadWeight.getWeight(); + System.out.println("ID " +currentWeighted.getIndex() + "\tCount:" + weight[0] +"\tLoad:"+weight[1]+"\t"+"Norm:"+weight[2]); + db.setMaximalWeightsCrossroadImproved(currentWeighted.getIndex(), weight[0], weight[1], initDateTime,db.timeRange); currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); g.addNode(currentWeighted); diff --git a/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java index 537ae62e..50ec559c 100644 --- a/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java @@ -76,7 +76,7 @@ public Graph generate() { case 0: weight = db.getInputWayWeight(currentWeighted.getIndex(), initDateTime, initDateTime.plusMinutes(stepsize)); break; - case 1: + case 1: case 3: weight = db.getInputWayWeight(currentWeighted.getIndex(),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange)); break; case 2: @@ -92,7 +92,9 @@ public Graph generate() { currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); g.addNode(currentWeighted); - + if(weight[2]>96) + System.out.println("ID " +currentWeighted.getIndex() + "\tCount:" + weight[0] +"\tLoad:"+weight[1]+"\t"+"Norm:"+weight[2]); + } List connection = db.getInputWaysConnectionForDNA(); diff --git a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java index 0a79461c..914c03c6 100644 --- a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java @@ -131,6 +131,7 @@ else if (modus == 3){ // Aggregiert die Weiter für einen Beobachtungszeitraum i Double3dWeight oldWeight = (Double3dWeight) n.getWeight(); Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); //System.out.println("Index: \t"+n.getIndex()+"\tOldWeight: "+oldWeight.asString()+"\tNewWeight:"+newWeight.asString()); + db.setMaximalWeightsCrossroadImproved(n.getIndex(), update[0], update[1], time,db.timeRange); if(Math.abs(oldWeight.getZ() - newWeight.getZ())>10 ) System.out.println("Alarm."); if(!oldWeight.equals(newWeight)) diff --git a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java index 841d815f..da1b7a9f 100644 --- a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java @@ -9,6 +9,7 @@ import java.util.Set; import org.joda.time.DateTime; +import org.mockito.internal.util.collections.ListUtil; import dna.graph.Graph; import dna.graph.IElement; @@ -28,6 +29,7 @@ import dna.updates.update.EdgeRemoval; import dna.updates.update.NodeWeight; import dna.updates.update.Update; +import dna.util.ArrayUtils; import dna.util.parameters.IntParameter; import dna.util.parameters.ObjectParameter; import dna.util.parameters.Parameter; @@ -44,6 +46,7 @@ public class TrafficInputWayBatchGenerator extends BatchGenerator{ private HashMap> newDisabledEdges = new HashMap<>(); private double treshold; private TrafficUpdate trafficUpdate; + private HashMap> nodeHistory; public TrafficInputWayBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, int modus, DateTime holidayStart, boolean [] daySelection, double treshold,TrafficUpdate trafficUpdate) { @@ -59,6 +62,7 @@ public TrafficInputWayBatchGenerator(String name,DB db, DateTime initDateTime, i this.daySelection = daySelection; this.treshold = treshold; this.trafficUpdate = trafficUpdate; + this.nodeHistory = new HashMap<>(); } @Override @@ -96,7 +100,35 @@ public Batch generate(Graph g) { case 2: update = (trafficUpdate.isAffected(n.getIndex()))? db.getInputWayWeightStaticBatch(n.getIndex(),trafficUpdate) : null; break; - + case 3: + time = initDateTime; + int index = n.getIndex(); + long start = g.getTimestamp(); + double max = 0; + for (int i = 0; i < 5; i++) { + time = Helpers.calculateNextDay(initDateTime, start++, daySelection, holidayStart, false); + double[] weightOfDay = db.getInputWayWeight(n.getIndex(),time.minusMinutes(db.timeRange),time.plusMinutes(db.timeRange)); + if(nodeHistory.containsKey(index)){ + System.out.println(weightOfDay[2]); + nodeHistory.get(index).add(weightOfDay[2]); + } + else { + List weightList = new ArrayList<>(); + weightList.add(weightOfDay[2]); + nodeHistory.put(index, weightList); + } + //System.out.println("Aggregate " +time); + + } + double sum = 0; + List values = nodeHistory.get(index); + for (int i = 0; i < values.size(); i++) { + sum+=values.get(i); + } + double value = (values.isEmpty())? 0 : sum/values.size(); + update = new double[]{0,0,value}; + System.out.println("Avg: " + value); + break; default: System.out.println("Modus nicht definiert"); break; @@ -106,6 +138,8 @@ public Batch generate(Graph g) { Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); if(!oldWeight.equals(newWeight)) b.add(new NodeWeight((dna.graph.weights.IWeightedNode) currentNode,new Double3dWeight(update[0],update[1],update[2]))); + if(update[2]>95) + System.out.println("ID " +n.getIndex() + "\tCount:" + update[0] +"\tLoad:"+update[1]+"\t"+"Norm:"+update[2]); } else{ update = new double[]{oldWeight.getX(),oldWeight.getY(),oldWeight.getZ()}; From 41cf3d9dc604f08104af89acb58b1b17f02e1886 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Mon, 5 Jan 2015 13:10:24 +0100 Subject: [PATCH 08/24] Numerische Modi-Definition auf Enum umgestellt --- src/dna/graph/generators/traffic/DB.java | 53 ++++--------------- .../TrafficCrossroadGraphGenerator.java | 14 ++--- .../TrafficInputWayGraphGenerator.java | 16 +++--- .../graph/generators/traffic/TrafficModi.java | 26 +++++++++ .../traffic/TrafficSensorGraphGenerator.java | 17 +++--- .../TrafficCrossroadBatchGenerator.java | 39 +++++++------- .../TrafficInputWayBatchGenerator.java | 29 +++++----- .../traffic/TrafficSensorBatchGenerator.java | 19 +++---- 8 files changed, 102 insertions(+), 111 deletions(-) create mode 100644 src/dna/graph/generators/traffic/TrafficModi.java diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index 1d31ce39..c2465ce9 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -60,7 +60,7 @@ public class DB { private HashMap> disabledEdgesInputWay; private boolean dummyMax; private boolean backupWays = false; - private boolean improvedMax = true; + private boolean improvedMax = false; /** * Konstruktor für die Nutzung der Datenbank ohne @@ -680,7 +680,7 @@ public HashMap getInputWays(int crossroadID) { } /** - * liefert eine Liste von Ausfahrtswegen, vonden der übergebene Einfahrtsweg direkt zu erreichen ist + * liefert eine Liste von Ausfahrtswegen, von denen der übergebene Einfahrtsweg direkt zu erreichen ist * @param crossroadID * @param toWay * @return @@ -866,7 +866,7 @@ public int getInputWay(int crossroadID,int wayID){ * * @return */ - public List getInputWaysForDNA(int modus) { + public List getInputWaysForDNA() { List nodes = new ArrayList(); Node currentWeighted = null; try { @@ -900,7 +900,6 @@ public List getInputWaysConnectionForDNA() { ResultSet rs = stmt.executeQuery(statementString); int i = 0; while(rs.next() ) { - System.out.println("Added " +i++); edges.add(new EdgeContainer(rs.getInt("fromID"),rs.getInt("toID"))); } } catch (SQLException e) { @@ -911,16 +910,13 @@ public List getInputWaysConnectionForDNA() { /** - * liest alle Kreuzunen aus der Datenbank, das Gewicht wird gemäß dem Modus bestimmt - * @param modus 0 = Voraussage mit Stepsize, 1 = Rückblick für Tagesvergleich - * @return + * liest alle Knoten für das Kreuzungsmodell aus der Datenbank + * @return Knotenliste */ - public List getCrossroadsForDNA(int modus) { - if(modus == 1) { - if(timeRange==0){ - System.out.println("TimeRange ist 0, setze auf 1"); - timeRange=1; - } + public List getCrossroadsForDNA() { + if(timeRange==0){ + System.out.println("TimeRange ist 0, setze auf 1"); + timeRange=1; } List nodes = new ArrayList(); @@ -944,34 +940,7 @@ public List getCrossroadsForDNA(int modus) { } return nodes; } - /* - public List getCrossroadsForDNA_Mode1() { - - List nodes = new ArrayList(); - Node current = null; - DirectedWeightedNode currentWeighted = null; - try { - System.out.println("Lade Kreuzungen aus Datenbank..."); - Statement stmt = con.createStatement(); - String statementString; - statementString = "SELECT * FROM ((SELECT DISTINCT FROM_CROSSROAD as CROSSROAD FROM mw_CrossroadConnection) UNION (SELECT DISTINCT TO_CROSSROAD as CROSSROAD FROM mw_CrossroadConnection)) V"; - ResultSet rs = stmt.executeQuery(statementString); - while(rs.next() ) { - int label = rs.getInt(1); - double[] weight = getCrossroadWeight(rs.getInt(1),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange)).getWeight(); - //System.out.println("Füge Knoten " +label +" mit Gewicht " +weight[0]+"/"+weight[1] + " hinzu "); - current = gds.newNodeInstance(label); - currentWeighted = (current instanceof DirectedWeightedNode) ? (DirectedWeightedNode) current : null; - if(currentWeighted!=null) { - currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); - nodes.add(currentWeighted); - } - } - } catch (SQLException e) { - e.printStackTrace(); - } - return nodes; - }*/ + public int writeConnections(Set connections) { java.sql.PreparedStatement stmt; @@ -986,7 +955,7 @@ public int writeConnections(Set connections) { stmt.setInt(5, connection.toCrossroad); stmt.setString(6, getCrossroadName(connection.toCrossroad)); stmt.addBatch(); - }//System.out.println(strInsertIntoMyTable); + } stmt.executeBatch(); } catch (Exception e) { e.printStackTrace(); diff --git a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java index bdcd729b..f05b6de1 100644 --- a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java @@ -30,19 +30,19 @@ public class TrafficCrossroadGraphGenerator extends GraphGenerator{ List nodeslist; private DB db; - private int modus; + private TrafficModi modus; private DateTime initDateTime; private int stepsize; private int timeRange; private TrafficUpdate trafficUpdate; - public TrafficCrossroadGraphGenerator(String name, GraphDataStructure gds, DB db,long timeStampInit,int modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate) { + public TrafficCrossroadGraphGenerator(String name, GraphDataStructure gds, DB db,long timeStampInit,TrafficModi modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate) { this(name, null, gds,timeStampInit, 0, 0,db,modus,initDateTime,stepsize,timeRange,trafficupdate); } public TrafficCrossroadGraphGenerator(String name, Parameter[] params, GraphDataStructure gds, long timestampInit, int nodesInit, - int edgesInit,DB db,int modus,DateTime initDateTime,int stepsize,int timeRange,TrafficUpdate trafficUpdate) { + int edgesInit,DB db,TrafficModi modus,DateTime initDateTime,int stepsize,int timeRange,TrafficUpdate trafficUpdate) { super(name, params, gds, timestampInit, nodesInit, edgesInit); this.db= db; this.modus=modus; @@ -62,7 +62,7 @@ public Graph generate() { HashMap disabledEdges = new HashMap<>(); // Nodes - nodes = db.getCrossroadsForDNA(modus); + nodes = db.getCrossroadsForDNA(); CrossroadWeight crossroadWeight = null; Node currentNode = null; DirectedWeightedNode currentWeighted = null; @@ -76,13 +76,13 @@ public Graph generate() { } switch (modus) { - case 0: + case Continuous: crossroadWeight = db.getCrossroadWeight(currentWeighted.getIndex(),initDateTime,initDateTime.plusMinutes(stepsize),0); break; - case 1:case 3: + case DayTimeRange: case Aggregation: crossroadWeight = db.getCrossroadWeight(currentWeighted.getIndex(),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange),0); break; - case 2: + case Simulation: crossroadWeight = db.getCrossroadWeightStaticInit(currentWeighted.getIndex(),initDateTime,initDateTime.plusMinutes(1),0,trafficUpdate); break; default: diff --git a/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java index 50ec559c..f6b87fe8 100644 --- a/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java @@ -25,7 +25,7 @@ public class TrafficInputWayGraphGenerator extends GraphGenerator{ List nodeslist; private DB db; private DateTime initTime; - private int modus; + private TrafficModi modus; private DateTime initDateTime; private int stepsize; private int timeRange; @@ -33,13 +33,13 @@ public class TrafficInputWayGraphGenerator extends GraphGenerator{ private double treshold; private HashMap> disabledEdges = new HashMap<>(); - public TrafficInputWayGraphGenerator(String name, GraphDataStructure gds, DB db, long timeStamp, int modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold) { + public TrafficInputWayGraphGenerator(String name, GraphDataStructure gds, DB db, long timeStamp, TrafficModi modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold) { this(name, null, gds,timeStamp, 0, 0,db, modus,initDateTime,stepsize,timeRange,trafficupdate,treshold); } public TrafficInputWayGraphGenerator(String name, Parameter[] params, GraphDataStructure gds, long timestampInit, int nodesInit, - int edgesInit,DB db,int modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold) { + int edgesInit,DB db,TrafficModi modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold) { super(name, params, gds, timestampInit, nodesInit, edgesInit); this.db= db; this.modus = modus; @@ -59,7 +59,7 @@ public Graph generate() { Set overloaded = new HashSet<>(); // Nodes - nodes = db.getInputWaysForDNA(modus); + nodes = db.getInputWaysForDNA(); Node currentNode = null; DirectedWeightedNode currentWeighted = null; @@ -73,17 +73,17 @@ public Graph generate() { } switch (modus) { - case 0: + case Continuous: weight = db.getInputWayWeight(currentWeighted.getIndex(), initDateTime, initDateTime.plusMinutes(stepsize)); break; - case 1: case 3: + case DayTimeRange: case Aggregation: weight = db.getInputWayWeight(currentWeighted.getIndex(),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange)); break; - case 2: + case Simulation: weight = db.getInputWayWeightStaticInit(currentWeighted.getIndex(),trafficUpdate); break; default: - System.out.println("error - Modus nicht definiert"); + System.out.println("error - Modus nicht definiert @ TrafficInputwayGraphGenerator"); break; } if(weight[2] > treshold){ diff --git a/src/dna/graph/generators/traffic/TrafficModi.java b/src/dna/graph/generators/traffic/TrafficModi.java new file mode 100644 index 00000000..8d41c8a0 --- /dev/null +++ b/src/dna/graph/generators/traffic/TrafficModi.java @@ -0,0 +1,26 @@ +package dna.graph.generators.traffic; + +public enum TrafficModi { + /** + * Kontinuierlicher Modus, bei dem ausgehend von einem Startzeitpunkt, + * in jedem Batch ein Zeitschritt festgelegter Dauer addiert wird + */ + Continuous, + /** + * Tagesmodus, bei dem ausgehend von einem Startzeitpunkt und eines + * Zeitintervall, für jeden der durch daySelection ausgewählten Tage + * das entsprechende Intervall berechnet wird + */ + DayTimeRange, + /** + * Statischer Simulationsmodus, bei dem die Daten anhand des TrafficUpdate- + * Objekt geändert werden + */ + Simulation, + /** + * Aggregationmodus für den Vergleich, bei dem für den Batch die Tage eines + * festgelegten Zeitraums aggregiert werden, und dann ein Vergleichsmaß (z.b. + * Durchschnitt) berechnet wird + */ + Aggregation +} diff --git a/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java index b546f8c2..7be93820 100644 --- a/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java @@ -25,7 +25,7 @@ public class TrafficSensorGraphGenerator extends GraphGenerator{ List nodeslist; private DB db; - private int modus; + private TrafficModi modus; private DateTime initDateTime; private int stepsize; private int timeRange; @@ -33,13 +33,13 @@ public class TrafficSensorGraphGenerator extends GraphGenerator{ private double treshold; private HashMap> disabledEdges = new HashMap<>(); - public TrafficSensorGraphGenerator(String name, GraphDataStructure gds, DB db,long timeStamp,int modus,DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold) { + public TrafficSensorGraphGenerator(String name, GraphDataStructure gds, DB db,long timeStamp,TrafficModi modus,DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold) { this(name, null, gds,timeStamp, 0, 0,db,modus,initDateTime,stepsize,timeRange,trafficupdate,treshold); } public TrafficSensorGraphGenerator(String name, Parameter[] params, GraphDataStructure gds, long timestampInit, int nodesInit, - int edgesInit,DB db, int modus,DateTime initDateTime,int stepsize,int timeRange,TrafficUpdate trafficUpdate,double treshold) { + int edgesInit,DB db, TrafficModi modus,DateTime initDateTime,int stepsize,int timeRange,TrafficUpdate trafficUpdate,double treshold) { super(name, params, gds, timestampInit, nodesInit, edgesInit); this.db= db; this.modus = modus; @@ -60,10 +60,10 @@ public Graph generate() { Node currentNode = null; DirectedWeightedNode currentWeighted = null; switch (modus) { - case 0: + case Continuous: db.getSensorWeights(initDateTime, initDateTime.plusMinutes(stepsize), 0); break; - case 1: + case DayTimeRange: db.getSensorWeights(initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange),0); break; @@ -81,13 +81,13 @@ public Graph generate() { continue; } switch (modus) { - case 0: + case Continuous: weight = db.getSensorModelWeight(currentWeighted.getIndex(),initDateTime,initDateTime.plusMinutes(stepsize),0); break; - case 1: + case DayTimeRange: weight = db.getSensorModelWeight(currentWeighted.getIndex(),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange),0); break; - case 2: + case Simulation: weight = db.getSensorModelWeightStaticInit(currentWeighted.getIndex(),trafficUpdate); break; default: @@ -98,7 +98,6 @@ public Graph generate() { weight = new double[]{0,0,0}; } if(weight[2] > treshold){ - System.out.println("Overloaded " +currentWeighted.getIndex()); overloaded.add(currentWeighted.getIndex()); } currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); diff --git a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java index 914c03c6..9d106add 100644 --- a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java @@ -18,6 +18,7 @@ import dna.graph.generators.traffic.CrossroadWeight; import dna.graph.generators.traffic.DB; import dna.graph.generators.traffic.EdgeContainer; +import dna.graph.generators.traffic.TrafficModi; import dna.graph.generators.traffic.TrafficUpdate; import dna.graph.nodes.DirectedNode; import dna.graph.nodes.DirectedWeightedNode; @@ -44,14 +45,14 @@ public class TrafficCrossroadBatchGenerator extends BatchGenerator{ int stepSize; int run=0; int observationDays; - private int modus; + private TrafficModi modus; DateTime holidayStart; boolean[] daySelection; HashMap disabledEdges = new HashMap<>(); private TrafficUpdate trafficUpdate; HashMap nodeHistory; - public TrafficCrossroadBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, int modus, DateTime holidayStart, boolean [] daySelection,TrafficUpdate trafficUpdate, int observationDays) { + public TrafficCrossroadBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, TrafficModi modus, DateTime holidayStart, boolean [] daySelection,TrafficUpdate trafficUpdate, int observationDays) { super(name, new IntParameter("NA", 0), new IntParameter("NR", 0), new IntParameter("NW", 0), new ObjectParameter("NWS", 0), new IntParameter("EA", 0), @@ -79,13 +80,11 @@ public Batch generate(Graph g) { Iterable nodes = g.getNodes(); CrossroadWeight crossroadWeight = null; DateTime time = null; - if(modus == 1 || modus == 2){ - System.out.println("Alter Batch am : \t" +initDateTime); + if(modus == TrafficModi.DayTimeRange || modus == TrafficModi.Simulation){ time = initDateTime; time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart,true); - System.out.println("Neuer Batch am : \t" +time); } - if(modus == 3){ + if(modus == TrafficModi.Aggregation){ nodeHistory = new HashMap<>(); } int newTimeStamp = (int) g.getTimestamp() + 1; @@ -95,17 +94,17 @@ public Batch generate(Graph g) { double[] update = null; // Gewichts-Update - - if(modus==0){ // Vergleich in Schritten der Größe Stepsize + switch (modus) { + case Continuous: crossroadWeight =db.getCrossroadWeight(n.getIndex(), initDateTime.plusMinutes((int) (g.getTimestamp()*stepSize)),initDateTime.plusMinutes((int) (g.getTimestamp()+stepSize)*stepSize),newTimeStamp); - } - else if (modus == 1 ){ // Vergleich für Zeiträume der Länge timeRange an Tagen aus Dayselection, Geht in die Zukunft + break; + case DayTimeRange: crossroadWeight = db.getCrossroadWeight(n.getIndex(),time.minusMinutes(db.timeRange),time.plusMinutes(db.timeRange),newTimeStamp); - } - else if (modus == 2){ // Statische Verkehrsanalyse + break; + case Simulation: crossroadWeight = db.getCrossroadWeightStaticBatch(n.getIndex(),trafficUpdate); - } - else if (modus == 3){ // Aggregiert die Weiter für einen Beobachtungszeitraum in der Vergangenheit + break; + case Aggregation: time = initDateTime; int index = n.getIndex(); long start = g.getTimestamp(); @@ -120,20 +119,19 @@ else if (modus == 3){ // Aggregiert die Weiter für einen Beobachtungszeitraum i weightList.add(weightOfDay); nodeHistory.put(index, weightList); } - System.out.println("Aggreate: "+time); - //System.out.println("Alter Batch am "+initDateTime); - //System.out.println("Update auf Knoten mit Index " +index +" am " + time); } crossroadWeight = nodeHistory.get(index).getAverage(); + break; + default: + System.out.println("error - Modus nicht definiert"); + break; } + update = crossroadWeight.getWeight(); Double3dWeight oldWeight = (Double3dWeight) n.getWeight(); Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); - //System.out.println("Index: \t"+n.getIndex()+"\tOldWeight: "+oldWeight.asString()+"\tNewWeight:"+newWeight.asString()); db.setMaximalWeightsCrossroadImproved(n.getIndex(), update[0], update[1], time,db.timeRange); - if(Math.abs(oldWeight.getZ() - newWeight.getZ())>10 ) - System.out.println("Alarm."); if(!oldWeight.equals(newWeight)) b.add(new NodeWeight((dna.graph.weights.IWeightedNode) currentNode,newWeight)); @@ -165,6 +163,7 @@ else if (modus == 3){ // Aggregiert die Weiter für einen Beobachtungszeitraum i for (Map.Entry oldDeletedEdge : disabledEdges.entrySet()) { b.add(new EdgeAddition(oldDeletedEdge.getValue())); } + disabledEdges=newDisabled; return b; diff --git a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java index da1b7a9f..e1538d09 100644 --- a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java @@ -17,6 +17,7 @@ import dna.graph.edges.Edge; import dna.graph.generators.traffic.DB; import dna.graph.generators.traffic.EdgeContainer; +import dna.graph.generators.traffic.TrafficModi; import dna.graph.generators.traffic.TrafficUpdate; import dna.graph.nodes.DirectedNode; import dna.graph.nodes.DirectedWeightedNode; @@ -39,7 +40,7 @@ public class TrafficInputWayBatchGenerator extends BatchGenerator{ DateTime initDateTime; int stepSize; int step=0; - int modus; + private TrafficModi modus; private DateTime holidayStart; private boolean[] daySelection; private HashMap> disabledEdges = new HashMap<>(); @@ -49,7 +50,7 @@ public class TrafficInputWayBatchGenerator extends BatchGenerator{ private HashMap> nodeHistory; - public TrafficInputWayBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, int modus, DateTime holidayStart, boolean [] daySelection, double treshold,TrafficUpdate trafficUpdate) { + public TrafficInputWayBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, TrafficModi modus, DateTime holidayStart, boolean [] daySelection, double treshold,TrafficUpdate trafficUpdate) { super(name, new IntParameter("NA", 0), new IntParameter("NR", 0), new IntParameter("NW", 10), new ObjectParameter("NWS", 0), new IntParameter("EA", 0), @@ -79,10 +80,9 @@ public Batch generate(Graph g) { DateTime time = null; Edge edge = null; Integer newKey = null; - if(modus == 1){ + if(modus == TrafficModi.DayTimeRange){ time = initDateTime; time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart,true); - System.out.println("Neuer Batch am : \t" +time); } newDisabledEdges = new HashMap<>(); for (IElement currentNode : nodes) { @@ -91,16 +91,16 @@ public Batch generate(Graph g) { //WeightUpdate switch (modus) { - case 0: + case Continuous: update = db.getInputWayWeight(n.getIndex(),initDateTime.plusMinutes((int) (g.getTimestamp()+1)*stepSize),initDateTime.plusMinutes((int) (g.getTimestamp()+2)*stepSize)); break; - case 1: + case DayTimeRange: update = db.getInputWayWeight(n.getIndex(),time.minusMinutes(db.timeRange),time.plusMinutes(db.timeRange)); break; - case 2: + case Simulation: update = (trafficUpdate.isAffected(n.getIndex()))? db.getInputWayWeightStaticBatch(n.getIndex(),trafficUpdate) : null; break; - case 3: + case Aggregation: time = initDateTime; int index = n.getIndex(); long start = g.getTimestamp(); @@ -109,16 +109,13 @@ public Batch generate(Graph g) { time = Helpers.calculateNextDay(initDateTime, start++, daySelection, holidayStart, false); double[] weightOfDay = db.getInputWayWeight(n.getIndex(),time.minusMinutes(db.timeRange),time.plusMinutes(db.timeRange)); if(nodeHistory.containsKey(index)){ - System.out.println(weightOfDay[2]); nodeHistory.get(index).add(weightOfDay[2]); } else { List weightList = new ArrayList<>(); weightList.add(weightOfDay[2]); nodeHistory.put(index, weightList); - } - //System.out.println("Aggregate " +time); - + } } double sum = 0; List values = nodeHistory.get(index); @@ -127,24 +124,24 @@ public Batch generate(Graph g) { } double value = (values.isEmpty())? 0 : sum/values.size(); update = new double[]{0,0,value}; - System.out.println("Avg: " + value); break; default: - System.out.println("Modus nicht definiert"); + System.out.println("error - Modus nicht definiert"); break; } + Double3dWeight oldWeight = (Double3dWeight) n.getWeight(); if(update!=null){ Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); if(!oldWeight.equals(newWeight)) b.add(new NodeWeight((dna.graph.weights.IWeightedNode) currentNode,new Double3dWeight(update[0],update[1],update[2]))); - if(update[2]>95) - System.out.println("ID " +n.getIndex() + "\tCount:" + update[0] +"\tLoad:"+update[1]+"\t"+"Norm:"+update[2]); } else{ update = new double[]{oldWeight.getX(),oldWeight.getY(),oldWeight.getZ()}; } + EdgeContainer ec = null; + if(update[2] > treshold) { newKey = n.getIndex(); int from; diff --git a/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java index 7ad86e73..fe3963f2 100644 --- a/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java @@ -16,6 +16,7 @@ import dna.graph.edges.Edge; import dna.graph.generators.traffic.DB; import dna.graph.generators.traffic.EdgeContainer; +import dna.graph.generators.traffic.TrafficModi; import dna.graph.generators.traffic.TrafficUpdate; import dna.graph.nodes.DirectedNode; import dna.graph.nodes.DirectedWeightedNode; @@ -41,7 +42,7 @@ public class TrafficSensorBatchGenerator extends BatchGenerator{ DateTime initDateTime; int stepSize; int step=0; - int modus; + TrafficModi modus; private DateTime holidayStart; private boolean[] daySelection; private double treshold; @@ -51,7 +52,7 @@ public class TrafficSensorBatchGenerator extends BatchGenerator{ private HashMap> newDisabledEdges; private TrafficUpdate trafficUpdate; - public TrafficSensorBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, int modus, DateTime holidayStart, boolean [] daySelection, double treshold,int timeRange,TrafficUpdate trafficUpdate) { + public TrafficSensorBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, TrafficModi modus, DateTime holidayStart, boolean [] daySelection, double treshold,int timeRange,TrafficUpdate trafficUpdate) { super(name, new IntParameter("NA", 0), new IntParameter("NR", 0), new IntParameter("NW", 0), new ObjectParameter("NWS", 0), new IntParameter("EA", 0), @@ -90,11 +91,11 @@ public Batch generate(Graph g) { Edge edge = null; switch (modus) { - case 0: + case Continuous: fromTime = initDateTime.plusMinutes((int) (g.getTimestamp()+1)*stepSize); toTime = initDateTime.plusMinutes((int) (g.getTimestamp()+2)*stepSize); break; - case 1: + case DayTimeRange: time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart,true); fromTime = time.minusMinutes(db.timeRange); toTime = time.plusMinutes(db.timeRange); @@ -104,7 +105,7 @@ public Batch generate(Graph g) { break; } // Vorabberechnung aller Gewichte der Realen Sensoren - if(modus == 0 || modus == 1){ + if(modus == TrafficModi.Continuous || modus == TrafficModi.DayTimeRange){ db.getSensorWeights(fromTime,toTime, newTimestamp); } @@ -120,17 +121,17 @@ public Batch generate(Graph g) { // Get Weight switch (modus) { - case 0: + case Continuous: update = db.getSensorModelWeight(currentWeighted.getIndex(),fromTime,toTime,newTimestamp); break; - case 1: + case DayTimeRange: update = db.getSensorModelWeight(currentWeighted.getIndex(),fromTime,toTime,newTimestamp); break; - case 2: + case Simulation: update = trafficUpdate.isAffected(currentWeighted.getIndex()) ? db.getSensorModelWeightStaticBatch(currentWeighted.getIndex(),trafficUpdate) : null; break; default: - System.out.println("error - Modus nicht definiert"); + System.out.println("error - Modus nicht definiert @ TrafficSensorBatchGenerator"); break; } Double3dWeight oldWeight = (Double3dWeight) currentWeighted.getWeight(); From 35f3040efb4a8b8e4373045b68dbd1ad6fd4e8da Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Mon, 5 Jan 2015 13:36:46 +0100 Subject: [PATCH 09/24] Kommentare CrossroadWeight --- .../generators/traffic/CardinalDirection.java | 2 +- .../generators/traffic/CrossroadWeight.java | 24 ++++++++----------- .../TrafficInputWayBatchGenerator.java | 2 -- 3 files changed, 11 insertions(+), 17 deletions(-) diff --git a/src/dna/graph/generators/traffic/CardinalDirection.java b/src/dna/graph/generators/traffic/CardinalDirection.java index e70ab2ed..53c6b19e 100644 --- a/src/dna/graph/generators/traffic/CardinalDirection.java +++ b/src/dna/graph/generators/traffic/CardinalDirection.java @@ -1,5 +1,5 @@ package dna.graph.generators.traffic; public enum CardinalDirection { -NORTH, EAST,SOUTH,WEST + NORTH, EAST,SOUTH,WEST } diff --git a/src/dna/graph/generators/traffic/CrossroadWeight.java b/src/dna/graph/generators/traffic/CrossroadWeight.java index 67e6d1ba..5d727872 100644 --- a/src/dna/graph/generators/traffic/CrossroadWeight.java +++ b/src/dna/graph/generators/traffic/CrossroadWeight.java @@ -65,7 +65,7 @@ public void resetInputWayWeight(double count, double load){ } /** - * calculates and returns the weight of a crossroad. + * berechnet das Gewicht des Kreuzungsknotens * Index 0 - count * Index 1 - load * Index 2 - count/maxcount @@ -88,36 +88,32 @@ public double[] getWeight(){ else sum[2]=0; - /* - // Load/Count - if(sum[0]>1) - sum[2] = sum[1]/(sum[0]*10)*10; - else - sum[2] = 0; - */ - /* - // Load-Wert - sum[2] = sum[1]; - */ return sum; } + /** + * liefert alle Einfahrtswege, deren Gewicht den Schwellwert überschritten hat + * @return + */ public HashMap getOverladedEdges() { HashMap result = new HashMap<>(); for (Map.Entry inputWay : inputWayWeights.entrySet()) { if(inputWay.getValue()[2] >threshold){ result.put(inputWay.getKey(), inputWay.getValue()); - System.out.println("Overloaded: " +inputWay.getKey() +"Crossroad " +crossroadID +"\t"+inputWay.getValue()[0]+"\tNorm:" +inputWay.getValue()[2]); } } return result; } + /** + * liefert alle Einfahrtswege mit ihren Gewichten + * @return + */ public HashMap getWayWeights(){ return inputWayWeights; - } + public boolean addWeights(HashMap wayWeights){ for (Integer keys : wayWeights.keySet()) { if(!inputWayWeights.containsKey(keys)) diff --git a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java index 37a2ce74..3678c9e7 100644 --- a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java @@ -136,8 +136,6 @@ public Batch generate(Graph g) { Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); if(!oldWeight.equals(newWeight)) b.add(new NodeWeight((dna.graph.weights.IWeightedNode) currentNode,new Double3dWeight(update[0],update[1],update[2]))); - if(update[2]>95) - System.out.println("ID " +n.getIndex() + "\tCount:" + update[0] +"\tLoad:"+update[1]+"\t"+"Norm:"+update[2]); } else{ update = new double[]{oldWeight.getX(),oldWeight.getY(),oldWeight.getZ()}; From fdb53a5038f3f95dae71c25291373c444c48c999 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Tue, 6 Jan 2015 12:14:22 +0100 Subject: [PATCH 10/24] Kommentare Crossroad-Klasse --- .../graph/generators/traffic/Crossroad.java | 67 ++++++++++++++----- src/dna/graph/generators/traffic/DB.java | 7 +- 2 files changed, 55 insertions(+), 19 deletions(-) diff --git a/src/dna/graph/generators/traffic/Crossroad.java b/src/dna/graph/generators/traffic/Crossroad.java index c3a2013c..90bcbc72 100644 --- a/src/dna/graph/generators/traffic/Crossroad.java +++ b/src/dna/graph/generators/traffic/Crossroad.java @@ -9,49 +9,70 @@ public class Crossroad { - HashMap inputWays; - HashMap outputWays; - HashMap> inputToOutput; - HashMap outputToInput; - int crossroadID; - DB db; + private HashMap inputWays; + private HashMap outputWays; + private HashMap> inputToOutput; + private HashMap outputToInput; + private int crossroadID; + private DB db; public Crossroad(int crossroadID, DB db){ - inputToOutput=new HashMap<>(); + this.inputToOutput=new HashMap<>(); this.crossroadID=crossroadID; this.db=db; - outputToInput = new HashMap<>(); + this.outputToInput = new HashMap<>(); } - + /** + * speichert die übergebene HashMap von Einfahrtswegen + * @param newInputWays + * @return Setzen = true, Ersetzen = False + */ public boolean setInputWays(HashMap newInputWays) { boolean wasNull = inputWays==null; inputWays=newInputWays; return wasNull; } - + /** + * speichert die übergebene HashMap von Ausfahrtswegen + * @param newOutputWays + * @return Setzen = true, Ersetzen = False + */ public boolean setOutputWays(HashMap newOutputWays) { boolean wasNull = outputWays==null; outputWays=newOutputWays; return wasNull; } - + /** + * Verbindet einen Einfahrtsweg mit einem Ausfahrtsweg + * @param inDir CardinalDirection des Einfahrtsweges + * @param outDir CardinalDirection des Ausfahrtsweges + * @return Wert neu gesetzt = true, Wert bereits vorhanden = false + */ public boolean setOutputWay(CardinalDirection inDir, CardinalDirection outDir){ if(!inputToOutput.containsKey(inDir)){ inputToOutput.put(inDir, new HashSet()); } return inputToOutput.get(inDir).add(outDir); } - - public Integer getWay(CardinalDirection direction, int type) { - if(type==0) + /** + * liefert den Identifier eines Weges + * @param direction, Himmelsrichtung des Weges + * @param isInputWay, Einfahrtsweg = true, Ausfahrtsweg = false + * @return + */ + public Integer getWay(CardinalDirection direction, boolean isInputWay) { + if(isInputWay) return (inputWays.containsKey(direction)) ? inputWays.get(direction) : -1; else return (outputWays.containsKey(direction)) ? outputWays.get(direction) : -1; } + /** + * verbindet die Ausfahrtswege mit den Einfahrtswegen benachbarter Kreuzungen + */ public void connectWays () { for (CardinalDirection outDir : outputWays.keySet()) { - List connectedWays = db.getConnectedInputWays(getWay(outDir,1), crossroadID); + List connectedWays = db.getConnectedInputWays(getWay(outDir,false), crossroadID); for (InputWay integers : connectedWays) { if(integers!=null) { outputToInput.put(outDir, integers); @@ -59,7 +80,10 @@ public void connectWays () { } } } - + /** + * liefert eine Menge von Verbindungen von Einfahrtswegen zu benachbarten Einfahrtswegen + * @return + */ public Set getConnections(){ Set connectedOutputways; Set connectedCrossroads = new HashSet<>(); @@ -76,13 +100,18 @@ public Set getConnections(){ return connectedCrossroads; } + /** + * Kontrollausgabe für die Einfahrtswege + */ public void printInputWays(){ System.out.println("InputWays von:\t"+this.crossroadID); for (Map.Entry inputWay : inputWays.entrySet()) { System.out.println(inputWay.getKey() +"\t"+inputWay.getValue()); } } - + /** + * Kontrollausgabe für die innere Verbindung von Wegen + */ public void printInput2Output(){ System.out.println("Input2Output von:\t"+this.crossroadID); for (Map.Entry> inputWay : inputToOutput.entrySet()) { @@ -92,7 +121,9 @@ public void printInput2Output(){ } } } - + /** + * Kontrollausgabe für die Ausfahrtswege + */ public void printOutputWays(){ System.out.println("OutputWays von:\t"+this.crossroadID); for (Map.Entry outputWay : outputWays.entrySet()) { diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index 623774dd..bbf3637e 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -799,7 +799,12 @@ public HashMap getOutputWays(int sensorID, int crossroadID) { } return outputDirection; } - + /** + * liefert alle Einfahrtswege, die mit dem übergebenen Ausfahrtsweg verbunden sind + * @param outputOSM, OSM-ID des Weges + * @param outputCrossroad, ID der Kreuzung, zu der der Weg gehört + * @return + */ public List getConnectedInputWays(int outputOSM, int outputCrossroad) { List connections = new ArrayList<>(); try { From 1ff55a06fdc57bcdb9e673228efe3af1089fafe5 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Tue, 6 Jan 2015 13:44:20 +0100 Subject: [PATCH 11/24] Auswahl der Maximalwerte - dummyMax,ImprovedMax --- .../generators/traffic/CrossroadWeight.java | 73 +++++++++-- src/dna/graph/generators/traffic/DB.java | 119 +++++++++--------- .../traffic/CrossroadWeightList.java | 2 +- .../TrafficCrossroadBatchGenerator.java | 2 +- 4 files changed, 126 insertions(+), 70 deletions(-) diff --git a/src/dna/graph/generators/traffic/CrossroadWeight.java b/src/dna/graph/generators/traffic/CrossroadWeight.java index 5d727872..beb2d4b0 100644 --- a/src/dna/graph/generators/traffic/CrossroadWeight.java +++ b/src/dna/graph/generators/traffic/CrossroadWeight.java @@ -6,55 +6,100 @@ public class CrossroadWeight { public int crossroadID; - public String crossroadName; + private String crossroadName; public HashMap inputWayWeights; - public HashMap inputWayMaxWeights; - public double maxCount; - public double maxLoad; + private HashMap inputWayMaxWeights; + private double maxCount; + private double maxLoad; private double threshold; private int timestamp; public CrossroadWeight(int crossroadID,String crossroadName, double treshold){ this.crossroadID = crossroadID; this.crossroadName = crossroadName; - inputWayWeights = new HashMap<>(); - inputWayMaxWeights = new HashMap<>(); + this.inputWayWeights = new HashMap<>(); + this.inputWayMaxWeights = new HashMap<>(); this.threshold = treshold; this.timestamp=0; } - + /** + * liefert den Schwellwert für die Überlastung + * @return + */ public double getThreshold(){ return threshold; } - + /** + * liefert den Namen der Kreuzung im Format "A ..." + * @return + */ + public String getCrossroadName(){ + return crossroadName; + } + /** + * fügt Gewichte zu einem Einfahrtsweg hinzu + * @param osmWayID, OSM-ID des Einfahrtsweges + * @param weights, Gewichte des Einfahrtsweges + */ public void addWeightWay(int osmWayID, double[] weights) { inputWayWeights.put(osmWayID, weights); } - + /** + * fügt die maximalen Gewichte des Einfahrtsweges hinzu + * @param osmWayID - OSM-ID des Einfahrtsweges + * @param maxWeights + */ public void setMaxWeightWay(int osmWayID, double[] maxWeights) { inputWayMaxWeights.put(osmWayID, maxWeights); } + /** + * liefert die maximalen Gewichte des Einfahrtsweges + * @param osmWayID, OSM-ID des Einfahrtsweges + * @return + */ public double[] getMaxWeightWay(int osmWayID) { return inputWayMaxWeights.get(osmWayID); } + /** + * setzt den Zeitstempel, für den das letzte Gewicht vorliegt + * @param timestamp + */ public void setTimestamp(int timestamp){ this.timestamp = timestamp; } + /** + * liefert den Zeitstempel, für den das letzte Gewicht vorliegt + * @return + */ public int getTimestamp(){ return timestamp; } + /** + * setzt die maximalen Gewichte für die gesamte Kreuzung + * @param maxWeights + */ public void setMaxWeight(double[] maxWeights) { this.maxCount=maxWeights[0]; this.maxLoad=maxWeights[1]; } + + /** + * liefert die maximalen Werte für die gesamte Kreuzung + * @return + */ public double[] getMaxWeight() { return new double[] {maxCount,maxLoad}; } + /** + * verteilt das Knotengewicht gleichmäßig auf die Einfahrtswege, wird bei der Simulation verwendet + * @param count + * @param load + */ public void resetInputWayWeight(double count, double load){ double numOfInputWays = inputWayWeights.keySet().size(); double count_value = count/numOfInputWays; @@ -113,7 +158,11 @@ public HashMap getWayWeights(){ return inputWayWeights; } - + /** + * addiert die übergebenen Gewichte auf die Gewichte der Einfahrtswege + * @param wayWeights + * @return + */ public boolean addWeights(HashMap wayWeights){ for (Integer keys : wayWeights.keySet()) { if(!inputWayWeights.containsKey(keys)) @@ -130,6 +179,10 @@ public boolean addWeights(HashMap wayWeights){ return true; } + /** + * bildet den Durchschnitt der aufsummierten Gewichte + * @param divisor, Anzahl der Batches/Tage über die aggregiert wurde + */ public void divWays(int divisor){ if(divisor>0){ for (Map.Entry entry : inputWayWeights.entrySet()) { diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index bbf3637e..e88d92ef 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -60,20 +60,22 @@ public class DB { private HashMap> disabledEdgesInputWay; private boolean dummyMax; private boolean backupWays = false; - private boolean improvedMax = false; - + private boolean improvedMax = true; + private boolean newMaxValues = false; /** - * Konstruktor für die Nutzung der Datenbank ohne - * @param stepSize - * @param initTDateTime - * @param days - * @param timeRange - * @param treshold - * @param trafficUpdate - * @param dummyMax + * Konstruktur der Datenbank, die Login-Daten werden entweder aus einer Txt-Datei gelesen, + * oder falls diese nicht vorhanden ist, aus den Parametern übernommen. + * @param gds, Datenstruktur, welcher der Verwendung von DNA zugrunde liegt (für Knotentypen, Kantentypen ..) + * @param initTDateTime, Startzeitpunkt für die Modi mit realen Daten + * @param stepSize, Schrittweite für den kontinuerlichen Modus + * @param daySelection, Boolean-Array mit 7 Einträgen für die Wochentage + * @param timeRange, Intervalllänge für den Tages und Aggregationsmodus + * @param treshold, Schwellwert für die Überlastungserkennung + * @param trafficUpdate, statische Daten für den Simulationsmodus + * @param dummyMax, Verwendung von synthetischen Max-Werten oder realen Max-Werten */ - public DB(GraphDataStructure gds, DateTime initTDateTime, int stepSize, boolean[] days , int timeRange, double treshold,TrafficUpdate trafficUpdate,boolean dummyMax) { + public DB(GraphDataStructure gds, DateTime initTDateTime, int stepSize, boolean[] daySelection , int timeRange, double treshold,TrafficUpdate trafficUpdate,boolean dummyMax) { try { FileReader fr = new FileReader("db.txt"); BufferedReader br = new BufferedReader(fr); @@ -126,7 +128,7 @@ public DB(GraphDataStructure gds, DateTime initTDateTime, int stepSize, boolean[ this.gds = gds; this.stepSize=stepSize; this.initDateTime = initTDateTime; - this.days = days; + this.days = daySelection; this.timeRange = timeRange; this.maxValuesInputWays = new HashMap<>(); this.maxValuesCrossroad = new HashMap<>(); @@ -148,9 +150,14 @@ public DB(GraphDataStructure gds, DateTime initTDateTime, int stepSize, boolean[ loadFromWays(); } - + /** + * schreibt das maximale Gewicht für eine Kreuzung in die Tabelle mw_MaxValues_Crossroad, + * die Daten sind auf 1x Stepsize berechnet, ACHTUNG: Datenbankabfrage nicht mehr durchführbar, da zu viele Daten + * @param crossroadID + * @return + */ public double[] writeMaximalWeightsCrossroad(int crossroadID) { - System.out.println("Prüfe ID " +crossroadID); + System.out.println("Schreibe reale Maximalwerte (Dauer 1x stepSize) für Kreuzung mit ID " +crossroadID); if(crossroadID==43 || crossroadID == 44 || crossroadID == 63 || crossroadID == 99 || crossroadID == 147 || crossroadID == 93) { return new double[]{0.0,0.0}; } @@ -160,11 +167,12 @@ public double[] writeMaximalWeightsCrossroad(int crossroadID) { ResultSet rs; String selectStmt = null; try { - selectStmt = "SELECT * FROM (SELECT SUM(COUNT_VALUE) AS ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG, DATETIME,CROSSROAD_ID, CROSSROAD_NAME FROM (SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM (SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM (SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID="+crossroadID+") SENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays SW WHERE crossroadID = "+crossroadID+" AND wayID IS NOT NULL) SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN (SELECT DATETIME,ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET FROM jee_trafficlight_rawevents RE WHERE CROSSROAD = '"+crossroadName+"') EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET) CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID) RESULT WHERE FRONT_BACK = 0 GROUP BY DATETIME ORDER BY ANZAHL DESC LIMIT 1) GROUPED"; - + String sensorsOfCrossroad = "SELECT ID AS SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID="+crossroadID; + String sensorWaysOfCrossroad = "SELECT * FROM mw_SensorWays SW WHERE crossroadID = "+crossroadID+" AND wayID IS NOT NULL"; + String eventData = "SELECT DATETIME, ID AS EVENT_ID, cr_count AS COUNT_VALUE, cr_load AS LOAD_VALUE, RE.CSVOFFSET FROM jee_trafficlight_rawevents RE WHERE CROSSROAD = '"+crossroadName+"'"; + String crossroadWeight = "SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM ("+sensorsOfCrossroad+") SENSORS RIGHT JOIN ("+sensorWaysOfCrossroad+") SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN ("+eventData+") EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET"; + selectStmt = "SELECT * FROM (SELECT SUM(COUNT_VALUE) AS ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG, DATETIME,CROSSROAD_ID, CROSSROAD_NAME FROM (SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM ("+crossroadWeight+") CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID) RESULT WHERE FRONT_BACK = 0 GROUP BY DATETIME ORDER BY ANZAHL DESC LIMIT 1) GROUPED"; // COUNT - if(crossroadID==1) - System.out.println(selectStmt); Statement stmt = con.createStatement(); rs= stmt.executeQuery(selectStmt); if(rs.first() && rs.getTime("DATETIME")!=null){ @@ -179,57 +187,53 @@ public double[] writeMaximalWeightsCrossroad(int crossroadID) { System.out.println(insertStmt); insertStmt.executeUpdate(); count = rs.getDouble("ANZAHL"); - //LOAD - //TODO: LOAD - /* - selectStmt = "SELECT * FROM (SELECT SUM(COUNT_VALUE) AS ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG, DATETIME,CROSSROAD_ID, CROSSROAD_NAME FROM (SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM (SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM (SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID="+crossroadID+") SENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays SW WHERE crossroadID = "+crossroadID+" AND wayID IS NOT NULL) SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN (SELECT DATETIME,ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET FROM jee_trafficlight_rawevents RE WHERE CROSSROAD = '"+crossroadName+"') EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET) CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID) RESULT WHERE FRONT_BACK = 0 GROUP BY DATETIME ORDER BY BELEGUNG DESC LIMIT 1) GROUPED"; - // COUNT - - if(crossroadID==10) - System.out.println(selectStmt); - stmt = con.createStatement(); - rs = null; - rs= stmt.executeQuery(selectStmt); - rs.first(); - inserTableSQL = "REPLACE INTO mw_MaxValues_Crossroad VALUES (?,?,?,?,?,?,DEFAULT)"; - insertStmt = con.prepareStatement(inserTableSQL); - System.out.println(rs.getInt("CROSSROAD_ID")); - insertStmt.setInt(1, rs.getInt("CROSSROAD_ID")); - insertStmt.setString(2, rs.getString("CROSSROAD_NAME")); - insertStmt.setInt(3, rs.getInt("ANZAHL")); - insertStmt.setInt(4, rs.getInt("BELEGUNG")); - insertStmt.setTimestamp(5, rs.getTimestamp("DATETIME")); - insertStmt.setInt(6, 1); - System.out.println(insertStmt); - insertStmt.executeUpdate();*/ - return new double[]{count,0.0}; + return new double[]{count,load}; } } catch (SQLException e) { e.printStackTrace(); - System.out.println(crossroadID+"\t\t"+selectStmt); + System.out.println("SQLException bei " +crossroadID+"\t\t"+selectStmt); } return new double[]{0.0,0.0}; } + /** + * aktualisiert die maximalen Wert der Kreuzung, sofern dies nötig ist + * - wird nur ausgeführt, wenn newMaxValues auf TRUE gesetzt ist + * @param crossroadID - ID der Kreuzung + * @param count - neuer Count-Wert + * @param load - neuer Load-Wert + * @param time - Beginn der Aggregation + * @param timeRange - Zeitintervall der Aggregation + * @return + */ public boolean setMaximalWeightsCrossroadImproved(int crossroadID, double count, double load, DateTime time, int timeRange){ String inserTableSQL = "UPDATE mw_MaxValues_CrossroadImproved SET COUNT_VALUE = ?, LOAD_VALUE = ?, DATETIME = ?,timeRange = ? WHERE CROSSROAD_ID ="+crossroadID+" AND COUNT_VALUE<"+count; - try { PreparedStatement insertStmt = con.prepareStatement(inserTableSQL); insertStmt.setDouble(1,count); insertStmt.setDouble(2, load); insertStmt.setTimestamp(3, Timestamp.valueOf(toSql(time))); insertStmt.setInt(4, timeRange*2); - insertStmt.execute(); + if(newMaxValues) + insertStmt.execute(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } return true; } + + /** + * Aktualisiert die maximalen Werte des Einfahrtsweges, sofern dies nötig ist + * - wird nur ausgeführt, wenn newMaxValues auf TRUE gesetzt ist + * @param inputWayID - globale ID des Einfahrtsweges + * @param count - neuer Count-Wert + * @param load - neuer Load-Wert + * @param time Beginn der Aggregation + * @param timeRange Zeitintervall der Aggregation + * @return + */ public boolean setMaximalWeightsInputWayImproved(int inputWayID, double count, double load, DateTime time, int timeRange){ - if(true) - return true; String inserTableSQL = "UPDATE mw_MaxValues_InputWaysImproved SET COUNT_VALUE = ?, LOAD_VALUE = ?, DATETIME = ?, timeRange = ? WHERE INPUT_WAY_ID ="+inputWayID+" AND COUNT_VALUE<"+count; try { PreparedStatement insertStmt = con.prepareStatement(inserTableSQL); @@ -237,7 +241,8 @@ public boolean setMaximalWeightsInputWayImproved(int inputWayID, double count, d insertStmt.setDouble(2, load); insertStmt.setTimestamp(3, Timestamp.valueOf(toSql(time))); insertStmt.setInt(4, timeRange*2); - insertStmt.execute(); + if(newMaxValues) + insertStmt.execute(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); @@ -532,7 +537,7 @@ else if(!dummyMax) } } /** - * schreibt Maximale Werte für die Einfahrtswege einer Kreuzung, die Werte orientieren sich dabei an den Maximalwerten der Kreuzung + * schreibt maximale Werte für die Einfahrtswege einer Kreuzung, die Werte orientieren sich dabei an den Maximalwerten der Kreuzung */ public void writeMaximalWeightInputWayRandom() { Random rand = new Random(); @@ -556,7 +561,7 @@ public void writeMaximalWeightInputWayRandom() { } /** - * schreibt Maximale Werte für die realen Sensoren in die Datenbank, welche sich grob an den Werten für den passenden virtuellen Sensor orientieren + * schreibt maximale Werte für die realen Sensoren in die Datenbank, welche sich grob an den Werten für den passenden virtuellen Sensor orientieren */ public void writeMaximalWeightSensorRandom() { Random rand = new Random(); @@ -587,26 +592,24 @@ public void writeMaximalWeightSensorRandom() { */ public void getMaximalWeightCrossroad() { try { - String selectStmt = "SELECT * FROM mw_MaxValues_Crossroad WHERE COUNT_OR_LOAD =0"; + String selectStmt; if(dummyMax) selectStmt = "SELECT * FROM mw_MaxValues_Crossroad_Random"; - if(improvedMax) + else selectStmt = "SELECT * FROM mw_MaxValues_CrossroadImproved"; Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); while(rs.next()){ - if(improvedMax){ + if(dummyMax) + maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getDouble("MAX_COUNT"),0}); + else{ double maxCount = rs.getDouble("COUNT_VALUE"); if(maxCount <1) maxCount = 1; maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {maxCount,rs.getDouble("LOAD_VALUE")}); } - else if(!dummyMax) - maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getInt("COUNT"),0}); - else{ - maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getDouble("MAX_COUNT"),0}); - } + } } catch (SQLException e) { e.printStackTrace(); diff --git a/src/dna/updates/generators/traffic/CrossroadWeightList.java b/src/dna/updates/generators/traffic/CrossroadWeightList.java index 7b797296..c728d142 100644 --- a/src/dna/updates/generators/traffic/CrossroadWeightList.java +++ b/src/dna/updates/generators/traffic/CrossroadWeightList.java @@ -24,7 +24,7 @@ public CrossroadWeightList(int index, String crossroadName, double threshold){ } public boolean add(CrossroadWeight crw){ - if(crw.crossroadID != crossroadID || !crw.crossroadName.equals(crossroadName) ) + if(crw.crossroadID != crossroadID || !crw.getCrossroadName().equals(crossroadName) ) return false; else{ if(sum==null){ diff --git a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java index a36084cc..ecfbac06 100644 --- a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java @@ -115,7 +115,7 @@ public Batch generate(Graph g) { nodeHistory.get(index).add(weightOfDay); } else{ - CrossroadWeightList weightList = new CrossroadWeightList(weightOfDay.crossroadID,weightOfDay.crossroadName,weightOfDay.getThreshold()); + CrossroadWeightList weightList = new CrossroadWeightList(weightOfDay.crossroadID,weightOfDay.getCrossroadName(),weightOfDay.getThreshold()); weightList.add(weightOfDay); nodeHistory.put(index, weightList); } From ecc26a8ef84d50b34d663c0e9ac7d6a9846c3d80 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Tue, 6 Jan 2015 14:53:59 +0100 Subject: [PATCH 12/24] =?UTF-8?q?Kommentare=20f=C3=BCr=20DB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/dna/graph/generators/traffic/DB.java | 160 ++++++++++------------- 1 file changed, 67 insertions(+), 93 deletions(-) diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index e88d92ef..685ee954 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -250,67 +250,11 @@ public boolean setMaximalWeightsInputWayImproved(int inputWayID, double count, d return true; } - - - public double[] writeMaximalWeightsInputWays_5Minutes(int inputwayID) { - System.out.println("Prüfe ID " +inputwayID); - double count = 0; - ResultSet rs; - int[] inputData = inputWays.get(inputwayID); - if(inputData==null) - return new double[]{0,0}; - int crossroadID = inputData[1]; - System.out.println("InputWay:\t"+inputwayID+"CrossroadID:\t"+crossroadID); - String selectStmt = null; - try { - //selectStmt = "SELECT SUM(cr_count) as ANZAHL,SUM(cr_load)/COUNT(cr_load) AS BELEGUNG, DATETIME,SENSORS_ON_WAY.* FROM (SELECT * FROM (SELECT ID AS SENSOR_ID, REALNAME AS SENSOR_NAME, CSVOFFSET, wayID AS WAY_ID, CROSSROAD_ID, crossroadName AS CROSSROAD_NAME FROM (SELECT ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') GLOBALSENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays WHERE crossroadID = '"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON GLOBALSENSORS.ID = SENSORS_MAPPED.sensorID) SENSORS JOIN (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID = '"+inputwayID+"') INPUT_WAYS ON SENSORS.WAY_ID = INPUT_WAYS.wayID) SENSORS_ON_WAY LEFT JOIN jee_trafficlight_rawevents RE ON RE.CSVOFFSET = SENSORS_ON_WAY.CSVOFFSET AND RE.CROSSROAD = SENSORS_ON_WAY.CROSSROAD_NAME GROUP BY DATETIME ORDER BY ANZAHL DESC LIMIT 1"; - selectStmt = "SELECT MAX(ANZAHL_5) as MAX_ANZAHL FROM (SELECT SUM(ANZAHL)/COUNT(DATETIME) as ANZAHL_5,COUNT(DATETIME) as MINUTES ,DATETIME FROM (SELECT SUM(cr_count) as ANZAHL,COUNT(DATETIME) as MINUTES ,SUM(cr_load)/COUNT(cr_load) AS BELEGUNG, DATETIME,SENSORS_ON_WAY.* FROM (SELECT * FROM (SELECT ID AS SENSOR_ID, REALNAME AS SENSOR_NAME, CSVOFFSET, wayID AS WAY_ID, CROSSROAD_ID, crossroadName AS CROSSROAD_NAME FROM (SELECT ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') GLOBALSENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays WHERE crossroadID = '"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON GLOBALSENSORS.ID = SENSORS_MAPPED.sensorID) SENSORS JOIN (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID = '"+inputwayID+"') INPUT_WAYS ON SENSORS.WAY_ID = INPUT_WAYS.wayID) SENSORS_ON_WAY LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents LIMIT 1000000) RE ON RE.CSVOFFSET = SENSORS_ON_WAY.CSVOFFSET AND RE.CROSSROAD = SENSORS_ON_WAY.CROSSROAD_NAME GROUP BY DATETIME) FOR_MINUTES GROUP BY (UNIX_TIMESTAMP(DATETIME) DIV 300)) MAXIMA"; - System.out.println("WEIGHT\t\t"+selectStmt); - // COUNT - Statement stmt = con.createStatement(); - rs= stmt.executeQuery(selectStmt); - if(rs.first()){ - count = rs.getDouble("MAX_ANZAHL"); - String inserTableSQL = "REPLACE INTO mw_MaxValues_InputWay_5 VALUES (?,?)"; - java.sql.PreparedStatement insertStmt = con.prepareStatement(inserTableSQL); - insertStmt.setInt(1,inputwayID); - insertStmt.setDouble(2, count); - insertStmt.executeUpdate(); - - - //TODO: LOAD - //LOAD - /* - selectStmt = "SELECT SUM(cr_count) as ANZAHL,SUM(cr_load) AS BELEGUNG, DATETIME,SENSORS_ON_WAY.* FROM (SELECT * FROM (SELECT ID AS SENSOR_ID, REALNAME AS SENSOR_NAME, CSVOFFSET, wayID AS WAY_ID, CROSSROAD_ID, crossroadName AS CROSSROAD_NAME FROM (SELECT ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') GLOBALSENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays WHERE crossroadID = '"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON GLOBALSENSORS.ID = SENSORS_MAPPED.sensorID) SENSORS JOIN (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID = '"+inputwayID+"') INPUT_WAYS ON SENSORS.WAY_ID = INPUT_WAYS.wayID) SENSORS_ON_WAY LEFT JOIN jee_trafficlight_rawevents RE ON RE.CSVOFFSET = SENSORS_ON_WAY.CSVOFFSET AND RE.CROSSROAD = SENSORS_ON_WAY.CROSSROAD_NAME GROUP BY DATETIME ORDER BY BELEGUNG DESC LIMIT 1"; - - // COUNT - - if(inputwayID==10) - System.out.println(selectStmt); - stmt = con.createStatement(); - rs = null; - rs= stmt.executeQuery(selectStmt); - rs.first(); - inserTableSQL = "REPLACE INTO mw_MaxValues_InputWays VALUES (?,?,?,?,?,?,?,DEFAULT)"; - insertStmt = con.prepareStatement(inserTableSQL); - insertStmt.setInt(1,inputwayID); - insertStmt.setInt(2, rs.getInt("CROSSROAD_ID")); - insertStmt.setString(3, rs.getString("CROSSROAD_NAME")); - insertStmt.setInt(4, rs.getInt("ANZAHL")); - insertStmt.setInt(5, rs.getInt("BELEGUNG")); - insertStmt.setTimestamp(6, rs.getTimestamp("DATETIME")); - insertStmt.setInt(7, 1); - System.out.println(insertStmt); - insertStmt.executeUpdate();*/ - return new double[]{count,0}; - } - } catch (SQLException e) { - e.printStackTrace(); - System.out.println(inputwayID+"\t\t"+selectStmt); - } - return new double[]{0,0}; - } - + /** + * schreibt einen neuen Zufallswert für die Kreuzung in mw_MaxValues_Crossroad_Random + * @param crossroadID - globale ID der Kreuzung + * @param random - Count-Wert als Zufallswert + */ public void writeMaximalWeightsCrossroadsRandom(int crossroadID,double random){ java.sql.PreparedStatement stmt; try { @@ -324,9 +268,16 @@ public void writeMaximalWeightsCrossroadsRandom(int crossroadID,double random){ } } + /** + * schreibt das maximale Gewicht (nur Count) für einen Einfahrtsweg in die Tabelle mw_MaxValues_InputWays, + * die Daten sind auf 1x Stepsize berechnet, ACHTUNG: Datenbankabfrage nicht mehr durchführbar, da zu viele Daten + * @param inputwayID globale ID des Einfahrtsweges + * @return + */ public double[] writeMaximalWeightsInputWays(int inputwayID) { System.out.println("Prüfe ID MaximalWeightsInputWays " +inputwayID); int count = 0; + int load = 0; ResultSet rs; int[] inputData = inputWays.get(inputwayID); int crossroadID = inputData[1]; @@ -334,7 +285,6 @@ public double[] writeMaximalWeightsInputWays(int inputwayID) { String selectStmt = null; try { selectStmt = "SELECT SUM(cr_count) as ANZAHL,SUM(cr_load)/COUNT(cr_load) AS BELEGUNG, DATETIME,SENSORS_ON_WAY.* FROM (SELECT * FROM (SELECT ID AS SENSOR_ID, REALNAME AS SENSOR_NAME, CSVOFFSET, wayID AS WAY_ID, CROSSROAD_ID, crossroadName AS CROSSROAD_NAME FROM (SELECT ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') GLOBALSENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays WHERE crossroadID = '"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON GLOBALSENSORS.ID = SENSORS_MAPPED.sensorID) SENSORS JOIN (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID = '"+inputwayID+"') INPUT_WAYS ON SENSORS.WAY_ID = INPUT_WAYS.wayID) SENSORS_ON_WAY LEFT JOIN jee_trafficlight_rawevents RE ON RE.CSVOFFSET = SENSORS_ON_WAY.CSVOFFSET AND RE.CROSSROAD = SENSORS_ON_WAY.CROSSROAD_NAME GROUP BY DATETIME ORDER BY ANZAHL DESC LIMIT 1"; - System.out.println("WEIGHT\t\t"+selectStmt); // COUNT Statement stmt = con.createStatement(); rs= stmt.executeQuery(selectStmt); @@ -351,40 +301,23 @@ public double[] writeMaximalWeightsInputWays(int inputwayID) { System.out.println(insertStmt); insertStmt.executeUpdate(); count = rs.getInt("ANZAHL"); - - //TODO: LOAD - //LOAD - /* - selectStmt = "SELECT SUM(cr_count) as ANZAHL,SUM(cr_load) AS BELEGUNG, DATETIME,SENSORS_ON_WAY.* FROM (SELECT * FROM (SELECT ID AS SENSOR_ID, REALNAME AS SENSOR_NAME, CSVOFFSET, wayID AS WAY_ID, CROSSROAD_ID, crossroadName AS CROSSROAD_NAME FROM (SELECT ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') GLOBALSENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays WHERE crossroadID = '"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON GLOBALSENSORS.ID = SENSORS_MAPPED.sensorID) SENSORS JOIN (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID = '"+inputwayID+"') INPUT_WAYS ON SENSORS.WAY_ID = INPUT_WAYS.wayID) SENSORS_ON_WAY LEFT JOIN jee_trafficlight_rawevents RE ON RE.CSVOFFSET = SENSORS_ON_WAY.CSVOFFSET AND RE.CROSSROAD = SENSORS_ON_WAY.CROSSROAD_NAME GROUP BY DATETIME ORDER BY BELEGUNG DESC LIMIT 1"; - - // COUNT - - if(inputwayID==10) - System.out.println(selectStmt); - stmt = con.createStatement(); - rs = null; - rs= stmt.executeQuery(selectStmt); - rs.first(); - inserTableSQL = "REPLACE INTO mw_MaxValues_InputWays VALUES (?,?,?,?,?,?,?,DEFAULT)"; - insertStmt = con.prepareStatement(inserTableSQL); - insertStmt.setInt(1,inputwayID); - insertStmt.setInt(2, rs.getInt("CROSSROAD_ID")); - insertStmt.setString(3, rs.getString("CROSSROAD_NAME")); - insertStmt.setInt(4, rs.getInt("ANZAHL")); - insertStmt.setInt(5, rs.getInt("BELEGUNG")); - insertStmt.setTimestamp(6, rs.getTimestamp("DATETIME")); - insertStmt.setInt(7, 1); - System.out.println(insertStmt); - insertStmt.executeUpdate();*/ - return new double[]{count,0}; + return new double[]{count,load}; } } catch (SQLException e) { e.printStackTrace(); - System.out.println(inputwayID+"\t\t"+selectStmt); + System.out.println("SQLException in writeMaximalWeightsInputWays mit ID"+ inputwayID+"\t\t"+selectStmt); } - return new double[]{0,0}; + return new double[]{count,load}; } + /** + * berechnet das Gewicht (als CrossroadWeight-Objekt) für die Kreuzung + * @param crossroadID - globale ID der Kreuzung + * @param from - Startzeitpunkt + * @param to - Endzeitpunkt + * @param timestamp - Zeitstempel für den das Gewicht berechnet wird + * @return + */ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTime to,int timestamp) { String crossroadName = getCrossroadName(crossroadID); if(!maxValuesCrossroad.containsKey(crossroadID)){ @@ -392,9 +325,21 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi } CrossroadWeight crw = new CrossroadWeight(crossroadID, crossroadName,treshold); try { - String selectStmt = "SELECT SUM(COUNT_VALUE)/COUNT(DISTINCT DATETIME) as ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG ,FROM_DIRECTION, OSMWAY_ID FROM (SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM (SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM (SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"') SENSORS RIGHT JOIN (SELECT * FROM mw_SensorWays SW WHERE crossroadID ='"+crossroadID+"' AND wayID IS NOT NULL) SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN (SELECT ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET,DATETIME FROM jee_trafficlight_rawevents RE WHERE RE.DATETIME >= '"+toSql(from)+"'AND RE.DATETIME < '"+toSql(to)+"' AND CROSSROAD = '"+crossroadName+"') EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET) CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID) RESULT LEFT JOIN (SELECT * FROM mw_CrossroadWays WHERE TYPE = '0')CRW on RESULT.FROM_DIRECTION = CRW.DIRECTION AND RESULT.CROSSROAD_ID = CRW.CROSSROAD_ID WHERE FRONT_BACK = 0 GROUP BY OSMWAY_ID"; + // Wählt alle Sensoren aus, die zur Kreuzung gehören + String sensors = "SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"'"; + // Wählt die Wege der Kreuzung aus, um die Sensoren darauf zu mappen + String sensorWays = "SELECT * FROM mw_SensorWays SW WHERE crossroadID ='"+crossroadID+"' AND wayID IS NOT NULL"; + // Lädt die entsprechenden Sensordaten für die definierten Zeitraum + String eventData = "SELECT ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET,DATETIME FROM jee_trafficlight_rawevents RE WHERE RE.DATETIME >= '"+toSql(from)+"'AND RE.DATETIME < '"+toSql(to)+"' AND CROSSROAD = '"+crossroadName+"'"; + // Filtert aus den Sensordaten die Daten für die Sensoren raus + String crossroadWeight ="SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM ("+sensors+") SENSORS RIGHT JOIN ("+sensorWays+") SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN ("+eventData+") EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET"; + // Mapped die Sensoren auf die Richtung des Einfahrtsweges für die Gruppierung + String resultData = "SELECT CROSSROAD_WEIGHT.*,mw_SensorConnection.FRONT_BACK,mw_SensorConnection.FROM_DIRECTION, mw_SensorConnection.TO_LEFT,mw_SensorConnection.TO_STRAIGHT,mw_SensorConnection.TO_RIGHT FROM ("+crossroadWeight+") CROSSROAD_WEIGHT JOIN mw_SensorConnection ON CROSSROAD_WEIGHT.SENSOR_ID = mw_SensorConnection.SENSOR_ID"; + // Kombiniert die ermittelten Sensorwert mit den Einfahrtswegen (aus OSM) der Kreuzung und summiert die Werte auf + String selectStmt = "SELECT SUM(COUNT_VALUE)/COUNT(DISTINCT DATETIME) as ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG ,FROM_DIRECTION, OSMWAY_ID FROM ("+resultData+") RESULT LEFT JOIN (SELECT * FROM mw_CrossroadWays WHERE TYPE = '0')CRW on RESULT.FROM_DIRECTION = CRW.DIRECTION AND RESULT.CROSSROAD_ID = CRW.CROSSROAD_ID WHERE FRONT_BACK = 0 GROUP BY OSMWAY_ID"; Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); + System.out.println(selectStmt); while (rs.next()) { int wayID = rs.getInt("OSMWAY_ID"); double[] maxValue = getMaximalWeightInputWayFromMap(wayID,crossroadID); //Index 0 = MaxCount, Index 1 = MaxLoad @@ -417,11 +362,27 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi return crw; } + /** + * berechnet das synthetische InitialGewicht im Simulationsmodus, beinhaltet eine DB-Abfrage zur Erstellung des CrossroadWeight-Objekts + * @param crossroadID, globale KreuzungsID + * @param from Startzeitpunkt für DB-Abfrage + * @param to Entzeitpunkt für DB-Abfrage + * @param timestamp, Zeitstempel für die Definition im CrossroadWeightObjekt + * @param trafficUpdate, beinhaltet die synthetischen Daten + * @return + */ public CrossroadWeight getCrossroadWeightStaticInit(int crossroadID,DateTime from, DateTime to, int timestamp,TrafficUpdate trafficUpdate) { CrossroadWeight crw = getCrossroadWeight(crossroadID, from, to,timestamp); crw.resetInputWayWeight(trafficUpdate.getInitCount(), trafficUpdate.getInitLoad()); return crw; } + + /** + * berechnet das synthetische Gewicht im Simulationsmodus für fortlaufende Batches + * @param crossroadID gloable KreuzungsID + * @param update beinhaltet die synthetischen Daten + * @return + */ public CrossroadWeight getCrossroadWeightStaticBatch(int crossroadID,TrafficUpdate update) { CrossroadWeight crw = crossroadModelNodes.get(crossroadID); crw.setTimestamp(crw.getTimestamp()+1); @@ -431,6 +392,11 @@ public CrossroadWeight getCrossroadWeightStaticBatch(int crossroadID,TrafficUpda return crw; } + /** + * liest das maximale Gewicht aus der Tabelle mw_MaxValues_Crossroad (auf 1xTimestep berechnet) + * @param crossroadID + * @return + */ public double[] getMaximalWeightCrossroad(int crossroadID) { try { String selectStmt = "SELECT * FROM mw_MaxValues_Crossroad WHERE CROSSROAD_ID = "+crossroadID+" AND COUNT_OR_LOAD =0"; @@ -447,6 +413,12 @@ public double[] getMaximalWeightCrossroad(int crossroadID) { return null; } + /** + * liest Maximalwerte des Einfahrtsweges aus der HashMap (zwischengespeichert nach DB-Abfrage) + * @param wayID + * @param crossroadID + * @return + */ private double[] getMaximalWeightInputWayFromMap(int wayID,int crossroadID){ int inputWayID = getInputWay(crossroadID, wayID); double[] result = maxValuesInputWays.get(inputWayID); @@ -454,7 +426,7 @@ private double[] getMaximalWeightInputWayFromMap(int wayID,int crossroadID){ } /** - * liest den Maximalwert für einen Einfahrtsweg direkt aus der Datenbank + * liest den Maximalwert für einen Einfahrtsweg direkt aus der Datenbank (aus mw_MaxValues_InputWays) * @param osmWayID * @param crossroadRoad * @return @@ -502,7 +474,9 @@ private double[] getMaximalWeightInputWay(int osmWayID, int crossroadRoad) { } return null; } - + /** + * liest die Maximalwerte der Einfahrtswege aus der, durch die Parameter festgelegten Tabelle + */ public void getMaximalWeightInputWay() { try { String selectStmt = null; From 4940fa6fda333566b9acdb5d8730027ac806dd9a Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Wed, 7 Jan 2015 12:48:22 +0100 Subject: [PATCH 13/24] Kommentare DB --- src/dna/graph/generators/traffic/DB.java | 249 ++++++++++++++--------- 1 file changed, 150 insertions(+), 99 deletions(-) diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index 685ee954..a4e95bb3 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -23,14 +23,10 @@ import org.joda.time.DateTime; -import sun.security.action.GetIntegerAction; -import dna.graph.datastructures.DataStructure.ListType; import dna.graph.datastructures.GraphDataStructure; import dna.graph.edges.Edge; -import dna.graph.nodes.DirectedWeightedNode; import dna.graph.nodes.INode; import dna.graph.nodes.Node; -import dna.graph.weights.Double3dWeight; public class DB { private static Connection con = null; @@ -329,7 +325,7 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi String sensors = "SELECT ID as SENSOR_ID, CSVOFFSET, REALNAME, CROSSROAD_ID FROM jee_crmodel_SensorDim S WHERE S.CROSSROAD_ID='"+crossroadID+"'"; // Wählt die Wege der Kreuzung aus, um die Sensoren darauf zu mappen String sensorWays = "SELECT * FROM mw_SensorWays SW WHERE crossroadID ='"+crossroadID+"' AND wayID IS NOT NULL"; - // Lädt die entsprechenden Sensordaten für die definierten Zeitraum + // Lädt die entsprechenden Sensordaten für den definierten Zeitraum String eventData = "SELECT ID as EVENT_ID,cr_count as COUNT_VALUE, cr_load as LOAD_VALUE, RE.CSVOFFSET,DATETIME FROM jee_trafficlight_rawevents RE WHERE RE.DATETIME >= '"+toSql(from)+"'AND RE.DATETIME < '"+toSql(to)+"' AND CROSSROAD = '"+crossroadName+"'"; // Filtert aus den Sensordaten die Daten für die Sensoren raus String crossroadWeight ="SELECT EVENT_ID,DATETIME,COUNT_VALUE, LOAD_VALUE,sensorName as SENSOR_NAME, sensorID as SENSOR_ID, SENSORS.CSVOFFSET, crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME FROM (SELECT sensorID,sensorName, CSVOFFSET,crossroadID,crossroadName FROM ("+sensors+") SENSORS RIGHT JOIN ("+sensorWays+") SENSORS_MAPPED ON SENSORS.SENSOR_ID = SENSORS_MAPPED.sensorID) SENSORS LEFT JOIN ("+eventData+") EVENT_DATA on SENSORS.CSVOFFSET = EVENT_DATA.CSVOFFSET"; @@ -339,7 +335,6 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi String selectStmt = "SELECT SUM(COUNT_VALUE)/COUNT(DISTINCT DATETIME) as ANZAHL, SUM(LOAD_VALUE)/COUNT(LOAD_VALUE) as BELEGUNG ,FROM_DIRECTION, OSMWAY_ID FROM ("+resultData+") RESULT LEFT JOIN (SELECT * FROM mw_CrossroadWays WHERE TYPE = '0')CRW on RESULT.FROM_DIRECTION = CRW.DIRECTION AND RESULT.CROSSROAD_ID = CRW.CROSSROAD_ID WHERE FRONT_BACK = 0 GROUP BY OSMWAY_ID"; Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); - System.out.println(selectStmt); while (rs.next()) { int wayID = rs.getInt("OSMWAY_ID"); double[] maxValue = getMaximalWeightInputWayFromMap(wayID,crossroadID); //Index 0 = MaxCount, Index 1 = MaxLoad @@ -349,7 +344,7 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi crw.setMaxWeightWay(wayID, maxValue); double count = rs.getDouble("ANZAHL"); double load = rs.getDouble("BELEGUNG"); - setMaximalWeightsInputWayImproved(getInputWay(crossroadID, wayID), count, load, from, timeRange); + setMaximalWeightsInputWayImproved(getInputWay(crossroadID, wayID), count, load, from, timeRange); // aktualisiert den maximalen Count-Wert, sofern dies notwendig ist crw.addWeightWay(wayID, new double[]{count,load,(count/maxValue[0])*100}); crw.setTimestamp(timestamp); @@ -455,56 +450,42 @@ private double[] getMaximalWeightInputWay(int inputWayID) { */ private double[] getMaximalWeightInputWay(int osmWayID, int crossroadRoad) { try { - String selectStmt = null; - if(backupWays) - selectStmt = "SELECT IW.*,wayID FROM mw_MaxValues_InputWays IW LEFT JOIN mw_InputWaysGlobal_bak2 IWG ON IW.INPUT_WAY_ID = IWG.ID WHERE wayID ='"+osmWayID+"' AND CROSSROAD_ID ="+crossroadRoad; - else - selectStmt = "SELECT IW.*,wayID FROM mw_MaxValues_InputWays IW LEFT JOIN mw_InputWaysGlobal IWG ON IW.INPUT_WAY_ID = IWG.ID WHERE wayID ='"+osmWayID+"' AND CROSSROAD_ID ="+crossroadRoad; + String selectStmt = "SELECT IW.*,wayID FROM mw_MaxValues_InputWays IW LEFT JOIN mw_InputWaysGlobal IWG ON IW.INPUT_WAY_ID = IWG.ID WHERE wayID ='"+osmWayID+"' AND CROSSROAD_ID ="+crossroadRoad; Statement stmt = con.createStatement(); - if(crossroadRoad == 8) - System.out.println(selectStmt); ResultSet rs = stmt.executeQuery(selectStmt); if(rs.first()){ return new double[]{rs.getDouble("COUNT"),0}; } else - return new double[]{100,100}; //TODO mit osmWay und Crossroad + return new double[]{Double.MAX_VALUE,Double.MAX_VALUE}; } catch (SQLException e) { e.printStackTrace(); } return null; } + /** * liest die Maximalwerte der Einfahrtswege aus der, durch die Parameter festgelegten Tabelle + * Random-Werte wenn dummyMax=true, sonst die MaximalWerte für den Berufsverkehr */ public void getMaximalWeightInputWay() { try { String selectStmt = null; - if(improvedMax){ + if(dummyMax) + selectStmt = "SELECT * FROM mw_MaxValues_InputWay_Random JOIN mw_InputWaysGlobal on INPUTWAY_ID = ID"; + else selectStmt = "SELECT * FROM mw_MaxValues_InputWaysImproved WHERE COUNT_OR_LOAD =0"; - } - else if(!dummyMax) - selectStmt = "SELECT * FROM mw_MaxValues_InputWays WHERE COUNT_OR_LOAD =0"; - else { - if(backupWays) - selectStmt = "SELECT * FROM mw_MaxValues_InputWay_Random JOIN mw_InputWaysGlobal_bak2 on INPUTWAY_ID = ID"; - else - selectStmt = "SELECT * FROM mw_MaxValues_InputWay_Random JOIN mw_InputWaysGlobal on INPUTWAY_ID = ID"; - } Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); while(rs.next()) { - if(improvedMax){ + if(dummyMax) + maxValuesInputWays.put(rs.getInt("INPUTWAY_ID"), new double[]{rs.getDouble("MAX_COUNT"),0}); + else{ double maxCount = rs.getDouble("COUNT_VALUE"); if(maxCount <1) maxCount= 1; maxValuesInputWays.put(rs.getInt(1), new double[]{maxCount,rs.getDouble("LOAD_VALUE")}); } - else if(!dummyMax) - maxValuesInputWays.put(rs.getInt(1), new double[]{rs.getDouble("COUNT"),rs.getDouble("LOAD")}); - else{ - maxValuesInputWays.put(rs.getInt("INPUTWAY_ID"), new double[]{rs.getDouble("MAX_COUNT"),0}); - } } } catch (SQLException e) { e.printStackTrace(); @@ -562,7 +543,8 @@ public void writeMaximalWeightSensorRandom() { /** - * liest die maximalen Werte, welche für einen Kreuzung gemessen wurden - über dummyMax können einmalig zufällig generierte Werte geladen werden + * liest die Maximalwerte der Kreuzungen aus der, durch die Parameter festgelegten Tabelle + * Random-Werte wenn dummyMax=true, sonst die MaximalWerte für den Berufsverkehr */ public void getMaximalWeightCrossroad() { try { @@ -573,6 +555,7 @@ public void getMaximalWeightCrossroad() { selectStmt = "SELECT * FROM mw_MaxValues_CrossroadImproved"; Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); + while(rs.next()){ if(dummyMax) maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {rs.getDouble("MAX_COUNT"),0}); @@ -581,19 +564,17 @@ public void getMaximalWeightCrossroad() { if(maxCount <1) maxCount = 1; maxValuesCrossroad.put(rs.getInt("CROSSROAD_ID"), new double[] {maxCount,rs.getDouble("LOAD_VALUE")}); - - } - + } } + } catch (SQLException e) { e.printStackTrace(); } } /** - * liest die maximalen Werte, welche für einen realen Sensor gemessen wurden - über dummyMax können einmalig zufällig generierte Werte geladen werden + * liest die hinterlegten, zufälligen Maximalwerte für die Sensoren */ public void getMaximalWeightSensor() { - Random rand = new Random(); try { String selectStmt = "SELECT * FROM mw_MaxValues_Sensor_Random"; Statement stmt = con.createStatement(); @@ -607,15 +588,32 @@ public void getMaximalWeightSensor() { } - + /** + * Aufruf von setID für Startknoten + * @param id - globale ID des Einfahrtsweges + * @return + */ public int setFromID(int id) { return setID(id,"from"); } + + /** + * Aufruf von setID für Zielknoten + * @param id - globale ID des Einfahrtsweges + * @return + */ public int setToID(int id) { return setID(id,"to"); } + + /** + * Hilfsmethode zur Generierung der Tabelle mw_InputWayConnection aus den Informationen der innerern Kreuzungsverbindung + * Einfahrtsweg -> Ausfahrtswege -> Einfahrtswege + * @param id globale ID des Einfahrtsweges + * @param mode from = Startknoten, to = Zielknoten + * @return + */ public int setID(int id,String mode) { - try { String selectStmtString = "SELECT * FROM mw_InputWaysGlobal WHERE ID = "+ id; Statement selectStmt = con.createStatement(); @@ -631,17 +629,21 @@ public int setID(int id,String mode) { return 0; } - + /** + * liest die Verbindungen der Kreuzungsknoten aus der Tabelle mw_CrossroadConnection + * @return Liste von EdgeContainern mit (from,to) + */ public List getCrossroadConnection() { List connection = new ArrayList<>(); try { String selectStmt = "SELECT FROM_CROSSROAD,TO_CROSSROAD FROM mw_CrossroadConnection"; Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); - int c = 0; + while(rs.next()) { connection.add(new EdgeContainer(rs.getInt(1),rs.getInt(2))); } + } catch (SQLException e) { e.printStackTrace(); } @@ -649,13 +651,47 @@ public List getCrossroadConnection() { } /** - * alle InputWays einer Kreuzung - * @param crossroadID + * liest alle Einfahrtswege einer Kreuzung + * @param crossroadID - globale KreuzungsID * @return */ public HashMap getInputWays(int crossroadID) { return getWays(crossroadID,0); } + + /** + * liest alle Ausfahrtswege einer Kreuzung + * @param crossroadID - globale KreuzungsID + * @return + */ + public HashMap getOutputWays(int crossroadID) { + return getWays(crossroadID,1); + } + + /** + * liest alle Wege des übergebenen Typs aus der Tabelle mw_CrossroadWays + * @param crossroadID - globale KreuzungsID + * @param type - 0 = Einfahrtsweg, 1 = Ausfahrtsweg + * @return HashMap mit Himmelsrichtung als Key, und OSM-ID des Weges als Value + */ + private HashMap getWays(int crossroadID, int type) { + HashMap ways = new HashMap<>(); + + try { + Statement stmt = con.createStatement(); + String statementString = "SELECT DIRECTION , OSMWAY_ID FROM mw_CrossroadWays WHERE CROSSROAD_ID ="+crossroadID+" AND TYPE =" +type; + ResultSet rs = stmt.executeQuery(statementString); + + while(rs.next()){ + ways.put(CardinalDirection.valueOf(rs.getString("DIRECTION")), rs.getInt("OSMWAY_ID")); + } + + } catch (SQLException e) { + e.printStackTrace(); + } + + return ways; + } /** * liefert eine Liste von Ausfahrtswegen, von denen der übergebene Einfahrtsweg direkt zu erreichen ist @@ -667,13 +703,19 @@ public List getFromWays(int crossroadID, int toWay) { return inputWayConnections.get(new InputWay(toWay, crossroadID)); } + + /** + * erstellt eine Hashmap mit Einfahrtswegen als Keys und Listen von Einfahrtswegen als Values + */ public void loadFromWays(){ InputWay key; int[] value; + try { String selectStmt = "SELECT FROM_CROSSROAD,FROM_WAY,TO_CROSSROAD,TO_WAY FROM mw_CrossroadConnection"; Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); + while(rs.next()) { key = new InputWay(rs.getInt("TO_WAY"),rs.getInt("TO_CROSSROAD")); value = new int[]{rs.getInt("FROM_CROSSROAD"), rs.getInt("FROM_WAY")}; @@ -682,35 +724,19 @@ public void loadFromWays(){ } this.inputWayConnections.get(key).add(value); } + } catch (SQLException e) { e.printStackTrace(); } } + /** - * alle Output-Ways einer Kreuzung - * @param crossroadID - * @return + * liest alle Sensoren, die auf den überlieferten Weg gemappt wurden + * @param crossroadID - globale KreuzungsID + * @param wayID - OSM-ID für den Weg + * @return, Liste von Sensoren */ - public HashMap getOutputWays(int crossroadID) { - return getWays(crossroadID,1); - } - - private HashMap getWays(int crossroadID, int type) { - HashMap ways = new HashMap<>(); - try { - Statement stmt = con.createStatement(); - String statementString = "SELECT DIRECTION , OSMWAY_ID FROM mw_CrossroadWays WHERE CROSSROAD_ID ="+crossroadID+" AND TYPE =" +type; - ResultSet rs = stmt.executeQuery(statementString); - while(rs.next()){ - ways.put(CardinalDirection.valueOf(rs.getString("DIRECTION")), rs.getInt("OSMWAY_ID")); - } - } catch (SQLException e) { - e.printStackTrace(); - } - return ways; - } - public List getSensors(int crossroadID, int wayID) { List sensors = new ArrayList<>(); try { @@ -725,6 +751,12 @@ public List getSensors(int crossroadID, int wayID) { } return sensors; } + + /** + * liefert ein Sensor-Objekt für einen modellierten Sensor + * @param sensorID - globale Sensor-ID + * @return + */ public Sensor getSensor(int sensorID) { Set directions= new HashSet<>(); try { @@ -732,6 +764,8 @@ public Sensor getSensor(int sensorID) { String statementString = "SELECT * FROM mw_SensorConnection WHERE SENSOR_ID = "+sensorID; ResultSet rs = stmt.executeQuery(statementString); if(rs.first()) { + + // Abfrage der Abbiegemöglichkeiten if(rs.getString("TO_LEFT")!=null) { directions.add(CardinalDirection.valueOf(rs.getString("TO_LEFT"))); } @@ -741,7 +775,8 @@ public Sensor getSensor(int sensorID) { if(rs.getString("TO_RIGHT")!=null) { directions.add(CardinalDirection.valueOf(rs.getString("TO_RIGHT"))); } - return new Sensor(rs.getInt(1), rs.getString(2), rs.getInt(3), rs.getString(4), rs.getInt(5),directions); + + return new Sensor(rs.getInt("sensorID"), rs.getString("sensorName"), rs.getInt("crossroadID"), rs.getString("crossroadName"), rs.getInt("wayID"),directions); } } catch (SQLException e) { e.printStackTrace(); @@ -750,10 +785,10 @@ public Sensor getSensor(int sensorID) { } /** - * liefert alle Outputways zu einem Sensor - * @param sensorID - * @param crossroadID - * @return + * liefert alle Ausfahrtswege, die durch die Abbiegemöglichkeiten des Sensors erreichbar sind + * @param sensorID - globale SensorID + * @param crossroadID - globale KreuzungsID + * @return HashMap mit Abbiegerichtung und WegeID */ public HashMap getOutputWays(int sensorID, int crossroadID) { HashMap outputDirection = new HashMap<>(); @@ -762,20 +797,24 @@ public HashMap getOutputWays(int sensorID, int crossroadID) { Statement stmt = con.createStatement(); int wayID; String statementString; + + // Eine Abfrage je Abbiegemöglichkeit for (int i = 0; i < direction.length; i++) { statementString = "SELECT SC.CROSSROAD_ID, SC.CROSSROAD_NAME, SC.SENSOR_ID, SC.SENSOR_NAME, SC.FROM_WAY, SC.FROM_DIRECTION, SC.TO_LEFT, CW.OSMWAY_ID as OUT_WAYID, CW.DIRECTION as OUTDIRECTION FROM mw_SensorConnection SC , mw_CrossroadWays CW WHERE SC.CROSSROAD_ID = CW.CROSSROAD_ID AND SC.TO_"+direction[i]+" = CW.DIRECTION AND SC.CROSSROAD_ID = "+crossroadID+" AND CW.TYPE=1 AND SC.SENSOR_ID = "+sensorID; ResultSet rs = stmt.executeQuery(statementString); while(rs.next() ) { wayID = rs.getInt("OUT_WAYID"); if( wayID >0 ) - outputDirection.put(direction[i],wayID); + outputDirection.put(direction[i],wayID); } } + } catch (SQLException e) { e.printStackTrace(); } return outputDirection; } + /** * liefert alle Einfahrtswege, die mit dem übergebenen Ausfahrtsweg verbunden sind * @param outputOSM, OSM-ID des Weges @@ -802,40 +841,57 @@ public List getConnectedInputWays(int outputOSM, int outputCrossroad) return connections; } + /** + * liefert die IDs aller Sensoren, die auf dieser Kreuzung modelliert wurden + * @param crossroadID - globale ID der Kreuzung + * @return + */ public List getSensorIDs(int crossroadID) { List sensors = new ArrayList<>(); try { Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery("SELECT SENSOR_ID FROM mw_SensorConnection WHERE CROSSROAD_ID = "+crossroadID); + while(rs.next()) { sensors.add(rs.getInt(1)); } + } catch (SQLException e) { e.printStackTrace(); } return sensors; } - public void getInputWays(){ + /** + * liest die Einfahrtswege für die interne Speicherung in der DB-Klasse + * erstellt daraus HashMaps für den schnellen Zugriff anhand der ID + */ + private void getInputWays(){ try { Statement stmt = con.createStatement(); - String statementString; - if(backupWays) - statementString = "SELECT * FROM mw_InputWaysGlobal_bak2"; - else - statementString = "SELECT * FROM mw_InputWaysGlobal"; + String statementString = "SELECT * FROM mw_InputWaysGlobal"; ResultSet rs = stmt.executeQuery(statementString); + while(rs.next() ) { + int wayID = rs.getInt("wayID"); int crossroadID = rs.getInt("crossroadID"); + inputWays.put(rs.getInt("ID"), new int[]{wayID,crossroadID}); inputWaysToID.put(new InputWay(wayID,crossroadID), rs.getInt(1)); } + } catch (SQLException e) { e.printStackTrace(); } } - //TODO: Datenbankabfrage ändern + + /** + * liest die globale ID des Einfahrtsweges aus der HashMap + * @param crossroadID - globale KreuzungsID + * @param wayID - OSMWay-ID + * @return globale ID des Einfahrtsweges + */ public int getInputWay(int crossroadID,int wayID){ InputWay key = new InputWay(wayID, crossroadID); if(inputWaysToID.containsKey(key)){ @@ -845,46 +901,46 @@ public int getInputWay(int crossroadID,int wayID){ return -1; } } + /** - * + * liefert eine Liste von Knoten, die alle Einfahrtsweges für den Wegegraph beinhaltet * @return */ public List getInputWaysForDNA() { List nodes = new ArrayList(); Node currentWeighted = null; + try { Statement stmt = con.createStatement(); - String statementString; - if(backupWays) - statementString = "SELECT * FROM mw_InputWaysGlobal_bak2"; - else - statementString = "SELECT * FROM mw_InputWaysGlobal"; + String statementString = "SELECT * FROM mw_InputWaysGlobal"; ResultSet rs = stmt.executeQuery(statementString); - int i = 0; + while(rs.next() ) { - currentWeighted = gds.newNodeInstance(rs.getInt(1)); + currentWeighted = gds.newNodeInstance(rs.getInt("ID")); nodes.add(currentWeighted); } + } catch (SQLException e) { e.printStackTrace(); } return nodes; } + /** + * liest die Verbindungen zwischen den Knoten im WegeGraph aus der Tabelle mw_InputWayConnection_bak3 (neuste Version) + * @return + */ public List getInputWaysConnectionForDNA() { List edges = new ArrayList<>(); try { Statement stmt = con.createStatement(); - String statementString; - if(backupWays) - statementString = "SELECT fromID , toID FROM mw_InputWayConnection_bak"; - else - statementString = "SELECT fromID , toID FROM mw_InputWayConnection_bak3"; + String statementString = "SELECT fromID , toID FROM mw_InputWayConnection_bak3"; ResultSet rs = stmt.executeQuery(statementString); - int i = 0; + while(rs.next() ) { edges.add(new EdgeContainer(rs.getInt("fromID"),rs.getInt("toID"))); } + } catch (SQLException e) { e.printStackTrace(); } @@ -894,14 +950,9 @@ public List getInputWaysConnectionForDNA() { /** * liest alle Knoten für das Kreuzungsmodell aus der Datenbank - * @return Knotenliste + * @return Knotenliste mit Knoten des Kreuzungsmodells */ - public List getCrossroadsForDNA() { - if(timeRange==0){ - System.out.println("TimeRange ist 0, setze auf 1"); - timeRange=1; - } - + public List getCrossroadsForDNA() { List nodes = new ArrayList(); Node current = null; From 7b6654d6e9d5fcaa033ae27f0d586ad6c661d5f0 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Wed, 7 Jan 2015 13:14:03 +0100 Subject: [PATCH 14/24] Kommentare DB bis LN 1220 --- src/dna/graph/generators/traffic/DB.java | 111 +++++++++++------------ 1 file changed, 53 insertions(+), 58 deletions(-) diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index a4e95bb3..5f4b655d 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -950,7 +950,7 @@ public List getInputWaysConnectionForDNA() { /** * liest alle Knoten für das Kreuzungsmodell aus der Datenbank - * @return Knotenliste mit Knoten des Kreuzungsmodells + * @return Knotenliste mit Knoten des Kreuzungsmodells und den globalen KreuzungsID als Labels */ public List getCrossroadsForDNA() { List nodes = new ArrayList(); @@ -964,7 +964,7 @@ public List getCrossroadsForDNA() { ResultSet rs = stmt.executeQuery(statementString); while(rs.next() ) { - int label = rs.getInt(1); + int label = rs.getInt("CROSSROAD"); current= gds.newNodeInstance(label); nodes.add(current); } @@ -975,7 +975,11 @@ public List getCrossroadsForDNA() { return nodes; } - + /** + * schreibt die berechneten Verbindungen zwischen Einfahrtswegen in die Datenbank (mw_InputWayConnection) + * @param connections - berechnete Verbindungen zwischen Einfahrtswegen + * @return + */ public int writeConnections(Set connections) { java.sql.PreparedStatement stmt; try { @@ -997,25 +1001,32 @@ public int writeConnections(Set connections) { return connections.size(); } - + /** + * erstellt das Modell einer Kreuzungs mit den internen Verbindungen zwischen Einfahrtswegen und Ausfahrtswegen + * @param crossroadID - globale KreuzungsID + * @return + */ public Crossroad innerconnectionForCrossroad(int crossroadID){ HashMap inputWays = getInputWays(crossroadID); + HashMap outputWays = getOutputWays(crossroadID); + if(inputWays.size()==0){ System.out.println("Keine Einfahrtswege"); return null; } + Crossroad crossroad = new Crossroad(crossroadID,this); crossroad.setInputWays(inputWays); - HashMap outPut = getOutputWays(crossroadID); - crossroad.setOutputWays(outPut); - HashMap outputWays; - + crossroad.setOutputWays(outputWays); + + // Verbindung innerhalb der Kreuzung + HashMap connectedOutputWays; for (Map.Entry way : inputWays.entrySet()) { - outputWays = getConnectedOutputWays(crossroadID, way.getValue(), way.getKey()); - if(outputWays==null) { + connectedOutputWays = getConnectedOutputWays(crossroadID, way.getValue(), way.getKey()); + if(connectedOutputWays==null) { continue; } - for (Map.Entry outputWay : outputWays.entrySet()) { + for (Map.Entry outputWay : connectedOutputWays.entrySet()) { crossroad.setOutputWay(way.getKey(), outputWay.getKey()); } } @@ -1023,10 +1034,10 @@ public Crossroad innerconnectionForCrossroad(int crossroadID){ } /** - * liefert für einen InputWay alle OuputWays die innerhalb der Kreuzung zu erreichen sind - * @param crossroadID - * @param wayID - * @param wayDirection + * liefert für einen Einfahrtsweg alle Ausfahrtswege die innerhalb der Kreuzung zu erreichen sind + * @param crossroadID - globale Kreuzungs-ID + * @param wayID - OSMWay-ID + * @param wayDirection - Direction des Einfahrtsweges * @return */ public HashMap getConnectedOutputWays(int crossroadID, int wayID, CardinalDirection wayDirection) { @@ -1034,8 +1045,10 @@ public HashMap getConnectedOutputWays(int crossroadI HashMap outputWaysCrossroad = new HashMap<>(); HashMap outputWaysSensor; CardinalDirection cd; + + // Für alle Sensoren auf den Einfahrtsweg for (Sensor sensor : sensors) { - outputWaysSensor = getOutputWays(sensor.sensorID, crossroadID); + outputWaysSensor = getOutputWays(sensor.sensorID, crossroadID); // Abbiegemöglichkeiten des Sensors for (Map.Entry integer : outputWaysSensor.entrySet()) { cd = transposeDirection(wayDirection, integer.getKey()); if(!outputWaysCrossroad.containsKey(cd)) @@ -1046,10 +1059,10 @@ public HashMap getConnectedOutputWays(int crossroadI } /** - * übersetzt InputWay-Direction und Richtung, in eine OutputWay-Direction - * @param inDir - * @param goDir - * @return + * übersetzt Himmelsrichtung und Abbiegemöglickeiten in neue Himmelsrichtung + * @param inDir - eigende Himmelsrichtung + * @param goDir - Abbiegerichtung + * @return - ausgehende Himmelsrichtung */ public CardinalDirection transposeDirection (CardinalDirection inDir, String goDir) { String[] directions = new String[]{"LEFT","STRAIGHT"}; @@ -1126,8 +1139,8 @@ public void disconnect() { } /** - * liefert die Knoten für das SensorModell - * @return + * liefert die Knoten für das SensorModell, speichert diese für weitere Abfragen in HashMap sensorModelNodes + * @return Liste von Knoten mit NODE_ID als Label und Key in sensorModelNodes */ public List getSensorsForDNA() { System.out.println("Erstelle den Graph ... "); @@ -1138,54 +1151,32 @@ public List getSensorsForDNA() { statementString = "SELECT SG.*, ID as INPUT_WAY_ID FROM (SELECT * FROM mw_SensorGlobal_bak) SG LEFT JOIN (SELECT * FROM mw_InputWaysGlobal) IWG ON SG.WAY_ID = IWG.wayID AND SG.CROSSROAD_ID = IWG.crossroadID"; ResultSet rs = stmt.executeQuery(statementString); int label; + while (rs.next()) { label = rs.getInt("NODE_ID"); nodes.add(gds.newNodeInstance(label)); sensorModelNodes.put(label, new SensorModelNode(label, !rs.getBoolean("SENSOR_TYPE"),rs.getInt("INPUT_WAY_ID"),CardinalDirection.valueOf(rs.getString("DIRECTION")))); } - /*double[] weight = null; - DateTime from = null; - DateTime to = null; - if(modus==0){ - from = initDateTime; - to = initDateTime.plusMinutes(stepSize); - } - else if (modus == 1){ - from = initDateTime.minusMinutes(timeRange); - to = initDateTime.plusMinutes(timeRange); - } - getSensorWeights(from, to,0); - while(rs.next() ) { - int label = rs.getInt("NODE_ID"); - if(rs.getBoolean("SENSOR_TYPE")){ - int id = getInputWay(rs.getInt("CROSSROAD_ID"),rs.getInt("WAY_ID")); - if(id>0){ - weight = getInputWayWeight(id,initDateTime, initDateTime.plusMinutes(stepSize)); - } - else { - weight = new double[]{-2,-2,-2}; - } - sensorModelNodes.put(label, new SensorModelNode(label,false, weight, 0,id)); - } - else { - weight = getSensorNodeWeight(label,0,from,to); - } - current = gds.newNodeInstance(label); - currentWeighted = (current instanceof DirectedWeightedNode) ? (DirectedWeightedNode) current : null; - if(currentWeighted!=null) { - currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); - nodes.add(currentWeighted); - } - }*/ + } catch (SQLException e) { e.printStackTrace(); } return nodes; } + /** + * liefert das Gewicht für einen Knoten mit Sensormodell + * @param nodeID - globale KnotenID im Sensormodel (kann realer oder virtueller Sensor sein) + * @param from - Startzeitpunkt der Aggregation + * @param to - Endzeitpunkt der Aggregation + * @param timestemp - Zeitstempel für den das Gewicht berechnet wird + * @return + */ public double[] getSensorModelWeight(int nodeID,DateTime from, DateTime to,int timestemp){ + if(sensorModelNodes.containsKey(nodeID)){ SensorModelNode sensorModelNode = sensorModelNodes.get(nodeID); + // Sensorknoten ist ein realer Sensor, Gewicht wurde bereits für alle realen Sensoren vorberechnet if(sensorModelNode.isReal()){ if(sensorModelNode.getTimestep()==timestemp){ return sensorModelNode.getWeight(); @@ -1197,6 +1188,7 @@ public double[] getSensorModelWeight(int nodeID,DateTime from, DateTime to,int t return weight; } } + //Sensorknoten ist virtueller Sensor, Gewicht wird wie beim Wegemodell abgefragt und in SensorModelNode zwischengespeichert else { int inputWayID = sensorModelNode.getInputWayID(); if(inputWayID>0){ @@ -1204,7 +1196,8 @@ public double[] getSensorModelWeight(int nodeID,DateTime from, DateTime to,int t sensorModelNode.setWeight(weight, timestemp); return weight; } - return new double[]{0,0,0}; + else + return new double[]{0,0,0}; } } else @@ -1215,7 +1208,7 @@ public double[] getSensorModelWeight(int nodeID,DateTime from, DateTime to,int t * liefert die Gewichte für den Einfahrtsweg * @param inputWayID * @param timestamp - * @return Index 0: count/maxCount, Index 1: load + * @return [0] = count, [1] = load, [2] = count/maxCount */ public double[] getInputWayWeight(int inputWayID, DateTime timestamp) { return getInputWayWeight(inputWayID, timestamp, timestamp.plusMinutes(5)); @@ -1228,11 +1221,13 @@ public double[] getInputWayWeight(int inputWayID, DateTime timestamp) { * @return Index 0: count/maxCount, Index 1: load */ public double[] getInputWayWeight(int inputWayID, DateTime from, DateTime to) { + //leeres Intervall auf Minimallänge setzen if(from.equals(to)){ to = from.plusMinutes(1); } double count =0; double load = 0; + // Nachladen von Maximalwerten if(!maxValuesInputWays.containsKey(inputWayID)){ maxValuesInputWays.put(inputWayID, getMaximalWeightInputWay(inputWayID) ); } From 3772bfea916b770747427d0c718545a5fe0adb24 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Wed, 7 Jan 2015 13:39:55 +0100 Subject: [PATCH 15/24] Aufsplitten InputWayWeight --- src/dna/graph/generators/traffic/DB.java | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index 5f4b655d..dacbfa6a 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -1236,12 +1236,19 @@ public double[] getInputWayWeight(int inputWayID, DateTime from, DateTime to) { int[] inputData = inputWays.get(inputWayID); int crossroadID = inputData[1]; Statement stmt = con.createStatement(); - if(backupWays) - statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID as INPUTWAY_ID, IWG.wayID as OSMWAY_ID, IWG.crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME, sensorID as SENSOR_ID, sensorName as SENSOR_NAME,IWG.direction as DIRECTION FROM (SELECT * FROM mw_InputWaysGlobal IWG WHERE IWG.ID ="+inputWayID+") IWG LEFT JOIN mw_SensorWays SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID AND IWG.direction = SW.direction) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ="+crossroadID+") S2 ON S1.SENSOR_ID = S2.ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; - else{ - statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID as INPUTWAY_ID, IWG.wayID as OSMWAY_ID, IWG.crossroadID as CROSSROAD_ID, crossroadName as CROSSROAD_NAME, sensorID as SENSOR_ID, sensorName as SENSOR_NAME FROM (SELECT * FROM mw_InputWaysGlobal_bak2 IWG WHERE IWG.ID ="+inputWayID+") IWG LEFT JOIN mw_SensorWays_bak SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ="+crossroadID+") S2 ON S1.SENSOR_ID = S2.ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; - statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM (SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT FRONT_AND_BACK.* FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID AS INPUTWAY_ID, IWG.wayID AS OSMWAY_ID, IWG.crossroadID AS CROSSROAD_ID, crossroadName AS CROSSROAD_NAME, sensorID AS SENSOR_ID, sensorName AS SENSOR_NAME FROM (SELECT * FROM mw_InputWaysGlobal_bak2 IWG WHERE IWG.ID ='"+inputWayID+"') IWG LEFT JOIN mw_SensorWays_bak SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID) S1 JOIN (SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ='"+crossroadID+"') S2 ON S1.SENSOR_ID = S2.ID) FRONT_AND_BACK JOIN (SELECT * FROM mw_SensorConnection_bak FR WHERE FR.FRONT_BACK = 0) ONLY_FRONT ON FRONT_AND_BACK.SENSOR_ID = ONLY_FRONT.SENSOR_ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"') EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; - } + // Selection des Einfahrtsweges (neueste Tabelle) + String inputWay = "SELECT * FROM mw_InputWaysGlobal_bak2 IWG WHERE IWG.ID ='"+inputWayID+"'"; + // Selection der Sensordaten für den vorgegebenen Zeitraum + String rawData = "SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME>='"+toSql(from)+"'"; + // Selection der für die Gewichtsberechnung relevanten Sensoren + String rawSensors = "SELECT * FROM jee_crmodel_SensorDim SENSOR_DIM WHERE CROSSROAD_ID ='"+crossroadID+"'"; + // Selection der frontSensoren + String frontSensors = "SELECT * FROM mw_SensorConnection FR WHERE FR.FRONT_BACK = 0"; + // Selection aller benätigten Sensoren + String sensors = "SELECT SENSORS.*,DATETIME,cr_count,cr_load FROM (SELECT FRONT_AND_BACK.* FROM (SELECT S1.*, CSVOFFSET FROM (SELECT ID AS INPUTWAY_ID, IWG.wayID AS OSMWAY_ID, IWG.crossroadID AS CROSSROAD_ID, crossroadName AS CROSSROAD_NAME, sensorID AS SENSOR_ID, sensorName AS SENSOR_NAME FROM ("+inputWay+") IWG LEFT JOIN mw_SensorWays_bak SW ON IWG.wayID = SW.wayID AND IWG.crossroadID= SW.crossroadID) S1 JOIN ("+rawSensors+") S2 ON S1.SENSOR_ID = S2.ID) FRONT_AND_BACK JOIN ("+frontSensors+") ONLY_FRONT ON FRONT_AND_BACK.SENSOR_ID = ONLY_FRONT.SENSOR_ID"; + // Abfrage des Gewichts aus den zuvor selektierten Daten + statementString = "SELECT SUM(ANZAHL)/COUNT(ANZAHL),SUM(BELEGUNG)/COUNT(BELEGUNG) FROM (SELECT SUM(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, DATETIME FROM ("+sensors+") SENSORS LEFT JOIN ("+rawData+") EVENTS_DAY ON SENSORS.CROSSROAD_NAME = EVENTS_DAY.CROSSROAD AND SENSORS.CSVOFFSET=EVENTS_DAY.CSVOFFSET) FINAL GROUP BY DATETIME) GROUPED"; + System.out.println(statementString); ResultSet rs = stmt.executeQuery(statementString); if(rs.first()){ count=rs.getDouble(1); @@ -1255,8 +1262,8 @@ public double[] getInputWayWeight(int inputWayID, DateTime from, DateTime to) { } catch (SQLException e) { e.printStackTrace(); } - double savedMax = maxValuesInputWays.get(inputWayID)[0]; - double countNorm = savedMax> 0 ? count/savedMax : 0; + double savedMax = maxValuesInputWays.get(inputWayID)[0]; // maxCount + double countNorm = savedMax> 0 ? count/savedMax : 0; // keine Normierung wegen div0 return new double[]{count,load,countNorm*100}; } From 205ba4f31225b04f9cd914d37b0ef735af52c882 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Wed, 7 Jan 2015 15:23:43 +0100 Subject: [PATCH 16/24] Kommentare DB - fertig --- src/dna/graph/generators/traffic/DB.java | 133 +++++++++++++---------- 1 file changed, 73 insertions(+), 60 deletions(-) diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index dacbfa6a..704f697e 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -1267,59 +1267,32 @@ public double[] getInputWayWeight(int inputWayID, DateTime from, DateTime to) { return new double[]{count,load,countNorm*100}; } - - - /** - * liefert das Knotengewicht für einer der tatsächlichen Sensoren - * @param to - * @param from - * @param sensorID - * @param timeStamp - * @return - */ - - // ALT - public double[] getSensorNodeWeight(int nodeID, int timestamp, DateTime from, DateTime to){ - if(sensorModelNodes.containsKey(nodeID)){ - SensorModelNode node = sensorModelNodes.get(nodeID); - if(node.getTimestep()==timestamp) - return node.getWeight(); - else { //Outdated Data - if(node.isReal()){ - getSensorWeights(from, to, timestamp); - return getSensorNodeWeight(nodeID, timestamp, from, to); - } - else{ - double[] weight = (node.getInputWayID()>0)?getInputWayWeight(node.getInputWayID(), from, to):new double[]{-2,-2,-2}; - node.setWeight(weight, timestamp); - return weight; - } - } - } - else{ - System.out.println("Nicht drin " +nodeID); - return new double[]{0,0,0}; - } - } /** - * Liefer TRUE, wenn es sich um einen realen Sensor handel, sonst FALSE - * @param nodeID + * Liefert TRUE, wenn es sich um einen realen Sensor handel, sonst FALSE + * @param nodeID - globale KnotenID im Sensormodell * @return */ public boolean getSensorType(int nodeID){ return sensorModelNodes.get(nodeID).isReal(); } + /** * liefert die Werte für alle tatsächlichen Sensoren - * @param from - * @param to + * @param from - Startzeitpunkt der Aggregation + * @param to - Endzeitpunkt der Aggreagtion * @return */ - public double[] getSensorWeights(DateTime from, DateTime to,int timestemp){ + public void getSensorWeights(DateTime from, DateTime to,int timestemp){ try { Statement stmt = con.createStatement(); String statementString; - statementString = "SELECT NODE_ID,SUM(cr_count)/COUNT(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, SENSOR_ID,SENSOR_NAME,WAY_ID,CROSSROAD_ID,CROSSROAD_NAME,SENSOR_TYPE,CSVOFFSET FROM (SELECT NODE_ID,SENSOR_ID,SENSOR_NAME,WAY_ID,CROSSROAD_ID,CROSSROAD_NAME,SENSOR_TYPE,SENSORS.CSVOFFSET,cr_count,DATETIME,cr_load FROM (SELECT NODES.*,CSVOFFSET FROM (SELECT * FROM mw_SensorGlobal SG WHERE SG.SENSOR_TYPE=0) NODES JOIN jee_crmodel_SensorDim SD ON NODES.SENSOR_ID = SD.ID) SENSORS LEFT JOIN (SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME >= '"+toSql(from)+"') RE ON SENSORS.CSVOFFSET = RE.CSVOFFSET AND SENSORS.CROSSROAD_NAME = RE.CROSSROAD) RESULT GROUP BY NODE_ID "; + // Selection der betrachteten Sensordaten + String rawData = "SELECT * FROM jee_trafficlight_rawevents RE WHERE DATETIME < '"+toSql(to)+"' AND DATETIME >= '"+toSql(from)+"'"; + // Selection der betrachteten Sensoren aus dem Modell + String realSensors = "SELECT * FROM mw_SensorGlobal SG WHERE SG.SENSOR_TYPE=0"; + // Selection für die Berechnung des Gewichts + String endSelection = "NODE_ID,SUM(cr_count)/COUNT(cr_count) as ANZAHL, SUM(cr_load)/COUNT(cr_load) as BELEGUNG, SENSOR_ID,SENSOR_NAME,WAY_ID,CROSSROAD_ID,CROSSROAD_NAME,SENSOR_TYPE,CSVOFFSET"; + statementString = "SELECT "+endSelection+" FROM (SELECT NODE_ID,SENSOR_ID,SENSOR_NAME,WAY_ID,CROSSROAD_ID,CROSSROAD_NAME,SENSOR_TYPE,SENSORS.CSVOFFSET,cr_count,DATETIME,cr_load FROM (SELECT NODES.*,CSVOFFSET FROM ("+realSensors+") NODES JOIN jee_crmodel_SensorDim SD ON NODES.SENSOR_ID = SD.ID) SENSORS LEFT JOIN ("+rawData+") RE ON SENSORS.CSVOFFSET = RE.CSVOFFSET AND SENSORS.CROSSROAD_NAME = RE.CROSSROAD) RESULT GROUP BY NODE_ID "; ResultSet rs = stmt.executeQuery(statementString); while(rs.next()){ if(!rs.getBoolean("SENSOR_TYPE")){ @@ -1332,31 +1305,19 @@ public double[] getSensorWeights(DateTime from, DateTime to,int timestemp){ } catch (SQLException e) { e.printStackTrace(); } - return new double[]{0,0,0}; } - + /** + * liefert die Verbindungen für das Sensorenmodell (Zwischen Virtuellen Sensoren zu realen Sensoren + * und von realen Sensoren zu virtuellen Sensoren ) + * @return + */ public List getSensorConnectionForDNA() { List edges = new ArrayList<>(); try { Statement vStmt = con.createStatement(); String statementString; - /* - // Virtual Sensor -> Real Sensor - // alle Sensoren statementString = "SELECT VS.NODE_ID AS V_NODE_ID, VS.WAY_ID as V_WAY_ID, VS.CROSSROAD_ID as V_CROSSROAD, RS.NODE_ID as R_NODE_ID, RS.WAY_ID as R_WAY_ID, RS.CROSSROAD_ID as R_CROSSROAD_ID FROM (SELECT * FROM mw_SensorGlobal SG1 WHERE SENSOR_TYPE = 1) VS LEFT JOIN (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 0) RS ON VS.WAY_ID = RS.WAY_ID AND VS.CROSSROAD_ID = RS.CROSSROAD_ID WHERE RS.NODE_ID IS NOT NULL"; - statementString = "SELECT VS.NODE_ID AS V_NODE_ID, VS.WAY_ID as V_WAY_ID, VS.CROSSROAD_ID as V_CROSSROAD, RS.NODE_ID as R_NODE_ID, RS.WAY_ID as R_WAY_ID, RS.CROSSROAD_ID as R_CROSSROAD_ID FROM (SELECT * FROM mw_SensorGlobal SG1 WHERE SENSOR_TYPE = 1) VS LEFT JOIN (SELECT REAL_SENSORS.* FROM (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 0) REAL_SENSORS JOIN (SELECT * FROM mw_SensorConnection WHERE FRONT_BACK = 0) FRONT_SENSORS ON REAL_SENSORS.SENSOR_ID = FRONT_SENSORS.SENSOR_ID) RS ON VS.WAY_ID = RS.WAY_ID AND VS.CROSSROAD_ID = RS.CROSSROAD_ID WHERE RS.NODE_ID IS NOT NULL"; - ResultSet v2r = vStmt.executeQuery(statementString); - while(v2r.next() ) { - edges.add(new EdgeContainer(v2r.getInt("V_NODE_ID"), v2r.getInt("R_NODE_ID"))); - } - // Real Sensor -> Virtual Sensor - Statement rStmt = con.createStatement(); - statementString = "SELECT DISTINCT R_NODE_ID,V_NODE_ID FROM (SELECT R_NODE.*,V_NODE.NODE_ID as V_NODE_ID FROM (SELECT FROM_NODE.*, TO_WAY,TO_CROSSROAD FROM (SELECT NODE_ID as R_NODE_ID,SENSOR_ID,SENSOR_NAME,WAY_ID as INNER_FROM_WAY,FROM_SENSOR.CROSSROAD_ID, FROM_SENSOR.CROSSROAD_NAME, FROM_SENSOR.DIRECTION as INNER_FROM_DIRECTION, TO_LEFT, OSMWAY_ID as INNER_TO_WAY,TO_WAY.DIRECTION as INNER_TO_DIRECTION FROM (SELECT NODE_ID,SC.SENSOR_ID,SC.SENSOR_NAME,SG.WAY_ID,SC.CROSSROAD_ID,SC.CROSSROAD_NAME,DIRECTION,TO_LEFT,TO_STRAIGHT,TO_RIGHT FROM (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 0) SG JOIN (SELECT * FROM mw_SensorConnection WHERE FRONT_BACK = 0) SC ON SG.SENSOR_ID = SC.SENSOR_ID) FROM_SENSOR JOIN (SELECT * FROM mw_CrossroadWays CRW WHERE TYPE = 1) TO_WAY ON FROM_SENSOR.TO_LEFT = TO_WAY.DIRECTION AND FROM_SENSOR.CROSSROAD_ID = TO_WAY.CROSSROAD_ID) FROM_NODE JOIN (SELECT * FROM mw_CrossroadConnection) CC ON FROM_NODE.CROSSROAD_ID = CC.FROM_CROSSROAD AND INNER_TO_WAY = CC.FROM_WAY) R_NODE JOIN (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 1) V_NODE ON R_NODE.TO_WAY = V_NODE.WAY_ID AND R_NODE.TO_CROSSROAD = V_NODE.CROSSROAD_ID) RESULT1 UNION SELECT DISTINCT R_NODE_ID, V_NODE_ID FROM (SELECT R_NODE.*, V_NODE.NODE_ID AS V_NODE_ID FROM (SELECT FROM_NODE.*, TO_WAY, TO_CROSSROAD FROM (SELECT NODE_ID AS R_NODE_ID, SENSOR_ID, SENSOR_NAME, WAY_ID AS INNER_FROM_WAY, FROM_SENSOR.CROSSROAD_ID, FROM_SENSOR.CROSSROAD_NAME, FROM_SENSOR.DIRECTION AS INNER_FROM_DIRECTION, TO_STRAIGHT, OSMWAY_ID AS INNER_TO_WAY, TO_WAY.DIRECTION AS INNER_TO_DIRECTION FROM (SELECT NODE_ID, SC.SENSOR_ID, SC.SENSOR_NAME, SG.WAY_ID, SC.CROSSROAD_ID, SC.CROSSROAD_NAME, DIRECTION, TO_LEFT, TO_STRAIGHT, TO_RIGHT FROM (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 0) SG JOIN (SELECT * FROM mw_SensorConnection WHERE FRONT_BACK = 0) SC ON SG.SENSOR_ID = SC.SENSOR_ID) FROM_SENSOR JOIN (SELECT * FROM mw_CrossroadWays CRW WHERE TYPE = 1) TO_WAY ON FROM_SENSOR.TO_STRAIGHT = TO_WAY.DIRECTION AND FROM_SENSOR.CROSSROAD_ID = TO_WAY.CROSSROAD_ID) FROM_NODE JOIN (SELECT * FROM mw_CrossroadConnection) CC ON FROM_NODE.CROSSROAD_ID = CC.FROM_CROSSROAD AND INNER_TO_WAY = CC.FROM_WAY) R_NODE JOIN (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 1) V_NODE ON R_NODE.TO_WAY = V_NODE.WAY_ID AND R_NODE.TO_CROSSROAD = V_NODE.CROSSROAD_ID) RESULT2 UNION SELECT DISTINCT R_NODE_ID, V_NODE_ID FROM (SELECT R_NODE.*, V_NODE.NODE_ID AS V_NODE_ID FROM (SELECT FROM_NODE.*, TO_WAY, TO_CROSSROAD FROM (SELECT NODE_ID AS R_NODE_ID, SENSOR_ID, SENSOR_NAME, WAY_ID AS INNER_FROM_WAY, FROM_SENSOR.CROSSROAD_ID, FROM_SENSOR.CROSSROAD_NAME, FROM_SENSOR.DIRECTION AS INNER_FROM_DIRECTION, TO_RIGHT, OSMWAY_ID AS INNER_TO_WAY, TO_WAY.DIRECTION AS INNER_TO_DIRECTION FROM (SELECT NODE_ID, SC.SENSOR_ID, SC.SENSOR_NAME, SG.WAY_ID, SC.CROSSROAD_ID, SC.CROSSROAD_NAME, DIRECTION, TO_LEFT, TO_STRAIGHT, TO_RIGHT FROM (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 0) SG JOIN (SELECT * FROM mw_SensorConnection WHERE FRONT_BACK = 0) SC ON SG.SENSOR_ID = SC.SENSOR_ID) FROM_SENSOR JOIN (SELECT * FROM mw_CrossroadWays CRW WHERE TYPE = 1) TO_WAY ON FROM_SENSOR.TO_RIGHT = TO_WAY.DIRECTION AND FROM_SENSOR.CROSSROAD_ID = TO_WAY.CROSSROAD_ID) FROM_NODE JOIN (SELECT * FROM mw_CrossroadConnection) CC ON FROM_NODE.CROSSROAD_ID = CC.FROM_CROSSROAD AND INNER_TO_WAY = CC.FROM_WAY) R_NODE JOIN (SELECT * FROM mw_SensorGlobal WHERE SENSOR_TYPE = 1) V_NODE ON R_NODE.TO_WAY = V_NODE.WAY_ID AND R_NODE.TO_CROSSROAD = V_NODE.CROSSROAD_ID) RESULT3"; - ResultSet r2v = rStmt.executeQuery(statementString); - while(r2v.next() ) { - edges.add(new EdgeContainer(r2v.getInt("R_NODE_ID"), r2v.getInt("V_NODE_ID"))); - }*/ statementString = "SELECT * FROM mw_SensorConnection_Global"; ResultSet sensor_con = vStmt.executeQuery(statementString); while(sensor_con.next() ) { @@ -1367,13 +1328,21 @@ public List getSensorConnectionForDNA() { } return edges; } - + + /** + * schreibt eine Verbindung zwischen realem Sensor und virtuellem Sensor in die Datenbank + * @param s + */ public void writeSensorConnection(Sensor s) { try { Statement stmt = con.createStatement(); String insertString; for (InputWay connectedInputWay : s.connections.values()) { - insertString="INSERT IGNORE INTO mw_SensorGlobalConnection SELECT * FROM (SELECT NODE_ID as FROM_NODE_ID FROM mw_SensorGlobal WHERE mw_SensorGlobal.SENSOR_ID ='"+s.sensorID+"' AND CROSSROAD_ID = '"+s.crossroadID+"') A , (SELECT NODE_ID as TO_NODE_ID FROM mw_SensorGlobal SG WHERE SG.SENSOR_TYPE=1 AND SG.CROSSROAD_ID = '"+connectedInputWay.wayID+"' AND SG.WAY_ID = '"+connectedInputWay.crossroadID+"') B "; + // realer Sensor + String from = "SELECT NODE_ID as FROM_NODE_ID FROM mw_SensorGlobal WHERE mw_SensorGlobal.SENSOR_ID ='"+s.sensorID+"' AND CROSSROAD_ID = '"+s.crossroadID+"'"; + // virtueller Sensor + String to = "SELECT NODE_ID as TO_NODE_ID FROM mw_SensorGlobal SG WHERE SG.SENSOR_TYPE=1 AND SG.CROSSROAD_ID = '"+connectedInputWay.wayID+"' AND SG.WAY_ID = '"+connectedInputWay.crossroadID+"'"; + insertString="INSERT IGNORE INTO mw_SensorGlobalConnection SELECT * FROM ("+from+") A , ("+to+") B "; stmt.executeUpdate(insertString); } } catch (SQLException e) { @@ -1383,21 +1352,44 @@ public void writeSensorConnection(Sensor s) { } - + /** + * setzt die temporär deaktiveren Kanten für die Zwischenspeicherung + * @param disabledEdges + */ public void setDisabledEdges(HashMap disabledEdges){ this.disabledEdges=disabledEdges; } + /** + * setzt die temporär deaktiveren Kanten für die Zwischenspeicherung für das Wegemodell + * @param disabledEdges + */ public void setDisabledEdgesInputWay(HashMap> disabledEdges){ this.disabledEdgesInputWay=disabledEdges; } + + /** + * liefert die temporär deaktiveren Kanten aus der Zwischenspeicherung + * @return + */ public HashMap getDisabledEdges(){ return disabledEdges; } + + /** + * liefert die temporär deaktiveren Kanten aus der Zwischenspeicherung für das Wegemodell + * @return + */ public HashMap> getDisabledEdgesInputWay(){ return disabledEdgesInputWay; } + /** + * liefert das statische Gewicht im Wegemodell für die Initialisierung + * @param index - Knotenindex + * @param trafficUpdate - beinhaltet die statischen Daten + * @return + */ public double[] getInputWayWeightStaticInit(int index,TrafficUpdate trafficUpdate) { double count = trafficUpdate.getInitCount(); double load = trafficUpdate.getInitLoad(); @@ -1405,6 +1397,13 @@ public double[] getInputWayWeightStaticInit(int index,TrafficUpdate trafficUpdat double countNorm = savedMax> 0 ? Double.valueOf(count)/savedMax : 0; return new double[]{count,load,countNorm*100}; } + + /** + * liefert das statische Gewicht im Wegemodell für den Batch + * @param index - Knotenindex + * @param trafficUpdate - beinhaltet die statischen Daten + * @return + */ public double[] getInputWayWeightStaticBatch(int index,TrafficUpdate trafficUpdate) { double count = (trafficUpdate.getSleepTillUpdate()*trafficUpdate.getInitCount()+trafficUpdate.getUpdateCount())/(trafficUpdate.getSleepTillUpdate()+1); double load = (trafficUpdate.getSleepTillUpdate()*trafficUpdate.getInitLoad()+trafficUpdate.getUpdateLoad())/(trafficUpdate.getSleepTillUpdate()+1); @@ -1412,6 +1411,13 @@ public double[] getInputWayWeightStaticBatch(int index,TrafficUpdate trafficUpda double countNorm = savedMax> 0 ? count/savedMax : 0; return new double[]{count,load,countNorm*100}; } + + /** + * liefert das statische Gewicht im Sensormodell für die Initialisierung + * @param index - Knotenindex + * @param trafficUpdate - beinhaltet die statischen Daten + * @return + */ public double[] getSensorModelWeightStaticInit(int index,TrafficUpdate trafficUpdate) { if(trafficUpdate.getModus()==0){ if(sensorModelNodes.containsKey(index)){ @@ -1438,6 +1444,13 @@ public double[] getSensorModelWeightStaticInit(int index,TrafficUpdate trafficUp return new double[]{-1,-1,trafficUpdate.getInitUtilization()*100}; } } + + /** + * liefert das statische Gewicht im Sensormodell für den Batch + * @param index - Knotenindex + * @param trafficUpdate - beinhaltet die statischen Daten + * @return + */ public double[] getSensorModelWeightStaticBatch(int index,TrafficUpdate trafficUpdate) { if(trafficUpdate.getModus()==0){ if(sensorModelNodes.containsKey(index)){ From c92456846293d004fce99e0a956a3e7b43217137 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Wed, 21 Jan 2015 12:39:04 +0100 Subject: [PATCH 17/24] Kommentare TrafficUpdate --- src/dna/graph/generators/traffic/DB.java | 4 + .../generators/traffic/TrafficUpdate.java | 84 +++++++++++++++++-- 2 files changed, 82 insertions(+), 6 deletions(-) diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index 704f697e..681a827a 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -1456,9 +1456,13 @@ public double[] getSensorModelWeightStaticBatch(int index,TrafficUpdate trafficU if(sensorModelNodes.containsKey(index)){ SensorModelNode sensorModelNode = sensorModelNodes.get(index); if(sensorModelNode.isReal()){ + // Count-Wert des Sensors double count = (trafficUpdate.getSleepTillUpdate()*trafficUpdate.getInitCount()+trafficUpdate.getUpdateCount())/(trafficUpdate.getSleepTillUpdate()+1); + // Load-Wert des Sensors double load = (trafficUpdate.getSleepTillUpdate()*trafficUpdate.getInitLoad()+trafficUpdate.getUpdateLoad())/(trafficUpdate.getSleepTillUpdate()+1); + // Maximalwert des sensors (hier statisch) double savedMax = maxValuesSensors.get(sensorModelNode.getNodeID())[0]; + // Normierter Count-Wert double countNorm = savedMax> 0 ? count/savedMax : 0; return new double[]{count,load,countNorm*100}; } diff --git a/src/dna/graph/generators/traffic/TrafficUpdate.java b/src/dna/graph/generators/traffic/TrafficUpdate.java index b60f2550..43c4950e 100644 --- a/src/dna/graph/generators/traffic/TrafficUpdate.java +++ b/src/dna/graph/generators/traffic/TrafficUpdate.java @@ -3,70 +3,142 @@ import java.util.List; public class TrafficUpdate { + + // Werte für die Initialiserung in NORMALIZATION private double initCount; private double initLoad; - private double initUtilization; + + // Werte für das UPDATE in NORMALIZATION private double updateCount; private double updateLoad; + + // Werte in FINAL_VALUE + private double initUtilization; private double updateUtilization; + + // Knoten für die im Update ein neuer Wert übernommen wird private List nodesToUpdate; - private int modus; - private int sleeptillUpdate; + public final static int NORMALIZATION = 0; // für jeden Knoten werden getrennt Count- und Load-Werte bestimmt, aus denen das Knotengewicht durch Normalisierung bestimmt werden kann + public final static int FINAL_VALUE = 1; // für jeden Knoten wird ein Knotengewicht als Auslastung übergeben + + private int modus; // Entweder NORMALITAT oder Final-Value + private int sleeptillUpdate; // Anzahl der vergangenen Batches bis das Update angewendet wird + /** + * Konstruktur für den Modus mit festgelegten Count und Load-Wert, + * die Berechnung des Knotengewichts erfolgt als normierter Wert mit dem maximalen Count-Wert + * @param initCount Count-Wert für die Initialisierung + * @param initLoad Load-Wert für die Initialisierung + * @param updateCount - Count-Wert für das Update + * @param updateLoad - Load-Wert für das Update + * @param sleeptillUpdate - Dauer des Aggregationszeitraums (Anzahl Batches) + * @param affectedNodes - Knoten für die eine Aktualisierung vorgenommen werden soll + */ public TrafficUpdate(double initCount,double initLoad,double updateCount,double updateLoad,int sleeptillUpdate, List affectedNodes){ this.initCount=initCount; this.initLoad=initLoad; this.updateCount=updateCount; this.updateLoad=updateLoad; this.nodesToUpdate = affectedNodes; - this.modus=0; + this.modus=NORMALIZATION; this.sleeptillUpdate = sleeptillUpdate; } + /** + * Konstruktur für den Modus mit übergebenen normalisierten Werten, + * es erfolgte keine weitere Normalisierung mittels Count-Werten + * count und load werden als Dummy auf den Knoten mitgeführt + * @param initUtilization - Knotengewicht bei der Initialisierung + * @param updateUtilization - Knotengewicht für das Update + * @param sleepTilleTimestamp - Dauer des Aggregationszeitraums (Anzahl Batches) + * @param affectedNodes - Knoten für die eine Aktualisierung vorgenommen werden soll + */ public TrafficUpdate(double initUtilization, double updateUtilization,int sleepTilleTimestamp,List affectedNodes){ this.initUtilization = initUtilization; this.updateUtilization = updateUtilization; this.nodesToUpdate = affectedNodes; - this.modus=1; + this.modus=FINAL_VALUE; } + /** + * liefert den Modus für den das Objekt erstellt wurde + * @return 0 = Normalization, 1 = Final_Values als Konstanten + */ public int getModus(){ return modus; } + /** + * liefert den Count-Wert für die Initialisierung + * @return + */ public double getInitCount(){ return initCount; } + /** + * liefert den Load-Wert für die Initialisierung + * @return + */ public double getInitLoad(){ return initLoad; } + /** + * liefert den Count-Wert für das Update + * @return + */ public double getUpdateCount(){ return updateCount; } + /** + * liefert den Load-Wert für das Update + * @return + */ public double getUpdateLoad(){ return updateLoad; } + /** + * prüft ob der übergebene Knoten für das Update berücksichtigt werden soll + * @param nodeID - globale ID des Knoten + * @return + */ public boolean isAffected(int nodeID){ return nodesToUpdate.contains(nodeID); } + /** + * prüft ob das Update angewendet werden soll + * @param timeStamp - aktuelle Zeitschritt + * @return + */ public boolean changeToUpdate(int timeStamp){ return sleeptillUpdate<=timeStamp; } + /** + * liefert das initiale Knotengewicht + * @return + */ public double getInitUtilization(){ return initUtilization; } + /** + * liefert das Knotengewicht im Update + * @return + */ public double getUpdateUtilization(){ return updateUtilization; } - public double getSleepTillUpdate(){ + /** + * liefert den Zeitraum für die Aggregation + * @return + */ + public int getSleepTillUpdate(){ return sleeptillUpdate; } } From 90c6faa5382a099fd0d269f00c26f9105482dae3 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Wed, 21 Jan 2015 13:32:24 +0100 Subject: [PATCH 18/24] Kommentare Crossroad, EdgeContainer, Inputway, InputWayConnection, Sensor Variablen private mit Gettern -> Anpassungen in DB --- .../graph/generators/traffic/Crossroad.java | 2 +- src/dna/graph/generators/traffic/DB.java | 27 ++++--- .../generators/traffic/EdgeContainer.java | 44 ++++++++++-- .../graph/generators/traffic/InputWay.java | 47 +++++++++++-- .../traffic/InputWayConnection.java | 70 +++++++++++++++++-- src/dna/graph/generators/traffic/Sensor.java | 62 +++++++++++++--- 6 files changed, 215 insertions(+), 37 deletions(-) diff --git a/src/dna/graph/generators/traffic/Crossroad.java b/src/dna/graph/generators/traffic/Crossroad.java index 90bcbc72..d64edb7a 100644 --- a/src/dna/graph/generators/traffic/Crossroad.java +++ b/src/dna/graph/generators/traffic/Crossroad.java @@ -93,7 +93,7 @@ public Set getConnections(){ for (CardinalDirection outputDirection : connectedOutputways) { if(outputToInput.containsKey(outputDirection)) { connection = outputToInput.get(outputDirection); - connectedCrossroads.add(new InputWayConnection(this.crossroadID, inputWays.get(innerConnection.getKey()),innerConnection.getKey(), connection.wayID , connection.crossroadID,outputDirection)); + connectedCrossroads.add(new InputWayConnection(this.crossroadID, inputWays.get(innerConnection.getKey()),innerConnection.getKey(), connection.getWayID() , connection.getCrossroadID() ,outputDirection)); } } } diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index 681a827a..77d5176d 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -986,12 +986,12 @@ public int writeConnections(Set connections) { String inserTableSQL = "INSERT IGNORE INTO mw_InputWayConnection VALUES (?,?,?,?,?,?,DEFAULT)"; stmt = con.prepareStatement(inserTableSQL); for (InputWayConnection connection : connections) { - stmt.setInt(1, connection.fromWayID); - stmt.setInt(2, connection.fromCrossroad); - stmt.setString(3, getCrossroadName(connection.fromCrossroad)); - stmt.setInt(4, connection.toWayID); - stmt.setInt(5, connection.toCrossroad); - stmt.setString(6, getCrossroadName(connection.toCrossroad)); + stmt.setInt(1, connection.getFromWayID()); + stmt.setInt(2, connection.getFromCrossroad()); + stmt.setString(3, getCrossroadName(connection.getFromCrossroad())); + stmt.setInt(4, connection.getToWayID()); + stmt.setInt(5, connection.getToCrossroad()); + stmt.setString(6, getCrossroadName(connection.getToCrossroad())); stmt.addBatch(); } stmt.executeBatch(); @@ -1048,7 +1048,7 @@ public HashMap getConnectedOutputWays(int crossroadI // Für alle Sensoren auf den Einfahrtsweg for (Sensor sensor : sensors) { - outputWaysSensor = getOutputWays(sensor.sensorID, crossroadID); // Abbiegemöglichkeiten des Sensors + outputWaysSensor = getOutputWays(sensor.getSensorID(), crossroadID); // Abbiegemöglichkeiten des Sensors for (Map.Entry integer : outputWaysSensor.entrySet()) { cd = transposeDirection(wayDirection, integer.getKey()); if(!outputWaysCrossroad.containsKey(cd)) @@ -1337,11 +1337,18 @@ public void writeSensorConnection(Sensor s) { try { Statement stmt = con.createStatement(); String insertString; - for (InputWay connectedInputWay : s.connections.values()) { + + int wayID; + int crossroadID; + for (InputWay connectedInputWay : s.getConnections().values()) { + + wayID = connectedInputWay.getWayID(); + crossroadID = connectedInputWay.getCrossroadID(); + // realer Sensor - String from = "SELECT NODE_ID as FROM_NODE_ID FROM mw_SensorGlobal WHERE mw_SensorGlobal.SENSOR_ID ='"+s.sensorID+"' AND CROSSROAD_ID = '"+s.crossroadID+"'"; + String from = "SELECT NODE_ID as FROM_NODE_ID FROM mw_SensorGlobal WHERE mw_SensorGlobal.SENSOR_ID ='"+s.getSensorID()+"' AND CROSSROAD_ID = '"+s.getCrossroadID()+"'"; // virtueller Sensor - String to = "SELECT NODE_ID as TO_NODE_ID FROM mw_SensorGlobal SG WHERE SG.SENSOR_TYPE=1 AND SG.CROSSROAD_ID = '"+connectedInputWay.wayID+"' AND SG.WAY_ID = '"+connectedInputWay.crossroadID+"'"; + String to = "SELECT NODE_ID as TO_NODE_ID FROM mw_SensorGlobal SG WHERE SG.SENSOR_TYPE=1 AND SG.CROSSROAD_ID = '"+crossroadID+"' AND SG.WAY_ID = '"+wayID+"'"; insertString="INSERT IGNORE INTO mw_SensorGlobalConnection SELECT * FROM ("+from+") A , ("+to+") B "; stmt.executeUpdate(insertString); } diff --git a/src/dna/graph/generators/traffic/EdgeContainer.java b/src/dna/graph/generators/traffic/EdgeContainer.java index 6bf1f5ad..b17fda14 100644 --- a/src/dna/graph/generators/traffic/EdgeContainer.java +++ b/src/dna/graph/generators/traffic/EdgeContainer.java @@ -2,31 +2,65 @@ import java.util.Arrays; +/** + * Container-Klasse für Edge-Information + * @author Maurice + * + */ public class EdgeContainer { - int from; - int to; + private int from; + private int to; + /** + * Konstruktur für den EdgeContainer + * @param from - Startknoten der Kante + * @param to - Endknoten der Kante + */ public EdgeContainer(int from, int to){ this.from = from; this.to = to; } + /** + * liefert den HashCode des Containers, abgeleitet aus der Array-Darstellung + */ public int hashCode(){ return Arrays.hashCode(new int[]{from,to}); } - + + /** + * vergleicht das Objekt mit einem übergebenen Objekt + * @return true, wenn Startknoten und Endknoten identisch, sonst false + */ public boolean equals(Object obj) { - EdgeContainer ec = (EdgeContainer) obj; - return Arrays.equals(new int[]{from, to},new int[]{ec.from,ec.to}); + if( obj instanceof EdgeContainer){ + EdgeContainer ec = (EdgeContainer) obj; + return Arrays.equals(new int[]{from, to},new int[]{ec.from,ec.to}); + } + else + return false; } + + /** + * Ausgabe für die manuelle Kontrolle + * @return + */ public String toString(){ return "FROM:"+from+"\tTO:"+to; } + /** + * liefert den Startknoten + * @return + */ public int getFrom(){ return from; } + /** + * liefert den Zielknoten + * @return + */ public int getTo(){ return to; } diff --git a/src/dna/graph/generators/traffic/InputWay.java b/src/dna/graph/generators/traffic/InputWay.java index 60fa7781..3840e37a 100644 --- a/src/dna/graph/generators/traffic/InputWay.java +++ b/src/dna/graph/generators/traffic/InputWay.java @@ -2,26 +2,63 @@ import java.util.Arrays; +/** + * Containerklasse für einen Einfahrtsweg + * @author Maurice + * + */ public class InputWay { - int wayID; - int crossroadID; + + private int wayID; // OSM-WayID + private int crossroadID; // globale Kreuzungs-ID public InputWay(int wayID, int crossroadID) { this.wayID=wayID; this.crossroadID=crossroadID; } + /** + * Kontrollausgbae + */ public String toString(){ - return String.valueOf(wayID) + "\t"+crossroadID; + return "Einfahrtsweg: wayID:"+String.valueOf(wayID) + "\t crossroadID:"+crossroadID; } + /** + * liefert den HashCode des Einfahrtsweges basierend auf der Array-Darstellung + */ public int hashCode(){ return Arrays.hashCode(new int[]{wayID,crossroadID}); } + /** + * liefert die OSM-ID für den Weg + * @return + */ + public int getWayID(){ + return wayID; + } + + /** + * liefert die KreuzungsID für den Weg + * @return + */ + public int getCrossroadID(){ + return crossroadID; + } + + /** + * vergleicht das Objekt mit dem übergebenen Objekt auf Gleichheit + * @param obj, zu vergleichendes Objekt + * @return true, wenn das übergebene Objekt den gleichen Einfahrtsweg repräsentiert + */ public boolean equals(Object obj) { - InputWay inputWay = (InputWay) obj; - return Arrays.equals(new int[]{wayID,crossroadID}, new int[]{inputWay.wayID,inputWay.crossroadID}); + if(obj instanceof InputWay){ + InputWay inputWay = (InputWay) obj; + return Arrays.equals(new int[]{wayID,crossroadID}, new int[]{inputWay.wayID,inputWay.crossroadID}); + } + else + return false; } } diff --git a/src/dna/graph/generators/traffic/InputWayConnection.java b/src/dna/graph/generators/traffic/InputWayConnection.java index 92c39161..b1abcc03 100644 --- a/src/dna/graph/generators/traffic/InputWayConnection.java +++ b/src/dna/graph/generators/traffic/InputWayConnection.java @@ -1,14 +1,19 @@ package dna.graph.generators.traffic; - +/** + * Container-Klasse für Verbindungen zwischen Einfahrtswegen + * @author Maurice + * + */ public class InputWayConnection { - int fromCrossroad; - int fromWayID; - CardinalDirection fromWayDirection; - int toCrossroad; - int toWayID; - CardinalDirection toWayDirection; + private int fromCrossroad; + private int fromWayID; + private CardinalDirection fromWayDirection; + private int toCrossroad; + private int toWayID; + private CardinalDirection toWayDirection; + public InputWayConnection(int fromCrossroad, int fromWayID,CardinalDirection fromWayDirection, int toCrossroad, int toWayID,CardinalDirection toWayDirection) { this.fromCrossroad=fromCrossroad; this.fromWayID=fromWayID; @@ -16,6 +21,57 @@ public InputWayConnection(int fromCrossroad, int fromWayID,CardinalDirection fro this.toWayID=toWayID; } + /** + * liefert die Startkreuzung + * @return + */ + public int getFromCrossroad(){ + return fromCrossroad; + } + + /** + * liefert den Startweg + * @return + */ + public int getFromWayID(){ + return fromWayID; + } + + /** + * liefert die Startrichtung + * @return + */ + public CardinalDirection getFromWayDirection(){ + return fromWayDirection; + } + + /** + * liefert die Zielkreuzung + * @return + */ + public int getToCrossroad(){ + return toCrossroad; + } + + /** + * liefert den Zielweg + * @return + */ + public int getToWayID(){ + return toWayID; + } + + /** + * liefert die Richtung des Zielweges + * @return + */ + public CardinalDirection getToWayDirection(){ + return toWayDirection; + } + + /** + * Kontrollausgabe für die Verbindung von Wegen + */ public String toString() { return "Connected " + fromWayID + " on " +fromCrossroad + " with " +toWayID + " on " + toCrossroad; } diff --git a/src/dna/graph/generators/traffic/Sensor.java b/src/dna/graph/generators/traffic/Sensor.java index 10ef32ba..5ac746e5 100644 --- a/src/dna/graph/generators/traffic/Sensor.java +++ b/src/dna/graph/generators/traffic/Sensor.java @@ -5,15 +5,19 @@ import java.util.Map; import java.util.Set; - +/** + * Container-Klasse für einen realen Sensor + * @author Maurice + * + */ public class Sensor { - int sensorID; - String sensorName; - int crossroadID; - String crossroadName; - int wayID; - Set outputDiretions; - HashMap connections; + private int sensorID; + private String sensorName; + private int crossroadID; + private String crossroadName; + private int wayID; + private Set outputDiretions; + private HashMap connections; public Sensor(int sensorID, String sensorName, int crossroadID, String crossroadName, int wayID,Set outputDirections){ this.sensorID=sensorID; @@ -23,6 +27,7 @@ public Sensor(int sensorID, String sensorName, int crossroadID, String crossroad this.wayID=wayID; this.outputDiretions=outputDirections; } + public Sensor(int sensorID, String sensorName, int crossroadID, String crossroadName, int wayID){ this.sensorID=sensorID; this.sensorName=sensorName; @@ -30,7 +35,33 @@ public Sensor(int sensorID, String sensorName, int crossroadID, String crossroad this.crossroadName=crossroadName; this.wayID=wayID; } - public HashMap getConnection(HashMap outputConnection) { + + public int getSensorID(){ + return sensorID; + } + + public String getSensorName(){ + return sensorName; + } + + public int getCrossroadID(){ + return crossroadID; + } + + public String getCrossroadName(){ + return crossroadName; + } + + public int getWayID(){ + return wayID; + } + + /** + * berechnet die Verbindungen zwischen den Ausfahrtswegen des Sensors und den Einfahrtswegen benachbarter Kreuzungen + * @param outputConnection Abbiegemöglichkeiten des Sensors + * @return Verbindungen mit Einfahrtswegen + */ + public HashMap calculateConnections(HashMap outputConnection) { HashMap connections = new HashMap<>(); for (CardinalDirection output : outputDiretions) { if(outputConnection.containsKey(output)) @@ -39,6 +70,19 @@ public HashMap getConnection(HashMap getConnections() { + return connections; + } + + + /** + * Kontrollausgabe + */ public void printConnection() { System.out.println("Verbindungen von:\t"+sensorID+"("+sensorName+") on " +crossroadID+"("+crossroadName+")"); for (Map.Entry connection : connections.entrySet()) { From 43e3dd0c720ea0c6f6c8a216d0047d768889088c Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Fri, 23 Jan 2015 11:54:22 +0100 Subject: [PATCH 19/24] =?UTF-8?q?Filterfunktionalit=C3=A4t?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/dna/graph/generators/traffic/DB.java | 86 ++++++++++++++++--- src/dna/graph/generators/traffic/Sensor.java | 36 +++++++- .../TrafficCrossroadGraphGenerator.java | 24 ++++-- .../TrafficInputWayGraphGenerator.java | 19 ++-- 4 files changed, 140 insertions(+), 25 deletions(-) diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index 77d5176d..0df3d97e 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -631,12 +631,27 @@ public int setID(int id,String mode) { /** * liest die Verbindungen der Kreuzungsknoten aus der Tabelle mw_CrossroadConnection + * @param nodesFilter Array von KnotenID, die als Startknoten oder Endknoten fungieren dürfen * @return Liste von EdgeContainern mit (from,to) */ - public List getCrossroadConnection() { + public List getCrossroadConnectionForDNA(int[] nodesFilter) { List connection = new ArrayList<>(); + + String filterString =""; + if(nodesFilter!= null && nodesFilter.length>0){ + StringBuffer sb = new StringBuffer(" IN ("); + for (int i = 0; i < nodesFilter.length; i++) { + sb.append(nodesFilter[i]); + if(i getInputWaysForDNA() { + public List getInputWaysForDNA(int[] nodesFilter) { List nodes = new ArrayList(); Node currentWeighted = null; + String filterString = ""; + + // Filter aktiviert, baue Filterstring auf + if(nodesFilter != null && nodesFilter.length>0){ + StringBuffer sb = new StringBuffer("WHERE ID IN ("); + for (int i = 0; i < nodesFilter.length; i++) { + sb.append(nodesFilter[i]); + if(i getInputWaysForDNA() { /** * liest die Verbindungen zwischen den Knoten im WegeGraph aus der Tabelle mw_InputWayConnection_bak3 (neuste Version) + * @param nodesFilter - Array mit Knoten, für als Start- oder Endknoten fungieren dürfen * @return */ - public List getInputWaysConnectionForDNA() { + public List getInputWaysConnectionForDNA(int[] nodesFilter) { List edges = new ArrayList<>(); + + String filterString = ""; + + // Filter aktiviert, baue Filterstring auf + if(nodesFilter != null && nodesFilter.length>0){ + StringBuffer sb = new StringBuffer("IN ("); + for (int i = 0; i < nodesFilter.length; i++) { + sb.append(nodesFilter[i]); + if(i getInputWaysConnectionForDNA() { /** * liest alle Knoten für das Kreuzungsmodell aus der Datenbank + * @param nodesFilter Array mit zu berücksichtigenden Knoten * @return Knotenliste mit Knoten des Kreuzungsmodells und den globalen KreuzungsID als Labels */ - public List getCrossroadsForDNA() { + public List getCrossroadsForDNA(int[] nodesFilter) { List nodes = new ArrayList(); Node current = null; + String filterString = ""; + + // Filter aktiviert, baue Filterstring auf + if(nodesFilter != null && nodesFilter.length>0){ + StringBuffer sb = new StringBuffer("WHERE CROSSROAD IN ("); + for (int i = 0; i < nodesFilter.length; i++) { + sb.append(nodesFilter[i]); + if(i outputDiretions; private HashMap connections; + /** + * Konstruktur für die nachträgliche Berechnung + * @param sensorID + * @param sensorName + * @param crossroadID + * @param crossroadName + * @param wayID + * @param outputDirections + */ public Sensor(int sensorID, String sensorName, int crossroadID, String crossroadName, int wayID,Set outputDirections){ this.sensorID=sensorID; this.sensorName=sensorName; @@ -28,6 +37,14 @@ public Sensor(int sensorID, String sensorName, int crossroadID, String crossroad this.outputDiretions=outputDirections; } + /** + * Konstruktur für die Nutzung als Container + * @param sensorID + * @param sensorName + * @param crossroadID + * @param crossroadName + * @param wayID + */ public Sensor(int sensorID, String sensorName, int crossroadID, String crossroadName, int wayID){ this.sensorID=sensorID; this.sensorName=sensorName; @@ -35,19 +52,34 @@ public Sensor(int sensorID, String sensorName, int crossroadID, String crossroad this.crossroadName=crossroadName; this.wayID=wayID; } - + /** + * liefert die globale ID des Sensors + * @return + */ public int getSensorID(){ return sensorID; } + /** + * liefert den Namen des Sensors + * @return + */ public String getSensorName(){ return sensorName; } + /** + * liefert die globale Kreuzungs-ID + * @return + */ public int getCrossroadID(){ return crossroadID; } + /** + * liefert den Namen der Kreuzung + * @return + */ public String getCrossroadName(){ return crossroadName; } @@ -63,7 +95,9 @@ public int getWayID(){ */ public HashMap calculateConnections(HashMap outputConnection) { HashMap connections = new HashMap<>(); + // Über alle Abbiegemöglichkeiten for (CardinalDirection output : outputDiretions) { + // Ausfahrtsweg ist mit Einfahrtsweg benachbarter Kreuzung verbunden if(outputConnection.containsKey(output)) connections.put(output, outputConnection.get(output)); } diff --git a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java index f05b6de1..211341d6 100644 --- a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java @@ -35,14 +35,15 @@ public class TrafficCrossroadGraphGenerator extends GraphGenerator{ private int stepsize; private int timeRange; private TrafficUpdate trafficUpdate; + private int[] nodesFilter; - public TrafficCrossroadGraphGenerator(String name, GraphDataStructure gds, DB db,long timeStampInit,TrafficModi modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate) { - this(name, null, gds,timeStampInit, 0, 0,db,modus,initDateTime,stepsize,timeRange,trafficupdate); + public TrafficCrossroadGraphGenerator(String name, GraphDataStructure gds, DB db,long timeStampInit,TrafficModi modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate, int[] nodesFilter) { + this(name, null, gds,timeStampInit, 0, 0,db,modus,initDateTime,stepsize,timeRange,trafficupdate,nodesFilter); } public TrafficCrossroadGraphGenerator(String name, Parameter[] params, GraphDataStructure gds, long timestampInit, int nodesInit, - int edgesInit,DB db,TrafficModi modus,DateTime initDateTime,int stepsize,int timeRange,TrafficUpdate trafficUpdate) { + int edgesInit,DB db,TrafficModi modus,DateTime initDateTime,int stepsize,int timeRange,TrafficUpdate trafficUpdate, int[] nodesFilter) { super(name, params, gds, timestampInit, nodesInit, edgesInit); this.db= db; this.modus=modus; @@ -50,6 +51,7 @@ public TrafficCrossroadGraphGenerator(String name, Parameter[] params, this.stepsize = stepsize; this.timeRange = timeRange; this.trafficUpdate = trafficUpdate; + this.nodesFilter = nodesFilter; } @Override @@ -62,7 +64,7 @@ public Graph generate() { HashMap disabledEdges = new HashMap<>(); // Nodes - nodes = db.getCrossroadsForDNA(); + nodes = db.getCrossroadsForDNA(nodesFilter); CrossroadWeight crossroadWeight = null; Node currentNode = null; DirectedWeightedNode currentWeighted = null; @@ -111,12 +113,20 @@ public Graph generate() { //Edges - List connection = db.getCrossroadConnection(); + List connection = db.getCrossroadConnectionForDNA(nodesFilter); EdgeContainer current = null; + + Node fromNode; + Node toNode; + Edge e; for (int i = 0; i < connection.size(); i++) { current = connection.get(i); - Edge e = gds.newEdgeInstance(g.getNode(current.getFrom()), g.getNode(current.getTo())); - + fromNode = g.getNode(current.getFrom()); + toNode = g.getNode(current.getTo()); + if(fromNode!= null && toNode!=null) + e = gds.newEdgeInstance(fromNode, toNode); + else + continue; if(disabledEdges.containsKey(current)){ disabledEdges.put(current, e); } diff --git a/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java index 8deb3da2..b454a70b 100644 --- a/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java @@ -32,14 +32,15 @@ public class TrafficInputWayGraphGenerator extends GraphGenerator{ private TrafficUpdate trafficUpdate; private double treshold; private HashMap> disabledEdges = new HashMap<>(); + private int[] nodesFilter; - public TrafficInputWayGraphGenerator(String name, GraphDataStructure gds, DB db, long timeStamp, TrafficModi modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold) { - this(name, null, gds,timeStamp, 0, 0,db, modus,initDateTime,stepsize,timeRange,trafficupdate,treshold); + public TrafficInputWayGraphGenerator(String name, GraphDataStructure gds, DB db, long timeStamp, TrafficModi modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold, int[] nodesFilter) { + this(name, null, gds,timeStamp, 0, 0,db, modus,initDateTime,stepsize,timeRange,trafficupdate,treshold, nodesFilter); } public TrafficInputWayGraphGenerator(String name, Parameter[] params, GraphDataStructure gds, long timestampInit, int nodesInit, - int edgesInit,DB db,TrafficModi modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold) { + int edgesInit,DB db,TrafficModi modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold, int[] nodesFilter) { super(name, params, gds, timestampInit, nodesInit, edgesInit); this.db= db; this.modus = modus; @@ -48,6 +49,7 @@ public TrafficInputWayGraphGenerator(String name, Parameter[] params, this.timeRange = timeRange; this.trafficUpdate = trafficupdate; this.treshold = treshold; + this.nodesFilter = nodesFilter; } @Override @@ -59,7 +61,7 @@ public Graph generate() { Set overloaded = new HashSet<>(); // Nodes - nodes = db.getInputWaysForDNA(); + nodes = db.getInputWaysForDNA(nodesFilter); Node currentNode = null; DirectedWeightedNode currentWeighted = null; @@ -98,7 +100,7 @@ public Graph generate() { } - List connection = db.getInputWaysConnectionForDNA(); + List connection = db.getInputWaysConnectionForDNA(nodesFilter); DirectedWeightedNode fromNode = null; DirectedWeightedNode toNode = null; Edge e = null; @@ -107,7 +109,12 @@ public Graph generate() { ec = connection.get(i); fromNode = (DirectedWeightedNode) g.getNode(ec.getFrom()); toNode = (DirectedWeightedNode) g.getNode(ec.getTo()); - e = gds.newEdgeInstance(fromNode,toNode); + + if(fromNode != null && toNode != null) + e = gds.newEdgeInstance(fromNode,toNode); + else + continue; + if(overloaded.contains(fromNode.getIndex()) || overloaded.contains((toNode.getIndex()))){ addEdge(fromNode.getIndex(),ec,e); addEdge(toNode.getIndex(),ec,e); From 49f663738d7868efa03da183c040083400680188 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Sun, 1 Feb 2015 20:18:59 +0100 Subject: [PATCH 20/24] Datenkapselung, Kommentare --- .../generators/traffic/CrossroadWeight.java | 10 +- src/dna/graph/generators/traffic/DB.java | 23 +-- .../generators/traffic/TrafficConfig.java | 165 ++++++++++++++++++ .../TrafficCrossroadGraphGenerator.java | 30 +++- .../TrafficInputWayGraphGenerator.java | 3 +- .../generators/traffic/TrafficModel.java | 5 + .../TrafficCrossroadBatchGenerator.java | 54 ++++-- .../TrafficInputWayBatchGenerator.java | 37 ++-- .../traffic/TrafficSensorBatchGenerator.java | 17 +- 9 files changed, 262 insertions(+), 82 deletions(-) create mode 100644 src/dna/graph/generators/traffic/TrafficConfig.java create mode 100644 src/dna/graph/generators/traffic/TrafficModel.java diff --git a/src/dna/graph/generators/traffic/CrossroadWeight.java b/src/dna/graph/generators/traffic/CrossroadWeight.java index beb2d4b0..2b6deaaf 100644 --- a/src/dna/graph/generators/traffic/CrossroadWeight.java +++ b/src/dna/graph/generators/traffic/CrossroadWeight.java @@ -12,7 +12,7 @@ public class CrossroadWeight { private double maxCount; private double maxLoad; private double threshold; - private int timestamp; + private long timestamp; public CrossroadWeight(int crossroadID,String crossroadName, double treshold){ this.crossroadID = crossroadID; @@ -64,17 +64,17 @@ public double[] getMaxWeightWay(int osmWayID) { /** * setzt den Zeitstempel, für den das letzte Gewicht vorliegt - * @param timestamp + * @param timestampInit */ - public void setTimestamp(int timestamp){ - this.timestamp = timestamp; + public void setTimestamp(long timestampInit){ + this.timestamp = timestampInit; } /** * liefert den Zeitstempel, für den das letzte Gewicht vorliegt * @return */ - public int getTimestamp(){ + public long getTimestamp(){ return timestamp; } diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index 0df3d97e..10fb78b2 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -38,7 +38,6 @@ public class DB { private GraphDataStructure gds; - private int stepSize; public DateTime initDateTime; private HashMap maxValuesCrossroad; private HashMap maxValuesInputWays; @@ -49,9 +48,7 @@ public class DB { public HashMap inputWaysToID; public HashMap> inputWayConnections; //Key: ToCrossroad,ToWay - Value: List public boolean[] days; - public int timeRange; private double treshold; - private TrafficUpdate trafficUpdate; private HashMap disabledEdges; private HashMap> disabledEdgesInputWay; private boolean dummyMax; @@ -64,14 +61,13 @@ public class DB { * oder falls diese nicht vorhanden ist, aus den Parametern übernommen. * @param gds, Datenstruktur, welcher der Verwendung von DNA zugrunde liegt (für Knotentypen, Kantentypen ..) * @param initTDateTime, Startzeitpunkt für die Modi mit realen Daten - * @param stepSize, Schrittweite für den kontinuerlichen Modus * @param daySelection, Boolean-Array mit 7 Einträgen für die Wochentage * @param timeRange, Intervalllänge für den Tages und Aggregationsmodus * @param treshold, Schwellwert für die Überlastungserkennung * @param trafficUpdate, statische Daten für den Simulationsmodus * @param dummyMax, Verwendung von synthetischen Max-Werten oder realen Max-Werten */ - public DB(GraphDataStructure gds, DateTime initTDateTime, int stepSize, boolean[] daySelection , int timeRange, double treshold,TrafficUpdate trafficUpdate,boolean dummyMax) { + public DB(GraphDataStructure gds, DateTime initTDateTime, boolean[] daySelection , int timeRange, double treshold,boolean dummyMax) { try { FileReader fr = new FileReader("db.txt"); BufferedReader br = new BufferedReader(fr); @@ -122,10 +118,9 @@ public DB(GraphDataStructure gds, DateTime initTDateTime, int stepSize, boolean[ System.out.println("VendorError: " + e.getErrorCode()); } this.gds = gds; - this.stepSize=stepSize; this.initDateTime = initTDateTime; this.days = daySelection; - this.timeRange = timeRange; + this.maxValuesInputWays = new HashMap<>(); this.maxValuesCrossroad = new HashMap<>(); this.maxValuesSensors = new HashMap<>(); @@ -135,7 +130,6 @@ public DB(GraphDataStructure gds, DateTime initTDateTime, int stepSize, boolean[ this.inputWaysToID = new HashMap<>(); this.inputWays= new HashMap<>(); this.treshold = treshold; - this.trafficUpdate = trafficUpdate; this.disabledEdges = new HashMap<>(); this.disabledEdgesInputWay = new HashMap<>(); this.dummyMax = dummyMax; @@ -311,10 +305,10 @@ public double[] writeMaximalWeightsInputWays(int inputwayID) { * @param crossroadID - globale ID der Kreuzung * @param from - Startzeitpunkt * @param to - Endzeitpunkt - * @param timestamp - Zeitstempel für den das Gewicht berechnet wird + * @param timestampInit - Zeitstempel für den das Gewicht berechnet wird * @return */ - public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTime to,int timestamp) { + public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTime to,long timestampInit) { String crossroadName = getCrossroadName(crossroadID); if(!maxValuesCrossroad.containsKey(crossroadID)){ maxValuesCrossroad.put(crossroadID, getMaximalWeightCrossroad(crossroadID) ); @@ -344,9 +338,10 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi crw.setMaxWeightWay(wayID, maxValue); double count = rs.getDouble("ANZAHL"); double load = rs.getDouble("BELEGUNG"); - setMaximalWeightsInputWayImproved(getInputWay(crossroadID, wayID), count, load, from, timeRange); // aktualisiert den maximalen Count-Wert, sofern dies notwendig ist + //TODO: Verbindung zur TimeRange, war zuvor als Parameter in Datenbank, nun nur noch im TrafficConfig + setMaximalWeightsInputWayImproved(getInputWay(crossroadID, wayID), count, load, from, 5); // aktualisiert den maximalen Count-Wert, sofern dies notwendig ist crw.addWeightWay(wayID, new double[]{count,load,(count/maxValue[0])*100}); - crw.setTimestamp(timestamp); + crw.setTimestamp(timestampInit); } } catch (SQLException e) { @@ -366,8 +361,8 @@ public CrossroadWeight getCrossroadWeight(int crossroadID, DateTime from, DateTi * @param trafficUpdate, beinhaltet die synthetischen Daten * @return */ - public CrossroadWeight getCrossroadWeightStaticInit(int crossroadID,DateTime from, DateTime to, int timestamp,TrafficUpdate trafficUpdate) { - CrossroadWeight crw = getCrossroadWeight(crossroadID, from, to,timestamp); + public CrossroadWeight getCrossroadWeightStaticInit(int crossroadID,DateTime from, DateTime to, long timestampInit,TrafficUpdate trafficUpdate) { + CrossroadWeight crw = getCrossroadWeight(crossroadID, from, to,timestampInit); crw.resetInputWayWeight(trafficUpdate.getInitCount(), trafficUpdate.getInitLoad()); return crw; } diff --git a/src/dna/graph/generators/traffic/TrafficConfig.java b/src/dna/graph/generators/traffic/TrafficConfig.java new file mode 100644 index 00000000..d5d2550a --- /dev/null +++ b/src/dna/graph/generators/traffic/TrafficConfig.java @@ -0,0 +1,165 @@ +package dna.graph.generators.traffic; + + +import org.joda.time.DateTime; + +import dna.updates.generators.traffic.Helpers; + +public class TrafficConfig { + + private DateTime initDateTime; + private int stepSize; + + // Auswahl des Modells und Modus + private TrafficModel model; + private String graphGeneratorName; + private String batchGeneratorName; + private TrafficModi modus; + private double treshold; // Schwellwert, ab dem ein Knoten �berlastet ist + + // Parameter f�r Tages-Modus + private boolean[] daySelection; + private int timeRange; + private DateTime holidayStart = new DateTime(2014,10,6,7,0,0); + private int observationWeeks = 1; + private int observationDays = Helpers.weekToDay(observationWeeks, daySelection); + + private int[] nodesFilter; + + //Verwende reale Maximalwerte oder Dummy-Maximalwerte + private boolean dummyMax = false; + + // Parameter f�r die Simulation + private TrafficUpdate trafficUpdate; + /** + * Basis-Konstruktor + * @param modus + * @param nodesFilter + * @param initDateTime + */ + private TrafficConfig(TrafficModi modus, TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime ){ + this.modus = modus; + this.treshold = treshold; + this.nodesFilter = nodesFilter; + this.initDateTime = initDateTime; + + // Namensgenerierung + + switch (model) { + case CrossroadModel: + graphGeneratorName = "CrossroadGraph"; + batchGeneratorName = "CrossroadBatch"; + break; + + case WayModel: + graphGeneratorName = "InputWayGraph"; + batchGeneratorName = "InputWayBatch"; + break; + + case SensorModel: + graphGeneratorName = "SensorGraph"; + batchGeneratorName = "SensorBatch"; + break; + + default: + graphGeneratorName = "DefaultTrafficGraph"; + batchGeneratorName = "DefaultTrafficBatch"; + break; + } + } + + /** + * Konstruktor für den Continuous-Modus + * @param modus + * @param nodesFilter + * @param initDateTime + * @param stepsize + */ + private TrafficConfig(TrafficModi modus, TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime, int stepsize){ + this(modus,model,treshold,nodesFilter,initDateTime); + this.stepSize = stepsize; + } + /** + * Konstruktor für den TimeRange-Modus + * @param modus + * @param treshold + * @param nodesFilter + * @param initDateTime + * @param timeRange + * @param daySelection + * @param holidayStart + */ + private TrafficConfig(TrafficModi modus, TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime, int timeRange, boolean[] daySelection, DateTime holidayStart){ + this(modus,model,treshold,nodesFilter,initDateTime); + this.timeRange = timeRange; + this.daySelection = daySelection; + this.holidayStart = holidayStart; + } + + /** + * Konsruktor für den Simulations-Modus + * @param modus + * @param treshold + * @param nodesFilter + * @param initDateTime + * @param trafficUpdate + */ + private TrafficConfig(TrafficModi modus, TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime, TrafficUpdate trafficUpdate){ + this(modus,model,treshold,nodesFilter,initDateTime); + this.trafficUpdate = trafficUpdate; + } + + + public static TrafficConfig getContinousConfig(TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime, int stepsize){ + return new TrafficConfig(TrafficModi.Continuous,model,treshold, nodesFilter, initDateTime, stepsize); + } + + public static TrafficConfig getDayTimeRangeConfig(TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime, int timeRange, boolean[] daySelection, DateTime holidayStart){ + return new TrafficConfig(TrafficModi.DayTimeRange, model, treshold, nodesFilter, initDateTime, timeRange, daySelection, holidayStart); + } + + public static TrafficConfig getAggregationConfig(){ + return null; + } + + public static TrafficConfig getSimulationConfig(TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime, TrafficUpdate trafficUpdate){ + return new TrafficConfig(TrafficModi.Simulation, model, treshold, nodesFilter, initDateTime, trafficUpdate); + } + + public TrafficModi getModus(){ + return modus; + } + + public String getGraphName(){ + return graphGeneratorName; + } + + public String getBatchName(){ + return batchGeneratorName; + } + + public DateTime getInitDateTime(){ + return initDateTime; + } + + public int getStepSize(){ + return stepSize; + } + + public int getTimeRange(){ + return timeRange; + } + + public TrafficUpdate getTrafficUpdate(){ + return trafficUpdate; + } + + public int[] getNodesFilter(){ + return nodesFilter; + } + + public double getTreshold(){ + return treshold; + } + +} diff --git a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java index 211341d6..ca2442e0 100644 --- a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java @@ -21,6 +21,7 @@ import dna.graph.weights.Double3dWeight; import dna.io.GraphReader; import dna.io.GraphWriter; +import dna.metrics.IMetric; import dna.updates.update.EdgeRemoval; import dna.util.ArrayUtils; import dna.util.parameters.IntParameter; @@ -53,6 +54,17 @@ public TrafficCrossroadGraphGenerator(String name, Parameter[] params, this.trafficUpdate = trafficUpdate; this.nodesFilter = nodesFilter; } + + public TrafficCrossroadGraphGenerator(TrafficConfig tc, GraphDataStructure gds, DB db, long timeStampInit){ + super(tc.getGraphName(), null, gds, timeStampInit,0,0); + this.db = db; + this.modus = tc.getModus(); + this.initDateTime = tc.getInitDateTime(); + this.stepsize = tc.getStepSize(); + this.timeRange = tc.getTimeRange(); + this.trafficUpdate = tc.getTrafficUpdate(); + this.nodesFilter = tc.getNodesFilter(); + } @Override public Graph generate() { @@ -68,6 +80,7 @@ public Graph generate() { CrossroadWeight crossroadWeight = null; Node currentNode = null; DirectedWeightedNode currentWeighted = null; + for (int i = 0; i < nodes.size(); i++) { currentNode = (Node) nodes.get(i); @@ -78,24 +91,31 @@ public Graph generate() { } switch (modus) { + case Continuous: - crossroadWeight = db.getCrossroadWeight(currentWeighted.getIndex(),initDateTime,initDateTime.plusMinutes(stepsize),0); + crossroadWeight = db.getCrossroadWeight(currentWeighted.getIndex(),initDateTime,initDateTime.plusMinutes(stepsize),timestampInit); break; + case DayTimeRange: case Aggregation: - crossroadWeight = db.getCrossroadWeight(currentWeighted.getIndex(),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange),0); + crossroadWeight = db.getCrossroadWeight(currentWeighted.getIndex(),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange),timestampInit); break; + case Simulation: - crossroadWeight = db.getCrossroadWeightStaticInit(currentWeighted.getIndex(),initDateTime,initDateTime.plusMinutes(1),0,trafficUpdate); + crossroadWeight = db.getCrossroadWeightStaticInit(currentWeighted.getIndex(),initDateTime,initDateTime.plusMinutes(1),timestampInit,trafficUpdate); break; + default: System.out.println("error - Modus nicht definiert"); break; + } double[] weight = crossroadWeight.getWeight(); - System.out.println("ID " +currentWeighted.getIndex() + "\tCount:" + weight[0] +"\tLoad:"+weight[1]+"\t"+"Norm:"+weight[2]); - db.setMaximalWeightsCrossroadImproved(currentWeighted.getIndex(), weight[0], weight[1], initDateTime,db.timeRange); + + db.setMaximalWeightsCrossroadImproved(currentWeighted.getIndex(), weight[0], weight[1], initDateTime,timeRange); + currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); + g.addNode(currentWeighted); EdgeContainer ec = null; diff --git a/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java index b454a70b..043277ab 100644 --- a/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java @@ -95,8 +95,7 @@ public Graph generate() { currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); g.addNode(currentWeighted); - if(weight[2]>96) - System.out.println("ID " +currentWeighted.getIndex() + "\tCount:" + weight[0] +"\tLoad:"+weight[1]+"\t"+"Norm:"+weight[2]); + System.out.println("New Node Weight"); } diff --git a/src/dna/graph/generators/traffic/TrafficModel.java b/src/dna/graph/generators/traffic/TrafficModel.java new file mode 100644 index 00000000..82345aff --- /dev/null +++ b/src/dna/graph/generators/traffic/TrafficModel.java @@ -0,0 +1,5 @@ +package dna.graph.generators.traffic; + +public enum TrafficModel { + CrossroadModel, WayModel, SensorModel +} diff --git a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java index ecfbac06..77e85c32 100644 --- a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java @@ -40,19 +40,21 @@ import dna.util.parameters.Parameter; public class TrafficCrossroadBatchGenerator extends BatchGenerator{ - DB db; - DateTime initDateTime; - int stepSize; - int run=0; - int observationDays; + + private DB db; + private DateTime initDateTime; + private int stepSize; + private int run=0; + private int observationDays; private TrafficModi modus; - DateTime holidayStart; - boolean[] daySelection; - HashMap disabledEdges = new HashMap<>(); + private DateTime holidayStart; + private boolean[] daySelection; + private HashMap disabledEdges = new HashMap<>(); private TrafficUpdate trafficUpdate; - HashMap nodeHistory; + private HashMap nodeHistory; + private int timeRange; - public TrafficCrossroadBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, TrafficModi modus, DateTime holidayStart, boolean [] daySelection,TrafficUpdate trafficUpdate, int observationDays) { + public TrafficCrossroadBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, TrafficModi modus, DateTime holidayStart, boolean [] daySelection,TrafficUpdate trafficUpdate,int timeRange, int observationDays) { super(name, new IntParameter("NA", 0), new IntParameter("NR", 0), new IntParameter("NW", 0), new ObjectParameter("NWS", 0), new IntParameter("EA", 0), @@ -64,7 +66,9 @@ public TrafficCrossroadBatchGenerator(String name,DB db, DateTime initDateTime, this.holidayStart = holidayStart; this.daySelection = daySelection; this.trafficUpdate = trafficUpdate; + this.timeRange = timeRange; this.observationDays = observationDays; + } @Override @@ -80,15 +84,20 @@ public Batch generate(Graph g) { Iterable nodes = g.getNodes(); CrossroadWeight crossroadWeight = null; DateTime time = null; - if(modus == TrafficModi.DayTimeRange || modus == TrafficModi.Simulation){ + + // Bestimmte den nächsten Tag + if(modus == TrafficModi.DayTimeRange){ time = initDateTime; time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart,true); } - if(modus == TrafficModi.Aggregation){ + else if(modus == TrafficModi.Aggregation){ nodeHistory = new HashMap<>(); } - int newTimeStamp = (int) g.getTimestamp() + 1; + // neuer Timestamp durch Batch-Generierung + long newTimeStamp = (int) g.getTimestamp() + 1; + + // Berechne neues Gewicht für jeden Knoten for (IElement currentNode : nodes) { DirectedWeightedNode n = (DirectedWeightedNode) currentNode; double[] update = null; @@ -98,19 +107,29 @@ public Batch generate(Graph g) { case Continuous: crossroadWeight =db.getCrossroadWeight(n.getIndex(), initDateTime.plusMinutes((int) (g.getTimestamp()*stepSize)),initDateTime.plusMinutes((int) (g.getTimestamp()+stepSize)*stepSize),newTimeStamp); break; + case DayTimeRange: - crossroadWeight = db.getCrossroadWeight(n.getIndex(),time.minusMinutes(db.timeRange),time.plusMinutes(db.timeRange),newTimeStamp); + crossroadWeight = db.getCrossroadWeight(n.getIndex(),time.minusMinutes(timeRange),time.plusMinutes(timeRange),newTimeStamp); break; + case Simulation: crossroadWeight = db.getCrossroadWeightStaticBatch(n.getIndex(),trafficUpdate); break; + case Aggregation: + //Initialisierung auf Starttag time = initDateTime; int index = n.getIndex(); long start = g.getTimestamp(); + + // Aggregiere für observationDays-viele Tage for (int i = 0; i < observationDays; i++) { + + // Gehe einen Tag zurück (gemäß daySelection) und berechne den entsprechenden Wert time = Helpers.calculateNextDay(initDateTime, start++,daySelection,holidayStart,false); - CrossroadWeight weightOfDay = db.getCrossroadWeight(n.getIndex(),time.minusMinutes(db.timeRange*2),time.plusMinutes(db.timeRange*2),newTimeStamp); + CrossroadWeight weightOfDay = db.getCrossroadWeight(n.getIndex(),time.minusMinutes(timeRange*2),time.plusMinutes(timeRange*2),newTimeStamp); + + // Sammler für jeden Knoten die Gewichte der einzelnen Tage if(nodeHistory.containsKey(index)){ nodeHistory.get(index).add(weightOfDay); } @@ -119,10 +138,13 @@ public Batch generate(Graph g) { weightList.add(weightOfDay); nodeHistory.put(index, weightList); } + } + // Nach der Aggregation, berechne den Average crossroadWeight = nodeHistory.get(index).getAverage(); break; + default: System.out.println("error - Modus nicht definiert"); break; @@ -132,7 +154,7 @@ public Batch generate(Graph g) { Double3dWeight oldWeight = (Double3dWeight) n.getWeight(); Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); - db.setMaximalWeightsCrossroadImproved(n.getIndex(), update[0], update[1], time,db.timeRange); + db.setMaximalWeightsCrossroadImproved(n.getIndex(), update[0], update[1], time,timeRange); if(!oldWeight.equals(newWeight)) b.add(new NodeWeight((dna.graph.weights.IWeightedNode) currentNode,newWeight)); diff --git a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java index 3678c9e7..68e4bec8 100644 --- a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java @@ -43,14 +43,16 @@ public class TrafficInputWayBatchGenerator extends BatchGenerator{ private TrafficModi modus; private DateTime holidayStart; private boolean[] daySelection; + private int observationDays; private HashMap> disabledEdges = new HashMap<>(); private HashMap> newDisabledEdges = new HashMap<>(); private double treshold; private TrafficUpdate trafficUpdate; private HashMap> nodeHistory; + private int timeRange; - public TrafficInputWayBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, TrafficModi modus, DateTime holidayStart, boolean [] daySelection, double treshold,TrafficUpdate trafficUpdate) { + public TrafficInputWayBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, TrafficModi modus, DateTime holidayStart, boolean [] daySelection, double treshold, TrafficUpdate trafficUpdate, int timeRange, int observationDays) { super(name, new IntParameter("NA", 0), new IntParameter("NR", 0), new IntParameter("NW", 10), new ObjectParameter("NWS", 0), new IntParameter("EA", 0), @@ -64,6 +66,8 @@ public TrafficInputWayBatchGenerator(String name,DB db, DateTime initDateTime, i this.treshold = treshold; this.trafficUpdate = trafficUpdate; this.nodeHistory = new HashMap<>(); + this.timeRange = timeRange; + this.observationDays = observationDays; } @Override @@ -95,7 +99,7 @@ public Batch generate(Graph g) { update = db.getInputWayWeight(n.getIndex(),initDateTime.plusMinutes((int) (g.getTimestamp()+1)*stepSize),initDateTime.plusMinutes((int) (g.getTimestamp()+2)*stepSize)); break; case DayTimeRange: - update = db.getInputWayWeight(n.getIndex(),time.minusMinutes(db.timeRange),time.plusMinutes(db.timeRange)); + update = db.getInputWayWeight(n.getIndex(),time.minusMinutes(timeRange),time.plusMinutes(timeRange)); break; case Simulation: update = (trafficUpdate.isAffected(n.getIndex()))? db.getInputWayWeightStaticBatch(n.getIndex(),trafficUpdate) : null; @@ -104,10 +108,10 @@ public Batch generate(Graph g) { time = initDateTime; int index = n.getIndex(); long start = g.getTimestamp(); - double max = 0; - for (int i = 0; i < 5; i++) { + + for (int i = 0; i < observationDays; i++) { time = Helpers.calculateNextDay(initDateTime, start++, daySelection, holidayStart, false); - double[] weightOfDay = db.getInputWayWeight(n.getIndex(),time.minusMinutes(db.timeRange),time.plusMinutes(db.timeRange)); + double[] weightOfDay = db.getInputWayWeight(n.getIndex(),time.minusMinutes(timeRange),time.plusMinutes(timeRange)); if(nodeHistory.containsKey(index)){ nodeHistory.get(index).add(weightOfDay[2]); } @@ -179,29 +183,8 @@ public Batch generate(Graph g) { } } - - - /* - //EdgeRemoval - if(update[2] > treshold){ //Knoten ist überlastet - key = n.getIndex(); - if(!disabledEdges.containsKey(key)){ - List edges= new ArrayList<>(); - for (IElement e : n.getEdges()) { - if(e instanceof Edge){ - edge = (Edge) e; - b.add(new EdgeRemoval(edge)); - } - } - newDisabledEdges.put(key, edges); - } - else{ - newDisabledEdges.put(key, disabledEdges.get(key)); - } - disabledEdges.remove(key); - }*/ } - //TODO: War in der Schleife, prüfen + for (Edge e : toDisable) { b.add(new EdgeRemoval(e)); } diff --git a/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java index fe3963f2..2bdf1f35 100644 --- a/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java @@ -97,8 +97,8 @@ public Batch generate(Graph g) { break; case DayTimeRange: time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart,true); - fromTime = time.minusMinutes(db.timeRange); - toTime = time.plusMinutes(db.timeRange); + fromTime = time.minusMinutes(timeRange); + toTime = time.plusMinutes(timeRange); break; default: @@ -193,18 +193,9 @@ public Batch generate(Graph g) { b.add(new EdgeAddition(elem.getValue())); } } + disabledEdges=newDisabledEdges; - /* - int node = 0; - //NodeWeight - db.getSensorWeights(from, to, newTimestamp); - for (IElement currentNode : g.getNodes()) { - Node n = (DirectedWeightedNode) currentNode; - double[] update = db.getSensorModelWeight(n.getIndex(), from, to, newTimestamp); - b.add(new NodeWeight((IWeightedNode) currentNode,new Double3dWeight(update[0],update[1],update[2]))); - System.out.println("Updated: "+node++); - } - */ + return b; } From f1f9fee7562babbd7c87cf6aaee227fb1bdef9a8 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Sun, 1 Feb 2015 21:17:14 +0100 Subject: [PATCH 21/24] Rearrangement, Kommentare --- src/dna/graph/generators/traffic/DB.java | 5 ++--- .../generators/traffic/TrafficConfig.java | 1 + .../TrafficCrossroadGraphGenerator.java | 6 ++++- .../TrafficCrossroadBatchGenerator.java | 22 ++++++++++++++----- .../TrafficInputWayBatchGenerator.java | 20 +++++++++++------ 5 files changed, 38 insertions(+), 16 deletions(-) diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index 10fb78b2..d015b7d2 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -47,7 +47,7 @@ public class DB { public HashMap inputWays; public HashMap inputWaysToID; public HashMap> inputWayConnections; //Key: ToCrossroad,ToWay - Value: List - public boolean[] days; + private double treshold; private HashMap disabledEdges; private HashMap> disabledEdgesInputWay; @@ -67,7 +67,7 @@ public class DB { * @param trafficUpdate, statische Daten für den Simulationsmodus * @param dummyMax, Verwendung von synthetischen Max-Werten oder realen Max-Werten */ - public DB(GraphDataStructure gds, DateTime initTDateTime, boolean[] daySelection , int timeRange, double treshold,boolean dummyMax) { + public DB(GraphDataStructure gds, DateTime initTDateTime, boolean[] daySelection, double treshold,boolean dummyMax) { try { FileReader fr = new FileReader("db.txt"); BufferedReader br = new BufferedReader(fr); @@ -119,7 +119,6 @@ public DB(GraphDataStructure gds, DateTime initTDateTime, boolean[] daySelection } this.gds = gds; this.initDateTime = initTDateTime; - this.days = daySelection; this.maxValuesInputWays = new HashMap<>(); this.maxValuesCrossroad = new HashMap<>(); diff --git a/src/dna/graph/generators/traffic/TrafficConfig.java b/src/dna/graph/generators/traffic/TrafficConfig.java index d5d2550a..3a6f4898 100644 --- a/src/dna/graph/generators/traffic/TrafficConfig.java +++ b/src/dna/graph/generators/traffic/TrafficConfig.java @@ -39,6 +39,7 @@ public class TrafficConfig { */ private TrafficConfig(TrafficModi modus, TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime ){ this.modus = modus; + this.model = model; this.treshold = treshold; this.nodesFilter = nodesFilter; this.initDateTime = initDateTime; diff --git a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java index ca2442e0..4a2c40d7 100644 --- a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java @@ -112,7 +112,8 @@ public Graph generate() { double[] weight = crossroadWeight.getWeight(); - db.setMaximalWeightsCrossroadImproved(currentWeighted.getIndex(), weight[0], weight[1], initDateTime,timeRange); + if(modus == TrafficModi.DayTimeRange) + db.setMaximalWeightsCrossroadImproved(currentWeighted.getIndex(), weight[0], weight[1], initDateTime, timeRange); currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); @@ -140,13 +141,16 @@ public Graph generate() { Node toNode; Edge e; for (int i = 0; i < connection.size(); i++) { + current = connection.get(i); fromNode = g.getNode(current.getFrom()); toNode = g.getNode(current.getTo()); + if(fromNode!= null && toNode!=null) e = gds.newEdgeInstance(fromNode, toNode); else continue; + if(disabledEdges.containsKey(current)){ disabledEdges.put(current, e); } diff --git a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java index 77e85c32..1cf6fe90 100644 --- a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java @@ -74,24 +74,36 @@ public TrafficCrossroadBatchGenerator(String name,DB db, DateTime initDateTime, @Override public Batch generate(Graph g) { GraphWriter.write(g, "CrossroadGraph/", "batch"+run+++".txt"); + Batch b = new Batch(g.getGraphDatastructures(), g.getTimestamp(), g.getTimestamp() + 1, 0, 0, 0, 0, 0, 0); + + // Infos aus Initialisierungsschritt holen if(g.getTimestamp()==0){ disabledEdges = db.getDisabledEdges(); } + HashMap newDisabled = new HashMap<>(); Iterable nodes = g.getNodes(); CrossroadWeight crossroadWeight = null; DateTime time = null; - // Bestimmte den nächsten Tag - if(modus == TrafficModi.DayTimeRange){ + + // Spezialkonfigurationen für bestimmte Modi + switch (modus) { + + case DayTimeRange: time = initDateTime; time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart,true); - } - else if(modus == TrafficModi.Aggregation){ + break; + + case Aggregation: nodeHistory = new HashMap<>(); + break; + + default: + break; } // neuer Timestamp durch Batch-Generierung @@ -154,7 +166,7 @@ else if(modus == TrafficModi.Aggregation){ Double3dWeight oldWeight = (Double3dWeight) n.getWeight(); Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); - db.setMaximalWeightsCrossroadImproved(n.getIndex(), update[0], update[1], time,timeRange); + db.setMaximalWeightsCrossroadImproved(n.getIndex(), update[0], update[1], time, timeRange); if(!oldWeight.equals(newWeight)) b.add(new NodeWeight((dna.graph.weights.IWeightedNode) currentNode,newWeight)); diff --git a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java index 68e4bec8..92e29e09 100644 --- a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java @@ -75,20 +75,17 @@ public Batch generate(Graph g) { Batch b = new Batch(g.getGraphDatastructures(), g.getTimestamp(), g.getTimestamp() + 1, 0, 0, 0, 0, 0, 0); - if(g.getTimestamp()==0){ - disabledEdges=db.getDisabledEdgesInputWay(); - } + + Set toDisable = new HashSet<>(); - GraphWriter.write(g, "InputWayGraph/", "batch"+step+++".txt"); Iterable nodes = g.getNodes(); DateTime time = null; - Edge edge = null; - Integer newKey = null; + if(modus == TrafficModi.DayTimeRange){ time = initDateTime; time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart,true); } - newDisabledEdges = new HashMap<>(); + for (IElement currentNode : nodes) { DirectedWeightedNode n = (DirectedWeightedNode) currentNode; double[] update =null; @@ -146,6 +143,15 @@ public Batch generate(Graph g) { } EdgeContainer ec = null; + Integer newKey = null; + Edge edge = null; + + // Infos aus Initialisierungsschritt holen + if(g.getTimestamp()==0){ + disabledEdges=db.getDisabledEdgesInputWay(); + } + newDisabledEdges = new HashMap<>(); + if(update[2] > treshold) { newKey = n.getIndex(); From 232646e236601c9210ac3e3e7175f9f5b6b97fe8 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Wed, 11 Feb 2015 16:17:43 +0100 Subject: [PATCH 22/24] Umstellung auf TrafficConfig in Crossgroad und InputWay + Kommentare und Umstrukturierung des Layouts der Klassen --- src/dna/graph/generators/traffic/DB.java | 4 +- .../generators/traffic/TrafficConfig.java | 80 +++++++++++++++- .../TrafficInputWayGraphGenerator.java | 74 ++++++++++++--- .../traffic/TrafficSensorGraphGenerator.java | 12 ++- .../TrafficCrossroadBatchGenerator.java | 19 +++- .../TrafficInputWayBatchGenerator.java | 94 ++++++++++++++----- 6 files changed, 239 insertions(+), 44 deletions(-) diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index d015b7d2..8b879881 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -543,10 +543,12 @@ public void writeMaximalWeightSensorRandom() { public void getMaximalWeightCrossroad() { try { String selectStmt; + if(dummyMax) selectStmt = "SELECT * FROM mw_MaxValues_Crossroad_Random"; else selectStmt = "SELECT * FROM mw_MaxValues_CrossroadImproved"; + Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); @@ -645,7 +647,6 @@ public List getCrossroadConnectionForDNA(int[] nodesFilter) { try { String selectStmt = "SELECT FROM_CROSSROAD,TO_CROSSROAD FROM mw_CrossroadConnection " +filterString; - System.out.println(selectStmt); Statement stmt = con.createStatement(); ResultSet rs = stmt.executeQuery(selectStmt); @@ -1019,7 +1020,6 @@ public List getCrossroadsForDNA(int[] nodesFilter) { String statementString; statementString = "SELECT * FROM ((SELECT DISTINCT FROM_CROSSROAD as CROSSROAD FROM mw_CrossroadConnection) UNION (SELECT DISTINCT TO_CROSSROAD as CROSSROAD FROM mw_CrossroadConnection)) V " +filterString; ResultSet rs = stmt.executeQuery(statementString); - System.out.println(statementString); while(rs.next() ) { int label = rs.getInt("CROSSROAD"); current= gds.newNodeInstance(label); diff --git a/src/dna/graph/generators/traffic/TrafficConfig.java b/src/dna/graph/generators/traffic/TrafficConfig.java index 3a6f4898..4834ef37 100644 --- a/src/dna/graph/generators/traffic/TrafficConfig.java +++ b/src/dna/graph/generators/traffic/TrafficConfig.java @@ -22,7 +22,7 @@ public class TrafficConfig { private int timeRange; private DateTime holidayStart = new DateTime(2014,10,6,7,0,0); private int observationWeeks = 1; - private int observationDays = Helpers.weekToDay(observationWeeks, daySelection); + private int observationDays; //TODO wo kommt es her? private int[] nodesFilter; @@ -31,6 +31,7 @@ public class TrafficConfig { // Parameter f�r die Simulation private TrafficUpdate trafficUpdate; + /** * Basis-Konstruktor * @param modus @@ -110,23 +111,79 @@ private TrafficConfig(TrafficModi modus, TrafficModel model, double treshold, in this.trafficUpdate = trafficUpdate; } + /** + * Konstruktor für den Aggregations-Modus + * @param modus + * @param model + * @param treshold + * @param nodesFilter + * @param initDateTime + * @param trafficUpdate + */ + private TrafficConfig(TrafficModi modus, TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime, boolean[] daySelection, int observationWeeks){ + this(modus,model,treshold,nodesFilter,initDateTime); + this.daySelection = daySelection; + this.observationWeeks = observationWeeks; + this.observationDays = Helpers.weekToDay(observationWeeks, daySelection); + } - public static TrafficConfig getContinousConfig(TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime, int stepsize){ - return new TrafficConfig(TrafficModi.Continuous,model,treshold, nodesFilter, initDateTime, stepsize); + /** + * liefert eine gültige TrafficConfig für die Verwendung des Continous-Modus + * @param model + * @param treshold + * @param nodesFilter + * @param initDateTime + * @param stepsize + * @return + */ + public static TrafficConfig getContinousConfig(TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime, int stepSize){ + return new TrafficConfig(TrafficModi.Continuous,model,treshold, nodesFilter, initDateTime, stepSize); } + /** + * liefert eine gültige TrafficConfig für die Verwendung des DayTimeRange-Modus + * @param model + * @param treshold + * @param nodesFilter + * @param initDateTime + * @param timeRange + * @param daySelection + * @param holidayStart + * @return + */ public static TrafficConfig getDayTimeRangeConfig(TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime, int timeRange, boolean[] daySelection, DateTime holidayStart){ return new TrafficConfig(TrafficModi.DayTimeRange, model, treshold, nodesFilter, initDateTime, timeRange, daySelection, holidayStart); } - public static TrafficConfig getAggregationConfig(){ - return null; + /** + * liefert eine gültige TrafficConfig für die Verwendung des Aggregations-Modus + * @param model + * @param treshold + * @param nodesFilter + * @param initDateTime + * @return + */ + public static TrafficConfig getAggregationConfig(TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime){ + return new TrafficConfig(TrafficModi.Aggregation, model, treshold, nodesFilter,initDateTime); } + /** + * liefert eine gültige TrafficConfig für die Verwendung des Simulations-Modus + * @param model + * @param treshold + * @param nodesFilter + * @param initDateTime + * @param trafficUpdate + * @return + */ public static TrafficConfig getSimulationConfig(TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime, TrafficUpdate trafficUpdate){ return new TrafficConfig(TrafficModi.Simulation, model, treshold, nodesFilter, initDateTime, trafficUpdate); } + public TrafficModel getModel(){ + return model; + } + public TrafficModi getModus(){ return modus; } @@ -162,5 +219,18 @@ public int[] getNodesFilter(){ public double getTreshold(){ return treshold; } + + public DateTime getHolidayStart(){ + return holidayStart; + } + + public boolean[] getDaySelection(){ + return daySelection; + } + + public int getOberservationDays(){ + return observationDays; + + } } diff --git a/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java index 043277ab..5bdb888e 100644 --- a/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficInputWayGraphGenerator.java @@ -1,7 +1,5 @@ package dna.graph.generators.traffic; - -import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -17,22 +15,30 @@ import dna.graph.nodes.INode; import dna.graph.nodes.Node; import dna.graph.weights.Double3dWeight; -import dna.io.GraphWriter; import dna.util.parameters.Parameter; public class TrafficInputWayGraphGenerator extends GraphGenerator{ - List nodeslist; private DB db; - private DateTime initTime; + + // Allgemeine Parameter private TrafficModi modus; private DateTime initDateTime; - private int stepsize; + private int[] nodesFilter; + + // Continuous-Modus + private int stepSize; + + // DayTimeRange / Aggregation private int timeRange; - private TrafficUpdate trafficUpdate; private double treshold; + + // Simulation + private TrafficUpdate trafficUpdate; + + private HashMap> disabledEdges = new HashMap<>(); - private int[] nodesFilter; + public TrafficInputWayGraphGenerator(String name, GraphDataStructure gds, DB db, long timeStamp, TrafficModi modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold, int[] nodesFilter) { this(name, null, gds,timeStamp, 0, 0,db, modus,initDateTime,stepsize,timeRange,trafficupdate,treshold, nodesFilter); @@ -45,12 +51,31 @@ public TrafficInputWayGraphGenerator(String name, Parameter[] params, this.db= db; this.modus = modus; this.initDateTime = initDateTime; - this.stepsize = stepsize; + this.stepSize = stepsize; this.timeRange = timeRange; this.trafficUpdate = trafficupdate; this.treshold = treshold; this.nodesFilter = nodesFilter; } + + /** + * Erstellt einen GraphGenerator für das WayModel für die übergebene TrafficConfig + * @param tc + * @param gds + * @param db + * @param timeStampInit + */ + public TrafficInputWayGraphGenerator(TrafficConfig tc, GraphDataStructure gds, DB db, long timeStampInit){ + super(tc.getGraphName(), null, gds, timeStampInit,0,0); + this.db = db; + this.modus = tc.getModus(); + this.initDateTime = tc.getInitDateTime(); + this.stepSize = tc.getStepSize(); + this.timeRange = tc.getTimeRange(); + this.trafficUpdate = tc.getTrafficUpdate(); + this.treshold = tc.getTreshold(); + this.nodesFilter = tc.getNodesFilter(); + } @Override public Graph generate() { @@ -60,14 +85,20 @@ public Graph generate() { List nodes = null; Set overloaded = new HashSet<>(); - // Nodes + + // Knoten + + // Lade abstrakte Knoten gemäß NodesFilter nodes = db.getInputWaysForDNA(nodesFilter); Node currentNode = null; DirectedWeightedNode currentWeighted = null; double[] weight = null; + + // Berechne für jeden abstrakten Knoten das Gewicht gemäß des ausgewählten Modus for (int i = 0; i < nodes.size(); i++) { currentNode = (Node) nodes.get(i); + if(currentNode instanceof DirectedWeightedNode) currentWeighted = (DirectedWeightedNode) currentNode; else{ @@ -76,34 +107,44 @@ public Graph generate() { switch (modus) { case Continuous: - weight = db.getInputWayWeight(currentWeighted.getIndex(), initDateTime, initDateTime.plusMinutes(stepsize)); + weight = db.getInputWayWeight(currentWeighted.getIndex(), initDateTime, initDateTime.plusMinutes(stepSize)); break; case DayTimeRange: case Aggregation: weight = db.getInputWayWeight(currentWeighted.getIndex(),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange)); break; + case Simulation: weight = db.getInputWayWeightStaticInit(currentWeighted.getIndex(),trafficUpdate); break; + default: System.out.println("error - Modus nicht definiert @ TrafficInputwayGraphGenerator"); break; + } + + // Knoten ist überlastet if(weight[2] > treshold){ overloaded.add(currentWeighted.getIndex()); } currentWeighted.setWeight(new Double3dWeight(weight[0],weight[1],weight[2])); g.addNode(currentWeighted); - System.out.println("New Node Weight"); } + // Kanten + + // Lade die Kanten für die durch NodesFilter definierten Knoten List connection = db.getInputWaysConnectionForDNA(nodesFilter); + DirectedWeightedNode fromNode = null; DirectedWeightedNode toNode = null; Edge e = null; EdgeContainer ec = null; + + // Prüfe für jede Kante, ob sie gültig oder überlastet ist, sortiere dementsprechend ein for (int i = 0; i < connection.size(); i++) { ec = connection.get(i); fromNode = (DirectedWeightedNode) g.getNode(ec.getFrom()); @@ -114,19 +155,28 @@ public Graph generate() { else continue; + // einer der Enknoten ist ueberlastet if(overloaded.contains(fromNode.getIndex()) || overloaded.contains((toNode.getIndex()))){ addEdge(fromNode.getIndex(),ec,e); addEdge(toNode.getIndex(),ec,e); } + // Gültige Kante else{ g.addEdge(e); e.connectToNodes(); } } + // Zwischenspeichern der überlasteten Kanten in der DB db.setDisabledEdgesInputWay(disabledEdges); return g; } + /** + * fügt eine Kante in den Zwischenspeicher ein, der über die DB-Klasse an den Batch übergeben wird. + * @param index Knotenindex des Endknoten + * @param ec ContainerKlasse der Kante + * @param e Kante + */ public void addEdge(int index,EdgeContainer ec, Edge e){ if(disabledEdges.containsKey(index)) disabledEdges.get(index).put(ec,e); diff --git a/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java index 7be93820..2cda0951 100644 --- a/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java @@ -49,6 +49,17 @@ public TrafficSensorGraphGenerator(String name, Parameter[] params, this.trafficUpdate = trafficUpdate; this.treshold = treshold; } + + public TrafficSensorGraphGenerator(TrafficConfig tc, GraphDataStructure gds, DB db, long timeStampInit){ + super(tc.getGraphName(), null, gds, timeStampInit,0,0); + this.db = db; + this.modus = tc.getModus(); + this.initDateTime=tc.getInitDateTime(); + this.stepsize = tc.getStepSize(); + this.timeRange = tc.getTimeRange(); + this.trafficUpdate = tc.getTrafficUpdate(); + this.treshold = tc.getTreshold(); + } @Override public Graph generate() { @@ -77,7 +88,6 @@ public Graph generate() { if(currentNode instanceof DirectedWeightedNode) currentWeighted = (DirectedWeightedNode) currentNode; else{ - System.out.println("Continue"); continue; } switch (modus) { diff --git a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java index 1cf6fe90..f3e386c3 100644 --- a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java @@ -18,6 +18,7 @@ import dna.graph.generators.traffic.CrossroadWeight; import dna.graph.generators.traffic.DB; import dna.graph.generators.traffic.EdgeContainer; +import dna.graph.generators.traffic.TrafficConfig; import dna.graph.generators.traffic.TrafficModi; import dna.graph.generators.traffic.TrafficUpdate; import dna.graph.nodes.DirectedNode; @@ -68,7 +69,22 @@ public TrafficCrossroadBatchGenerator(String name,DB db, DateTime initDateTime, this.trafficUpdate = trafficUpdate; this.timeRange = timeRange; this.observationDays = observationDays; - + } + + public TrafficCrossroadBatchGenerator(DB db, TrafficConfig tc){ + super(tc.getBatchName(), new IntParameter("NA", 0), new IntParameter("NR", + 0), new IntParameter("NW", 0), + new ObjectParameter("NWS", 0), new IntParameter("EA", 0), + new IntParameter("ER", 0)); + this.db = db; + this.initDateTime = tc.getInitDateTime(); + this.stepSize = tc.getStepSize(); + this.modus = tc.getModus(); + this.holidayStart = tc.getHolidayStart(); + this.daySelection = tc.getDaySelection(); + this.trafficUpdate = tc.getTrafficUpdate(); + this.timeRange = tc.getTimeRange(); + this.observationDays = tc.getOberservationDays(); } @Override @@ -116,6 +132,7 @@ public Batch generate(Graph g) { // Gewichts-Update switch (modus) { + case Continuous: crossroadWeight =db.getCrossroadWeight(n.getIndex(), initDateTime.plusMinutes((int) (g.getTimestamp()*stepSize)),initDateTime.plusMinutes((int) (g.getTimestamp()+stepSize)*stepSize),newTimeStamp); break; diff --git a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java index 92e29e09..442d549c 100644 --- a/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficInputWayBatchGenerator.java @@ -4,52 +4,55 @@ import java.util.HashMap; import java.util.HashSet; import java.util.List; -import java.util.Map; import java.util.Map.Entry; import java.util.Set; import org.joda.time.DateTime; -import org.mockito.internal.util.collections.ListUtil; import dna.graph.Graph; import dna.graph.IElement; -import dna.graph.datastructures.INodeListDatastructure; import dna.graph.edges.Edge; import dna.graph.generators.traffic.DB; import dna.graph.generators.traffic.EdgeContainer; +import dna.graph.generators.traffic.TrafficConfig; import dna.graph.generators.traffic.TrafficModi; import dna.graph.generators.traffic.TrafficUpdate; -import dna.graph.nodes.DirectedNode; import dna.graph.nodes.DirectedWeightedNode; -import dna.graph.nodes.Node; import dna.graph.weights.Double3dWeight; -import dna.io.GraphWriter; import dna.updates.batch.Batch; import dna.updates.generators.BatchGenerator; import dna.updates.update.EdgeAddition; import dna.updates.update.EdgeRemoval; import dna.updates.update.NodeWeight; -import dna.updates.update.Update; -import dna.util.ArrayUtils; import dna.util.parameters.IntParameter; import dna.util.parameters.ObjectParameter; -import dna.util.parameters.Parameter; public class TrafficInputWayBatchGenerator extends BatchGenerator{ - DB db; - DateTime initDateTime; - int stepSize; - int step=0; + + private DB db; + + // Allgemeine Parameter + private DateTime initDateTime; private TrafficModi modus; + private double treshold; + + // Continous + private int stepSize; + + // DayTimeRange / Aggregation private DateTime holidayStart; private boolean[] daySelection; + private int timeRange; + + // Aggregation private int observationDays; + + // Simulation + private TrafficUpdate trafficUpdate; + + private HashMap> nodeHistory = new HashMap<>(); private HashMap> disabledEdges = new HashMap<>(); private HashMap> newDisabledEdges = new HashMap<>(); - private double treshold; - private TrafficUpdate trafficUpdate; - private HashMap> nodeHistory; - private int timeRange; public TrafficInputWayBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, TrafficModi modus, DateTime holidayStart, boolean [] daySelection, double treshold, TrafficUpdate trafficUpdate, int timeRange, int observationDays) { @@ -65,10 +68,26 @@ public TrafficInputWayBatchGenerator(String name,DB db, DateTime initDateTime, i this.daySelection = daySelection; this.treshold = treshold; this.trafficUpdate = trafficUpdate; - this.nodeHistory = new HashMap<>(); this.timeRange = timeRange; this.observationDays = observationDays; } + + public TrafficInputWayBatchGenerator(DB db, TrafficConfig tc){ + super(tc.getBatchName(), new IntParameter("NA", 0), new IntParameter("NR", + 0), new IntParameter("NW", 0), + new ObjectParameter("NWS", 0), new IntParameter("EA", 0), + new IntParameter("ER", 0)); + this.db = db; + this.initDateTime = tc.getInitDateTime(); + this.stepSize = tc.getStepSize(); + this.modus = tc.getModus(); + this.holidayStart = tc.getHolidayStart(); + this.daySelection = tc.getDaySelection(); + this.treshold = tc.getTreshold(); + this.trafficUpdate = tc.getTrafficUpdate(); + this.timeRange = tc.getTimeRange(); + this.observationDays = tc.getOberservationDays(); + } @Override public Batch generate(Graph g) { @@ -76,8 +95,10 @@ public Batch generate(Graph g) { g.getTimestamp() + 1, 0, 0, 0, 0, 0, 0); - Set toDisable = new HashSet<>(); + + // Knoten + Iterable nodes = g.getNodes(); DateTime time = null; @@ -86,26 +107,33 @@ public Batch generate(Graph g) { time = Helpers.calculateNextDay(time, g.getTimestamp(),daySelection,holidayStart,true); } + // Aktualisiere das Gewicht für jeden Knoten, gemäß dem aktuellen Modus for (IElement currentNode : nodes) { + DirectedWeightedNode n = (DirectedWeightedNode) currentNode; double[] update =null; //WeightUpdate switch (modus) { + case Continuous: update = db.getInputWayWeight(n.getIndex(),initDateTime.plusMinutes((int) (g.getTimestamp()+1)*stepSize),initDateTime.plusMinutes((int) (g.getTimestamp()+2)*stepSize)); break; + case DayTimeRange: update = db.getInputWayWeight(n.getIndex(),time.minusMinutes(timeRange),time.plusMinutes(timeRange)); break; + case Simulation: update = (trafficUpdate.isAffected(n.getIndex()))? db.getInputWayWeightStaticBatch(n.getIndex(),trafficUpdate) : null; - break; + break; + case Aggregation: time = initDateTime; int index = n.getIndex(); long start = g.getTimestamp(); + // Summiere für alle Beobachtungstage auf for (int i = 0; i < observationDays; i++) { time = Helpers.calculateNextDay(initDateTime, start++, daySelection, holidayStart, false); double[] weightOfDay = db.getInputWayWeight(n.getIndex(),time.minusMinutes(timeRange),time.plusMinutes(timeRange)); @@ -118,6 +146,8 @@ public Batch generate(Graph g) { nodeHistory.put(index, weightList); } } + + //Berechne das Knotengewicht aus der Aggregation double sum = 0; List values = nodeHistory.get(index); for (int i = 0; i < values.size(); i++) { @@ -132,6 +162,7 @@ public Batch generate(Graph g) { break; } + // Wende das Update des Gewichts auf den Knoten an Double3dWeight oldWeight = (Double3dWeight) n.getWeight(); if(update!=null){ Double3dWeight newWeight = new Double3dWeight(update[0],update[1],update[2]); @@ -152,11 +183,13 @@ public Batch generate(Graph g) { } newDisabledEdges = new HashMap<>(); - + // Knoten ist ueberlastet if(update[2] > treshold) { + newKey = n.getIndex(); int from; int to; + // Verhindere das Hinzufügen bereits gelöschter Kante if(disabledEdges.containsKey(newKey)){ HashMap oldMap = disabledEdges.get(newKey); @@ -191,10 +224,12 @@ public Batch generate(Graph g) { } + // Füge die Löschoperation in den Batch hinzu for (Edge e : toDisable) { b.add(new EdgeRemoval(e)); } + // Füge nicht mehr ueberlastet Knoten wieder dem Graph hinzu for (Entry> freeEdges : disabledEdges.entrySet()) { int node = freeEdges.getKey(); for (Entry elem : freeEdges.getValue().entrySet()) { @@ -219,7 +254,13 @@ public boolean isFurtherBatchPossible(Graph g) { return true; } - public void removeEdge(int index, EdgeContainer ec, Edge e){ + /** + * Entfernt eine Kante aus dem Zwischenspeicher + * @param index + * @param ec + * @param e + */ + private void removeEdge(int index, EdgeContainer ec, Edge e){ if(disabledEdges.containsKey(index)){ HashMap oldMap = disabledEdges.get(index); oldMap.remove(ec); @@ -228,7 +269,14 @@ public void removeEdge(int index, EdgeContainer ec, Edge e){ } } } - public void addEdge(int index, EdgeContainer ec, Edge e){ + + /** + * fügte eine Kante zum Zwischenspeicher hinzu + * @param index + * @param ec + * @param e + */ + private void addEdge(int index, EdgeContainer ec, Edge e){ if(newDisabledEdges.containsKey(index)){ HashMap oldMap = newDisabledEdges.get(index); oldMap.put(ec, e); From 29375f4c91e6fa5bd40b8853f2af799a9bd57463 Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Wed, 11 Feb 2015 18:30:57 +0100 Subject: [PATCH 23/24] =?UTF-8?q?Kommentare,=20ungenutzte=20Importe=20und?= =?UTF-8?q?=20Variablen=20gel=C3=B6scht?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../graph/generators/traffic/Crossroad.java | 1 - .../generators/traffic/CrossroadWeight.java | 1 - src/dna/graph/generators/traffic/DB.java | 4 +- src/dna/graph/generators/traffic/Sensor.java | 1 - .../generators/traffic/TrafficConfig.java | 35 ++++--------- .../TrafficCrossroadGraphGenerator.java | 39 +++++++-------- .../traffic/TrafficSensorGraphGenerator.java | 50 +++++++++++++++---- .../traffic/CrossroadWeightList.java | 1 - .../updates/generators/traffic/Helpers.java | 25 +++++++--- .../TrafficCrossroadBatchGenerator.java | 42 ++++++++-------- .../traffic/TrafficSensorBatchGenerator.java | 28 ++++------- 11 files changed, 122 insertions(+), 105 deletions(-) diff --git a/src/dna/graph/generators/traffic/Crossroad.java b/src/dna/graph/generators/traffic/Crossroad.java index d64edb7a..887c1402 100644 --- a/src/dna/graph/generators/traffic/Crossroad.java +++ b/src/dna/graph/generators/traffic/Crossroad.java @@ -1,6 +1,5 @@ package dna.graph.generators.traffic; -import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.List; diff --git a/src/dna/graph/generators/traffic/CrossroadWeight.java b/src/dna/graph/generators/traffic/CrossroadWeight.java index 2b6deaaf..fe26b6ae 100644 --- a/src/dna/graph/generators/traffic/CrossroadWeight.java +++ b/src/dna/graph/generators/traffic/CrossroadWeight.java @@ -1,7 +1,6 @@ package dna.graph.generators.traffic; import java.util.HashMap; -import java.util.List; import java.util.Map; public class CrossroadWeight { diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index 8b879881..0a7ea2e3 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -13,7 +13,6 @@ import java.sql.Statement; import java.sql.Timestamp; import java.util.ArrayList; -import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -67,7 +66,7 @@ public class DB { * @param trafficUpdate, statische Daten für den Simulationsmodus * @param dummyMax, Verwendung von synthetischen Max-Werten oder realen Max-Werten */ - public DB(GraphDataStructure gds, DateTime initTDateTime, boolean[] daySelection, double treshold,boolean dummyMax) { + public DB(GraphDataStructure gds, DateTime initTDateTime, boolean[] daySelection, double treshold,boolean dummyMax, boolean newMaxValues) { try { FileReader fr = new FileReader("db.txt"); BufferedReader br = new BufferedReader(fr); @@ -132,6 +131,7 @@ public DB(GraphDataStructure gds, DateTime initTDateTime, boolean[] daySelection this.disabledEdges = new HashMap<>(); this.disabledEdgesInputWay = new HashMap<>(); this.dummyMax = dummyMax; + this.newMaxValues = newMaxValues; getInputWays(); getMaximalWeightCrossroad(); getMaximalWeightInputWay(); diff --git a/src/dna/graph/generators/traffic/Sensor.java b/src/dna/graph/generators/traffic/Sensor.java index 673aa45e..e2eb81a1 100644 --- a/src/dna/graph/generators/traffic/Sensor.java +++ b/src/dna/graph/generators/traffic/Sensor.java @@ -1,7 +1,6 @@ package dna.graph.generators.traffic; import java.util.HashMap; -import java.util.HashSet; import java.util.Map; import java.util.Set; diff --git a/src/dna/graph/generators/traffic/TrafficConfig.java b/src/dna/graph/generators/traffic/TrafficConfig.java index 4834ef37..6b2b77c0 100644 --- a/src/dna/graph/generators/traffic/TrafficConfig.java +++ b/src/dna/graph/generators/traffic/TrafficConfig.java @@ -22,13 +22,9 @@ public class TrafficConfig { private int timeRange; private DateTime holidayStart = new DateTime(2014,10,6,7,0,0); private int observationWeeks = 1; - private int observationDays; //TODO wo kommt es her? private int[] nodesFilter; - //Verwende reale Maximalwerte oder Dummy-Maximalwerte - private boolean dummyMax = false; - // Parameter f�r die Simulation private TrafficUpdate trafficUpdate; @@ -82,7 +78,7 @@ private TrafficConfig(TrafficModi modus, TrafficModel model, double treshold, in this.stepSize = stepsize; } /** - * Konstruktor für den TimeRange-Modus + * Konstruktor für den DayTimeRange-Modus und den Aggregation-Modus * @param modus * @param treshold * @param nodesFilter @@ -110,22 +106,7 @@ private TrafficConfig(TrafficModi modus, TrafficModel model, double treshold, in this(modus,model,treshold,nodesFilter,initDateTime); this.trafficUpdate = trafficUpdate; } - - /** - * Konstruktor für den Aggregations-Modus - * @param modus - * @param model - * @param treshold - * @param nodesFilter - * @param initDateTime - * @param trafficUpdate - */ - private TrafficConfig(TrafficModi modus, TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime, boolean[] daySelection, int observationWeeks){ - this(modus,model,treshold,nodesFilter,initDateTime); - this.daySelection = daySelection; - this.observationWeeks = observationWeeks; - this.observationDays = Helpers.weekToDay(observationWeeks, daySelection); - } + /** * liefert eine gültige TrafficConfig für die Verwendung des Continous-Modus @@ -161,10 +142,13 @@ public static TrafficConfig getDayTimeRangeConfig(TrafficModel model, double tre * @param treshold * @param nodesFilter * @param initDateTime + * @param holidayStart2 + * @param daySelection2 + * @param timeRange2 * @return */ - public static TrafficConfig getAggregationConfig(TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime){ - return new TrafficConfig(TrafficModi.Aggregation, model, treshold, nodesFilter,initDateTime); + public static TrafficConfig getAggregationConfig(TrafficModel model, double treshold, int[] nodesFilter, DateTime initDateTime, int timeRange, boolean[] daySelection, DateTime holidayStart){ + return new TrafficConfig(TrafficModi.Aggregation, model, treshold, nodesFilter,initDateTime, timeRange, daySelection,holidayStart); } /** @@ -229,7 +213,10 @@ public boolean[] getDaySelection(){ } public int getOberservationDays(){ - return observationDays; + if(modus == TrafficModi.Aggregation) + return Helpers.weekToDay(observationWeeks, daySelection); + else + return 1; } diff --git a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java index 4a2c40d7..5b2d3070 100644 --- a/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficCrossroadGraphGenerator.java @@ -1,42 +1,38 @@ package dna.graph.generators.traffic; -import java.io.IOException; import java.util.HashMap; -import java.util.HashSet; import java.util.List; import org.joda.time.DateTime; import dna.graph.Graph; -import dna.graph.IElement; import dna.graph.datastructures.GraphDataStructure; -import dna.graph.edges.DirectedEdge; import dna.graph.edges.Edge; import dna.graph.generators.GraphGenerator; -import dna.graph.generators.random.IRandomGenerator; -import dna.graph.nodes.DirectedNode; import dna.graph.nodes.DirectedWeightedNode; import dna.graph.nodes.INode; import dna.graph.nodes.Node; import dna.graph.weights.Double3dWeight; -import dna.io.GraphReader; -import dna.io.GraphWriter; -import dna.metrics.IMetric; -import dna.updates.update.EdgeRemoval; -import dna.util.ArrayUtils; -import dna.util.parameters.IntParameter; import dna.util.parameters.Parameter; public class TrafficCrossroadGraphGenerator extends GraphGenerator{ - List nodeslist; private DB db; + + // Allgemeine Parameter private TrafficModi modus; private DateTime initDateTime; + private int[] nodesFilter; + + // Continuous private int stepsize; + + // Daytime-Range Aggregation private int timeRange; + + // Simulation private TrafficUpdate trafficUpdate; - private int[] nodesFilter; + public TrafficCrossroadGraphGenerator(String name, GraphDataStructure gds, DB db,long timeStampInit,TrafficModi modus, DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate, int[] nodesFilter) { this(name, null, gds,timeStampInit, 0, 0,db,modus,initDateTime,stepsize,timeRange,trafficupdate,nodesFilter); @@ -68,19 +64,19 @@ public TrafficCrossroadGraphGenerator(TrafficConfig tc, GraphDataStructure gds, @Override public Graph generate() { - System.out.println("Generiere den Graph"); - db.getMaximalWeightInputWay(); - db.getMaximalWeightCrossroad(); + Graph g = this.newGraphInstance(); List nodes = null; HashMap disabledEdges = new HashMap<>(); - // Nodes + // Lade abstrakte Knoten gemäß dem NodesFilter nodes = db.getCrossroadsForDNA(nodesFilter); + CrossroadWeight crossroadWeight = null; Node currentNode = null; DirectedWeightedNode currentWeighted = null; + // Berechne das Gewicht des abstrakten Knoten gemäß definiertem Modus for (int i = 0; i < nodes.size(); i++) { currentNode = (Node) nodes.get(i); @@ -119,6 +115,7 @@ public Graph generate() { g.addNode(currentWeighted); + // Entferne die ueberlasteten Kanten EdgeContainer ec = null; for (Integer wayId : crossroadWeight.getOverladedEdges().keySet()) { List edgesToRemove = db.getFromWays(currentWeighted.getIndex(), wayId); @@ -131,9 +128,8 @@ public Graph generate() { } } - - - //Edges + // Kanten + List connection = db.getCrossroadConnectionForDNA(nodesFilter); EdgeContainer current = null; @@ -161,6 +157,7 @@ public Graph generate() { } + // Speichere die deaktiverten Kanten für den Batch in die DB-Klasse db.setDisabledEdges(disabledEdges); return g; } diff --git a/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java b/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java index 2cda0951..96433d33 100644 --- a/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java +++ b/src/dna/graph/generators/traffic/TrafficSensorGraphGenerator.java @@ -8,29 +8,35 @@ import org.joda.time.DateTime; import dna.graph.Graph; -import dna.graph.IElement; import dna.graph.datastructures.GraphDataStructure; import dna.graph.edges.Edge; import dna.graph.generators.GraphGenerator; -import dna.graph.generators.random.IRandomGenerator; import dna.graph.nodes.DirectedWeightedNode; import dna.graph.nodes.INode; import dna.graph.nodes.Node; import dna.graph.weights.Double3dWeight; -import dna.util.ArrayUtils; -import dna.util.parameters.IntParameter; + import dna.util.parameters.Parameter; public class TrafficSensorGraphGenerator extends GraphGenerator{ - - List nodeslist; + private DB db; + + // Allgemeine Parameter private TrafficModi modus; private DateTime initDateTime; + private double treshold; + + // Continous private int stepsize; + + // DayTimeRange private int timeRange; + + // Simulation private TrafficUpdate trafficUpdate; - private double treshold; + + private HashMap> disabledEdges = new HashMap<>(); public TrafficSensorGraphGenerator(String name, GraphDataStructure gds, DB db,long timeStamp,TrafficModi modus,DateTime initDateTime, int stepsize,int timeRange,TrafficUpdate trafficupdate,double treshold) { @@ -66,14 +72,20 @@ public Graph generate() { Graph g = this.newGraphInstance(); Set overloaded = new HashSet<>(); + // Lade Sensoren aus der Datenbank List nodes = db.getSensorsForDNA(); + double[] weight = null; Node currentNode = null; DirectedWeightedNode currentWeighted = null; + + // Vorabberechnung der Knotengewichte für alle realen Sensoren switch (modus) { + case Continuous: db.getSensorWeights(initDateTime, initDateTime.plusMinutes(stepsize), 0); break; + case DayTimeRange: db.getSensorWeights(initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange),0); break; @@ -82,31 +94,40 @@ public Graph generate() { break; } - // Knoten + // Berechne das Knotengewicht für alle Knoten for (int i = 0; i < nodes.size(); i++) { + currentNode = (Node) nodes.get(i); if(currentNode instanceof DirectedWeightedNode) currentWeighted = (DirectedWeightedNode) currentNode; else{ continue; } + switch (modus) { + case Continuous: weight = db.getSensorModelWeight(currentWeighted.getIndex(),initDateTime,initDateTime.plusMinutes(stepsize),0); break; + case DayTimeRange: weight = db.getSensorModelWeight(currentWeighted.getIndex(),initDateTime.minusMinutes(timeRange),initDateTime.plusMinutes(timeRange),0); break; + case Simulation: weight = db.getSensorModelWeightStaticInit(currentWeighted.getIndex(),trafficUpdate); break; + default: - System.out.println("error - Modus nicht definiert"); + System.out.println("error - TrafficSensorGraphGenerator- Modus nicht definiert"); break; } + if(weight== null){ weight = new double[]{0,0,0}; } + + // Knoten überlastet if(weight[2] > treshold){ overloaded.add(currentWeighted.getIndex()); } @@ -120,6 +141,8 @@ public Graph generate() { DirectedWeightedNode toNode; Edge e = null; EdgeContainer ec = null; + + // Prüfe ob Kante gültig ist for (int i = 0; i < connection.size(); i++) { ec = connection.get(i); fromNode = (DirectedWeightedNode) g.getNode(ec.getFrom()); @@ -143,7 +166,14 @@ public Graph generate() { db.setDisabledEdgesInputWay(disabledEdges); return g; } - public void addEdge(int index,EdgeContainer ec, Edge e){ + + /** + * Füge Kante zum Zwischenspeicher hinzu + * @param index Kontenindex eines Endknotens + * @param ec ContainerKlasse der Kante + * @param e Kante + */ + private void addEdge(int index,EdgeContainer ec, Edge e){ if(disabledEdges.containsKey(index)) disabledEdges.get(index).put(ec,e); else{ diff --git a/src/dna/updates/generators/traffic/CrossroadWeightList.java b/src/dna/updates/generators/traffic/CrossroadWeightList.java index c728d142..bf460d9e 100644 --- a/src/dna/updates/generators/traffic/CrossroadWeightList.java +++ b/src/dna/updates/generators/traffic/CrossroadWeightList.java @@ -3,7 +3,6 @@ import java.util.ArrayList; import java.util.List; import java.util.Map; -import java.util.Map.Entry; import dna.graph.generators.traffic.CrossroadWeight; diff --git a/src/dna/updates/generators/traffic/Helpers.java b/src/dna/updates/generators/traffic/Helpers.java index 0d6e84ac..6c6e874e 100644 --- a/src/dna/updates/generators/traffic/Helpers.java +++ b/src/dna/updates/generators/traffic/Helpers.java @@ -1,23 +1,36 @@ package dna.updates.generators.traffic; - import org.joda.time.DateTime; -import org.joda.time.DateTimeConstants; -import org.joda.time.JodaTimePermission; public class Helpers { public static boolean isWorkDay(Days d) { return !(d == Days.SATURDAY || d==Days.SUNDAY); } + /** + * berechnet ausgehend von "start" den nächsten Werktag in der Zukunft(forward) oder Vergangenheit (!forward) + * @param start - Startdatum + * @param l - Timestep + * @param forward - true = in der Zukunft, false = in der Vergangenheit + * @return + */ public static DateTime calculateNextWorkDay(DateTime start,long l, boolean forward){ return calculateNextDay(start, l, new boolean[]{true,true,true,true,true,false,false},null,forward); } - public static DateTime calculateNextDay(DateTime end, long timestamp, boolean[] daySelection,DateTime ignoreTo, boolean forward){ - DateTime current = end; + /** + * berechnet ausgehend von "start" den nächsten Tag in der Zukunft(forward) oder Vergangenheit (!forward) + * @param start - Startdatum + * @param timestep - Zeitschritt für den der nächste Tag berechnet werden soll + * @param daySelection - Array mit Wochentagen, die für die Berechnung berücksichtigt werden sollen + * @param ignoreTo - Zeitpunkt bis zu welchem die Berechnung ignoriert wird + * @param forward - true = in der Zukunft, false = in der Vergangenheit + * @return + */ + public static DateTime calculateNextDay(DateTime start, long timestep, boolean[] daySelection,DateTime ignoreTo, boolean forward){ + DateTime current = start; int count = 0; - while(count <= timestamp) { + while(count <= timestep) { current = forward ? current.plusDays(1) : current.minusDays(1); if(daySelection[current.getDayOfWeek()-1] && (current.isBefore(ignoreTo) || forward)){ count++; diff --git a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java index f3e386c3..2e308690 100644 --- a/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficCrossroadBatchGenerator.java @@ -1,19 +1,13 @@ package dna.updates.generators.traffic; -import java.util.ArrayList; -import java.util.Collection; import java.util.HashMap; -import java.util.HashSet; import java.util.List; import java.util.Map; -import java.util.Random; -import java.util.Set; import org.joda.time.DateTime; import dna.graph.Graph; import dna.graph.IElement; -import dna.graph.datastructures.INodeListDatastructure; import dna.graph.edges.Edge; import dna.graph.generators.traffic.CrossroadWeight; import dna.graph.generators.traffic.DB; @@ -21,39 +15,41 @@ import dna.graph.generators.traffic.TrafficConfig; import dna.graph.generators.traffic.TrafficModi; import dna.graph.generators.traffic.TrafficUpdate; -import dna.graph.nodes.DirectedNode; import dna.graph.nodes.DirectedWeightedNode; -import dna.graph.nodes.Node; -import dna.graph.weights.Double2dWeight; import dna.graph.weights.Double3dWeight; -import dna.graph.weights.Int2dWeight; -import dna.graph.weights.IntWeight; -import dna.io.GraphWriter; import dna.updates.batch.Batch; import dna.updates.generators.BatchGenerator; import dna.updates.update.EdgeAddition; import dna.updates.update.EdgeRemoval; import dna.updates.update.NodeWeight; -import dna.updates.update.Update; -import dna.util.Rand; import dna.util.parameters.IntParameter; import dna.util.parameters.ObjectParameter; -import dna.util.parameters.Parameter; public class TrafficCrossroadBatchGenerator extends BatchGenerator{ private DB db; + + //Allgemeine Parameter private DateTime initDateTime; - private int stepSize; - private int run=0; - private int observationDays; private TrafficModi modus; + + // Continous + private int stepSize; + + //DayTimeRange - Aggregation private DateTime holidayStart; private boolean[] daySelection; - private HashMap disabledEdges = new HashMap<>(); + private int timeRange; + + //Aggregation + private int observationDays; + + //Simulation private TrafficUpdate trafficUpdate; + + private HashMap disabledEdges = new HashMap<>(); private HashMap nodeHistory; - private int timeRange; + public TrafficCrossroadBatchGenerator(String name,DB db, DateTime initDateTime, int stepSize, TrafficModi modus, DateTime holidayStart, boolean [] daySelection,TrafficUpdate trafficUpdate,int timeRange, int observationDays) { super(name, new IntParameter("NA", 0), new IntParameter("NR", @@ -71,6 +67,11 @@ public TrafficCrossroadBatchGenerator(String name,DB db, DateTime initDateTime, this.observationDays = observationDays; } + /** + * Erstellt einen TrafficCrossroadBatchGeneratur unter Verwendung der Paramtere auf TrafficConfig + * @param db + * @param tc + */ public TrafficCrossroadBatchGenerator(DB db, TrafficConfig tc){ super(tc.getBatchName(), new IntParameter("NA", 0), new IntParameter("NR", 0), new IntParameter("NW", 0), @@ -89,7 +90,6 @@ public TrafficCrossroadBatchGenerator(DB db, TrafficConfig tc){ @Override public Batch generate(Graph g) { - GraphWriter.write(g, "CrossroadGraph/", "batch"+run+++".txt"); Batch b = new Batch(g.getGraphDatastructures(), g.getTimestamp(), g.getTimestamp() + 1, 0, 0, 0, 0, diff --git a/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java b/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java index 2bdf1f35..0cd11183 100644 --- a/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java +++ b/src/dna/updates/generators/traffic/TrafficSensorBatchGenerator.java @@ -1,10 +1,7 @@ package dna.updates.generators.traffic; -import java.util.Collection; import java.util.HashMap; import java.util.HashSet; -import java.util.List; -import java.util.Random; import java.util.Set; import java.util.Map.Entry; @@ -12,37 +9,28 @@ import dna.graph.Graph; import dna.graph.IElement; -import dna.graph.datastructures.INodeListDatastructure; import dna.graph.edges.Edge; import dna.graph.generators.traffic.DB; import dna.graph.generators.traffic.EdgeContainer; import dna.graph.generators.traffic.TrafficModi; import dna.graph.generators.traffic.TrafficUpdate; -import dna.graph.nodes.DirectedNode; import dna.graph.nodes.DirectedWeightedNode; -import dna.graph.nodes.Node; import dna.graph.weights.Double3dWeight; -import dna.graph.weights.IWeightedNode; -import dna.graph.weights.Int2dWeight; -import dna.graph.weights.IntWeight; import dna.io.GraphWriter; import dna.updates.batch.Batch; import dna.updates.generators.BatchGenerator; import dna.updates.update.EdgeAddition; import dna.updates.update.EdgeRemoval; import dna.updates.update.NodeWeight; -import dna.updates.update.Update; -import dna.util.Rand; import dna.util.parameters.IntParameter; import dna.util.parameters.ObjectParameter; -import dna.util.parameters.Parameter; public class TrafficSensorBatchGenerator extends BatchGenerator{ - DB db; - DateTime initDateTime; - int stepSize; - int step=0; - TrafficModi modus; + private DB db; + private DateTime initDateTime; + private int stepSize; + private int step=0; + private TrafficModi modus; private DateTime holidayStart; private boolean[] daySelection; private double treshold; @@ -211,6 +199,12 @@ public boolean isFurtherBatchPossible(Graph g) { return true; } + /** + * + * @param index + * @param ec + * @param e + */ public void removeEdge(int index, EdgeContainer ec, Edge e){ if(disabledEdges.containsKey(index)){ HashMap oldMap = disabledEdges.get(index); From dbeffa1f8c9660282157fb2c0d8ce2d96583005a Mon Sep 17 00:00:00 2001 From: barracuda317 Date: Thu, 19 Feb 2015 14:23:47 +0100 Subject: [PATCH 24/24] =?UTF-8?q?Tabellenname=20ge=C3=A4ndert?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/dna/graph/generators/traffic/DB.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/dna/graph/generators/traffic/DB.java b/src/dna/graph/generators/traffic/DB.java index 0a7ea2e3..1f2932f7 100644 --- a/src/dna/graph/generators/traffic/DB.java +++ b/src/dna/graph/generators/traffic/DB.java @@ -952,7 +952,7 @@ public List getInputWaysForDNA(int[] nodesFilter) { } /** - * liest die Verbindungen zwischen den Knoten im WegeGraph aus der Tabelle mw_InputWayConnection_bak3 (neuste Version) + * liest die Verbindungen zwischen den Knoten im WegeGraph aus der Tabelle mw_InputWayConnection (neuste Version) * @param nodesFilter - Array mit Knoten, für als Start- oder Endknoten fungieren dürfen * @return */ @@ -975,7 +975,7 @@ public List getInputWaysConnectionForDNA(int[] nodesFilter) { try { Statement stmt = con.createStatement(); - String statementString = "SELECT fromID , toID FROM mw_InputWayConnection_bak3" +filterString; + String statementString = "SELECT fromID , toID FROM mw_InputWayConnection" +filterString; ResultSet rs = stmt.executeQuery(statementString); while(rs.next() ) {