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
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) {
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;
+ }
}
@Override
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
+ monitor.beginTask("Importing CSV", 1000);
try {
Path csvFile = model.getSource();
char delim = model.getDelimiter();
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();
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();
@Override
public void perform(WriteGraph graph) throws DatabaseException {
+ graph.markUndoPoint();
DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph);
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);
+ }
}
}
}
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);
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;
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);
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);
+ }
+ }
+ }
+ }
}
}
});
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();
}
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;
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;
// Common for vertex and edge
private DynamicComboFieldEditor componentMappingSelector;
+ private DynamicComboFieldEditor idSelector;
private DynamicComboFieldEditor labelSelector;
// For vertex import
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;
private DynamicComboFieldEditor endXCoordSelector;
private DynamicComboFieldEditor endYCoordSelector;
private DynamicComboFieldEditor endZValueSelector;
- private DynamicComboFieldEditor tempValueSelector;
- private DynamicComboFieldEditor pressureValueSelector;
+
+ private Text edgeConnectionPadding;
private DynamicComboFieldEditor outerDiameterSelector;
private DynamicComboFieldEditor diameterSelector;
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");
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
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) {
}
});
+ 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) {
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) {
@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) {
@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() {
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();
updateEdgeCombos(namesAndValues);
componentMappingSelector.updateCombo(namesAndValues);
+ idSelector.updateCombo(namesAndValues);
}
private void updateEdgeCombos(String[][] namesAndValues) {
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)
Map<String, Character> delimiters = new HashMap<>();
delimiters.put("Comma", ',');
delimiters.put("Semicolon", ';');
+ delimiters.put("Tabulator", '\t');
return delimiters;
}
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();
}
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 {
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
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
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
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
>-- 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
--- /dev/null
+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
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;
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;
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;
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;
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";
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";
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";
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";
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";
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) {
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);
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);
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);
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);
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) {
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!");
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;
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();
}
@Override
public void init() {
-
}
@Override
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;
updateBounds();
}
+ @Override
+ public AffineTransform getTransform() {
+ return super.getTransform();
+ }
+
private Rectangle2D calculateBounds(Rectangle2D rect) {
Point2D calcPoint = calculatePoint2D(vertex);
AffineTransform at = getTransform();
return ModelledCRS.yToLatitude(value);
}
+ @Override
+ protected int getMaxDigits() {
+ return 7;
+ }
}
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;
Object obj = ElementUtils.getObject(e);
- if (obj instanceof Resource) {
+ if (obj instanceof Resource && graph.isInstanceOf((Resource) obj, DN.Vertex)) {
Resource res = (Resource) obj;
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
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 ()
+ ()
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);
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();
}
public static int defaultPort() {
- return getPreferences().getInt(P_DEFAULT_PORT, 8080);
+ return getPreferences().getInt(P_DEFAULT_PORT, 8585);
}
public static String currentMBTiles() {
Code Review / simantics / district.git / commitdiff