From 36d6d10e40cf262fd59ec67351f8e5d966af0fb6 Mon Sep 17 00:00:00 2001
From: jsimomaa <jani.simomaa@gmail.com>
Date: Wed, 20 Jun 2018 14:47:41 +0300
Subject: [PATCH] Pushing some (very) old changes to remote.. should have done
 long ago

gitlab #1

Change-Id: I3ec1b6b460d82851f9c16188d3e6d80386f90770
---
 .../district/imports/ui/CSVImportModel.java   | 223 +++++++++-
 .../district/imports/ui/CSVImportWizard.java  | 153 ++++---
 .../imports/ui/CSVImportWizardFirstPage.java  |   5 +
 .../imports/ui/CSVImportWizardPage.java       | 404 +++++++++++++++++-
 .../district/imports/DistrictImportUtils.java |   1 +
 .../simantics/maps/MapScalingTransform.java   |   2 +-
 .../maps/prefs/MapsClientPreferences.java     |   2 +-
 .../META-INF/MANIFEST.MF                      |   3 +-
 .../graph.tg                                  | Bin 13814 -> 25552 bytes
 .../graph/DistrictNetwork.pgraph              | 197 ++++++++-
 .../scl/Simantics/District/SCLMain.scl        |  13 +
 .../ontology/DistrictNetworkResource.java     | 342 +++++++++++++--
 .../graph.tg                                  | Bin 2444 -> 2469 bytes
 .../DistrictNetworkAdditionalColor.java       |  16 +
 .../network/ui/function/Functions.java        |   6 +-
 .../ui/nodes/DistrictNetworkEdgeNode.java     |   1 -
 .../ui/nodes/DistrictNetworkVertexNode.java   |   6 +
 .../network/ui/nodes/MapRulerNode.java        |   4 +
 .../ui/participants/DNTranslateMode.java      |   4 +-
 .../scl/Simantics/District.scl                |  72 +++-
 .../district/network/DistrictNetworkUtil.java |   2 +-
 .../server/prefs/MapsServerInitializer.java   |   2 +-
 .../server/prefs/MapsServerPreferences.java   |   2 +-
 23 files changed, 1329 insertions(+), 131 deletions(-)
 create mode 100644 org.simantics.district.network.ontology/scl/Simantics/District/SCLMain.scl

diff --git a/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportModel.java b/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportModel.java
index 2f13692b..e2a6b7ee 100644
--- a/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportModel.java
+++ b/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportModel.java
@@ -42,11 +42,33 @@ public class CSVImportModel {
     private Map<String, Resource> componentMappings = new HashMap<>();
     private boolean isVertexImport;
     private String sourceCRS;
-    private int tempIndex;
-    private int pressureIndex;
-    private int diameterIndex;
-    private int outerDiamterIndex;
-    private int nominalMassFlowIndex;
+    private int supplytempIndex = -1;
+    private int supplypressureIndex= -1;
+    private int diameterIndex = -1;
+    private int outerDiamterIndex = -1;
+    private int nominalMassFlowIndex = -1;
+    private int returnTempIndex = -1;
+    private int returnPressureIndex = -1;
+    private int deltaPressureIndex = -1;
+    private int deltaTemperatureIndex = -1;
+    private int heatPowerIndex = -1;
+    private int nominalHeadMIndex = -1;
+    private int nominalHeadBIndex = -1;
+    private int nominalFlowIndex = -1;
+    private int maximumHeadMIndex = -1;
+    private int heatLoadDsIndex = -1;
+    private int massFlowIndex = -1;
+    private int volFlowIndex = -1;
+    private int velocityIndex = -1;
+    private int flowAreaIndex = -1;
+    private int nominalPressureLossIndex = -1;
+    private int edgeFlowAreaIndex = -1;
+    private int kReturnIndex = -1;
+    private int kSupplyIndex = -1;
+    private int tGroundIndex = -1;
+    private int idIndex = -1;
+    private double edgePadding = 0.0001; // default
+    private int valvePositionIndx = -1;
     
     // Third page
 
@@ -236,20 +258,36 @@ public class CSVImportModel {
         return sourceCRS;
     }
 
-    public void setTempIndex(int tempIndex) {
-        this.tempIndex = tempIndex;
+    public void setSupplyTempIndex(int supplyTempIndex) {
+        this.supplytempIndex = supplyTempIndex;
     }
     
-    public int getTempIndex() {
-        return tempIndex;
+    public int getSupplyTempIndex() {
+        return supplytempIndex;
     }
 
-    public void setPressureIndex(int pressureIndex) {
-        this.pressureIndex = pressureIndex;
+    public void setSupplyPressureIndex(int supplyPressureIndex) {
+        this.supplypressureIndex = supplyPressureIndex;
     }
 
-    public int getPressureIndex() {
-        return pressureIndex;
+    public int getSupplyPressureIndex() {
+        return supplypressureIndex;
+    }
+
+    public void setReturnTempIndex(int returnTempIndex) {
+        this.returnTempIndex = returnTempIndex;
+    }
+    
+    public int getReturnTempIndex() {
+        return returnTempIndex;
+    }
+
+    public void setReturnPressureIndex(int returnPressureIndex) {
+        this.returnPressureIndex = returnPressureIndex;
+    }
+
+    public int getReturnPressureIndex() {
+        return returnPressureIndex;
     }
 
     public void setDiameterIndex(int parseInt) {
@@ -276,4 +314,163 @@ public class CSVImportModel {
         return nominalMassFlowIndex;
     }
 
+    public void setDeltaPressureIndex(int parseInt) {
+        this.deltaPressureIndex = parseInt;
+    }
+    
+    public int getDeltaPressureIndex() {
+        return deltaPressureIndex;
+    }
+
+    public void setDeltaTemperatureIndex(int parseInt) {
+        this.deltaTemperatureIndex = parseInt;
+    }
+    
+    public int getDeltaTemperatureIndex() {
+        return deltaTemperatureIndex;
+    }
+
+    public void setHeatPowerIndex(int parseInt) {
+        this.heatPowerIndex = parseInt;
+    }
+    
+    public int getHeatPowerIndex() {
+        return heatPowerIndex;
+    }
+
+    public void setNominalHeadMIndex(int parseInt) {
+        this.nominalHeadMIndex = parseInt;
+    }
+    
+    public int getNominalHeadMIndex() {
+        return nominalHeadMIndex;
+    }
+
+    public void setNominalHeadBIndex(int parseInt) {
+        this.nominalHeadBIndex = parseInt;
+    }
+    
+    public int getNominalHeadBIndex() {
+        return nominalHeadBIndex;
+    }
+
+    public void setNominalFlowIndex(int parseInt) {
+        this.nominalFlowIndex = parseInt;
+    }
+    
+    public int getNominalFlowIndex() {
+        return nominalFlowIndex;
+    }
+
+    public void setMaximumHeadMIndex(int parseInt) {
+        this.maximumHeadMIndex = parseInt;
+    }
+    
+    public int getMaximumHeadMIndex() {
+        return maximumHeadMIndex;
+    }
+
+    public void setHeatLoadDsIndex(int parseInt) {
+        this.heatLoadDsIndex = parseInt;
+    }
+    
+    public int getHeatLoadDsIndex() {
+        return heatLoadDsIndex;
+    }
+
+    public void setMassFlowIndex(int parseInt) {
+        this.massFlowIndex = parseInt;
+    }
+    
+    public int getMassFlowIndex() {
+        return massFlowIndex;
+    }
+
+    public void setVolFlowIndex(int parseInt) {
+        this.volFlowIndex = parseInt;
+    }
+    
+    public int getVolFlowIndex() {
+        return volFlowIndex;
+    }
+
+    public void setVelocityIndex(int parseInt) {
+        this.velocityIndex = parseInt;
+    }
+    
+    public int getVelocityIndex() {
+        return velocityIndex;
+    }
+
+    public void setFlowAreaIndex(int parseInt) {
+        this.flowAreaIndex = parseInt;
+    }
+    
+    public int getFlowAreaIndex() {
+        return flowAreaIndex;
+    }
+
+    public void setNominalPressureLossIndex(int parseInt) {
+        this.nominalPressureLossIndex = parseInt;
+    }
+    
+    public int getNominalPressureLossIndex() {
+        return nominalPressureLossIndex;
+    }
+
+    public void setEdgeFlowAreaIndex(int parseInt) {
+        this.edgeFlowAreaIndex = parseInt;
+    }
+    
+    public int getEdgeFlowAreaIndex() {
+        return edgeFlowAreaIndex;
+    }
+
+    public void setKReturnIndex(int parseInt) {
+        this.kReturnIndex = parseInt;
+    }
+    
+    public int getkReturnIndex() {
+        return kReturnIndex;
+    }
+
+    public void setKSupplyIndex(int parseInt) {
+        this.kSupplyIndex = parseInt;
+    }
+    
+    public int getkSupplyIndex() {
+        return kSupplyIndex;
+    }
+
+    public void setTGroundIndex(int parseInt) {
+        this.tGroundIndex = parseInt;
+    }
+    
+    public int gettGroundIndex() {
+        return tGroundIndex;
+    }
+
+    public int getIdIndex() {
+        return idIndex;
+    }
+    
+    public void setIdIndex(int idIndex) {
+        this.idIndex = idIndex;
+    }
+
+    public void setEdgePapping(double edgePadding) {
+        this.edgePadding = edgePadding;
+    }
+    
+    public double getEdgePadding() {
+        return edgePadding;
+    }
+
+    public void setValvePositionIndex(int valvePositionIndx) {
+        this.valvePositionIndx = valvePositionIndx;
+    }
+    
+    public int getValvePositionIndx() {
+        return valvePositionIndx;
+    }
 }
diff --git a/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizard.java b/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizard.java
index 7ce7d3c6..80bf1447 100644
--- a/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizard.java
+++ b/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizard.java
@@ -56,6 +56,7 @@ public class CSVImportWizard extends Wizard implements IImportWizard {
 
                 @Override
                 public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
+                    monitor.beginTask("Importing CSV", 1000);
                     try {
                         Path csvFile = model.getSource();
                         char delim = model.getDelimiter();
@@ -67,8 +68,24 @@ public class CSVImportWizard extends Wizard implements IImportWizard {
                         int xCoordColumnIndex = model.getXCoordIndex();
                         int yCoordColumnIndex = model.getYCoordIndex();
                         int zCoordColumnIndex = model.getZCoordIndex();
-                        int tempColumnIndex = model.getTempIndex();
-                        int pressureColumnIndex = model.getPressureIndex();
+                        int supplyTempColumnIndex = model.getSupplyTempIndex();
+                        int returnTempColumnIndex = model.getReturnTempIndex();
+                        int supplyPressureColumnIndex = model.getSupplyPressureIndex();
+                        int returnPressureColumnIndex = model.getReturnPressureIndex();
+                        int dpIndex = model.getDeltaPressureIndex();
+                        int dtIndex = model.getDeltaTemperatureIndex();
+                        int heatPowerIndex = model.getHeatPowerIndex();
+                        int valvePositionIndex = model.getValvePositionIndx();
+                        int nominalHeadMIndex = model.getNominalHeadMIndex();
+                        int nominalHeadBIndex = model.getNominalHeadBIndex();
+                        int nominalFlowIndex = model.getNominalFlowIndex();
+                        int maximumHeadMIndex = model.getMaximumHeadMIndex();
+                        int heatLoadDsIndex = model.getHeatLoadDsIndex();
+                        int massFlowIndex = model.getMassFlowIndex();
+                        int volFlowIndex = model.getVolFlowIndex();
+                        int velocityIndex = model.getVelocityIndex();
+                        int flowAreaIndex = model.getFlowAreaIndex();
+                        int nominalPressureLossIndex = model.getNominalPressureLossIndex();
                         
                         int startXCoordColumnIndex = model.getStartXCoordIndex();
                         int startYCoordColumnIndex = model.getStartYCoordIndex();
@@ -79,8 +96,15 @@ public class CSVImportWizard extends Wizard implements IImportWizard {
                         int diameterColumnIndex= model.getDiameterIndex();
                         int outerDiameterColumnIndex = model.getOuterDiamterIndex();
                         int nominalMassFlowIndex = model.getNominalMassFlowIndex();
+                        int tGroundIndex = model.gettGroundIndex();
+                        int edgeFlowAreaIndex = model.getEdgeFlowAreaIndex();
+                        int kReturnIndex = model.getkReturnIndex();
+                        int kSupplyIndex = model.getkSupplyIndex();
                         
                         int mappingColumn = model.getComponentMappingIndex();
+                        int idColumn = model.getIdIndex();
+                        
+                        double padding = model.getEdgePadding();
                         
                         String sourceEPSGCRS = model.getSourceCRS();
                         
@@ -99,6 +123,7 @@ public class CSVImportWizard extends Wizard implements IImportWizard {
                             
                             @Override
                             public void perform(WriteGraph graph) throws DatabaseException {
+                                graph.markUndoPoint();
                                 
                                 DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
                                 
@@ -111,16 +136,19 @@ public class CSVImportWizard extends Wizard implements IImportWizard {
                                         if (model.isVertexImport()) {
                                             String xCoords = row.get(xCoordColumnIndex);
                                             String yCoords = row.get(yCoordColumnIndex);
-                                            double xCoord = Double.parseDouble(xCoords);
+                                            double xCoord = - Double.parseDouble(xCoords); // make negative for now
                                             double yCoord = Double.parseDouble(yCoords);
                                             
-                                            String zs = row.get(zCoordColumnIndex);
                                             double z = 0;
-                                            if (!zs.isEmpty()) {
-                                                try {
-                                                    z = Double.parseDouble(zs);
-                                                } catch (NumberFormatException e) {
-                                                    throw new DatabaseException(e);
+                                            if (zCoordColumnIndex != -1) {
+                                                String zs = row.get(zCoordColumnIndex);
+                                                
+                                                if (!zs.isEmpty()) {
+                                                    try {
+                                                        z = Double.parseDouble(zs);
+                                                    } catch (NumberFormatException e) {
+                                                        throw new DatabaseException(e);
+                                                    }
                                                 }
                                             }
 
@@ -135,26 +163,28 @@ public class CSVImportWizard extends Wizard implements IImportWizard {
                                             }
                                             Resource vertex = DistrictNetworkUtil.createVertex(graph, model.getParentDiagram(), new double[] { coords[1], -coords[0]}, model.getComponentMappings().get(mappingValue));
                                             
+                                            writeStringValue(graph, row, idColumn, vertex, DN.HasId);
+                                            
                                             graph.claimLiteral(vertex, DN.Vertex_HasElevation, z, Bindings.DOUBLE);
                                             
-                                            String tempS = row.get(tempColumnIndex);
-                                            if (!tempS.isEmpty()) {
-                                                try {
-                                                    double temp = Double.parseDouble(tempS);
-                                                    graph.claimLiteral(vertex, DN.Vertex_HasTemperature, temp, Bindings.DOUBLE);
-                                                } catch (NumberFormatException e) {
-                                                    throw new DatabaseException(e);
-                                                }
-                                            }
-                                            String pressureS = row.get(pressureColumnIndex);
-                                            if (!pressureS.isEmpty()) {
-                                                try {
-                                                    double pressure = Double.parseDouble(pressureS);
-                                                    graph.claimLiteral(vertex, DN.Vertex_HasPressure, pressure, Bindings.DOUBLE);
-                                                } catch (NumberFormatException e) {
-                                                    throw new DatabaseException(e);
-                                                }
-                                            }
+                                            writeValue(graph, row, supplyTempColumnIndex, vertex, DN.Vertex_HasSupplyTemperature);
+                                            writeValue(graph, row, returnTempColumnIndex, vertex, DN.Vertex_HasReturnTemperature);
+                                            writeValue(graph, row, supplyPressureColumnIndex, vertex, DN.Vertex_HasSupplyPressure);
+                                            writeValue(graph, row, returnPressureColumnIndex, vertex, DN.Vertex_HasReturnPressure);
+                                            writeValue(graph, row, dpIndex, vertex, DN.Vertex_HasDeltaPressure);
+                                            writeValue(graph, row, dtIndex, vertex, DN.Vertex_HasDeltaTemperature);
+                                            writeValue(graph, row, heatPowerIndex, vertex, DN.Vertex_HasHeatPower);
+                                            writeValue(graph, row, valvePositionIndex, vertex, DN.Vertex_HasValvePosition);
+                                            writeValue(graph, row, nominalHeadMIndex, vertex, DN.Vertex_HasNominalHeadM);
+                                            writeValue(graph, row, nominalHeadBIndex, vertex, DN.Vertex_HasNominalHeadB);
+                                            writeValue(graph, row, nominalFlowIndex, vertex, DN.Vertex_HasNominalFlow);
+                                            writeValue(graph, row, maximumHeadMIndex, vertex, DN.Vertex_HasMaximumHeadM);
+                                            writeValue(graph, row, heatLoadDsIndex, vertex, DN.Vertex_HasHeatLoadDs);
+                                            writeValue(graph, row, massFlowIndex, vertex, DN.Vertex_HasMassFlow);
+                                            writeValue(graph, row, volFlowIndex, vertex, DN.Vertex_HasVolFlow);
+                                            writeValue(graph, row, velocityIndex, vertex, DN.Vertex_HasVelocity);
+                                            writeValue(graph, row, flowAreaIndex, vertex, DN.Vertex_HasFlowArea);
+                                            writeValue(graph, row, nominalPressureLossIndex, vertex, DN.Vertex_HasNominalPressureLoss);
 
                                         } else {
                                             String startXCoords = row.get(startXCoordColumnIndex);
@@ -162,10 +192,10 @@ public class CSVImportWizard extends Wizard implements IImportWizard {
                                             String endXCoords = row.get(endXCoordColumnIndex);
                                             String endYCoords = row.get(endYCoordColumnIndex);
                                             
-                                            double startXCoord = Double.parseDouble(startXCoords);
+                                            double startXCoord = - Double.parseDouble(startXCoords); // make negative
                                             double startYCoord = Double.parseDouble(startYCoords);
                                             
-                                            double endXCoord = Double.parseDouble(endXCoords);
+                                            double endXCoord = - Double.parseDouble(endXCoords); // make negative
                                             double endYCoord = Double.parseDouble(endYCoords);
                                             
                                             double[] startCoords;
@@ -184,36 +214,17 @@ public class CSVImportWizard extends Wizard implements IImportWizard {
                                                 startCoords = new double[] { startXCoord / MapScalingTransform.getScaleX(), startYCoord / MapScalingTransform.getScaleY() };
                                                 endCoords = new double[] { endXCoord / MapScalingTransform.getScaleX(), endYCoord / MapScalingTransform.getScaleY() };
                                             }
+                                             
+                                            Resource edge = DNEdgeBuilder.create(graph, model.getParentDiagram(), model.getComponentMappings().get(mappingValue), new double[] { startCoords[1], -startCoords[0]}, new double[] { endCoords[1], -endCoords[0]}, padding);
+                                            writeStringValue(graph, row, idColumn, edge, DN.HasId);
                                             
-                                            Resource edge = DNEdgeBuilder.create(graph, model.getParentDiagram(), model.getComponentMappings().get(mappingValue), new double[] { startCoords[1], -startCoords[0]}, new double[] { endCoords[1], -endCoords[0]}, 0.0000001);
-                                            
-                                            String diameterS = row.get(diameterColumnIndex);
-                                            if (!diameterS.isEmpty()) {
-                                                try {
-                                                    double diameter = Double.parseDouble(diameterS);
-                                                    graph.claimLiteral(edge, DN.Edge_HasDiameter, diameter);
-                                                } catch (NumberFormatException e) {
-                                                    throw new DatabaseException(e);
-                                                }
-                                            }
-                                            String outerDiameterS = row.get(outerDiameterColumnIndex);
-                                            if (!outerDiameterS.isEmpty()) {
-                                                try {
-                                                    double outerDiameter = Double.parseDouble(outerDiameterS);
-                                                    graph.claimLiteral(edge, DN.Edge_HasOuterDiameter, outerDiameter);
-                                                } catch (NumberFormatException e) {
-                                                    throw new DatabaseException(e);
-                                                }
-                                            }
-                                            String nominalMassFlowS = row.get(nominalMassFlowIndex);
-                                            if (!nominalMassFlowS.isEmpty()) {
-                                                try {
-                                                    double nominalMassFlow = Double.parseDouble(nominalMassFlowS);
-                                                    graph.claimLiteral(edge, DN.Edge_HasNominalMassFlow, nominalMassFlow);
-                                                } catch (NumberFormatException e) {
-                                                    throw new DatabaseException(e);
-                                                }
-                                            }
+                                            writeValue(graph, row, diameterColumnIndex, edge, DN.Edge_HasDiameter);
+                                            writeValue(graph, row, outerDiameterColumnIndex, edge, DN.Edge_HasOuterDiameter);
+                                            writeValue(graph, row, nominalMassFlowIndex, edge, DN.Edge_HasNominalMassFlow);
+                                            writeValue(graph, row, tGroundIndex, edge, DN.Edge_HasTGround);
+                                            writeValue(graph, row, kReturnIndex, edge, DN.Edge_HasKReturn);
+                                            writeValue(graph, row, kSupplyIndex, edge, DN.Edge_HasKSupply);
+                                            writeValue(graph, row, edgeFlowAreaIndex, edge, DN.Edge_HasFlowArea);
                                         }
                                     } catch (MismatchedDimensionException | TransformException | DatabaseException e) {
                                         throw new DatabaseException(e);
@@ -238,4 +249,30 @@ public class CSVImportWizard extends Wizard implements IImportWizard {
             return false;
         }
     }
+    
+    private static void writeValue(WriteGraph graph, CSVRecord row, int index, Resource subject, Resource relation) throws DatabaseException {
+        if (index != -1) {
+            String stringValue = row.get(index);
+            if (!stringValue.isEmpty()) {
+                try {
+                    graph.claimLiteral(subject, relation, Double.parseDouble(stringValue), Bindings.DOUBLE);
+                } catch (NumberFormatException e) {
+                    throw new DatabaseException(e);
+                }
+            }
+        }
+    }
+    
+    private static void writeStringValue(WriteGraph graph, CSVRecord row, int index, Resource subject, Resource relation) throws DatabaseException {
+        if (index != -1) {
+            String stringValue = row.get(index);
+            if (!stringValue.isEmpty()) {
+                try {
+                    graph.claimLiteral(subject, relation, stringValue, Bindings.STRING);
+                } catch (NumberFormatException e) {
+                    throw new DatabaseException(e);
+                }
+            }
+        }
+    }
 }
diff --git a/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizardFirstPage.java b/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizardFirstPage.java
index 830b1264..9ba7e2da 100644
--- a/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizardFirstPage.java
+++ b/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizardFirstPage.java
@@ -100,6 +100,11 @@ public class CSVImportWizardFirstPage extends WizardPage implements FileSelectio
                 }
             });
             diagramCombo.setItems(diagrams.keySet().toArray(new String[diagrams.size()]));
+            if (diagrams.size() > 0) {
+                diagramCombo.select(0);
+                model.setParentDiagram(diagrams.get(diagramCombo.getItem(0)));
+                diagramCombo.getDisplay().asyncExec(() -> validateComplete());
+            }
         } catch (DatabaseException e) {
             e.printStackTrace();
         }
diff --git a/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizardPage.java b/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizardPage.java
index 23571930..0035f6b7 100644
--- a/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizardPage.java
+++ b/org.simantics.district.imports.ui/src/org/simantics/district/imports/ui/CSVImportWizardPage.java
@@ -12,6 +12,7 @@ import org.eclipse.jface.dialogs.IPageChangeProvider;
 import org.eclipse.jface.dialogs.IPageChangedListener;
 import org.eclipse.jface.dialogs.PageChangedEvent;
 import org.eclipse.jface.layout.GridDataFactory;
+import org.eclipse.jface.layout.GridLayoutFactory;
 import org.eclipse.jface.layout.TableColumnLayout;
 import org.eclipse.jface.viewers.ColumnWeightData;
 import org.eclipse.jface.wizard.IWizardContainer;
@@ -31,6 +32,7 @@ import org.eclipse.swt.widgets.Label;
 import org.eclipse.swt.widgets.Table;
 import org.eclipse.swt.widgets.TableColumn;
 import org.eclipse.swt.widgets.TableItem;
+import org.eclipse.swt.widgets.Text;
 import org.geotools.referencing.CRS;
 import org.simantics.district.imports.ui.controls.DynamicComboFieldEditor;
 
@@ -50,6 +52,7 @@ public class CSVImportWizardPage extends WizardPage {
 
     // Common for vertex and edge
     private DynamicComboFieldEditor componentMappingSelector;
+    private DynamicComboFieldEditor idSelector;
     private DynamicComboFieldEditor labelSelector;
     
     // For vertex import
@@ -57,6 +60,25 @@ public class CSVImportWizardPage extends WizardPage {
     private DynamicComboFieldEditor yCoordSelector;
     private DynamicComboFieldEditor zValueSelector;
 
+    private DynamicComboFieldEditor supplyTempValueSelector;
+    private DynamicComboFieldEditor returnTempValueSelector;
+    private DynamicComboFieldEditor supplyPressureValueSelector;
+    private DynamicComboFieldEditor returnPressureValueSelector;
+    private DynamicComboFieldEditor dpSelector;
+    private DynamicComboFieldEditor dtSelector;
+    private DynamicComboFieldEditor heatPowerSelector;
+    private DynamicComboFieldEditor nominalHeadMSelector;
+    private DynamicComboFieldEditor nominalHeadBSelector;
+    private DynamicComboFieldEditor nominalFlowSelector;
+    private DynamicComboFieldEditor maximumHeadMSelector;
+    private DynamicComboFieldEditor heatLoadDsSelector;
+    private DynamicComboFieldEditor massFlowSelector;
+    private DynamicComboFieldEditor volFlowSelector;
+    private DynamicComboFieldEditor velocitySelector;
+    private DynamicComboFieldEditor flowAreaSelector;
+    private DynamicComboFieldEditor nominalPressureLossSelector;
+    private DynamicComboFieldEditor valvePositionSelector;
+
     // For edge import
     private DynamicComboFieldEditor startXCoordSelector;
     private DynamicComboFieldEditor startYCoordSelector;
@@ -64,8 +86,8 @@ public class CSVImportWizardPage extends WizardPage {
     private DynamicComboFieldEditor endXCoordSelector;
     private DynamicComboFieldEditor endYCoordSelector;
     private DynamicComboFieldEditor endZValueSelector;
-    private DynamicComboFieldEditor tempValueSelector;
-    private DynamicComboFieldEditor pressureValueSelector;
+
+    private Text edgeConnectionPadding;
     
     private DynamicComboFieldEditor outerDiameterSelector;
     private DynamicComboFieldEditor diameterSelector;
@@ -78,6 +100,14 @@ public class CSVImportWizardPage extends WizardPage {
     private Button isVertexImport;
 
     private Combo sourceCRSCombo;
+
+    private DynamicComboFieldEditor edgeFlowAreaSelector;
+
+    private DynamicComboFieldEditor kReturnSelector;
+
+    private DynamicComboFieldEditor kSupplySelector;
+
+    private DynamicComboFieldEditor tGroundSelector;
     
     protected CSVImportWizardPage(CSVImportModel model) {
         super("Import CSV Data");
@@ -96,7 +126,10 @@ public class CSVImportWizardPage extends WizardPage {
         
         delimiterCombo = new Combo(composite, SWT.DROP_DOWN | SWT.READ_ONLY);
         delimiterCombo.setToolTipText("Select the delimiter that is used to separate elements in the CSV file");
-        delimiterCombo.setItems(model.getDelimiterFormats());
+        String[] formats = model.getDelimiterFormats();
+        delimiterCombo.setItems(formats);
+        if (formats.length > 0)
+            delimiterCombo.select(0);
         delimiterCombo.addSelectionListener(new SelectionListener() {
 
             @Override
@@ -252,6 +285,27 @@ public class CSVImportWizardPage extends WizardPage {
             createEdgeIndexMappingField(indexMappingGroup);
         
         createCommonIndexMappingField(indexMappingGroup);
+        
+        if (!model.isVertexImport()) {
+            Label label = new Label(indexMappingGroup, SWT.NONE);
+            label.setText("Connection point padding");
+            GridDataFactory.fillDefaults().applyTo(label);
+            edgeConnectionPadding = new Text(indexMappingGroup, SWT.BORDER);
+            GridDataFactory.fillDefaults().applyTo(edgeConnectionPadding);
+            edgeConnectionPadding.setText("0.0001"); // default
+            edgeConnectionPadding.addModifyListener(new ModifyListener() {
+                
+                @Override
+                public void modifyText(ModifyEvent e) {
+                    try {
+                        double padding = Double.parseDouble("");
+                        model.setEdgePapping(padding);
+                    } catch (NumberFormatException ee) {
+                        // ignore
+                    }
+                }
+            });
+        }
     }
 
     private void createCommonIndexMappingField(Group parent) {
@@ -271,6 +325,21 @@ public class CSVImportWizardPage extends WizardPage {
             }
         });
         
+        idSelector = new DynamicComboFieldEditor("id", "ID", parent);
+        idSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setIdIndex(Integer.parseInt(idSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        
     }
 
     private void createVertexIndexMappingField(Group parent) {
@@ -317,8 +386,8 @@ public class CSVImportWizardPage extends WizardPage {
                 validatePageComplete();
             }
         });
-        tempValueSelector = new DynamicComboFieldEditor("tempValue", "Temperature value", parent);
-        tempValueSelector.addComboListener(new SelectionListener() {
+        supplyTempValueSelector = new DynamicComboFieldEditor("tempValue", "Supply Temperature value", parent);
+        supplyTempValueSelector.addComboListener(new SelectionListener() {
 
             @Override
             public void widgetSelected(SelectionEvent e) {
@@ -327,12 +396,12 @@ public class CSVImportWizardPage extends WizardPage {
 
             @Override
             public void widgetDefaultSelected(SelectionEvent e) {
-                model.setTempIndex(Integer.parseInt(tempValueSelector.getValue()));
+                model.setSupplyTempIndex(Integer.parseInt(supplyTempValueSelector.getValue()));
                 validatePageComplete();
             }
         });
-        pressureValueSelector = new DynamicComboFieldEditor("pressureValue", "Pressure value", parent);
-        pressureValueSelector.addComboListener(new SelectionListener() {
+        returnTempValueSelector = new DynamicComboFieldEditor("returnTempValue", "Return Temperature value", parent);
+        returnTempValueSelector.addComboListener(new SelectionListener() {
 
             @Override
             public void widgetSelected(SelectionEvent e) {
@@ -341,13 +410,242 @@ public class CSVImportWizardPage extends WizardPage {
 
             @Override
             public void widgetDefaultSelected(SelectionEvent e) {
-                model.setPressureIndex(Integer.parseInt(pressureValueSelector.getValue()));
+                model.setReturnTempIndex(Integer.parseInt(returnTempValueSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        supplyPressureValueSelector = new DynamicComboFieldEditor("pressureValue", "Supply Pressure value", parent);
+        supplyPressureValueSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setSupplyPressureIndex(Integer.parseInt(supplyPressureValueSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        returnPressureValueSelector = new DynamicComboFieldEditor("returnPressureValue", "Return Pressure value", parent);
+        returnPressureValueSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setReturnPressureIndex(Integer.parseInt(returnPressureValueSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        dpSelector = new DynamicComboFieldEditor("dpValue", "Delta pressure ", parent);
+        dpSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setDeltaPressureIndex(Integer.parseInt(dpSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        dtSelector = new DynamicComboFieldEditor("dtValue", "Delta temperature ", parent);
+        dtSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setDeltaTemperatureIndex(Integer.parseInt(dtSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        heatPowerSelector = new DynamicComboFieldEditor("heatPowerValue", "Heat Power", parent);
+        heatPowerSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setHeatPowerIndex(Integer.parseInt(heatPowerSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        nominalHeadMSelector = new DynamicComboFieldEditor("nominalHeadMValue", "nominalHeadM", parent);
+        nominalHeadMSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setNominalHeadMIndex(Integer.parseInt(nominalHeadMSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        nominalHeadBSelector = new DynamicComboFieldEditor("nominalHeadBValue", "nominalHeadB", parent);
+        nominalHeadBSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setNominalHeadBIndex(Integer.parseInt(nominalHeadBSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        nominalFlowSelector = new DynamicComboFieldEditor("nominalFlowValue", "nominalFlow", parent);
+        nominalFlowSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setNominalFlowIndex(Integer.parseInt(nominalFlowSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+
+        maximumHeadMSelector = new DynamicComboFieldEditor("maximumHeadMValue", "maximumHeadM", parent);
+        maximumHeadMSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setMaximumHeadMIndex(Integer.parseInt(maximumHeadMSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        heatLoadDsSelector = new DynamicComboFieldEditor("heatLoadDsValue", "heatLoadDs", parent);
+        heatLoadDsSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setHeatLoadDsIndex(Integer.parseInt(heatLoadDsSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        massFlowSelector = new DynamicComboFieldEditor("massFlowValue", "massFlow", parent);
+        massFlowSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setMassFlowIndex(Integer.parseInt(massFlowSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        volFlowSelector = new DynamicComboFieldEditor("volFlowValue", "volFlow", parent);
+        volFlowSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setVolFlowIndex(Integer.parseInt(volFlowSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        velocitySelector = new DynamicComboFieldEditor("velocityValue", "velocity", parent);
+        velocitySelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setVelocityIndex(Integer.parseInt(velocitySelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        flowAreaSelector = new DynamicComboFieldEditor("flowAreaValue", "flowArea", parent);
+        flowAreaSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setFlowAreaIndex(Integer.parseInt(flowAreaSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        nominalPressureLossSelector = new DynamicComboFieldEditor("nominalPressureLossValue", "nominalPressureLoss", parent);
+        nominalPressureLossSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setNominalPressureLossIndex(Integer.parseInt(nominalPressureLossSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        valvePositionSelector = new DynamicComboFieldEditor("valvePositionSelectorValue", "valvePositionSelector", parent);
+        valvePositionSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setValvePositionIndex(Integer.parseInt(valvePositionSelector.getValue()));
                 validatePageComplete();
             }
         });
     }
 
     private void createEdgeIndexMappingField(Group parent) {
+        
+//        Composite paddingComposite = new Composite(parent, SWT.NONE);
+//        GridLayoutFactory.fillDefaults().numColumns(2).applyTo(paddingComposite);
+        
         startXCoordSelector = new DynamicComboFieldEditor("startxCoord", "Start X Coordinate", parent);
         startXCoordSelector.addComboListener(new SelectionListener() {
 
@@ -477,12 +775,69 @@ public class CSVImportWizardPage extends WizardPage {
                 validatePageComplete();
             }
         });
+        edgeFlowAreaSelector = new DynamicComboFieldEditor("edgeFlowAreaValue", "Flow Area", parent);
+        edgeFlowAreaSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setEdgeFlowAreaIndex(Integer.parseInt(edgeFlowAreaSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        kReturnSelector = new DynamicComboFieldEditor("kReturnValue", "K Return", parent);
+        kReturnSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setKReturnIndex(Integer.parseInt(kReturnSelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        kSupplySelector = new DynamicComboFieldEditor("kSupplyValue", "K Supply", parent);
+        kSupplySelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setKSupplyIndex(Integer.parseInt(kSupplySelector.getValue()));
+                validatePageComplete();
+            }
+        });
+        tGroundSelector = new DynamicComboFieldEditor("tGroundValue", "Temperature Ground", parent);
+        tGroundSelector.addComboListener(new SelectionListener() {
+
+            @Override
+            public void widgetSelected(SelectionEvent e) {
+                widgetDefaultSelected(e);
+            }
+
+            @Override
+            public void widgetDefaultSelected(SelectionEvent e) {
+                model.setTGroundIndex(Integer.parseInt(tGroundSelector.getValue()));
+                validatePageComplete();
+            }
+        });
     }
 
     private void updateCombos() {
-        String[][] namesAndValues = new String[headerIndexAndValues.size()][];
+        String[][] namesAndValues = new String[headerIndexAndValues.size() + 1][];
 
-        int i = 0;
+        namesAndValues[0] = new String[] {"", "-1"};
+        int i = 1;
         for (Entry<Integer, String> entry : headerIndexAndValues.entrySet()) {
             int key = entry.getKey();
             String value = entry.getValue();
@@ -499,6 +854,7 @@ public class CSVImportWizardPage extends WizardPage {
             updateEdgeCombos(namesAndValues);
 
         componentMappingSelector.updateCombo(namesAndValues);
+        idSelector.updateCombo(namesAndValues);
     }
 
     private void updateEdgeCombos(String[][] namesAndValues) {
@@ -511,15 +867,37 @@ public class CSVImportWizardPage extends WizardPage {
         diameterSelector.updateCombo(namesAndValues);
         outerDiameterSelector.updateCombo(namesAndValues);
         nominalMassFlowSelector.updateCombo(namesAndValues);
+        edgeFlowAreaSelector.updateCombo(namesAndValues);
+        kReturnSelector.updateCombo(namesAndValues);
+        kSupplySelector.updateCombo(namesAndValues);
+        tGroundSelector.updateCombo(namesAndValues);
     }
 
     private void updateVertexCombos(String[][] namesAndValues) {
         xCoordSelector.updateCombo(namesAndValues);
         yCoordSelector.updateCombo(namesAndValues);
         zValueSelector.updateCombo(namesAndValues);
-        pressureValueSelector.updateCombo(namesAndValues);
-        tempValueSelector.updateCombo(namesAndValues);
+        supplyTempValueSelector.updateCombo(namesAndValues);       
+        returnTempValueSelector.updateCombo(namesAndValues);       
+        supplyPressureValueSelector.updateCombo(namesAndValues);   
+        returnPressureValueSelector.updateCombo(namesAndValues);   
+        dpSelector.updateCombo(namesAndValues);                    
+        dtSelector.updateCombo(namesAndValues);                    
+        heatPowerSelector.updateCombo(namesAndValues);             
+        valvePositionSelector.updateCombo(namesAndValues);             
+        nominalHeadMSelector.updateCombo(namesAndValues);          
+        nominalHeadBSelector.updateCombo(namesAndValues);          
+        nominalFlowSelector.updateCombo(namesAndValues);           
+        maximumHeadMSelector.updateCombo(namesAndValues);          
+        heatLoadDsSelector.updateCombo(namesAndValues);            
+        massFlowSelector.updateCombo(namesAndValues);              
+        volFlowSelector.updateCombo(namesAndValues);               
+        velocitySelector.updateCombo(namesAndValues);              
+        flowAreaSelector.updateCombo(namesAndValues);              
+        nominalPressureLossSelector.updateCombo(namesAndValues);   
     }
+    
+    
 
     private void updateHeaders() {
         if (headerTable != null)
diff --git a/org.simantics.district.imports/src/org/simantics/district/imports/DistrictImportUtils.java b/org.simantics.district.imports/src/org/simantics/district/imports/DistrictImportUtils.java
index f123855d..6b22746c 100644
--- a/org.simantics.district.imports/src/org/simantics/district/imports/DistrictImportUtils.java
+++ b/org.simantics.district.imports/src/org/simantics/district/imports/DistrictImportUtils.java
@@ -46,6 +46,7 @@ public class DistrictImportUtils {
         Map<String, Character> delimiters = new HashMap<>();
         delimiters.put("Comma", ',');
         delimiters.put("Semicolon", ';');
+        delimiters.put("Tabulator", '\t');
         return delimiters;
     }
 
diff --git a/org.simantics.district.maps/src/org/simantics/maps/MapScalingTransform.java b/org.simantics.district.maps/src/org/simantics/maps/MapScalingTransform.java
index e208be71..f64a99f4 100644
--- a/org.simantics.district.maps/src/org/simantics/maps/MapScalingTransform.java
+++ b/org.simantics.district.maps/src/org/simantics/maps/MapScalingTransform.java
@@ -7,7 +7,7 @@ public class MapScalingTransform {
     private MapScalingTransform() {
     }
 
-    public static final AffineTransform INSTANCE = new AffineTransform(100000, 0, 0, 100000, 0, 0);
+    public static final AffineTransform INSTANCE = new AffineTransform(10000, 0, 0, 10000, 0, 0);
 
     public static double getScaleX() {
         return INSTANCE.getScaleX();
diff --git a/org.simantics.district.maps/src/org/simantics/maps/prefs/MapsClientPreferences.java b/org.simantics.district.maps/src/org/simantics/maps/prefs/MapsClientPreferences.java
index b0611313..fbc8b9e0 100644
--- a/org.simantics.district.maps/src/org/simantics/maps/prefs/MapsClientPreferences.java
+++ b/org.simantics.district.maps/src/org/simantics/maps/prefs/MapsClientPreferences.java
@@ -34,7 +34,7 @@ public class MapsClientPreferences {
     }
     
     public static String possibleBuiltinServerURL() {
-        int port = getServerPreferences().getInt(P_DEFAULT_PORT, 8080);
+        int port = getServerPreferences().getInt(P_DEFAULT_PORT, 8585);
         String style = getServerPreferences().get(P_CURRENT_TM2STYLE, "mapbox-studio-osm-bright.tm2");
         if (port != -1 && style != null) {
             try {
diff --git a/org.simantics.district.network.ontology/META-INF/MANIFEST.MF b/org.simantics.district.network.ontology/META-INF/MANIFEST.MF
index 6ac026c7..16df5e15 100644
--- a/org.simantics.district.network.ontology/META-INF/MANIFEST.MF
+++ b/org.simantics.district.network.ontology/META-INF/MANIFEST.MF
@@ -10,6 +10,7 @@ Require-Bundle: org.simantics.layer0,
  org.simantics.viewpoint.ontology;bundle-version="1.2.0",
  org.simantics.image2.ontology;bundle-version="1.2.0",
  org.simantics.selectionview.ontology;bundle-version="1.2.0",
- org.simantics.selectionview.ui.ontology;bundle-version="1.1.0"
+ org.simantics.selectionview.ui.ontology;bundle-version="1.1.0",
+ org.simantics.g2d.ontology;bundle-version="1.1.0"
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Export-Package: org.simantics.district.network.ontology
diff --git a/org.simantics.district.network.ontology/graph.tg b/org.simantics.district.network.ontology/graph.tg
index 9755fbfd1782b7aa5d3e7144722988ef740c1471..be35590cce833b30baf3448c0490abb4740de784 100644
GIT binary patch
literal 25552
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
b%*qoFy>a)4E_w#T+^eacT6OQ(`OE(o2L5%2

literal 13814
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

diff --git a/org.simantics.district.network.ontology/graph/DistrictNetwork.pgraph b/org.simantics.district.network.ontology/graph/DistrictNetwork.pgraph
index e819f445..75716c69 100644
--- a/org.simantics.district.network.ontology/graph/DistrictNetwork.pgraph
+++ b/org.simantics.district.network.ontology/graph/DistrictNetwork.pgraph
@@ -6,6 +6,7 @@ VP = <http://www.simantics.org/Viewpoint-1.2>
 IMAGE = <http://www.simantics.org/Image2-1.2>
 SEL = <http://www.simantics.org/SelectionView-1.2>
 SEL_UI = <http://www.simantics.org/SelectionViewUI-1.1>
+G2D = <http://www.simantics.org/G2D-1.1>
 
 DN = <http://www.simantics.org/DistrictNetwork-1.0> : L0.Ontology
     @L0.new
@@ -50,6 +51,106 @@ DN.MappingParameterType <T SEL.GenericParameterType
 DN.HasMapping <R L0.HasProperty : DN.MappingParameterType
     L0.HasLabel "Mapping"
 
+DN.HasId <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Id"
+    L0.HasRange L0.String
+    L0.readOnly false
+
+DN.Vertex.HasElevation <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Elevation"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasSupplyTemperature <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Supply Temperature"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasReturnTemperature <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Return Temperature"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasSupplyPressure <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Supply Pressure"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasReturnPressure <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Return Pressure"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasDeltaPressure <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Delta pressure"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasDeltaTemperature <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Delta temperature"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasHeatPower <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Heat Power"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasNominalHeadM <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "NominalHeadM"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasNominalHeadB <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "NominalHeadB"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasNominalFlow <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Nominal Flow"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasMaximumHeadM <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Maximum head M"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasHeatLoadDs <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Heat Load ds"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasMassFlow <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Mass Flow"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasVolFlow <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Vol Flow"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasVelocity <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Velocity"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasFlowArea <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Flow Area"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasValvePosition <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Valve position"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
+DN.Vertex.HasNominalPressureLoss <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Nominal Pressure Loss"
+    L0.HasRange L0.Double
+    L0.readOnly false
+
 DN.Edge.HasLength <R L0.HasProperty : SEL.GenericParameterType
     L0.HasLabel "Length"
     L0.HasRange L0.Double
@@ -60,31 +161,35 @@ DN.Edge.HasDiameter <R L0.HasProperty : SEL.GenericParameterType
     L0.HasRange L0.Double
     L0.readOnly false
 
-DN.Vertex.HasElevation <R L0.HasProperty : SEL.GenericParameterType
-    L0.HasLabel "Elevation"
+DN.Edge.HasOuterDiameter <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Outer Diameter"
     L0.HasRange L0.Double
     L0.readOnly false
 
-DN.Vertex.HasTemperature <R L0.HasProperty : SEL.GenericParameterType
-    L0.HasLabel "Temperature"
+DN.Edge.HasNominalMassFlow <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Nominal Mass Flow"
     L0.HasRange L0.Double
     L0.readOnly false
 
-DN.Vertex.HasPressure <R L0.HasProperty : SEL.GenericParameterType
-    L0.HasLabel "Pressure"
+DN.Edge.HasFlowArea <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "Flow Area"
     L0.HasRange L0.Double
     L0.readOnly false
 
-DN.Edge.HasOuterDiameter <R L0.HasProperty : SEL.GenericParameterType
-    L0.HasLabel "Outer Diameter"
+DN.Edge.HasKReturn <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "K Return"
     L0.HasRange L0.Double
     L0.readOnly false
 
-DN.Edge.HasNominalMassFlow <R L0.HasProperty : SEL.GenericParameterType
-    L0.HasLabel "Nominal Mass Flow"
+DN.Edge.HasKSupply <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "K Supply"
     L0.HasRange L0.Double
     L0.readOnly false
 
+DN.Edge.HasTGround <R L0.HasProperty : SEL.GenericParameterType
+    L0.HasLabel "T Ground"
+    L0.HasRange L0.Double
+    L0.readOnly false
 
 DN.InLayer
     @L0.defTag 
@@ -189,16 +294,84 @@ DN.Mapping.TerminalPair <T L0.Entity
     >-- DN.Mapping.OutputTerminal --> DN.Mapping.Terminal <R L0.HasProperty
 
 DN.Mapping.VertexMapping <T DN.Mapping.Base
+    // Common
+    >-- DN.Mapping.Id --> L0.String <R L0.HasProperty
     >-- DN.Mapping.ComponentType --> STR.ComponentType <R L0.DependsOn
     >-- DN.Mapping.VertexMapping.ElevationAttribute --> L0.String <R L0.HasProperty
-    >-- DN.Mapping.VertexMapping.TemperatureAttribute --> L0.String <R L0.HasProperty
-    >-- DN.Mapping.VertexMapping.PressureAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.SupplyTemperatureAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.ReturnTemperatureAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.SupplyPressureAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.ReturnPressureAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.DeltaPressureAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.DeltaTemperatureAttribute --> L0.String <R L0.HasProperty
     >-- DN.Mapping.Terminals --> DN.Mapping.TerminalPair <R L0.HasProperty
+    // Production
+    >-- DN.Mapping.VertexMapping.dpAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.dtAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.HeatPowerAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.NominalHeadMAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.NominalHeadBAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.NominalFlowAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.MaximumHeadMAttribute --> L0.String <R L0.HasProperty
+    // Consumers
+    >-- DN.Mapping.VertexMapping.HeatLoadDsAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.MassFlowAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.VolFlowAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.VelocityAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.FlowAreaAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.ValvePositionAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.NominalPressureLossAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.VertexMapping.NominalMassFlowAttribute --> L0.String <R L0.HasProperty
 
 DN.Mapping.EdgeMapping <T DN.Mapping.Base
+    >-- DN.Mapping.Id
     >-- DN.Mapping.ComponentType
     >-- DN.Mapping.EdgeMapping.LengthAttribute --> L0.String <R L0.HasProperty
     >-- DN.Mapping.EdgeMapping.DiameterAttribute --> L0.String <R L0.HasProperty
     >-- DN.Mapping.EdgeMapping.OuterDiameterAttribute --> L0.String <R L0.HasProperty
     >-- DN.Mapping.EdgeMapping.NominalMassFlowAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.EdgeMapping.FlowAreaAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.EdgeMapping.KReturnAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.EdgeMapping.KSupplyAttribute --> L0.String <R L0.HasProperty
+    >-- DN.Mapping.EdgeMapping.TGroundAttribute --> L0.String <R L0.HasProperty
     >-- DN.Mapping.Terminals
+
+DN.SCLMain : L0.SCLModule
+    L0.SCLModule.definition
+        """
+        include "Simantics/District/SCLMain"
+        """
+
+DN.DistrictProfile : DIA.Profile
+    L0.HasLabel "District Network Profile"
+    DIA.Profile.priority 0.0
+    DIA.HasEntries
+      _ : DIA.Profile
+        @L0.list
+          DN.DistrictProfile.entry
+            L0.HasLabel "Component names"
+            @DIA.groupStyleProfileEntry DN.ComponentNameStyle DN.Groups.ElementGroup
+          DN.DistrictProfile.entry1
+            L0.HasLabel "Id"
+            @DIA.groupStyleProfileEntry DN.ComponentIdStyle DN.Groups.ElementGroup
+
+DN.Groups : L0.Library
+
+DN.Groups.ElementGroup : DIA.TypeGroup
+  DIA.TypeGroup.HasType DIA.Element
+
+DN.ComponentNameStyle : DIA.ResourceSCLTextGridStyle
+    @MOD.scl DIA.ResourceSCLTextGridStyle.texts 
+        """
+        districtNetworkProfileStyle "http://www.simantics.org/Layer0-1.1/HasName"
+        """
+        "String -> Variable -> <ReadGraph> (String, String, String)"
+    @G2D.fontProperty DIA.TextElement.font "Arial" 30 G2D.FontStyle.normal_font_style
+
+DN.ComponentIdStyle : DIA.ResourceSCLTextGridStyle
+    @MOD.scl DIA.ResourceSCLTextGridStyle.texts 
+        """
+        districtNetworkProfileStyle "http://www.simantics.org/Layer0-1.1/HasName" 
+        """
+        "String -> Variable -> <ReadGraph> (String, String, String)"
+    @G2D.fontProperty DIA.TextElement.font "Arial" 30 G2D.FontStyle.normal_font_style
diff --git a/org.simantics.district.network.ontology/scl/Simantics/District/SCLMain.scl b/org.simantics.district.network.ontology/scl/Simantics/District/SCLMain.scl
new file mode 100644
index 00000000..2d46af92
--- /dev/null
+++ b/org.simantics.district.network.ontology/scl/Simantics/District/SCLMain.scl
@@ -0,0 +1,13 @@
+import "Simantics/DB"
+import "Simantics/Variables"
+
+districtNetworkProfileStyle :: String -> Resource -> <ReadGraph> (String, String, String)
+districtNetworkProfileStyle relation element = do
+    rel = possibleResource relation
+    result = match rel with
+        Just rel -> do
+            match possibleRelatedValue element rel with
+                Just res -> res
+                Nothing -> ""
+        Nothing -> ""
+    ("", result, "")
\ No newline at end of file
diff --git a/org.simantics.district.network.ontology/src/org/simantics/district/network/ontology/DistrictNetworkResource.java b/org.simantics.district.network.ontology/src/org/simantics/district/network/ontology/DistrictNetworkResource.java
index 4adb19d3..32aabfa2 100644
--- a/org.simantics.district.network.ontology/src/org/simantics/district/network/ontology/DistrictNetworkResource.java
+++ b/org.simantics.district.network.ontology/src/org/simantics/district/network/ontology/DistrictNetworkResource.java
@@ -16,10 +16,15 @@ public class DistrictNetworkResource {
     public final Resource Actions_NewDNDiagram;
     public final Resource AddLayerToDNDiagramTemplate;
     public final Resource BrowseContext;
+    public final Resource ComponentIdStyle;
+    public final Resource ComponentNameStyle;
     public final Resource Composite;
     public final Resource Connection;
     public final Resource Diagram;
     public final Resource Diagram_MappedDiagram;
+    public final Resource DistrictProfile;
+    public final Resource DistrictProfile_entry;
+    public final Resource DistrictProfile_entry1;
     public final Resource EPSG_4326;
     public final Resource Edge;
     public final Resource EdgeDefaultMapping;
@@ -27,12 +32,20 @@ public class DistrictNetworkResource {
     public final Resource EdgeMappingParameterType;
     public final Resource Edge_HasDiameter;
     public final Resource Edge_HasDiameter_Inverse;
+    public final Resource Edge_HasFlowArea;
+    public final Resource Edge_HasFlowArea_Inverse;
+    public final Resource Edge_HasKReturn;
+    public final Resource Edge_HasKReturn_Inverse;
+    public final Resource Edge_HasKSupply;
+    public final Resource Edge_HasKSupply_Inverse;
     public final Resource Edge_HasLength;
     public final Resource Edge_HasLength_Inverse;
     public final Resource Edge_HasNominalMassFlow;
     public final Resource Edge_HasNominalMassFlow_Inverse;
     public final Resource Edge_HasOuterDiameter;
     public final Resource Edge_HasOuterDiameter_Inverse;
+    public final Resource Edge_HasTGround;
+    public final Resource Edge_HasTGround_Inverse;
     public final Resource Functions;
     public final Resource Functions_compositeInstantiator;
     public final Resource Functions_convertToValue;
@@ -40,8 +53,12 @@ public class DistrictNetworkResource {
     public final Resource Functions_defaultVertexMappingModifier;
     public final Resource Functions_enumerationValues;
     public final Resource Functions_mappingModifier;
+    public final Resource Groups;
+    public final Resource Groups_ElementGroup;
     public final Resource HasEndVertex;
     public final Resource HasEndVertex_Inverse;
+    public final Resource HasId;
+    public final Resource HasId_Inverse;
     public final Resource HasInLayerTag;
     public final Resource HasInLayerTag_Inverse;
     public final Resource HasMapping;
@@ -67,12 +84,22 @@ public class DistrictNetworkResource {
     public final Resource Mapping_EdgeMapping;
     public final Resource Mapping_EdgeMapping_DiameterAttribute;
     public final Resource Mapping_EdgeMapping_DiameterAttribute_Inverse;
+    public final Resource Mapping_EdgeMapping_FlowAreaAttribute;
+    public final Resource Mapping_EdgeMapping_FlowAreaAttribute_Inverse;
+    public final Resource Mapping_EdgeMapping_KReturnAttribute;
+    public final Resource Mapping_EdgeMapping_KReturnAttribute_Inverse;
+    public final Resource Mapping_EdgeMapping_KSupplyAttribute;
+    public final Resource Mapping_EdgeMapping_KSupplyAttribute_Inverse;
     public final Resource Mapping_EdgeMapping_LengthAttribute;
     public final Resource Mapping_EdgeMapping_LengthAttribute_Inverse;
     public final Resource Mapping_EdgeMapping_NominalMassFlowAttribute;
     public final Resource Mapping_EdgeMapping_NominalMassFlowAttribute_Inverse;
     public final Resource Mapping_EdgeMapping_OuterDiameterAttribute;
     public final Resource Mapping_EdgeMapping_OuterDiameterAttribute_Inverse;
+    public final Resource Mapping_EdgeMapping_TGroundAttribute;
+    public final Resource Mapping_EdgeMapping_TGroundAttribute_Inverse;
+    public final Resource Mapping_Id;
+    public final Resource Mapping_Id_Inverse;
     public final Resource Mapping_InputTerminal;
     public final Resource Mapping_InputTerminal_Inverse;
     public final Resource Mapping_OutputTerminal;
@@ -82,23 +109,94 @@ public class DistrictNetworkResource {
     public final Resource Mapping_Terminals;
     public final Resource Mapping_Terminals_Inverse;
     public final Resource Mapping_VertexMapping;
+    public final Resource Mapping_VertexMapping_DeltaPressureAttribute;
+    public final Resource Mapping_VertexMapping_DeltaPressureAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_DeltaTemperatureAttribute;
+    public final Resource Mapping_VertexMapping_DeltaTemperatureAttribute_Inverse;
     public final Resource Mapping_VertexMapping_ElevationAttribute;
     public final Resource Mapping_VertexMapping_ElevationAttribute_Inverse;
-    public final Resource Mapping_VertexMapping_PressureAttribute;
-    public final Resource Mapping_VertexMapping_PressureAttribute_Inverse;
-    public final Resource Mapping_VertexMapping_TemperatureAttribute;
-    public final Resource Mapping_VertexMapping_TemperatureAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_FlowAreaAttribute;
+    public final Resource Mapping_VertexMapping_FlowAreaAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_HeatLoadDsAttribute;
+    public final Resource Mapping_VertexMapping_HeatLoadDsAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_HeatPowerAttribute;
+    public final Resource Mapping_VertexMapping_HeatPowerAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_MassFlowAttribute;
+    public final Resource Mapping_VertexMapping_MassFlowAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_MaximumHeadMAttribute;
+    public final Resource Mapping_VertexMapping_MaximumHeadMAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_NominalFlowAttribute;
+    public final Resource Mapping_VertexMapping_NominalFlowAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_NominalHeadBAttribute;
+    public final Resource Mapping_VertexMapping_NominalHeadBAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_NominalHeadMAttribute;
+    public final Resource Mapping_VertexMapping_NominalHeadMAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_NominalMassFlowAttribute;
+    public final Resource Mapping_VertexMapping_NominalMassFlowAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_NominalPressureLossAttribute;
+    public final Resource Mapping_VertexMapping_NominalPressureLossAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_ReturnPressureAttribute;
+    public final Resource Mapping_VertexMapping_ReturnPressureAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_ReturnTemperatureAttribute;
+    public final Resource Mapping_VertexMapping_ReturnTemperatureAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_SupplyPressureAttribute;
+    public final Resource Mapping_VertexMapping_SupplyPressureAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_SupplyTemperatureAttribute;
+    public final Resource Mapping_VertexMapping_SupplyTemperatureAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_ValvePositionAttribute;
+    public final Resource Mapping_VertexMapping_ValvePositionAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_VelocityAttribute;
+    public final Resource Mapping_VertexMapping_VelocityAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_VolFlowAttribute;
+    public final Resource Mapping_VertexMapping_VolFlowAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_dpAttribute;
+    public final Resource Mapping_VertexMapping_dpAttribute_Inverse;
+    public final Resource Mapping_VertexMapping_dtAttribute;
+    public final Resource Mapping_VertexMapping_dtAttribute_Inverse;
+    public final Resource SCLMain;
     public final Resource SpatialRefSystem;
     public final Resource Vertex;
     public final Resource VertexDefaultMapping;
     public final Resource VertexDefaultMapping_Inverse;
     public final Resource VertexMappingParameterType;
+    public final Resource Vertex_HasDeltaPressure;
+    public final Resource Vertex_HasDeltaPressure_Inverse;
+    public final Resource Vertex_HasDeltaTemperature;
+    public final Resource Vertex_HasDeltaTemperature_Inverse;
     public final Resource Vertex_HasElevation;
     public final Resource Vertex_HasElevation_Inverse;
-    public final Resource Vertex_HasPressure;
-    public final Resource Vertex_HasPressure_Inverse;
-    public final Resource Vertex_HasTemperature;
-    public final Resource Vertex_HasTemperature_Inverse;
+    public final Resource Vertex_HasFlowArea;
+    public final Resource Vertex_HasFlowArea_Inverse;
+    public final Resource Vertex_HasHeatLoadDs;
+    public final Resource Vertex_HasHeatLoadDs_Inverse;
+    public final Resource Vertex_HasHeatPower;
+    public final Resource Vertex_HasHeatPower_Inverse;
+    public final Resource Vertex_HasMassFlow;
+    public final Resource Vertex_HasMassFlow_Inverse;
+    public final Resource Vertex_HasMaximumHeadM;
+    public final Resource Vertex_HasMaximumHeadM_Inverse;
+    public final Resource Vertex_HasNominalFlow;
+    public final Resource Vertex_HasNominalFlow_Inverse;
+    public final Resource Vertex_HasNominalHeadB;
+    public final Resource Vertex_HasNominalHeadB_Inverse;
+    public final Resource Vertex_HasNominalHeadM;
+    public final Resource Vertex_HasNominalHeadM_Inverse;
+    public final Resource Vertex_HasNominalPressureLoss;
+    public final Resource Vertex_HasNominalPressureLoss_Inverse;
+    public final Resource Vertex_HasReturnPressure;
+    public final Resource Vertex_HasReturnPressure_Inverse;
+    public final Resource Vertex_HasReturnTemperature;
+    public final Resource Vertex_HasReturnTemperature_Inverse;
+    public final Resource Vertex_HasSupplyPressure;
+    public final Resource Vertex_HasSupplyPressure_Inverse;
+    public final Resource Vertex_HasSupplyTemperature;
+    public final Resource Vertex_HasSupplyTemperature_Inverse;
+    public final Resource Vertex_HasValvePosition;
+    public final Resource Vertex_HasValvePosition_Inverse;
+    public final Resource Vertex_HasVelocity;
+    public final Resource Vertex_HasVelocity_Inverse;
+    public final Resource Vertex_HasVolFlow;
+    public final Resource Vertex_HasVolFlow_Inverse;
         
     public static class URIs {
         public static final String ActionContext = "http://www.simantics.org/DistrictNetwork-1.0/ActionContext";
@@ -107,10 +205,15 @@ public class DistrictNetworkResource {
         public static final String Actions_NewDNDiagram = "http://www.simantics.org/DistrictNetwork-1.0/Actions/NewDNDiagram";
         public static final String AddLayerToDNDiagramTemplate = "http://www.simantics.org/DistrictNetwork-1.0/AddLayerToDNDiagramTemplate";
         public static final String BrowseContext = "http://www.simantics.org/DistrictNetwork-1.0/BrowseContext";
+        public static final String ComponentIdStyle = "http://www.simantics.org/DistrictNetwork-1.0/ComponentIdStyle";
+        public static final String ComponentNameStyle = "http://www.simantics.org/DistrictNetwork-1.0/ComponentNameStyle";
         public static final String Composite = "http://www.simantics.org/DistrictNetwork-1.0/Composite";
         public static final String Connection = "http://www.simantics.org/DistrictNetwork-1.0/Connection";
         public static final String Diagram = "http://www.simantics.org/DistrictNetwork-1.0/Diagram";
         public static final String Diagram_MappedDiagram = "http://www.simantics.org/DistrictNetwork-1.0/Diagram/MappedDiagram";
+        public static final String DistrictProfile = "http://www.simantics.org/DistrictNetwork-1.0/DistrictProfile";
+        public static final String DistrictProfile_entry = "http://www.simantics.org/DistrictNetwork-1.0/DistrictProfile/entry";
+        public static final String DistrictProfile_entry1 = "http://www.simantics.org/DistrictNetwork-1.0/DistrictProfile/entry1";
         public static final String EPSG_4326 = "http://www.simantics.org/DistrictNetwork-1.0/EPSG_4326";
         public static final String Edge = "http://www.simantics.org/DistrictNetwork-1.0/Edge";
         public static final String EdgeDefaultMapping = "http://www.simantics.org/DistrictNetwork-1.0/EdgeDefaultMapping";
@@ -118,12 +221,20 @@ public class DistrictNetworkResource {
         public static final String EdgeMappingParameterType = "http://www.simantics.org/DistrictNetwork-1.0/EdgeMappingParameterType";
         public static final String Edge_HasDiameter = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasDiameter";
         public static final String Edge_HasDiameter_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasDiameter/Inverse";
+        public static final String Edge_HasFlowArea = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasFlowArea";
+        public static final String Edge_HasFlowArea_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasFlowArea/Inverse";
+        public static final String Edge_HasKReturn = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasKReturn";
+        public static final String Edge_HasKReturn_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasKReturn/Inverse";
+        public static final String Edge_HasKSupply = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasKSupply";
+        public static final String Edge_HasKSupply_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasKSupply/Inverse";
         public static final String Edge_HasLength = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasLength";
         public static final String Edge_HasLength_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasLength/Inverse";
         public static final String Edge_HasNominalMassFlow = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasNominalMassFlow";
         public static final String Edge_HasNominalMassFlow_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasNominalMassFlow/Inverse";
         public static final String Edge_HasOuterDiameter = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasOuterDiameter";
         public static final String Edge_HasOuterDiameter_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasOuterDiameter/Inverse";
+        public static final String Edge_HasTGround = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasTGround";
+        public static final String Edge_HasTGround_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Edge/HasTGround/Inverse";
         public static final String Functions = "http://www.simantics.org/DistrictNetwork-1.0/Functions";
         public static final String Functions_compositeInstantiator = "http://www.simantics.org/DistrictNetwork-1.0/Functions/compositeInstantiator";
         public static final String Functions_convertToValue = "http://www.simantics.org/DistrictNetwork-1.0/Functions/convertToValue";
@@ -131,8 +242,12 @@ public class DistrictNetworkResource {
         public static final String Functions_defaultVertexMappingModifier = "http://www.simantics.org/DistrictNetwork-1.0/Functions/defaultVertexMappingModifier";
         public static final String Functions_enumerationValues = "http://www.simantics.org/DistrictNetwork-1.0/Functions/enumerationValues";
         public static final String Functions_mappingModifier = "http://www.simantics.org/DistrictNetwork-1.0/Functions/mappingModifier";
+        public static final String Groups = "http://www.simantics.org/DistrictNetwork-1.0/Groups";
+        public static final String Groups_ElementGroup = "http://www.simantics.org/DistrictNetwork-1.0/Groups/ElementGroup";
         public static final String HasEndVertex = "http://www.simantics.org/DistrictNetwork-1.0/HasEndVertex";
         public static final String HasEndVertex_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/HasEndVertex_Inverse";
+        public static final String HasId = "http://www.simantics.org/DistrictNetwork-1.0/HasId";
+        public static final String HasId_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/HasId/Inverse";
         public static final String HasInLayerTag = "http://www.simantics.org/DistrictNetwork-1.0/HasInLayerTag";
         public static final String HasInLayerTag_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/HasInLayerTag/Inverse";
         public static final String HasMapping = "http://www.simantics.org/DistrictNetwork-1.0/HasMapping";
@@ -158,12 +273,22 @@ public class DistrictNetworkResource {
         public static final String Mapping_EdgeMapping = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping";
         public static final String Mapping_EdgeMapping_DiameterAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/DiameterAttribute";
         public static final String Mapping_EdgeMapping_DiameterAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/DiameterAttribute/Inverse";
+        public static final String Mapping_EdgeMapping_FlowAreaAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/FlowAreaAttribute";
+        public static final String Mapping_EdgeMapping_FlowAreaAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/FlowAreaAttribute/Inverse";
+        public static final String Mapping_EdgeMapping_KReturnAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/KReturnAttribute";
+        public static final String Mapping_EdgeMapping_KReturnAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/KReturnAttribute/Inverse";
+        public static final String Mapping_EdgeMapping_KSupplyAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/KSupplyAttribute";
+        public static final String Mapping_EdgeMapping_KSupplyAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/KSupplyAttribute/Inverse";
         public static final String Mapping_EdgeMapping_LengthAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/LengthAttribute";
         public static final String Mapping_EdgeMapping_LengthAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/LengthAttribute/Inverse";
         public static final String Mapping_EdgeMapping_NominalMassFlowAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/NominalMassFlowAttribute";
         public static final String Mapping_EdgeMapping_NominalMassFlowAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/NominalMassFlowAttribute/Inverse";
         public static final String Mapping_EdgeMapping_OuterDiameterAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/OuterDiameterAttribute";
         public static final String Mapping_EdgeMapping_OuterDiameterAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/OuterDiameterAttribute/Inverse";
+        public static final String Mapping_EdgeMapping_TGroundAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/TGroundAttribute";
+        public static final String Mapping_EdgeMapping_TGroundAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/EdgeMapping/TGroundAttribute/Inverse";
+        public static final String Mapping_Id = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/Id";
+        public static final String Mapping_Id_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/Id/Inverse";
         public static final String Mapping_InputTerminal = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/InputTerminal";
         public static final String Mapping_InputTerminal_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/InputTerminal/Inverse";
         public static final String Mapping_OutputTerminal = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/OutputTerminal";
@@ -173,23 +298,94 @@ public class DistrictNetworkResource {
         public static final String Mapping_Terminals = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/Terminals";
         public static final String Mapping_Terminals_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/Terminals/Inverse";
         public static final String Mapping_VertexMapping = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping";
+        public static final String Mapping_VertexMapping_DeltaPressureAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/DeltaPressureAttribute";
+        public static final String Mapping_VertexMapping_DeltaPressureAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/DeltaPressureAttribute/Inverse";
+        public static final String Mapping_VertexMapping_DeltaTemperatureAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/DeltaTemperatureAttribute";
+        public static final String Mapping_VertexMapping_DeltaTemperatureAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/DeltaTemperatureAttribute/Inverse";
         public static final String Mapping_VertexMapping_ElevationAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/ElevationAttribute";
         public static final String Mapping_VertexMapping_ElevationAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/ElevationAttribute/Inverse";
-        public static final String Mapping_VertexMapping_PressureAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/PressureAttribute";
-        public static final String Mapping_VertexMapping_PressureAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/PressureAttribute/Inverse";
-        public static final String Mapping_VertexMapping_TemperatureAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/TemperatureAttribute";
-        public static final String Mapping_VertexMapping_TemperatureAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/TemperatureAttribute/Inverse";
+        public static final String Mapping_VertexMapping_FlowAreaAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/FlowAreaAttribute";
+        public static final String Mapping_VertexMapping_FlowAreaAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/FlowAreaAttribute/Inverse";
+        public static final String Mapping_VertexMapping_HeatLoadDsAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/HeatLoadDsAttribute";
+        public static final String Mapping_VertexMapping_HeatLoadDsAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/HeatLoadDsAttribute/Inverse";
+        public static final String Mapping_VertexMapping_HeatPowerAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/HeatPowerAttribute";
+        public static final String Mapping_VertexMapping_HeatPowerAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/HeatPowerAttribute/Inverse";
+        public static final String Mapping_VertexMapping_MassFlowAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/MassFlowAttribute";
+        public static final String Mapping_VertexMapping_MassFlowAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/MassFlowAttribute/Inverse";
+        public static final String Mapping_VertexMapping_MaximumHeadMAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/MaximumHeadMAttribute";
+        public static final String Mapping_VertexMapping_MaximumHeadMAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/MaximumHeadMAttribute/Inverse";
+        public static final String Mapping_VertexMapping_NominalFlowAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/NominalFlowAttribute";
+        public static final String Mapping_VertexMapping_NominalFlowAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/NominalFlowAttribute/Inverse";
+        public static final String Mapping_VertexMapping_NominalHeadBAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/NominalHeadBAttribute";
+        public static final String Mapping_VertexMapping_NominalHeadBAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/NominalHeadBAttribute/Inverse";
+        public static final String Mapping_VertexMapping_NominalHeadMAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/NominalHeadMAttribute";
+        public static final String Mapping_VertexMapping_NominalHeadMAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/NominalHeadMAttribute/Inverse";
+        public static final String Mapping_VertexMapping_NominalMassFlowAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/NominalMassFlowAttribute";
+        public static final String Mapping_VertexMapping_NominalMassFlowAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/NominalMassFlowAttribute/Inverse";
+        public static final String Mapping_VertexMapping_NominalPressureLossAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/NominalPressureLossAttribute";
+        public static final String Mapping_VertexMapping_NominalPressureLossAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/NominalPressureLossAttribute/Inverse";
+        public static final String Mapping_VertexMapping_ReturnPressureAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/ReturnPressureAttribute";
+        public static final String Mapping_VertexMapping_ReturnPressureAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/ReturnPressureAttribute/Inverse";
+        public static final String Mapping_VertexMapping_ReturnTemperatureAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/ReturnTemperatureAttribute";
+        public static final String Mapping_VertexMapping_ReturnTemperatureAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/ReturnTemperatureAttribute/Inverse";
+        public static final String Mapping_VertexMapping_SupplyPressureAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/SupplyPressureAttribute";
+        public static final String Mapping_VertexMapping_SupplyPressureAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/SupplyPressureAttribute/Inverse";
+        public static final String Mapping_VertexMapping_SupplyTemperatureAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/SupplyTemperatureAttribute";
+        public static final String Mapping_VertexMapping_SupplyTemperatureAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/SupplyTemperatureAttribute/Inverse";
+        public static final String Mapping_VertexMapping_ValvePositionAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/ValvePositionAttribute";
+        public static final String Mapping_VertexMapping_ValvePositionAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/ValvePositionAttribute/Inverse";
+        public static final String Mapping_VertexMapping_VelocityAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/VelocityAttribute";
+        public static final String Mapping_VertexMapping_VelocityAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/VelocityAttribute/Inverse";
+        public static final String Mapping_VertexMapping_VolFlowAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/VolFlowAttribute";
+        public static final String Mapping_VertexMapping_VolFlowAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/VolFlowAttribute/Inverse";
+        public static final String Mapping_VertexMapping_dpAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/dpAttribute";
+        public static final String Mapping_VertexMapping_dpAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/dpAttribute/Inverse";
+        public static final String Mapping_VertexMapping_dtAttribute = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/dtAttribute";
+        public static final String Mapping_VertexMapping_dtAttribute_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Mapping/VertexMapping/dtAttribute/Inverse";
+        public static final String SCLMain = "http://www.simantics.org/DistrictNetwork-1.0/SCLMain";
         public static final String SpatialRefSystem = "http://www.simantics.org/DistrictNetwork-1.0/SpatialRefSystem";
         public static final String Vertex = "http://www.simantics.org/DistrictNetwork-1.0/Vertex";
         public static final String VertexDefaultMapping = "http://www.simantics.org/DistrictNetwork-1.0/VertexDefaultMapping";
         public static final String VertexDefaultMapping_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/VertexDefaultMapping/Inverse";
         public static final String VertexMappingParameterType = "http://www.simantics.org/DistrictNetwork-1.0/VertexMappingParameterType";
+        public static final String Vertex_HasDeltaPressure = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasDeltaPressure";
+        public static final String Vertex_HasDeltaPressure_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasDeltaPressure/Inverse";
+        public static final String Vertex_HasDeltaTemperature = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasDeltaTemperature";
+        public static final String Vertex_HasDeltaTemperature_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasDeltaTemperature/Inverse";
         public static final String Vertex_HasElevation = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasElevation";
         public static final String Vertex_HasElevation_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasElevation/Inverse";
-        public static final String Vertex_HasPressure = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasPressure";
-        public static final String Vertex_HasPressure_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasPressure/Inverse";
-        public static final String Vertex_HasTemperature = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasTemperature";
-        public static final String Vertex_HasTemperature_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasTemperature/Inverse";
+        public static final String Vertex_HasFlowArea = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasFlowArea";
+        public static final String Vertex_HasFlowArea_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasFlowArea/Inverse";
+        public static final String Vertex_HasHeatLoadDs = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasHeatLoadDs";
+        public static final String Vertex_HasHeatLoadDs_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasHeatLoadDs/Inverse";
+        public static final String Vertex_HasHeatPower = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasHeatPower";
+        public static final String Vertex_HasHeatPower_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasHeatPower/Inverse";
+        public static final String Vertex_HasMassFlow = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasMassFlow";
+        public static final String Vertex_HasMassFlow_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasMassFlow/Inverse";
+        public static final String Vertex_HasMaximumHeadM = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasMaximumHeadM";
+        public static final String Vertex_HasMaximumHeadM_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasMaximumHeadM/Inverse";
+        public static final String Vertex_HasNominalFlow = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasNominalFlow";
+        public static final String Vertex_HasNominalFlow_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasNominalFlow/Inverse";
+        public static final String Vertex_HasNominalHeadB = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasNominalHeadB";
+        public static final String Vertex_HasNominalHeadB_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasNominalHeadB/Inverse";
+        public static final String Vertex_HasNominalHeadM = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasNominalHeadM";
+        public static final String Vertex_HasNominalHeadM_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasNominalHeadM/Inverse";
+        public static final String Vertex_HasNominalPressureLoss = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasNominalPressureLoss";
+        public static final String Vertex_HasNominalPressureLoss_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasNominalPressureLoss/Inverse";
+        public static final String Vertex_HasReturnPressure = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasReturnPressure";
+        public static final String Vertex_HasReturnPressure_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasReturnPressure/Inverse";
+        public static final String Vertex_HasReturnTemperature = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasReturnTemperature";
+        public static final String Vertex_HasReturnTemperature_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasReturnTemperature/Inverse";
+        public static final String Vertex_HasSupplyPressure = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasSupplyPressure";
+        public static final String Vertex_HasSupplyPressure_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasSupplyPressure/Inverse";
+        public static final String Vertex_HasSupplyTemperature = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasSupplyTemperature";
+        public static final String Vertex_HasSupplyTemperature_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasSupplyTemperature/Inverse";
+        public static final String Vertex_HasValvePosition = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasValvePosition";
+        public static final String Vertex_HasValvePosition_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasValvePosition/Inverse";
+        public static final String Vertex_HasVelocity = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasVelocity";
+        public static final String Vertex_HasVelocity_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasVelocity/Inverse";
+        public static final String Vertex_HasVolFlow = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasVolFlow";
+        public static final String Vertex_HasVolFlow_Inverse = "http://www.simantics.org/DistrictNetwork-1.0/Vertex/HasVolFlow/Inverse";
     }
     
     public static Resource getResourceOrNull(ReadGraph graph, String uri) {
@@ -208,10 +404,15 @@ public class DistrictNetworkResource {
         Actions_NewDNDiagram = getResourceOrNull(graph, URIs.Actions_NewDNDiagram);
         AddLayerToDNDiagramTemplate = getResourceOrNull(graph, URIs.AddLayerToDNDiagramTemplate);
         BrowseContext = getResourceOrNull(graph, URIs.BrowseContext);
+        ComponentIdStyle = getResourceOrNull(graph, URIs.ComponentIdStyle);
+        ComponentNameStyle = getResourceOrNull(graph, URIs.ComponentNameStyle);
         Composite = getResourceOrNull(graph, URIs.Composite);
         Connection = getResourceOrNull(graph, URIs.Connection);
         Diagram = getResourceOrNull(graph, URIs.Diagram);
         Diagram_MappedDiagram = getResourceOrNull(graph, URIs.Diagram_MappedDiagram);
+        DistrictProfile = getResourceOrNull(graph, URIs.DistrictProfile);
+        DistrictProfile_entry = getResourceOrNull(graph, URIs.DistrictProfile_entry);
+        DistrictProfile_entry1 = getResourceOrNull(graph, URIs.DistrictProfile_entry1);
         EPSG_4326 = getResourceOrNull(graph, URIs.EPSG_4326);
         Edge = getResourceOrNull(graph, URIs.Edge);
         EdgeDefaultMapping = getResourceOrNull(graph, URIs.EdgeDefaultMapping);
@@ -219,12 +420,20 @@ public class DistrictNetworkResource {
         EdgeMappingParameterType = getResourceOrNull(graph, URIs.EdgeMappingParameterType);
         Edge_HasDiameter = getResourceOrNull(graph, URIs.Edge_HasDiameter);
         Edge_HasDiameter_Inverse = getResourceOrNull(graph, URIs.Edge_HasDiameter_Inverse);
+        Edge_HasFlowArea = getResourceOrNull(graph, URIs.Edge_HasFlowArea);
+        Edge_HasFlowArea_Inverse = getResourceOrNull(graph, URIs.Edge_HasFlowArea_Inverse);
+        Edge_HasKReturn = getResourceOrNull(graph, URIs.Edge_HasKReturn);
+        Edge_HasKReturn_Inverse = getResourceOrNull(graph, URIs.Edge_HasKReturn_Inverse);
+        Edge_HasKSupply = getResourceOrNull(graph, URIs.Edge_HasKSupply);
+        Edge_HasKSupply_Inverse = getResourceOrNull(graph, URIs.Edge_HasKSupply_Inverse);
         Edge_HasLength = getResourceOrNull(graph, URIs.Edge_HasLength);
         Edge_HasLength_Inverse = getResourceOrNull(graph, URIs.Edge_HasLength_Inverse);
         Edge_HasNominalMassFlow = getResourceOrNull(graph, URIs.Edge_HasNominalMassFlow);
         Edge_HasNominalMassFlow_Inverse = getResourceOrNull(graph, URIs.Edge_HasNominalMassFlow_Inverse);
         Edge_HasOuterDiameter = getResourceOrNull(graph, URIs.Edge_HasOuterDiameter);
         Edge_HasOuterDiameter_Inverse = getResourceOrNull(graph, URIs.Edge_HasOuterDiameter_Inverse);
+        Edge_HasTGround = getResourceOrNull(graph, URIs.Edge_HasTGround);
+        Edge_HasTGround_Inverse = getResourceOrNull(graph, URIs.Edge_HasTGround_Inverse);
         Functions = getResourceOrNull(graph, URIs.Functions);
         Functions_compositeInstantiator = getResourceOrNull(graph, URIs.Functions_compositeInstantiator);
         Functions_convertToValue = getResourceOrNull(graph, URIs.Functions_convertToValue);
@@ -232,8 +441,12 @@ public class DistrictNetworkResource {
         Functions_defaultVertexMappingModifier = getResourceOrNull(graph, URIs.Functions_defaultVertexMappingModifier);
         Functions_enumerationValues = getResourceOrNull(graph, URIs.Functions_enumerationValues);
         Functions_mappingModifier = getResourceOrNull(graph, URIs.Functions_mappingModifier);
+        Groups = getResourceOrNull(graph, URIs.Groups);
+        Groups_ElementGroup = getResourceOrNull(graph, URIs.Groups_ElementGroup);
         HasEndVertex = getResourceOrNull(graph, URIs.HasEndVertex);
         HasEndVertex_Inverse = getResourceOrNull(graph, URIs.HasEndVertex_Inverse);
+        HasId = getResourceOrNull(graph, URIs.HasId);
+        HasId_Inverse = getResourceOrNull(graph, URIs.HasId_Inverse);
         HasInLayerTag = getResourceOrNull(graph, URIs.HasInLayerTag);
         HasInLayerTag_Inverse = getResourceOrNull(graph, URIs.HasInLayerTag_Inverse);
         HasMapping = getResourceOrNull(graph, URIs.HasMapping);
@@ -259,12 +472,22 @@ public class DistrictNetworkResource {
         Mapping_EdgeMapping = getResourceOrNull(graph, URIs.Mapping_EdgeMapping);
         Mapping_EdgeMapping_DiameterAttribute = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_DiameterAttribute);
         Mapping_EdgeMapping_DiameterAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_DiameterAttribute_Inverse);
+        Mapping_EdgeMapping_FlowAreaAttribute = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_FlowAreaAttribute);
+        Mapping_EdgeMapping_FlowAreaAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_FlowAreaAttribute_Inverse);
+        Mapping_EdgeMapping_KReturnAttribute = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_KReturnAttribute);
+        Mapping_EdgeMapping_KReturnAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_KReturnAttribute_Inverse);
+        Mapping_EdgeMapping_KSupplyAttribute = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_KSupplyAttribute);
+        Mapping_EdgeMapping_KSupplyAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_KSupplyAttribute_Inverse);
         Mapping_EdgeMapping_LengthAttribute = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_LengthAttribute);
         Mapping_EdgeMapping_LengthAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_LengthAttribute_Inverse);
         Mapping_EdgeMapping_NominalMassFlowAttribute = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_NominalMassFlowAttribute);
         Mapping_EdgeMapping_NominalMassFlowAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_NominalMassFlowAttribute_Inverse);
         Mapping_EdgeMapping_OuterDiameterAttribute = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_OuterDiameterAttribute);
         Mapping_EdgeMapping_OuterDiameterAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_OuterDiameterAttribute_Inverse);
+        Mapping_EdgeMapping_TGroundAttribute = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_TGroundAttribute);
+        Mapping_EdgeMapping_TGroundAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_EdgeMapping_TGroundAttribute_Inverse);
+        Mapping_Id = getResourceOrNull(graph, URIs.Mapping_Id);
+        Mapping_Id_Inverse = getResourceOrNull(graph, URIs.Mapping_Id_Inverse);
         Mapping_InputTerminal = getResourceOrNull(graph, URIs.Mapping_InputTerminal);
         Mapping_InputTerminal_Inverse = getResourceOrNull(graph, URIs.Mapping_InputTerminal_Inverse);
         Mapping_OutputTerminal = getResourceOrNull(graph, URIs.Mapping_OutputTerminal);
@@ -274,23 +497,94 @@ public class DistrictNetworkResource {
         Mapping_Terminals = getResourceOrNull(graph, URIs.Mapping_Terminals);
         Mapping_Terminals_Inverse = getResourceOrNull(graph, URIs.Mapping_Terminals_Inverse);
         Mapping_VertexMapping = getResourceOrNull(graph, URIs.Mapping_VertexMapping);
+        Mapping_VertexMapping_DeltaPressureAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_DeltaPressureAttribute);
+        Mapping_VertexMapping_DeltaPressureAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_DeltaPressureAttribute_Inverse);
+        Mapping_VertexMapping_DeltaTemperatureAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_DeltaTemperatureAttribute);
+        Mapping_VertexMapping_DeltaTemperatureAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_DeltaTemperatureAttribute_Inverse);
         Mapping_VertexMapping_ElevationAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_ElevationAttribute);
         Mapping_VertexMapping_ElevationAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_ElevationAttribute_Inverse);
-        Mapping_VertexMapping_PressureAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_PressureAttribute);
-        Mapping_VertexMapping_PressureAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_PressureAttribute_Inverse);
-        Mapping_VertexMapping_TemperatureAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_TemperatureAttribute);
-        Mapping_VertexMapping_TemperatureAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_TemperatureAttribute_Inverse);
+        Mapping_VertexMapping_FlowAreaAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_FlowAreaAttribute);
+        Mapping_VertexMapping_FlowAreaAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_FlowAreaAttribute_Inverse);
+        Mapping_VertexMapping_HeatLoadDsAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_HeatLoadDsAttribute);
+        Mapping_VertexMapping_HeatLoadDsAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_HeatLoadDsAttribute_Inverse);
+        Mapping_VertexMapping_HeatPowerAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_HeatPowerAttribute);
+        Mapping_VertexMapping_HeatPowerAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_HeatPowerAttribute_Inverse);
+        Mapping_VertexMapping_MassFlowAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_MassFlowAttribute);
+        Mapping_VertexMapping_MassFlowAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_MassFlowAttribute_Inverse);
+        Mapping_VertexMapping_MaximumHeadMAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_MaximumHeadMAttribute);
+        Mapping_VertexMapping_MaximumHeadMAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_MaximumHeadMAttribute_Inverse);
+        Mapping_VertexMapping_NominalFlowAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_NominalFlowAttribute);
+        Mapping_VertexMapping_NominalFlowAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_NominalFlowAttribute_Inverse);
+        Mapping_VertexMapping_NominalHeadBAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_NominalHeadBAttribute);
+        Mapping_VertexMapping_NominalHeadBAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_NominalHeadBAttribute_Inverse);
+        Mapping_VertexMapping_NominalHeadMAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_NominalHeadMAttribute);
+        Mapping_VertexMapping_NominalHeadMAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_NominalHeadMAttribute_Inverse);
+        Mapping_VertexMapping_NominalMassFlowAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_NominalMassFlowAttribute);
+        Mapping_VertexMapping_NominalMassFlowAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_NominalMassFlowAttribute_Inverse);
+        Mapping_VertexMapping_NominalPressureLossAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_NominalPressureLossAttribute);
+        Mapping_VertexMapping_NominalPressureLossAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_NominalPressureLossAttribute_Inverse);
+        Mapping_VertexMapping_ReturnPressureAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_ReturnPressureAttribute);
+        Mapping_VertexMapping_ReturnPressureAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_ReturnPressureAttribute_Inverse);
+        Mapping_VertexMapping_ReturnTemperatureAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_ReturnTemperatureAttribute);
+        Mapping_VertexMapping_ReturnTemperatureAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_ReturnTemperatureAttribute_Inverse);
+        Mapping_VertexMapping_SupplyPressureAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_SupplyPressureAttribute);
+        Mapping_VertexMapping_SupplyPressureAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_SupplyPressureAttribute_Inverse);
+        Mapping_VertexMapping_SupplyTemperatureAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_SupplyTemperatureAttribute);
+        Mapping_VertexMapping_SupplyTemperatureAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_SupplyTemperatureAttribute_Inverse);
+        Mapping_VertexMapping_ValvePositionAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_ValvePositionAttribute);
+        Mapping_VertexMapping_ValvePositionAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_ValvePositionAttribute_Inverse);
+        Mapping_VertexMapping_VelocityAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_VelocityAttribute);
+        Mapping_VertexMapping_VelocityAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_VelocityAttribute_Inverse);
+        Mapping_VertexMapping_VolFlowAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_VolFlowAttribute);
+        Mapping_VertexMapping_VolFlowAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_VolFlowAttribute_Inverse);
+        Mapping_VertexMapping_dpAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_dpAttribute);
+        Mapping_VertexMapping_dpAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_dpAttribute_Inverse);
+        Mapping_VertexMapping_dtAttribute = getResourceOrNull(graph, URIs.Mapping_VertexMapping_dtAttribute);
+        Mapping_VertexMapping_dtAttribute_Inverse = getResourceOrNull(graph, URIs.Mapping_VertexMapping_dtAttribute_Inverse);
+        SCLMain = getResourceOrNull(graph, URIs.SCLMain);
         SpatialRefSystem = getResourceOrNull(graph, URIs.SpatialRefSystem);
         Vertex = getResourceOrNull(graph, URIs.Vertex);
         VertexDefaultMapping = getResourceOrNull(graph, URIs.VertexDefaultMapping);
         VertexDefaultMapping_Inverse = getResourceOrNull(graph, URIs.VertexDefaultMapping_Inverse);
         VertexMappingParameterType = getResourceOrNull(graph, URIs.VertexMappingParameterType);
+        Vertex_HasDeltaPressure = getResourceOrNull(graph, URIs.Vertex_HasDeltaPressure);
+        Vertex_HasDeltaPressure_Inverse = getResourceOrNull(graph, URIs.Vertex_HasDeltaPressure_Inverse);
+        Vertex_HasDeltaTemperature = getResourceOrNull(graph, URIs.Vertex_HasDeltaTemperature);
+        Vertex_HasDeltaTemperature_Inverse = getResourceOrNull(graph, URIs.Vertex_HasDeltaTemperature_Inverse);
         Vertex_HasElevation = getResourceOrNull(graph, URIs.Vertex_HasElevation);
         Vertex_HasElevation_Inverse = getResourceOrNull(graph, URIs.Vertex_HasElevation_Inverse);
-        Vertex_HasPressure = getResourceOrNull(graph, URIs.Vertex_HasPressure);
-        Vertex_HasPressure_Inverse = getResourceOrNull(graph, URIs.Vertex_HasPressure_Inverse);
-        Vertex_HasTemperature = getResourceOrNull(graph, URIs.Vertex_HasTemperature);
-        Vertex_HasTemperature_Inverse = getResourceOrNull(graph, URIs.Vertex_HasTemperature_Inverse);
+        Vertex_HasFlowArea = getResourceOrNull(graph, URIs.Vertex_HasFlowArea);
+        Vertex_HasFlowArea_Inverse = getResourceOrNull(graph, URIs.Vertex_HasFlowArea_Inverse);
+        Vertex_HasHeatLoadDs = getResourceOrNull(graph, URIs.Vertex_HasHeatLoadDs);
+        Vertex_HasHeatLoadDs_Inverse = getResourceOrNull(graph, URIs.Vertex_HasHeatLoadDs_Inverse);
+        Vertex_HasHeatPower = getResourceOrNull(graph, URIs.Vertex_HasHeatPower);
+        Vertex_HasHeatPower_Inverse = getResourceOrNull(graph, URIs.Vertex_HasHeatPower_Inverse);
+        Vertex_HasMassFlow = getResourceOrNull(graph, URIs.Vertex_HasMassFlow);
+        Vertex_HasMassFlow_Inverse = getResourceOrNull(graph, URIs.Vertex_HasMassFlow_Inverse);
+        Vertex_HasMaximumHeadM = getResourceOrNull(graph, URIs.Vertex_HasMaximumHeadM);
+        Vertex_HasMaximumHeadM_Inverse = getResourceOrNull(graph, URIs.Vertex_HasMaximumHeadM_Inverse);
+        Vertex_HasNominalFlow = getResourceOrNull(graph, URIs.Vertex_HasNominalFlow);
+        Vertex_HasNominalFlow_Inverse = getResourceOrNull(graph, URIs.Vertex_HasNominalFlow_Inverse);
+        Vertex_HasNominalHeadB = getResourceOrNull(graph, URIs.Vertex_HasNominalHeadB);
+        Vertex_HasNominalHeadB_Inverse = getResourceOrNull(graph, URIs.Vertex_HasNominalHeadB_Inverse);
+        Vertex_HasNominalHeadM = getResourceOrNull(graph, URIs.Vertex_HasNominalHeadM);
+        Vertex_HasNominalHeadM_Inverse = getResourceOrNull(graph, URIs.Vertex_HasNominalHeadM_Inverse);
+        Vertex_HasNominalPressureLoss = getResourceOrNull(graph, URIs.Vertex_HasNominalPressureLoss);
+        Vertex_HasNominalPressureLoss_Inverse = getResourceOrNull(graph, URIs.Vertex_HasNominalPressureLoss_Inverse);
+        Vertex_HasReturnPressure = getResourceOrNull(graph, URIs.Vertex_HasReturnPressure);
+        Vertex_HasReturnPressure_Inverse = getResourceOrNull(graph, URIs.Vertex_HasReturnPressure_Inverse);
+        Vertex_HasReturnTemperature = getResourceOrNull(graph, URIs.Vertex_HasReturnTemperature);
+        Vertex_HasReturnTemperature_Inverse = getResourceOrNull(graph, URIs.Vertex_HasReturnTemperature_Inverse);
+        Vertex_HasSupplyPressure = getResourceOrNull(graph, URIs.Vertex_HasSupplyPressure);
+        Vertex_HasSupplyPressure_Inverse = getResourceOrNull(graph, URIs.Vertex_HasSupplyPressure_Inverse);
+        Vertex_HasSupplyTemperature = getResourceOrNull(graph, URIs.Vertex_HasSupplyTemperature);
+        Vertex_HasSupplyTemperature_Inverse = getResourceOrNull(graph, URIs.Vertex_HasSupplyTemperature_Inverse);
+        Vertex_HasValvePosition = getResourceOrNull(graph, URIs.Vertex_HasValvePosition);
+        Vertex_HasValvePosition_Inverse = getResourceOrNull(graph, URIs.Vertex_HasValvePosition_Inverse);
+        Vertex_HasVelocity = getResourceOrNull(graph, URIs.Vertex_HasVelocity);
+        Vertex_HasVelocity_Inverse = getResourceOrNull(graph, URIs.Vertex_HasVelocity_Inverse);
+        Vertex_HasVolFlow = getResourceOrNull(graph, URIs.Vertex_HasVolFlow);
+        Vertex_HasVolFlow_Inverse = getResourceOrNull(graph, URIs.Vertex_HasVolFlow_Inverse);
     }
     
     public static DistrictNetworkResource getInstance(ReadGraph graph) {
diff --git a/org.simantics.district.network.ui.ontology/graph.tg b/org.simantics.district.network.ui.ontology/graph.tg
index 2815e2f3f9098a21d7acc6cade172ca3768bb810..bb507c21ae764aac678bc1161485085f31b566db 100644
GIT binary patch
delta 48
zcmeAXUMj54nqHJxkio#fzzD+p$%)AssVRCHiNzVo`6;PPKtTpWd#{3xe07`v9|#NH

delta 23
ccmZ1~+#}4#nqHJxkio#fzzD<)8`bML0YW_l-2eap

diff --git a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/adapters/DistrictNetworkAdditionalColor.java b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/adapters/DistrictNetworkAdditionalColor.java
index ef3b10c9..dcf556ed 100644
--- a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/adapters/DistrictNetworkAdditionalColor.java
+++ b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/adapters/DistrictNetworkAdditionalColor.java
@@ -17,12 +17,28 @@ public class DistrictNetworkAdditionalColor implements AdditionalColor {
     public static final Key KEY_DN_MAPPING_RESOURCE = new KeyOf(Resource.class, "DN_MAPPING_RESOURCE");
     
     private static final long serialVersionUID = -6290147660355075322L;
+    
+    private static final org.simantics.utils.ui.color.Color lightBlue = new org.simantics.utils.ui.color.Color(34, 167, 240);
+    private static final org.simantics.utils.ui.color.Color lightRed = new org.simantics.utils.ui.color.Color(236, 100, 75);
+    private static final org.simantics.utils.ui.color.Color lightGreen = new org.simantics.utils.ui.color.Color(135, 211, 124);
+    private static final org.simantics.utils.ui.color.Color gray = new org.simantics.utils.ui.color.Color(108, 122, 137);
+    private static final org.simantics.utils.ui.color.Color orange = new org.simantics.utils.ui.color.Color(243, 156, 18);
+    private static final org.simantics.utils.ui.color.Color purple = new org.simantics.utils.ui.color.Color(190, 144, 212);
 
     public static final ElementHandler INSTANCE = new DistrictNetworkAdditionalColor();
 
     private ColorPool colorPool = new ColorPool();
     private List<Resource> mappings = new ArrayList<>();
     
+    public DistrictNetworkAdditionalColor() {
+        colorPool.add(lightBlue);
+        colorPool.add(lightRed);
+        colorPool.add(lightGreen);
+        colorPool.add(gray);
+        colorPool.add(orange);
+        colorPool.add(purple);
+    }
+    
     @Override
     public void setAdditionalColor(IElement e, Color c) {
         throw new UnsupportedOperationException("Not needed!");
diff --git a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/function/Functions.java b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/function/Functions.java
index b6132d20..d80082ec 100644
--- a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/function/Functions.java
+++ b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/function/Functions.java
@@ -35,7 +35,6 @@ import org.simantics.db.Resource;
 import org.simantics.db.Session;
 import org.simantics.db.WriteGraph;
 import org.simantics.db.common.request.IndexRoot;
-import org.simantics.db.common.request.IndexRoots;
 import org.simantics.db.common.request.ObjectsWithType;
 import org.simantics.db.common.request.ReadRequest;
 import org.simantics.db.common.request.WriteRequest;
@@ -123,7 +122,10 @@ public class Functions {
         mappings.forEach(mapping -> {
             try {
                 String name = graph.getRelatedValue2(mapping, L0.HasName);
-                result.put(name, mapping);
+                Resource existing = result.put(name, mapping);
+                if (existing != null) {
+                    LOGGER.warn("Duplicate mapping name! {} {} and existing is {}", name, mapping, existing);
+                }
             } catch (DatabaseException e) {
                 e.printStackTrace();
             }
diff --git a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/nodes/DistrictNetworkEdgeNode.java b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/nodes/DistrictNetworkEdgeNode.java
index cd35b2f0..745f2a80 100644
--- a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/nodes/DistrictNetworkEdgeNode.java
+++ b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/nodes/DistrictNetworkEdgeNode.java
@@ -33,7 +33,6 @@ public class DistrictNetworkEdgeNode extends G2DNode {
 
     @Override
     public void init() {
-
     }
     
     @Override
diff --git a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/nodes/DistrictNetworkVertexNode.java b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/nodes/DistrictNetworkVertexNode.java
index 011d682e..c566981e 100644
--- a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/nodes/DistrictNetworkVertexNode.java
+++ b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/nodes/DistrictNetworkVertexNode.java
@@ -11,6 +11,7 @@ import java.awt.geom.Rectangle2D;
 
 import org.simantics.district.network.ModelledCRS;
 import org.simantics.district.network.ui.adapters.DistrictNetworkVertex;
+import org.simantics.scenegraph.ParentNode;
 import org.simantics.scenegraph.g2d.G2DNode;
 import org.simantics.scenegraph.utils.GeometryUtils;
 import org.slf4j.Logger;
@@ -116,6 +117,11 @@ public class DistrictNetworkVertexNode extends G2DNode {
         updateBounds();
     }
     
+    @Override
+    public AffineTransform getTransform() {
+        return super.getTransform();
+    }
+    
     private Rectangle2D calculateBounds(Rectangle2D rect) {
         Point2D calcPoint = calculatePoint2D(vertex);
         AffineTransform at = getTransform();
diff --git a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/nodes/MapRulerNode.java b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/nodes/MapRulerNode.java
index b19c39bf..bb699269 100644
--- a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/nodes/MapRulerNode.java
+++ b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/nodes/MapRulerNode.java
@@ -17,4 +17,8 @@ public class MapRulerNode extends RulerNode {
         return ModelledCRS.yToLatitude(value);
     }
 
+    @Override
+    protected int getMaxDigits() {
+        return 7;
+    }
 }
diff --git a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/participants/DNTranslateMode.java b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/participants/DNTranslateMode.java
index 9132fa2f..fda0fc71 100644
--- a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/participants/DNTranslateMode.java
+++ b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/participants/DNTranslateMode.java
@@ -5,6 +5,8 @@ import java.awt.geom.Point2D;
 import java.util.ArrayList;
 import java.util.Collection;
 
+import javax.xml.bind.DataBindingException;
+
 import org.simantics.Simantics;
 import org.simantics.db.Resource;
 import org.simantics.db.WriteGraph;
@@ -40,7 +42,7 @@ public class DNTranslateMode extends TranslateMode {
                         
                         
                         Object obj = ElementUtils.getObject(e);
-                        if (obj instanceof Resource) {
+                        if (obj instanceof Resource && graph.isInstanceOf((Resource) obj, DN.Vertex)) {
                             
                             Resource res = (Resource) obj;
                             
diff --git a/org.simantics.district.network/scl/Simantics/District.scl b/org.simantics.district.network/scl/Simantics/District.scl
index 8025c9ad..c92cc4cc 100644
--- a/org.simantics.district.network/scl/Simantics/District.scl
+++ b/org.simantics.district.network/scl/Simantics/District.scl
@@ -1,4 +1,8 @@
 import "Simantics/DB"
+import "Simantics/Ontologies"
+
+import "Map" as Map
+import "MSet" as MSet
 
 importJava "org.simantics.district.network.DistrictNetworkUtil" where
     calculateDistance :: Resource -> Resource -> <ReadGraph> Double
@@ -7,4 +11,70 @@ importJava "org.simantics.district.network.ModelledCRS" where
     xToLongitude :: Double -> <Proc> Double
     yToLatitude :: Double -> <Proc> Double
     longitudeToX :: Double -> <Proc> Double
-    latitudeToY :: Double -> <Proc> Double
\ No newline at end of file
+    latitudeToY :: Double -> <Proc> Double
+
+findBrokenConnections :: Resource -> <ReadGraph, Proc> ()
+findBrokenConnections diagram = do
+    elements = objectsWithType diagram L0.ConsistsOf DIA.DefinedElement
+    print $ "Found " + show (length elements) + " elements from diagram"
+    symbols = MMap.create ()
+    iter (\el -> do
+        symbol = singleObject el L0.InstanceOf
+        print $ "Found symbol " + uriOf symbol
+        ccs = collectionToList $ objects_ symbol L0.ConsistsOf
+        connectionPointRelations = filter (\cc -> isSubrelationOf cc  STR.IsConnectedTo) ccs
+        print $ "Found " + show (length connectionPointRelations) + " cprs"
+        iter (\cpr -> do
+            connectionPoints = objectsWithType el cpr DIA.Connector
+            print $ "Found " + show (length connectionPoints) + " cps"
+            if length connectionPoints > 1 /*|| length connectionPoints == 0*/
+            then do
+                // get existing map
+                print $ "Found " + show (length connectionPoints) + " connections for element " + nameOf el
+                instances = match MMap.get symbols (uriOf symbol) with
+                    Just m -> m
+                    Nothing -> do
+                        set = MSet.create ()
+                        MMap.put symbols (uriOf symbol) set
+                        set
+                ignore $ MSet.add instances $ singleObject el MOD.ElementToComponent
+            else ()
+            ()
+        ) connectionPointRelations
+    ) elements
+    MMap.iter (\key val -> do
+        print key
+        MSet.iter (\v -> print (nameOf v)) val
+        ()
+    ) symbols 
+    ()
+
+translateAllElements :: Resource -> <WriteGraph, Proc> ()
+translateAllElements diagram = do
+    print $ "Translating elements of diagram " + uriOf diagram 
+    elements = objectsWithType diagram L0.ConsistsOf DIA.DefinedElement
+    print $ "Found " + show (length elements) + " elements from diagram"
+    iter (\el -> do
+        connectionPoints = objectsWithType el STR.IsConnectedTo DIA.Connector
+        print $ "Found " + show (length connectionPoints) + " connections for element " + nameOf el
+    ) elements
+
+
+translateElement :: Resource -> <WriteGraph, Proc> ()
+translateElement elem = do
+    connectionPoints = objectsWithType elem STR.IsConnectedTo DIA.Connector
+    if length connectionPoints < 5
+    then do //this we can handle
+        areConnected = MSet.create ()
+        iter (\cp -> do
+            aconnector = singleObject cp  DIA.AreConnected
+            //otherElem
+            ()
+        ) []
+        //if length areConnected == 2
+        //then do // this we can handle - only two symbols
+        //    ()
+        //else ()
+        ()
+    else ()
+    ()
diff --git a/org.simantics.district.network/src/org/simantics/district/network/DistrictNetworkUtil.java b/org.simantics.district.network/src/org/simantics/district/network/DistrictNetworkUtil.java
index a2779803..165e6e96 100644
--- a/org.simantics.district.network/src/org/simantics/district/network/DistrictNetworkUtil.java
+++ b/org.simantics.district.network/src/org/simantics/district/network/DistrictNetworkUtil.java
@@ -35,7 +35,7 @@ public class DistrictNetworkUtil {
         
         graph.claim(edge, DN.HasMapping, mapping);
         
-        OrderedSetUtils.add(graph, composite, edge);
+        OrderedSetUtils.addFirst(graph, composite, edge);
         graph.claim(composite, L0.ConsistsOf, L0.PartOf, edge);
         
         claimFreshElementName(graph, composite, edge);
diff --git a/org.simantics.maps.server/src/org/simantics/district/maps/server/prefs/MapsServerInitializer.java b/org.simantics.maps.server/src/org/simantics/district/maps/server/prefs/MapsServerInitializer.java
index 365a9ee8..bd892b39 100644
--- a/org.simantics.maps.server/src/org/simantics/district/maps/server/prefs/MapsServerInitializer.java
+++ b/org.simantics.maps.server/src/org/simantics/district/maps/server/prefs/MapsServerInitializer.java
@@ -20,7 +20,7 @@ public class MapsServerInitializer extends AbstractPreferenceInitializer {
                 node.putBoolean(MapsServerPreferences.P_START_AUTOMATICALLY, true);
             }
             if (!keyss.contains(MapsServerPreferences.P_DEFAULT_PORT)) {
-                node.putInt(MapsServerPreferences.P_DEFAULT_PORT, 8080);
+                node.putInt(MapsServerPreferences.P_DEFAULT_PORT, 8585);
             }
         } catch (BackingStoreException e) {
             e.printStackTrace();
diff --git a/org.simantics.maps.server/src/org/simantics/district/maps/server/prefs/MapsServerPreferences.java b/org.simantics.maps.server/src/org/simantics/district/maps/server/prefs/MapsServerPreferences.java
index 8ccb8147..816fdbb4 100644
--- a/org.simantics.maps.server/src/org/simantics/district/maps/server/prefs/MapsServerPreferences.java
+++ b/org.simantics.maps.server/src/org/simantics/district/maps/server/prefs/MapsServerPreferences.java
@@ -25,7 +25,7 @@ public class MapsServerPreferences {
     }
 
     public static int defaultPort() {
-        return getPreferences().getInt(P_DEFAULT_PORT, 8080);
+        return getPreferences().getInt(P_DEFAULT_PORT, 8585);
     }
     
     public static String currentMBTiles() {
-- 
2.45.2