Mercurial > dive4elements > river
changeset 9179:51b316de0d64
Merge
| author | gernotbelger |
|---|---|
| date | Tue, 26 Jun 2018 20:04:56 +0200 |
| parents | 2f5052835b76 (current diff) 1614cb14308f (diff) |
| children | 9ef1262487e7 |
| files | artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/RiversideRadioChoice.java artifacts/src/main/resources/messages.properties artifacts/src/main/resources/messages_de.properties gwt-client/src/main/java/org/dive4elements/river/client/client/FLYSConstants.java gwt-client/src/main/java/org/dive4elements/river/client/client/FLYSConstants.properties gwt-client/src/main/java/org/dive4elements/river/client/client/FLYSConstants_de.properties |
| diffstat | 35 files changed, 1284 insertions(+), 354 deletions(-) [+] |
line wrap: on
line diff
--- a/artifacts/doc/conf/artifacts/manualpoints.xml Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/doc/conf/artifacts/manualpoints.xml Tue Jun 26 20:04:56 2018 +0200 @@ -42,6 +42,7 @@ <facet name="sinfo_flow_depth_development_peryear.manualpoints" /> <facet name="sinfo_tkk" /> <facet name="sinfo_collision.manualpoints" /> + <facet name="sinfo_flood_duration.manualpoints" /> </facets> </outputmode> </outputmodes>
--- a/artifacts/doc/conf/artifacts/sinfo.xml Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/doc/conf/artifacts/sinfo.xml Tue Jun 26 20:04:56 2018 +0200 @@ -335,8 +335,6 @@ <condition data="calculation_mode" value="sinfo_calc_flood_duration" operator="equal" /> </transition> - - <transition transition="org.dive4elements.river.artifacts.transitions.ValueCompareTransition"> <from state="state.sinfo.wspl" /> <to state="state.sinfo.wq" /> @@ -359,7 +357,29 @@ <outputmodes> <outputmode name="sinfo_flood_duration" description="output.sinfo_flood_duration" mime-type="image/png" type="chart"> <facets> - + <facet name="sinfo_facet_flood_duration" description="flood duration of the heights of the infrastructures (points)"/> + <facet name="mainvalue.1.duration" description="flood duration of first W main value"/> + <facet name="mainvalue.2.duration" description="flood duration of second W main value"/> + <facet name="mainvalue.3.duration" description="flood duration of third W main value"/> + </facets> + </outputmode> + <outputmode name="sinfo_flood_height" description="output.sinfo_flood_height" mime-type="image/png" type="chart"> + <facets> + <facet name="infrastructure.flood.height" description="flood heights of the infrastructures (points)"/> + <facet name="mainvalue.1.w" description="W of first main value"/> + <facet name="mainvalue.2.w" description="W of second main value"/> + <facet name="mainvalue.3.w" description="W of third main value"/> + </facets> + </outputmode> + <outputmode name="sinfo_flood_duration_curve" description="output.sinfo_duration_curve" mime-type="image/png" type="chart"> + <facets> + <facet name="duration_curve.w" description="facet.duration_curve.w"/> + <facet name="duration_curve.q" description="facet.duration_curve.q"/> + <facet name="infrastructure.w" description="geodetic height of the infrastructure"/> + <facet name="mainvalues.w" description="W Main Values"/> + <facet name="mainvalues.q" description="Q Main Values at optional second axis"/> + <facet name="infrastructure.q" description="discharge of the infrastructure height"/> + <facet name="duration_curve.manualpoints" description="Manuelle Punkte"/> </facets> </outputmode>
--- a/artifacts/doc/conf/generators/longitudinal-diagram-defaults.xml Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/doc/conf/generators/longitudinal-diagram-defaults.xml Tue Jun 26 20:04:56 2018 +0200 @@ -19,6 +19,7 @@ <axis name="flowdepthDevelopmentAxis"/> <axis name="flowdepthDevelopmentPerYearAxis"/> <axis name="countAxis" include-zero="true"/> + <axis name="durationAxis" include-zero="true"/> <domain-axis key="chart.longitudinal.section.xaxis.label" default="Fluss-Km" inverted="org.dive4elements.river.exports.IsKmUpEvaluator()"> <arg expr="artifact.river"/> @@ -57,6 +58,7 @@ <processor class="org.dive4elements.river.artifacts.sinfo.common.FlowDepthDevelopmentProcessor" axis="flowdepthDevelopmentAxis"/> <processor class="org.dive4elements.river.artifacts.sinfo.common.FlowDepthDevelopmentPerYearProcessor" axis="flowdepthDevelopmentPerYearAxis"/> <processor class="org.dive4elements.river.artifacts.sinfo.common.CollisionCalcProcessor" axis="countAxis"/> + <processor class="org.dive4elements.river.artifacts.sinfo.common.FloodDurationProcessor" axis="durationAxis"/> <processor class="org.dive4elements.river.artifacts.sinfo.common.PredefinedChannelWidthProcessor" axis="Width"/> <processor class="org.dive4elements.river.artifacts.sinfo.common.PredefinedChannelDepthProcessor" axis="flowdepthAxis"/>
--- a/artifacts/doc/conf/generators/longitudinal-diagrams.xml Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/doc/conf/generators/longitudinal-diagrams.xml Tue Jun 26 20:04:56 2018 +0200 @@ -165,5 +165,18 @@ <arg expr="artifact.river"/> </subtitle> </output-generator> + + <output-generator + names="sinfo_flood_duration,sinfo_flood_duration_chartinfo" + class="org.dive4elements.river.exports.LongitudinalSectionGenerator2" + converter="org.dive4elements.river.exports.DiagramAttributes"> + <title key="sinfo.chart.flood_duration.section.title" default="Überflutungsdauer Infrastruktur BWaStr (DEFAULT)"/> + &longitudinal-defaults; + <processor class="org.dive4elements.river.exports.process.ManualPointsProcessor" + axis="durationAxis"/> + <subtitle key="chart.w_differences.subtitle" default="-"> + <arg expr="artifact.river"/> + </subtitle> + </output-generator> </longitudinal-diagrams> \ No newline at end of file
--- a/artifacts/doc/conf/meta-data.xml Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/doc/conf/meta-data.xml Tue Jun 26 20:04:56 2018 +0200 @@ -136,6 +136,15 @@ <dc:when test="$out = 'sinfo_collision'"> <dc:call-macro name="annotations" /> </dc:when> + <dc:when test="$out = 'sinfo_flood_duration'"> + <dc:call-macro name="annotations" /> + </dc:when> + <dc:when test="$out = 'sinfo_flood_height'"> + <dc:call-macro name="annotations" /> + </dc:when> + <dc:when test="$out = 'sinfo_flood_duration_curve'"> + <dc:call-macro name="annotations" /> + </dc:when> </dc:choose> </dc:iterate> </dc:when> @@ -303,6 +312,15 @@ <dc:when test="$out = 'sinfo_collision'"> <dc:call-macro name="longitudinal-section-prototype" /> </dc:when> + <dc:when test="$out = 'sinfo_flood_duration'"> + <dc:call-macro name="longitudinal-section-prototype" /> + </dc:when> + <dc:when test="$out = 'sinfo_flood_height'"> + <dc:call-macro name="longitudinal-section-prototype" /> + </dc:when> + <dc:when test="$out = 'sinfo_flood_duration_curve'"> + <dc:call-macro name="longitudinal-section-prototype" /> + </dc:when> </dc:choose> </dc:iterate> </dc:otherwise> @@ -1653,6 +1671,7 @@ <dc:call-macro name="sinfo_flow_depth_development" /> <dc:call-macro name="sinfo_tkh" /> <dc:call-macro name="sinfo_collision" /> + <dc:call-macro name="sinfo_flood_duration" /> <dc:comment> WINFO/DIFF/FIX </dc:comment> <dc:call-macro name="longitudinal" /> @@ -3414,6 +3433,24 @@ </dc:filter> </dc:macro> + <dc:macro name="sinfo_flood_duration"> + <dc:filter expr="$a_state = 'state.sinfo.flood_duration'"> + <dc:if test="dc:has-result()"> + <sinfo_flood_duration> + <dc:for-each> + <dc:element name="${facet_name}"> + <dc:attribute name="factory" value="sinfo" /> + <dc:attribute name="target_out" value="${out}" /> + <dc:attribute name="description" value="${facet_description}" /> + <dc:attribute name="ids" value="${facet_num}" /> + <dc:attribute name="artifact-id" value="${a_gid}" /> + <dc:attribute name="out" value="${out_name}" /> + </dc:element> + </dc:for-each> + </sinfo_flood_duration> + </dc:if> + </dc:filter> + </dc:macro> <!-- channel size imported from CSV-files for S-INFO --> <dc:macro name="sinfo_predefined_channel"> <dc:context>
--- a/artifacts/doc/conf/themes.xml Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/doc/conf/themes.xml Tue Jun 26 20:04:56 2018 +0200 @@ -442,6 +442,7 @@ <mapping from="sinfo_facet_bedheight_difference.filtered" to="SInfoBedHeightDifference" /> <mapping from ="sinfo_facet_collision_calc_count" to="SInfoCollisionCount" /> + <mapping from ="sinfo_facet_flood_duration" to="SInfoFloodDuration" /> <mapping from="sinfo_facet_predefined_channel_width" to="SInfoPredefinedChannelWidth" /> <mapping from="sinfo_facet_predefined_channel_depth" to="SInfoPredefinedChannelDepth" /> @@ -458,5 +459,6 @@ <mapping from="sinfo_flow_depth_development_peryear.manualpoints" to="ManualPoints" /> <mapping from="sinfo_tkk" to="ManualPoints" /> <mapping from="sinfo_collision.manualpoints" to="ManualPoints" /> + <mapping from="sinfo_flood_duration.manualpoints" to="ManualPoints" /> </mappings> </themes> \ No newline at end of file
--- a/artifacts/doc/conf/themes/default.xml Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/doc/conf/themes/default.xml Tue Jun 26 20:04:56 2018 +0200 @@ -3063,4 +3063,13 @@ <field name="pointcolor" type="Color" display="Punktfarbe" default="48, 96, 255" /> </fields> </theme> + <theme name="SInfoFloodDuration"> + <inherits> + <inherit from="LongitudinalSectionPoints" /> + </inherits> + <fields> + <field name="pointsize" type="int" display="Punktdicke" default="3" /> + <field name="pointcolor" type="Color" display="Punktfarbe" default="68, 216, 40" /> + </fields> + </theme> </themegroup> \ No newline at end of file
--- a/artifacts/doc/conf/themes/second.xml Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/doc/conf/themes/second.xml Tue Jun 26 20:04:56 2018 +0200 @@ -3050,4 +3050,13 @@ <field name="pointcolor" type="Color" display="Punktfarbe" default="48, 96, 192" /> </fields> </theme> + <theme name="SInfoFloodDuration"> + <inherits> + <inherit from="LongitudinalSectionPoints" /> + </inherits> + <fields> + <field name="pointsize" type="int" display="Punktdicke" default="3" /> + <field name="pointcolor" type="Color" display="Punktfarbe" default="68, 192, 40" /> + </fields> + </theme> </themegroup> \ No newline at end of file
--- a/artifacts/src/main/java/org/dive4elements/river/artifacts/common/AbstractResultType.java Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/common/AbstractResultType.java Tue Jun 26 20:04:56 2018 +0200 @@ -86,14 +86,14 @@ return this.formatters.get(locale); } + protected abstract NumberFormat createFormatter(CallContext context); + protected final String exportDateValue(final CallContext context, final Date value) { final Locale locale = Resources.getLocale(context.getMeta()); final DateFormat df = DateFormat.getDateInstance(DateFormat.MEDIUM, locale); return df.format(value); } - protected abstract NumberFormat createFormatter(CallContext context); - @Override public final String getCsvHeader() { return this.csvHeader;
--- a/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/collision/CollisionCalcDetailResult.java Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/collision/CollisionCalcDetailResult.java Tue Jun 26 20:04:56 2018 +0200 @@ -45,16 +45,16 @@ final int colSize = 6; exportContextCSV.writeTitleForTabs("sinfo.export.csv.title.collision.detail", 6); // Voraussetzung für Tabs ist, dass der Titel vor den Headern - // geschrieben wird. + // geschrieben wird. // Das ist etwas doof. final Collection<String> header = new ArrayList<>(colSize); header.add(exportContextCSV.formatCsvHeader(GeneralResultType.station)); header.add(exportContextCSV.formatCsvHeader(GeneralResultType.date)); - header.add(exportContextCSV.formatCsvHeader(SInfoResultType.collisionGaugeW)); + header.add(exportContextCSV.msgUnitCSV(SInfoResultType.collisionGaugeW, SInfoResultType.collisionGaugeW.getUnit())); header.add(exportContextCSV.formatCsvHeader(SInfoResultType.gaugeLabel)); - header.add(exportContextCSV.msgUnitCSV(SInfoResultType.discharge)); + header.add(exportContextCSV.msgUnitCSV(SInfoResultType.discharge, SInfoResultType.discharge.getUnit())); header.add(exportContextCSV.formatCsvHeader(SInfoResultType.dischargeZone)); exportContextCSV.writeCSVLine(header.toArray(new String[colSize]));
--- a/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/collision/CollisionCalculation.java Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/collision/CollisionCalculation.java Tue Jun 26 20:04:56 2018 +0200 @@ -23,12 +23,15 @@ import org.dive4elements.river.artifacts.model.DateRange; import org.dive4elements.river.artifacts.resources.Resources; import org.dive4elements.river.artifacts.sinfo.SINFOArtifact; +import org.dive4elements.river.artifacts.sinfo.common.GaugeDischargeValuesFinder; +import org.dive4elements.river.artifacts.sinfo.common.GaugeMainValueNameFinder; import org.dive4elements.river.artifacts.sinfo.common.RiverInfoProvider; import org.dive4elements.river.artifacts.sinfo.common.SInfoResultType; import org.dive4elements.river.artifacts.sinfo.util.CalculationUtils; import org.dive4elements.river.artifacts.sinfo.util.RiverInfo; import org.dive4elements.river.backend.utils.DateUtil; import org.dive4elements.river.model.Gauge; +import org.dive4elements.river.model.MainValueType.MainValueTypeKey; import org.dive4elements.river.model.River; import org.dive4elements.river.model.sinfo.CollisionAggregateValue; import org.dive4elements.river.model.sinfo.CollisionValue; @@ -77,10 +80,10 @@ // create q-for-w-finders for all gauges of the calculation km range final RiverInfoProvider infoProvider = RiverInfoProvider.forRange(this.context, river, calcRange); final Map<Gauge, GaugeDischargeValuesFinder> qFinders = new HashMap<>(); - final Map<Gauge, GaugeDischargeZoneFinder> zoneFinders = new HashMap<>(); + final Map<Gauge, GaugeMainValueNameFinder> zoneFinders = new HashMap<>(); for (final Gauge gauge : river.determineGauges(calcRange.getMinimumDouble(), calcRange.getMaximumDouble())) { qFinders.put(gauge, GaugeDischargeValuesFinder.loadValues(gauge, problems)); - zoneFinders.put(gauge, GaugeDischargeZoneFinder.loadValues(gauge, problems)); + zoneFinders.put(gauge, GaugeMainValueNameFinder.loadValues(MainValueTypeKey.Q, gauge, problems)); } final Collection<ResultRow> detailsRows = new ArrayList<>(); @@ -118,7 +121,7 @@ */ private void calculateDetails(final Collection<ResultRow> rows, final RiverInfoProvider riverInfo, final double fromKm, final double toKm, final int fromYear, final int toYear, final Map<Gauge, GaugeDischargeValuesFinder> qFinders, - final Map<Gauge, GaugeDischargeZoneFinder> zoneFinders) { + final Map<Gauge, GaugeMainValueNameFinder> zoneFinders) { for (final CollisionValue collision : CollisionValue.getValues(riverInfo.getRiver(), fromKm, toKm, DateUtil.getStartDateFromYear(fromYear), DateUtil.getEndDateFromYear(toYear))) { final Gauge gauge = riverInfo.getGauge(collision.getStation(), true); @@ -129,7 +132,7 @@ .putValue(SInfoResultType.collisionGaugeW, collision.getGaugeW()) .putValue(SInfoResultType.gaugeLabel, collision.getGaugeName()) .putValue(SInfoResultType.discharge, qOut) - .putValue(SInfoResultType.dischargeZone, zoneFinders.get(gauge).getDischargeZone(q))); + .putValue(SInfoResultType.dischargeZone, zoneFinders.get(gauge).getZoneName(q))); } } } \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/common/FloodDurationProcessor.java Tue Jun 26 20:04:56 2018 +0200 @@ -0,0 +1,73 @@ +/** Copyright (C) 2017 by Bundesanstalt für Gewässerkunde + * Software engineering by + * Björnsen Beratende Ingenieure GmbH + * Dr. Schumacher Ingenieurbüro für Wasser und Umwelt + * + * This file is Free Software under the GNU AGPL (>=v3) + * and comes with ABSOLUTELY NO WARRANTY! Check out the + * documentation coming with Dive4Elements River for details. + */ + +package org.dive4elements.river.artifacts.sinfo.common; + +import java.util.HashSet; +import java.util.Set; + +import org.dive4elements.artifactdatabase.state.Facet; +import org.dive4elements.artifacts.CallContext; +import org.dive4elements.river.artifacts.common.AbstractCalculationResult; + +/** + * Processor to generate the facet and data series of infrastructure flood durations + * + * @author Matthias Schäfer + * + */ +public final class FloodDurationProcessor extends AbstractSInfoLineProcessor<AbstractCalculationResult> { + + public static final String FACET_FLOOD_DURATION = "sinfo_facet_flood_duration"; + + public static final String FACET_FLOOD_DURATION_DESCRIPTION = "sinfo_facet_flood_duration.description"; + + public static final String FACET_MAIN_VALUE_1_DURATION = "mainvalue.1.duration"; + + public static final String FACET_MAIN_VALUE_DURATION_DESCRIPTION = "mainvalue.duration.description"; + + private static final String I18N_AXIS_LABEL = "sinfo.chart.flood_duration.section.yaxis.label"; + + private static final Set<String> HANDLED_FACET_TYPES = new HashSet<>(); + + static { + HANDLED_FACET_TYPES.add(FACET_FLOOD_DURATION); + HANDLED_FACET_TYPES.add(FACET_MAIN_VALUE_1_DURATION); + } + + public FloodDurationProcessor() { + super(I18N_AXIS_LABEL, HANDLED_FACET_TYPES); + } + + + @Override + protected double[][] doGetPoints(final AbstractCalculationResult data, final String facetName) { + if (FACET_FLOOD_DURATION.contentEquals(facetName)) + return data.getStationPoints(SInfoResultType.floodDuration); + + if (FACET_MAIN_VALUE_1_DURATION.contentEquals(facetName)) + return data.getStationPoints(SInfoResultType.mainValue1Duration); + + final String error = String.format("Unknown facet name: %s", facetName); + throw new UnsupportedOperationException(error); + } + + public static Facet createFloodDurationFacet(final CallContext context, final String hash, final String id, + final AbstractCalculationResult result, final int index) { + return AbstractSInfoLineProcessor.createFacet(context, hash, id, result, index, I18N_AXIS_LABEL, + FACET_MAIN_VALUE_1_DURATION, FACET_MAIN_VALUE_DURATION_DESCRIPTION); + } + + public static Facet createMainValueDurationFacet(final CallContext context, final String hash, final String id, + final AbstractCalculationResult result, final int index) { + return AbstractSInfoLineProcessor.createFacet(context, hash, id, result, index, I18N_AXIS_LABEL, + FACET_FLOOD_DURATION, FACET_FLOOD_DURATION_DESCRIPTION); + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/common/GaugeDischargeValuesFinder.java Tue Jun 26 20:04:56 2018 +0200 @@ -0,0 +1,118 @@ +/** Copyright (C) 2017 by Bundesanstalt für Gewässerkunde + * Software engineering by + * Björnsen Beratende Ingenieure GmbH + * Dr. Schumacher Ingenieurbüro für Wasser und Umwelt + * + * This file is Free Software under the GNU AGPL (>=v3) + * and comes with ABSOLUTELY NO WARRANTY! Check out the + * documentation coming with Dive4Elements River for details. + */ +package org.dive4elements.river.artifacts.sinfo.common; + +import org.apache.commons.lang.math.DoubleRange; +import org.apache.commons.math.FunctionEvaluationException; +import org.apache.commons.math.analysis.UnivariateRealFunction; +import org.apache.commons.math.analysis.interpolation.LinearInterpolator; +import org.dive4elements.river.artifacts.model.Calculation; +import org.dive4elements.river.model.DischargeTable; +import org.dive4elements.river.model.DischargeTableValue; +import org.dive4elements.river.model.Gauge; + +import gnu.trove.TDoubleArrayList; + +/** + * Loading and search/interpolation of a gauge's discharge table (.at) + * + * @author Matthias Schäfer + * + */ +public final class GaugeDischargeValuesFinder { + + /***** FIELDS *****/ + + // private static Logger log = Logger.getLogger(GaugeDischargeValuesFinder.class); + + private final Gauge gauge; + + private Calculation problems; + + private final UnivariateRealFunction wInterpolator; + + private final DoubleRange wRange; + + + /***** CONSTRUCTORS *****/ + + private GaugeDischargeValuesFinder(final Gauge gauge, final Calculation problems, final DischargeTable dischargeTable) { + this.gauge = gauge; + this.problems = problems; + final TDoubleArrayList ws = new TDoubleArrayList(); + final TDoubleArrayList qs = new TDoubleArrayList(); + for (final DischargeTableValue v : DischargeTable.getValuesSortedByW(dischargeTable)) { + ws.add(v.getW().doubleValue()); + qs.add(v.getQ().doubleValue()); + } + if (ws.size() >= 2) { + this.wInterpolator = new LinearInterpolator().interpolate(ws.toNativeArray(), qs.toNativeArray()); + this.wRange = new DoubleRange(ws.get(0), ws.get(ws.size() - 1)); + } + else { + this.wInterpolator = null; + this.wRange = null; + } + if ((this.wInterpolator == null) && (this.problems != null)) { + this.problems.addProblem("gauge_discharge_table.missing", gauge.getName()); + // Report only once + this.problems = null; + } + } + + + /***** METHODS *****/ + + /** + * Loads the the main discharge table of a gauge (GAUGE.at) + * + * @return The discharge table values finder of the gauge, or null + */ + public static GaugeDischargeValuesFinder loadValues(final Gauge gauge, final Calculation problems) { + final DischargeTable table = DischargeTable.getGaugeMainDischargeTable(gauge); + if ((table == null) || (table.getDischargeTableValues().size() == 0)) { + problems.addProblem("gauge_discharge_table.missing", gauge.getName()); + return null; + } + else + return new GaugeDischargeValuesFinder(gauge, problems, table); + } + + /** + * If this provider may return valid data at all. + */ + public boolean isValid() { + return (this.wInterpolator != null); + } + + /** + * Discharge for a W + * + * @param w + * W in cm above gauge datum + * @return Q, or NegInf for w less than all, or PosInf for w greater then all, or NaN in case of exception + */ + public double getDischarge(final double w) { + try { + if (this.wInterpolator == null) + return Double.NaN; + else if (w < this.wRange.getMinimumDouble()) + return Double.NEGATIVE_INFINITY; + else if (w > this.wRange.getMaximumDouble()) + return Double.POSITIVE_INFINITY; + else + return this.wInterpolator.value(w); + } + catch (@SuppressWarnings("unused") final FunctionEvaluationException e) { + // ignore exception because this can/will happen regularly + return Double.NaN; + } + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/common/GaugeDurationValuesFinder.java Tue Jun 26 20:04:56 2018 +0200 @@ -0,0 +1,152 @@ +/** Copyright (C) 2017 by Bundesanstalt für Gewässerkunde + * Software engineering by + * Björnsen Beratende Ingenieure GmbH + * Dr. Schumacher Ingenieurbüro für Wasser und Umwelt + * + * This file is Free Software under the GNU AGPL (>=v3) + * and comes with ABSOLUTELY NO WARRANTY! Check out the + * documentation coming with Dive4Elements River for details. + */ +package org.dive4elements.river.artifacts.sinfo.common; + +import org.apache.commons.lang.math.DoubleRange; +import org.apache.commons.math.FunctionEvaluationException; +import org.apache.commons.math.analysis.UnivariateRealFunction; +import org.apache.commons.math.analysis.interpolation.LinearInterpolator; +import org.dive4elements.river.artifacts.model.Calculation; +import org.dive4elements.river.model.Gauge; +import org.dive4elements.river.model.MainValue; +import org.dive4elements.river.model.MainValueType.MainValueTypeKey; + +import gnu.trove.TDoubleArrayList; + +/** + * Loading and search/interpolate the duration main values of a gauge + * + * @author Matthias Schäfer + * + */ +public final class GaugeDurationValuesFinder { + + /***** FIELDS *****/ + + // private static Logger log = Logger.getLogger(GaugeDurationValuesFinder.class); + + private final Gauge gauge; + + private Calculation problems; + + private UnivariateRealFunction qInterpolator; + + private DoubleRange qRange; + + private UnivariateRealFunction durInterpolator; + + private DoubleRange durRange; + + private final String approxPrefix = "ca."; // "\u2248" geht wohl nicht + + + /***** CONSTRUCTORS *****/ + + private GaugeDurationValuesFinder(final Gauge gauge, final Calculation problems) { + this.gauge = gauge; + this.problems = problems; + final TDoubleArrayList qs = new TDoubleArrayList(); + final TDoubleArrayList durs = new TDoubleArrayList(); + for (final MainValue v : MainValue.getValuesOfGaugeAndType(gauge, MainValueTypeKey.DURATION)) { + qs.add(v.getValue().doubleValue()); + durs.add(Integer.valueOf(v.getMainValue().getName()).doubleValue()); + } + try { + this.qInterpolator = new LinearInterpolator().interpolate(qs.toNativeArray(), durs.toNativeArray()); + this.qRange = new DoubleRange(qs.get(0), qs.get(qs.size() - 1)); + } + catch (final Exception e) { + this.qInterpolator = null; + this.qRange = null; + } + qs.clear(); + durs.clear(); + for (final MainValue v : MainValue.getDurationDischargesOfGauge(gauge)) { + durs.add(Integer.valueOf(v.getMainValue().getName()).doubleValue()); + qs.add(v.getValue().doubleValue()); + } + try { + this.durInterpolator = new LinearInterpolator().interpolate(durs.toNativeArray(), qs.toNativeArray()); + this.durRange = new DoubleRange(durs.get(0), durs.get(durs.size() - 1)); + } + catch (final Exception e) { + this.durInterpolator = null; + this.durRange = null; + } + if (((this.qInterpolator == null) || (this.durInterpolator == null)) && (this.problems != null)) { + this.problems.addProblem("gauge_duration.missing", gauge.getName()); + // Report only once + this.problems = null; + } + } + + + /***** METHODS *****/ + + /** + * Loads the the discharge-duration table of a gauge (GAUGE.glt) + * + * @return The main values finder of a a gauge, or null + */ + public static GaugeDurationValuesFinder loadValues(final Gauge gauge, final Calculation problems) { + return new GaugeDurationValuesFinder(gauge, problems); + } + + /** + * If this provider may return valid data at all. + */ + public boolean isValid() { + return (this.qInterpolator != null); + } + + /** + * Discharge for a duration + * + * @return Q, or NegInf for duration less than all, or PosInf for duration greater then all, or NaN in case of exception + */ + public double getDischarge(final int duration) { + try { + if (this.durInterpolator == null) + return Double.NaN; + else if (duration < this.durRange.getMinimumDouble()) + return Double.NEGATIVE_INFINITY; + else if (duration > this.durRange.getMaximumDouble()) + return Double.POSITIVE_INFINITY; + else + return this.durInterpolator.value(duration); + } + catch (@SuppressWarnings("unused") final FunctionEvaluationException e) { + // ignore exception because this can/will happen regularly + return Double.NaN; + } + } + + /** + * Duration for a discharge + * + * @return duration, or 0 for Q less than all, or 365 for duration greater then all, or -1 in case of exception + */ + public double getDuration(final double q) { + try { + if (this.qInterpolator == null) + return -1; + else if (q < this.qRange.getMinimumDouble()) + return 0; + else if (q > this.qRange.getMaximumDouble()) + return 365; + else + return this.qInterpolator.value(q); + } + catch (@SuppressWarnings("unused") final FunctionEvaluationException e) { + // ignore exception because this can/will happen regularly + return -1; + } + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/common/GaugeMainValueNameFinder.java Tue Jun 26 20:04:56 2018 +0200 @@ -0,0 +1,115 @@ +/** Copyright (C) 2017 by Bundesanstalt für Gewässerkunde + * Software engineering by + * Björnsen Beratende Ingenieure GmbH + * Dr. Schumacher Ingenieurbüro für Wasser und Umwelt + * + * This file is Free Software under the GNU AGPL (>=v3) + * and comes with ABSOLUTELY NO WARRANTY! Check out the + * documentation coming with Dive4Elements River for details. + */ +package org.dive4elements.river.artifacts.sinfo.common; + +import java.util.Map.Entry; +import java.util.NavigableMap; +import java.util.TreeMap; + +import org.dive4elements.river.artifacts.model.Calculation; +import org.dive4elements.river.model.Gauge; +import org.dive4elements.river.model.MainValue; +import org.dive4elements.river.model.MainValueType.MainValueTypeKey; + +/** + * Loading and search the main values of a gauge to find and build a name + * + * @author Matthias Schäfer + * + */ +public final class GaugeMainValueNameFinder { + + /***** FIELDS *****/ + + // private static Logger log = Logger.getLogger(GaugeMainValueNameFinder.class); + + private final Gauge gauge; + + private Calculation problems; + + private final NavigableMap<Double, MainValue> mainValues; + + private final String approxPrefix = "ca."; // "\u2248" geht wohl nicht + + + /***** CONSTRUCTORS *****/ + + private GaugeMainValueNameFinder(final MainValueTypeKey type, final Gauge gauge, final Calculation problems) { + this.gauge = gauge; + this.problems = problems; + this.mainValues = new TreeMap<>(); + for (final MainValue mainValue : MainValue.getValuesOfGaugeAndType(gauge, type)) + this.mainValues.put(Double.valueOf(mainValue.getValue().doubleValue()), mainValue); + if (this.mainValues.isEmpty() && (this.problems != null)) { + this.problems.addProblem("gauge_main_values.missing", gauge.getName()); + // Report only once + this.problems = null; + } + } + + + /***** METHODS *****/ + + /** + * Loads the the main values table of a type and a gauge (GAUGE.glt) + * + * @return The main values finder of a type and a gauge, or null + */ + public static GaugeMainValueNameFinder loadValues(final MainValueTypeKey type, final Gauge gauge, final Calculation problems) { + return new GaugeMainValueNameFinder(type, gauge, problems); + } + + /** + * If this provider may return valid data at all. + */ + public boolean isValid() { + return (this.mainValues != null); + } + + /** + * Main value zone for a value. + */ + public String getZoneName(final double value) { + if (!this.isValid()) + return ""; + if (Double.isNaN(value)) + return ""; + + // Exact match + if (this.mainValues.containsKey(Double.valueOf(value))) + return this.mainValues.get(Double.valueOf(value)).getMainValue().getName(); + + // Clearly below or just (max. 10%) below lowest named value + final Entry<Double, MainValue> lowerZone = this.mainValues.floorEntry(Double.valueOf(value)); + if (lowerZone == null) { + if (value >= this.mainValues.firstKey().doubleValue() * 0.9) + return this.approxPrefix + this.mainValues.firstEntry().getValue().getMainValue().getName(); + else + return "<" + this.mainValues.firstEntry().getValue().getMainValue().getName(); + } + + // Clearly above or just (max. 10%) above highest named value + final Entry<Double, MainValue> higherZone = this.mainValues.ceilingEntry(Double.valueOf(value)); + if (higherZone == null) { + if (value <= this.mainValues.lastKey().doubleValue() * 1.1) + return this.approxPrefix + this.mainValues.lastEntry().getValue().getMainValue().getName(); + else + return ">" + this.mainValues.lastEntry().getValue().getMainValue().getName(); + } + + // Near (10%) one of the borders of a zone interval, or clearly within a zone + if (value <= lowerZone.getKey().doubleValue() * 1.1) + return this.approxPrefix + lowerZone.getValue().getMainValue().getName(); + else if (value >= higherZone.getKey().doubleValue() * 0.9) + return this.approxPrefix + higherZone.getValue().getMainValue().getName(); + else + return lowerZone.getValue().getMainValue().getName() + "-" + higherZone.getValue().getMainValue().getName(); + } +} \ No newline at end of file
--- a/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/common/SInfoResultType.java Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/common/SInfoResultType.java Tue Jun 26 20:04:56 2018 +0200 @@ -55,20 +55,14 @@ }; - public static final SInfoResultType inundationdurationq = new SInfoResultType(null, "sinfo.export.flood_duration.csv.header.inundation_duration_q", - "sinfo.export.flood_duration.pdf.header.inundation_duration_q") { + public static final SInfoResultType floodDischarge = new SInfoResultType(I18NStrings.UNIT_CUBIC_M, "sinfo.export.flood_duration.csv.header.discharge", + "sinfo.export.flood_duration.pdf.header.discharge") { private static final long serialVersionUID = 1L; @Override public String exportValue(final CallContext context, final Object value) { final double doubleValue = asDouble(value); - return exportDoubleValue(context, doubleValue); // integer - // als - // double? - // finde - // gerade - // kein - // int-beispiel + return exportDoubleValue(context, doubleValue); } @Override @@ -77,20 +71,30 @@ } }; - public static final SInfoResultType inundationduration = new SInfoResultType(null, "sinfo.export.flood_duration.csv.header.inundation_duration", - "sinfo.export.flood_duration.pdf.header.inundation_duration") { + public static final SInfoResultType floodDuration = new SInfoResultType(null, "sinfo.export.flood_duration.csv.header.duration", + "sinfo.export.flood_duration.pdf.header.duration") { private static final long serialVersionUID = 1L; @Override public String exportValue(final CallContext context, final Object value) { final double doubleValue = asDouble(value); - return exportDoubleValue(context, doubleValue); // integer - // als - // double? - // finde - // gerade - // kein - // int-beispiel + return exportDoubleValue(context, doubleValue); + } + + @Override + protected NumberFormat createFormatter(final CallContext context) { + return Formatter.getIntegerFormatter(context); + } + }; + + public static final SInfoResultType mainValue1Duration = new SInfoResultType(null, "sinfo.export.main_value_1_duration.csv.header.duration", + "sinfo.export.main_value_1_duration.pdf.header.duration") { + private static final long serialVersionUID = 1L; + + @Override + public String exportValue(final CallContext context, final Object value) { + final double doubleValue = asDouble(value); + return exportDoubleValue(context, doubleValue); } @Override
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/common/WQBaseTableFinder.java Tue Jun 26 20:04:56 2018 +0200 @@ -0,0 +1,185 @@ +/** Copyright (C) 2017 by Bundesanstalt für Gewässerkunde + * Software engineering by + * Björnsen Beratende Ingenieure GmbH + * Dr. Schumacher Ingenieurbüro für Wasser und Umwelt + * + * This file is Free Software under the GNU AGPL (>=v3) + * and comes with ABSOLUTELY NO WARRANTY! Check out the + * documentation coming with Dive4Elements River for details. + */ +package org.dive4elements.river.artifacts.sinfo.common; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map.Entry; +import java.util.NavigableMap; +import java.util.TreeMap; + +import org.apache.commons.math.FunctionEvaluationException; +import org.apache.commons.math.analysis.interpolation.LinearInterpolator; +import org.apache.commons.math.analysis.polynomials.PolynomialSplineFunction; +import org.dive4elements.river.artifacts.math.Linear; +import org.dive4elements.river.artifacts.model.Calculation; +import org.dive4elements.river.backend.SessionHolder; +import org.dive4elements.river.model.River; +import org.hibernate.SQLQuery; +import org.hibernate.Session; +import org.hibernate.type.StandardBasicTypes; + +import gnu.trove.TDoubleArrayList; + +/** + * Loading and search/interpolation of a W/Q base table of a river + * + * @author Matthias Schäfer + * + */ +public final class WQBaseTableFinder { + + /***** FIELDS *****/ + + // private static Logger log = Logger.getLogger(WQTableFinder.class); + + private final River river; + + private Calculation problems; + + private final List<String> columnNames; + + private final NavigableMap<Double, PolynomialSplineFunction> kmWs; + + private final NavigableMap<Double, PolynomialSplineFunction> kmQs; + + private static final String SQLCOLUMNS = "SELECT wc.position AS colindex, wc.name AS qzone" + + " FROM wsts w" + + " INNER JOIN wst_columns wc ON w.id=wc.wst_id" + + " WHERE w.river_id = :river_id" + + " AND w.kind = 0" + + " ORDER BY wc.position ASC"; + + private static final String SQLMAIN = "SELECT wcv.position AS station, wc.position AS colindex, wcv.w, wqr.q" + + " FROM wsts w" + + " INNER JOIN wst_columns wc ON w.id=wc.wst_id" + + " INNER JOIN wst_column_values wcv ON wc.id=wcv.wst_column_id" + + " INNER JOIN wst_column_q_ranges wcqr ON wc.id=wcqr.wst_column_id" + + " INNER JOIN wst_q_ranges wqr ON wcqr.wst_q_range_id=wqr.id" + + " INNER JOIN ranges r ON wqr.range_id=r.id AND wcv.position BETWEEN r.a AND r.b" + + " WHERE w.river_id = :river_id" + + " AND w.kind = 0" + + " AND r.river_id = :river_id" + + " AND wcv.position BETWEEN :kmfrom - 1 AND :kmto + 1" // some tolerance for start and end of list + + " ORDER BY wcv.position ASC, " + + " wc.position ASC"; + + + /***** CONSTRUCTORS *****/ + + private WQBaseTableFinder(final River river, final Calculation problems, final List<Object[]> colnames, final List<Object[]> rows) { + this.river = river; + this.problems = problems; + this.columnNames = new ArrayList<>(); + for (final Object[] colname : colnames) + this.columnNames.add(colname[1].toString()); + this.kmWs = new TreeMap<>(); + this.kmQs = new TreeMap<>(); + final TDoubleArrayList ws = new TDoubleArrayList(); + final TDoubleArrayList qs = new TDoubleArrayList(); + double km = Double.NaN; + for (int i = 0; i <= rows.size() - 1; i++) { + if (ws.isEmpty() || ((double) rows.get(i)[0] <= km + 0.0001)) { + if (ws.isEmpty()) + km = (double) rows.get(i)[0]; + ws.add((double) rows.get(i)[2]); + qs.add((double) rows.get(i)[3]); + } + if ((i == rows.size() - 1) || ((double) rows.get(i)[0] > km + 0.0001)) { + try { + this.kmWs.put(km, new LinearInterpolator().interpolate(ws.toNativeArray(), qs.toNativeArray())); + this.kmQs.put(km, new LinearInterpolator().interpolate(qs.toNativeArray(), ws.toNativeArray())); + } + catch (final Exception e) { + if (this.problems != null) { + this.problems.addProblem(km, "wq_base_data.missing"); + // Report only once + this.problems = null; + } + } + ws.clear(); + qs.clear(); + km = (double) rows.get(i)[0]; + ws.add((double) rows.get(i)[2]); + qs.add((double) rows.get(i)[3]); + } + } + } + + + /***** METHODS *****/ + + /** + * Loads the the W/Q tables of a km range of a river + * + * @return The W/Q table finder of the river, or null + */ + public static WQBaseTableFinder loadValues(final River river, final double fromKm, final double toKm, final Calculation problems) { + final Session session = SessionHolder.HOLDER.get(); + final SQLQuery colQuery = session.createSQLQuery(SQLCOLUMNS) + .addScalar("colindex", StandardBasicTypes.INTEGER) + .addScalar("qzone", StandardBasicTypes.STRING); + colQuery.setParameter("river_id", river.getId()); + final List<Object[]> colnames = colQuery.list(); + if ((colnames == null) || colnames.isEmpty()) { + problems.addProblem("wq_table.missing"); + return null; + } + final SQLQuery wqQuery = session.createSQLQuery(SQLMAIN) + .addScalar("station", StandardBasicTypes.DOUBLE) + .addScalar("colindex", StandardBasicTypes.INTEGER) + .addScalar("w", StandardBasicTypes.DOUBLE) + .addScalar("q", StandardBasicTypes.DOUBLE); + wqQuery.setParameter("river_id", river.getId()); + wqQuery.setParameter("kmfrom", fromKm); + wqQuery.setParameter("kmto", toKm); + final List<Object[]> rows = wqQuery.list(); + if ((rows != null) && !rows.isEmpty()) + return new WQBaseTableFinder(river, problems, colnames, rows); + else { + problems.addProblem("wq_table.missing"); + return null; + } + } + + /** + * If this provider may return valid data at all. + */ + public boolean isValid() { + return (this.kmWs != null); + } + + /** + * Discharge for a W + * + * @param station + * station to find or interpolate + * @param w + * W in m+NN or m+NHN + * @return Q, or NegInf for w less than all, or PosInf for w greater then all, or NaN in case of exception + */ + public double getDischarge(final double station, final double w) { + if (this.kmWs == null) + return Double.NaN; + final Entry<Double, PolynomialSplineFunction> lowerEntry = this.kmWs.floorEntry(Double.valueOf(station)); + final Entry<Double, PolynomialSplineFunction> upperEntry = this.kmWs.ceilingEntry(Double.valueOf(station)); + if ((lowerEntry == null) || (upperEntry == null)) + return Double.NaN; + try { + final double lowerQ = lowerEntry.getValue().value(w); + final double upperQ = upperEntry.getValue().value(w); + return Linear.linear(station, lowerEntry.getKey().doubleValue(), upperEntry.getKey().doubleValue(), lowerQ, upperQ); + } + catch (@SuppressWarnings("unused") final FunctionEvaluationException e) { + // ignore exception because this can/will happen regularly + return Double.NaN; + } + } +} \ No newline at end of file
--- a/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/FloodDurationAccess.java Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/FloodDurationAccess.java Tue Jun 26 20:04:56 2018 +0200 @@ -12,12 +12,11 @@ import org.apache.log4j.Logger; import org.dive4elements.river.artifacts.access.RangeAccess; -import org.dive4elements.river.artifacts.common.EpochYearAccessHelper; import org.dive4elements.river.artifacts.sinfo.SINFOArtifact; import org.dive4elements.river.artifacts.sinfo.SinfoCalcMode; /** - * Access to the flow depth calculation type specific SInfo artifact data. + * Access to the flood duration calculation type specific SInfo artifact data. * REMARK: this class is NOT intended to be hold in the results (or anywhere else), in order to avoid a permanent * reference to the artifact instance. * Hence we do NOT cache any data. @@ -28,14 +27,11 @@ private static Logger log = Logger.getLogger(FloodDurationAccess.class); - private final EpochYearAccessHelper helper; - public FloodDurationAccess(final SINFOArtifact artifact) { super(artifact); /* assert calculation mode */ final SinfoCalcMode calculationMode = artifact.getCalculationMode(); - this.helper = new EpochYearAccessHelper(artifact); assert (calculationMode == SinfoCalcMode.sinfo_calc_flood_duration); } @@ -47,5 +43,4 @@ public String getRiverside() { return super.getString("riverside"); } - } \ No newline at end of file
--- a/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/FloodDurationCalculation.java Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/FloodDurationCalculation.java Tue Jun 26 20:04:56 2018 +0200 @@ -1,4 +1,4 @@ -/* Copyright (C) 2017 by Bundesanstalt für Gewässerkunde +/** Copyright (C) 2017 by Bundesanstalt für Gewässerkunde * Software engineering by * Björnsen Beratende Ingenieure GmbH * Dr. Schumacher Ingenieurbüro für Wasser und Umwelt @@ -11,19 +11,25 @@ import org.apache.commons.lang.math.DoubleRange; import org.dive4elements.artifacts.CallContext; +import org.dive4elements.river.artifacts.WINFOArtifact; import org.dive4elements.river.artifacts.model.Calculation; import org.dive4elements.river.artifacts.model.CalculationResult; import org.dive4elements.river.artifacts.resources.Resources; import org.dive4elements.river.artifacts.sinfo.SINFOArtifact; import org.dive4elements.river.artifacts.sinfo.common.RiverInfoProvider; +import org.dive4elements.river.artifacts.sinfo.flood_duration.RiversideRadioChoice.RiversideChoiceKey; import org.dive4elements.river.artifacts.sinfo.tkhstate.WinfoArtifactWrapper; import org.dive4elements.river.artifacts.sinfo.util.CalculationUtils; -import org.dive4elements.river.artifacts.sinfo.util.WstInfo; +import org.dive4elements.river.artifacts.sinfo.util.RiverInfo; import org.dive4elements.river.model.River; +import org.dive4elements.river.model.sinfo.Infrastructure; -class FloodDurationCalculation { - - // private static Logger log = Logger.getLogger(FloodDurationCalculation.class); +/** + * Calculation of the flood durations of the infrastructures of the km range of a river + * + * @author Matthias Schäfer + */ +final class FloodDurationCalculation { private final CallContext context; @@ -38,44 +44,39 @@ /* access input data */ final FloodDurationAccess access = new FloodDurationAccess(sinfo); final River river = access.getRiver(); - + final RiverInfo riverInfo = new RiverInfo(river); final DoubleRange calcRange = access.getRange(); - /* calculate results for each diff pair */ - final Calculation problems = new Calculation(); - final RiverInfoProvider infoProvider = RiverInfoProvider.forRange(this.context, river, calcRange); - final String calcModeLabel = Resources.getMsg(this.context.getMeta(), sinfo.getCalculationMode().name()); + final String riverside = Resources.getMsg(this.context.getMeta(), access.getRiverside()); + final Infrastructure infrasSeries = Infrastructure.getSeries(river); + final String infrasType = (infrasSeries != null) ? infrasSeries.getType().getName() : "?"; - // TODO: use enum for riverside - final String riverside = access.getRiverside(); - // more - // TODO: mis- ups.. re-use WINFO Artifact as in TkhState - final WinfoArtifactWrapper winfo = new WinfoArtifactWrapper(sinfo); - // winfo.computeWaterlevelData(); - final FloodDurationCalculationResults results = calculateResult(calcModeLabel, riverside, calcRange, infoProvider, user, problems); + final Calculation problems = new Calculation(); + + final FloodDurationCalculationResults results = new FloodDurationCalculationResults(calcModeLabel, user, riverInfo, calcRange); + + final FloodDurationCalculationResult result = calculateResult(calcModeLabel, infrasType, riverside, calcRange, infoProvider, + RiversideChoiceKey.fromKey(access.getRiverside()), user, problems); + results.addResult(result, problems); + + // Calculate the selected main values, if any + /* misuse winfo-artifact to calculate waterlevels in the same way */ + final WINFOArtifact winfo = new WinfoArtifactWrapper(sinfo); return new CalculationResult(results, problems); } /** - * Calculates FAKE Flood Duration - * - * @param riverside - * @param calcModeLabel - * @param user - * - * @param infoProvider + * Calculates the flood durations of the infrastructures of a km range of a river */ - private FloodDurationCalculationResults calculateResult(final String calcModeLabel, final String riverside, final DoubleRange calcRange, - final RiverInfoProvider riverInfoProvider, final String user, final Calculation problems) { + private FloodDurationCalculationResult calculateResult(final String calcModeLabel, final String infrastructureType, final String riverside, + final DoubleRange calcRange, final RiverInfoProvider riverInfoProvider, final RiversideChoiceKey riversideKey, final String user, + final Calculation problems) { final FloodDurationCalculator calculator = new FloodDurationCalculator(this.context, riverInfoProvider); - final String wspLabel = "WSP-Name";// wstKms.getName(); - final int wspYear = 9999; // waterlevel.getYear(); - final WstInfo wstInfo = new WstInfo(wspLabel, wspYear, riverInfoProvider.getReferenceGauge()); - final String label = String.format("%s - %s", wspLabel, " soundingLabel"); - return calculator.execute(problems, label, wstInfo, calcModeLabel, calcRange, riverside, user); + final String label = infrastructureType + ", " + riverside; + return calculator.execute(problems, label, calcModeLabel, calcRange, riversideKey, user).getResult(); } } \ No newline at end of file
--- a/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/FloodDurationCalculationResult.java Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/FloodDurationCalculationResult.java Tue Jun 26 20:04:56 2018 +0200 @@ -9,191 +9,115 @@ */ package org.dive4elements.river.artifacts.sinfo.flood_duration; -import java.text.NumberFormat; import java.util.ArrayList; import java.util.Collection; -import java.util.List; +import org.dive4elements.river.artifacts.common.AbstractCalculationExportableResult; import org.dive4elements.river.artifacts.common.ExportContextCSV; import org.dive4elements.river.artifacts.common.GeneralResultType; import org.dive4elements.river.artifacts.common.MetaAndTableJRDataSource; import org.dive4elements.river.artifacts.common.ResultRow; -import org.dive4elements.river.artifacts.sinfo.common.AbstractTkhCalculationResult; import org.dive4elements.river.artifacts.sinfo.common.SInfoResultType; import org.dive4elements.river.artifacts.sinfo.util.RiverInfo; -import org.dive4elements.river.artifacts.sinfo.util.WstInfo; /** - * Contains the results of a {@link FloodDurationCalculation}. + * Contains the result of a {@link FloodDurationCalculation}. * * @author Gernot Belger */ -final class FloodDurationCalculationResult extends AbstractTkhCalculationResult<FloodDurationCalculationResults> { +final class FloodDurationCalculationResult extends AbstractCalculationExportableResult<FloodDurationCalculationResults> { private static final long serialVersionUID = 1L; - private final int waterlevelCount; // TODO: ggf 2 verschiedene Result-Klassen? - // private final WstInfo wstInfo; - private final int maxWaterlevelPdf = 3; - private enum ExportMode { - pdf, csv + private static final String JASPER_FILE = "/jasper/templates/sinfo.floodduration.jrxml"; + + + public FloodDurationCalculationResult(final String label, final Collection<ResultRow> rows) { + super(label, rows); } - public FloodDurationCalculationResult(final String label, final WstInfo wstInfo, final Collection<ResultRow> rows, final boolean hasTkh, - final int waterlevelCount) { - super(label, wstInfo, hasTkh, rows); - this.waterlevelCount = waterlevelCount; - // this.wstInfo = wstInfo; + + @Override + protected void writeCSVResultMetadata(final ExportContextCSV exportContextCSV, final FloodDurationCalculationResults results) { + // TODO Metadaten der Wasserspiegellage(n) falls gewählt + // exportContextCSV.writeCSVWaterlevelMetadata(this.wstInfo); + // exportContextCSV.writeBlankLine(); + // writer.writeNext(new String[] { "" }); // break line + } + + @Override + protected String getJasperFile() { + // TODO Variante mit Wasserspiegellage(n) + return JASPER_FILE; + } + + protected String[] formatRow(final ExportContextCSV exportContextCSV, final FloodDurationCalculationResults results, final ResultRow row) { + + final Collection<String> lines = new ArrayList<>(10); + + lines.add(exportContextCSV.formatRowValue(row, GeneralResultType.station)); + lines.add(exportContextCSV.formatRowValue(row, SInfoResultType.riverside)); + lines.add(exportContextCSV.formatRowValue(row, SInfoResultType.floodDuration)); + lines.add(exportContextCSV.formatRowValue(row, SInfoResultType.floodDischarge)); + lines.add(exportContextCSV.formatRowValue(row, SInfoResultType.infrastructureHeight)); + lines.add(exportContextCSV.formatRowValue(row, SInfoResultType.infrastructuretype)); + + // TODO Wasserspiegellage(n) und Dauerzahlen falls gewählt + + lines.add(exportContextCSV.formatRowValue(row, SInfoResultType.gaugeLabel)); + lines.add(exportContextCSV.formatRowValue(row, SInfoResultType.location)); + + return lines.toArray(new String[lines.size()]); } @Override public void writeCSVHeader(final ExportContextCSV exportContextCSV, final FloodDurationCalculationResults results, final RiverInfo river) { - final Collection<String> header = new ArrayList<>(99); + final Collection<String> header = new ArrayList<>(20); header.add(exportContextCSV.formatCsvHeader(GeneralResultType.station)); header.add(exportContextCSV.formatCsvHeader(SInfoResultType.riverside)); - header.add(exportContextCSV.formatCsvHeader(SInfoResultType.inundationduration)); - header.add(exportContextCSV.formatCsvHeader(SInfoResultType.inundationdurationq)); - header.add(exportContextCSV.formatCsvHeader(SInfoResultType.infrastructureHeight)); + header.add(exportContextCSV.formatCsvHeader(SInfoResultType.floodDuration)); + header.add(exportContextCSV.msgUnitCSV(SInfoResultType.floodDischarge, SInfoResultType.floodDischarge.getUnit())); + header.add(exportContextCSV.msgUnitCSV(SInfoResultType.infrastructureHeight, SInfoResultType.infrastructureHeight.getUnit())); header.add(exportContextCSV.formatCsvHeader(SInfoResultType.infrastructuretype)); - // add dynamic headers - final int waterlevelCount = // results. - getWaterlevelCount(); - for (int i = 0; i < waterlevelCount; i++) { - final int naturalIndex = i + 1; - final String appendIndex = new StringBuilder().append("_").append(naturalIndex).toString(); - final Object[] args = new Object[] { appendIndex }; - // new StringBuilder().append('\u2081').toString(); // schlechter UTF-8-Support für subscript ints - header.add(exportContextCSV.msg(DurationWaterlevel.getHeaderW(), new Object[] { appendIndex, "results.getRiver().getWstUnit()" })); - header.add(exportContextCSV.msg(DurationWaterlevel.getHeaderFloodDurPerYear(), args)); - header.add(exportContextCSV.msg(DurationWaterlevel.getHeaderQ(), args)); - header.add(exportContextCSV.msg(DurationWaterlevel.getHeaderBezeichn(), args)); - } + // TODO Je vier Spalten der bis zu drei Wasserspiegellagen header.add(exportContextCSV.formatCsvHeader(SInfoResultType.gaugeLabel)); header.add(exportContextCSV.formatCsvHeader(SInfoResultType.location)); exportContextCSV.writeCSVLine(header.toArray(new String[header.size()])); - } - - @Override - protected void writeCSVResultMetadata(final ExportContextCSV exportContextCSV, final FloodDurationCalculationResults results) { - - exportContextCSV.writeCSVWaterlevelMetadata(super.getWst()); // -> export in super? -> TODO - exportContextCSV.writeBlankLine(); - // writer.writeNext(new String[] { "" }); // break line } @Override protected String[] formatCSVRow(final ExportContextCSV exportContextCSV, final FloodDurationCalculationResults results, final ResultRow row) { - // TODO Auto-generated method stub - return formatRow(exportContextCSV, results, row, ExportMode.csv); - } - - @Override - protected String[] formatPDFRow(final ExportContextCSV exportContextCSV, final FloodDurationCalculationResults results, final ResultRow row) { - return formatRow(exportContextCSV, results, row, ExportMode.pdf); - } - - @Override - protected String getJasperFile() { - if (this.waterlevelCount <= 1) - return "/jasper/templates/sinfo.floodduration.jrxml"; // TODO 2 different result-classes? - else - return "/jasper/templates/sinfo.floodduration2.jrxml"; + return this.formatRow(exportContextCSV, results, row); } @Override - protected void addJRTableHeader(final ExportContextCSV exportContextCSV, final MetaAndTableJRDataSource source, - final FloodDurationCalculationResults results) { - /* column headings */ - exportContextCSV.addJRMetadata(source, "station_header", GeneralResultType.station); - exportContextCSV.addJRMetadata(source, "riverside_header", SInfoResultType.riverside); - exportContextCSV.addJRMetadata(source, "inundationduration_header", SInfoResultType.inundationduration); - exportContextCSV.addJRMetadata(source, "inundationduration_q_header", SInfoResultType.inundationdurationq); - exportContextCSV.addJRMetadata(source, "infrastructure_height_header", SInfoResultType.infrastructureHeightFloodDur); - exportContextCSV.addJRMetadata(source, "infrastructure_type_header", SInfoResultType.infrastructuretype); - - // add dynamic headers - - if (this.waterlevelCount == 0 || this.waterlevelCount == 2) { - source.addMetaData("dummy", "dummy"); - source.addMetaData("dummy", "dummy"); - source.addMetaData("dummy", "dummy"); - source.addMetaData("dummy", "dummy"); - } + protected String[] formatPDFRow(final ExportContextCSV exportContextPDF, final FloodDurationCalculationResults results, final ResultRow row) { - for (int i = 0; i < this.waterlevelCount; i++) { - final int naturalIndex = i + 1; - - final Object[] args = new String[] { new StringBuilder().append("_").append(naturalIndex).toString() }; - exportContextCSV.addJRMetadata(source, getPdfHeader("w", naturalIndex), exportContextCSV.msg(DurationWaterlevel.getHeaderW(), args)); - exportContextCSV.addJRMetadata(source, getPdfHeader("duration", naturalIndex), - exportContextCSV.msg(DurationWaterlevel.getHeaderFloodDurPerYear(), args)); - exportContextCSV.addJRMetadata(source, getPdfHeader("q", naturalIndex), exportContextCSV.msg(DurationWaterlevel.getHeaderQ(), args)); - exportContextCSV.addJRMetadata(source, getPdfHeader("bezeichnung", naturalIndex), - exportContextCSV.msg(DurationWaterlevel.getHeaderBezeichn(), args)); - - } - - exportContextCSV.addJRMetadata(source, "gauge_header", SInfoResultType.gaugeLabel); - exportContextCSV.addJRMetadata(source, "location_header", SInfoResultType.location); - - } - - public int getWaterlevelCount() { // der exporter muss daran, um spalten auszublenden - return this.waterlevelCount; + return this.formatRow(exportContextPDF, results, row); } - private String[] formatRow(final ExportContextCSV exportContextCSV, final FloodDurationCalculationResults results, final ResultRow row, - final ExportMode mode) { - - final Collection<String> lines = new ArrayList<>(99); - - lines.add(exportContextCSV.formatRowValue(row, GeneralResultType.station)); - lines.add(exportContextCSV.formatRowValue(row, SInfoResultType.riverside)); - lines.add(exportContextCSV.formatRowValue(row, SInfoResultType.inundationduration)); - lines.add(exportContextCSV.formatRowValue(row, SInfoResultType.inundationdurationq)); - lines.add(exportContextCSV.formatRowValue(row, SInfoResultType.infrastructureHeight)); - lines.add(exportContextCSV.formatRowValue(row, SInfoResultType.infrastructuretype)); - - final List<DurationWaterlevel> waterlevelList = (List<DurationWaterlevel>) row.getValue(SInfoResultType.customMultiRowColWaterlevel); - if (waterlevelList != null) { - final NumberFormat wFormatter = exportContextCSV.getFlowDepthFormatter(); - final NumberFormat qFormatter = exportContextCSV.getQFormatter(); - - for (int i = 0; i < waterlevelList.size(); i++) { - - if (i == this.maxWaterlevelPdf && mode == ExportMode.pdf) - break; + @Override + protected void addJRTableHeader(final ExportContextCSV exportContextPDF, final MetaAndTableJRDataSource source, + final FloodDurationCalculationResults results) { - final DurationWaterlevel item = waterlevelList.get(i); - lines.add(item.getWFormatted(wFormatter)); - lines.add(item.getFloodDurDaysPerYearFormatted()); - lines.add(item.getQFormatted(qFormatter)); - lines.add(item.getBezeichnung()); - } - } + /* column headings */ + exportContextPDF.addJRMetadata(source, "station_header", GeneralResultType.station); + exportContextPDF.addJRMetadata(source, "riverside_header", SInfoResultType.riverside); + exportContextPDF.addJRMetadata(source, "inundationduration_header", SInfoResultType.floodDuration); + exportContextPDF.addJRMetadata(source, "inundationduration_q_header", SInfoResultType.floodDischarge); + exportContextPDF.addJRMetadata(source, "infrastructure_height_header", SInfoResultType.infrastructureHeightFloodDur); + exportContextPDF.addJRMetadata(source, "infrastructure_type_header", SInfoResultType.infrastructuretype); - if ((this.waterlevelCount == 0 || this.waterlevelCount == 2) && mode == ExportMode.pdf) { - lines.add("dummy"); - lines.add("dummy"); - lines.add("dummy"); - lines.add("dummy"); - } + // TODO Je vier Spalten der bis zu drei Wasserspiegellagen - lines.add(exportContextCSV.formatRowValue(row, SInfoResultType.gaugeLabel)); - lines.add(exportContextCSV.formatRowValue(row, SInfoResultType.location)); - return lines.toArray(new String[lines.size()]); - } - - private String getPdfHeader(final String rootStr, final int index) { - final String hd = "_header"; - final StringBuilder builder = new StringBuilder(); - return builder.append(rootStr).append("_").append(index).append(hd).toString(); + exportContextPDF.addJRMetadata(source, "gauge_header", SInfoResultType.gaugeLabel); + exportContextPDF.addJRMetadata(source, "location_header", SInfoResultType.location); } } \ No newline at end of file
--- a/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/FloodDurationCalculationResults.java Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/FloodDurationCalculationResults.java Tue Jun 26 20:04:56 2018 +0200 @@ -9,6 +9,8 @@ */ package org.dive4elements.river.artifacts.sinfo.flood_duration; +import java.util.List; + import org.apache.commons.lang.math.DoubleRange; import org.dive4elements.river.artifacts.common.AbstractCalculationExportableResult; import org.dive4elements.river.artifacts.common.AbstractCalculationResults; @@ -21,12 +23,18 @@ private static final long serialVersionUID = 1L; - private final String riverside; - - public FloodDurationCalculationResults(final String calcModeLabel, final String user, final RiverInfo river, final DoubleRange calcRange, - final String riverside) { + public FloodDurationCalculationResults(final String calcModeLabel, final String user, final RiverInfo river, final DoubleRange calcRange) { super(calcModeLabel, user, river, calcRange); - this.riverside = riverside; // lieber in Result? } + /** + * We know that this type of results only has one result member, so we can directly access it. + */ + public FloodDurationCalculationResult getResult() { + final List<AbstractCalculationExportableResult<FloodDurationCalculationResults>> results = getResults(); + if (results.size() < 1) + return null; + + return (FloodDurationCalculationResult) results.get(0); + } } \ No newline at end of file
--- a/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/FloodDurationCalculator.java Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/FloodDurationCalculator.java Tue Jun 26 20:04:56 2018 +0200 @@ -11,20 +11,29 @@ import java.util.ArrayList; import java.util.Collection; -import java.util.List; +import java.util.HashMap; +import java.util.Map; import org.apache.commons.lang.math.DoubleRange; import org.dive4elements.artifacts.CallContext; import org.dive4elements.river.artifacts.common.GeneralResultType; import org.dive4elements.river.artifacts.common.ResultRow; import org.dive4elements.river.artifacts.model.Calculation; +import org.dive4elements.river.artifacts.sinfo.common.GaugeDurationValuesFinder; import org.dive4elements.river.artifacts.sinfo.common.RiverInfoProvider; import org.dive4elements.river.artifacts.sinfo.common.SInfoResultType; +import org.dive4elements.river.artifacts.sinfo.common.WQBaseTableFinder; +import org.dive4elements.river.artifacts.sinfo.flood_duration.RiversideRadioChoice.RiversideChoiceKey; import org.dive4elements.river.artifacts.sinfo.util.RiverInfo; -import org.dive4elements.river.artifacts.sinfo.util.WstInfo; +import org.dive4elements.river.model.Attribute.AttributeKey; +import org.dive4elements.river.model.Gauge; +import org.dive4elements.river.model.sinfo.InfrastructureValue; /** - * @author Gernot Belger + * Calculation of the result rows of the flood duration of the infrastructures in a river km range + * and selected main value durations + * + * @author Matthias Schäfer */ final class FloodDurationCalculator { @@ -34,52 +43,66 @@ private final CallContext context; + public FloodDurationCalculator(final CallContext context, final RiverInfoProvider riverInfoProvider) { this.context = context; this.riverInfoProvider = riverInfoProvider; } - public FloodDurationCalculationResults execute(final Calculation problems, final String label, final WstInfo wstInfo, final String calcModeLabel, - final DoubleRange calcRange, final String riverside, final String user) { + /** + * Calculate the result rows + * + * @return a result collection with one result + */ + public FloodDurationCalculationResults execute(final Calculation problems, final String label, final String calcModeLabel, + final DoubleRange calcRange, final RiversideChoiceKey riverside, final String user) { - calculateResultRow(8888.888); - calculateResultRow(99); - calculateResultRow(77); - final boolean hasTkh = false; // TODO tkh richtig machen, oder anderen result-Type wählen als super-klasse für FloodDurationCalculationResult + final WQBaseTableFinder wqFinder = WQBaseTableFinder.loadValues(this.riverInfoProvider.getRiver(), calcRange.getMinimumDouble(), + calcRange.getMaximumDouble(), problems); + final Map<Gauge, GaugeDurationValuesFinder> durFinders = new HashMap<>(); + for (final Gauge gauge : this.riverInfoProvider.getRiver().determineGauges(calcRange.getMinimumDouble(), calcRange.getMaximumDouble())) { + durFinders.put(gauge, GaugeDurationValuesFinder.loadValues(gauge, problems)); + } + final AttributeKey bankKey = riverside.getAttributeKey(); + for (final InfrastructureValue infrastructure : InfrastructureValue.getValues(this.riverInfoProvider.getRiver(), calcRange.getMinimumDouble(), + calcRange.getMaximumDouble(), bankKey)) { + calculateResultRow(infrastructure, wqFinder, durFinders); + } - final FloodDurationCalculationResult result = new FloodDurationCalculationResult(label, wstInfo, this.rows, false, 4); + final FloodDurationCalculationResult result = new FloodDurationCalculationResult(label, this.rows); final RiverInfo riverInfo = new RiverInfo(this.riverInfoProvider.getRiver()); - final FloodDurationCalculationResults results = new FloodDurationCalculationResults(calcModeLabel, user, riverInfo, calcRange, riverside); + final FloodDurationCalculationResults results = new FloodDurationCalculationResults(calcModeLabel, user, riverInfo, calcRange); results.addResult(result, problems); return results; } - private void calculateResultRow(final double station) { + /** + * Calculate the result row for one infrastructure + */ + private void calculateResultRow(final InfrastructureValue infrastructure, final WQBaseTableFinder wqFinder, + final Map<Gauge, GaugeDurationValuesFinder> durFinders) { final ResultRow row = ResultRow.create(); + final Gauge gauge = this.riverInfoProvider.getGauge(infrastructure.getStation(), true); + final double q = wqFinder.getDischarge(infrastructure.getStation(), infrastructure.getHeight()); + final double qOut = Double.isInfinite(q) ? Double.NaN : q; // REMARK: access the location once only during calculation - final String location = this.riverInfoProvider.getLocation(station); - row.putValue(GeneralResultType.station, station); - row.putValue(SInfoResultType.riverside, "todo:getRiverside"); - row.putValue(SInfoResultType.inundationduration, 44); - row.putValue(SInfoResultType.inundationdurationq, 444); - row.putValue(SInfoResultType.infrastructureHeight, 55); - row.putValue(SInfoResultType.infrastructuretype, "todo_get_infrastructureType"); + final String location = this.riverInfoProvider.getLocation(infrastructure.getStation()); + row.putValue(GeneralResultType.station, infrastructure.getStation()); + row.putValue(SInfoResultType.riverside, infrastructure.getAttributeKey().getName()); // TODO i18n + row.putValue(SInfoResultType.floodDuration, 365 - durFinders.get(gauge).getDuration(q)); + row.putValue(SInfoResultType.floodDischarge, qOut); + row.putValue(SInfoResultType.infrastructureHeight, infrastructure.getHeight()); + row.putValue(SInfoResultType.infrastructuretype, infrastructure.getInfrastructure().getType().getName()); - // custom type; each entry produces 4 Columns - final List<DurationWaterlevel> rowWsps = new ArrayList<>(); + // TODO Berechne W, Überflutungsdauer, Q und Bezeichnung von bis zu drei WSPL + // row.putValue(SInfoResultType.customMultiRowColWaterlevel, rowWsps); - rowWsps.add(new DurationWaterlevel(222, 30, 666, "1. Test")); - rowWsps.add(new DurationWaterlevel(111, 40, 555, "2. Test")); - rowWsps.add(new DurationWaterlevel(123, 333, 33, "3. Test")); - rowWsps.add(new DurationWaterlevel(444, 452, 55, "4. Test")); - row.putValue(SInfoResultType.customMultiRowColWaterlevel, rowWsps); - - row.putValue(SInfoResultType.gaugeLabel, "todo:getReferencedGauge"); - row.putValue(SInfoResultType.location, "location"); + row.putValue(SInfoResultType.gaugeLabel, gauge.getName()); + row.putValue(SInfoResultType.location, location); this.rows.add(row); }
--- a/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/FloodDurationExporter.java Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/FloodDurationExporter.java Tue Jun 26 20:04:56 2018 +0200 @@ -31,39 +31,6 @@ public class FloodDurationExporter extends AbstractCommonExporter<FloodDurationCalculationResults> { @Override - protected void doWritePdf(final OutputStream out, final FloodDurationCalculationResults results) { - - // TODO: Move to super (hier ist aber spezieller code drin...) - try { - final ExportContextCSV exportContextCSV = new ExportContextCSV(this.context, null); - - final JasperReporter reporter = new JasperReporter(); - - for (final AbstractCalculationExportableResult<FloodDurationCalculationResults> result : results.getResults()) { - final MetaAndTableJRDataSource source = new MetaAndTableJRDataSource(); - getHelper().addJRMetaDataUSINFO(source, results); - - final JasperDesigner design = result.addReport(exportContextCSV, results, reporter, source); - if (result instanceof FloodDurationCalculationResult) { - final int wlCount = ((FloodDurationCalculationResult) result).getWaterlevelCount(); - if (wlCount == 0 || wlCount == 2) { - design.removeColumn("wOpt"); - design.removeColumn("qOpt"); - design.removeColumn("bezOpt"); - design.removeColumn("durOpt"); - } - } - } - - reporter.exportPDF(out); - } - catch (final JRException je) { - getLog().warn("Error generating PDF Report!", je); - } - - } - - @Override protected void doWriteCSVData(final CSVWriter writer, final FloodDurationCalculationResults results) { // TODO: Diesen Ablauf in super? @@ -96,4 +63,36 @@ } + @Override + protected void doWritePdf(final OutputStream out, final FloodDurationCalculationResults results) { + + // TODO: Move to super (hier ist aber spezieller code drin...) + try { + final ExportContextCSV exportContextCSV = new ExportContextCSV(this.context, null); + + final JasperReporter reporter = new JasperReporter(); + + for (final AbstractCalculationExportableResult<FloodDurationCalculationResults> result : results.getResults()) { + final MetaAndTableJRDataSource source = new MetaAndTableJRDataSource(); + getHelper().addJRMetaDataUSINFO(source, results); + + final JasperDesigner design = result.addReport(exportContextCSV, results, reporter, source); + if (result instanceof FloodDurationCalculationResult) { + // final int wlCount = ((FloodDurationCalculationResult) result).getWaterlevelCount(); + // if (wlCount == 0 || wlCount == 2) { + design.removeColumn("wOpt"); + design.removeColumn("qOpt"); + design.removeColumn("bezOpt"); + design.removeColumn("durOpt"); + // } + } + } + + reporter.exportPDF(out); + } + catch (final JRException je) { + getLog().warn("Error generating PDF Report!", je); + } + + } } \ No newline at end of file
--- a/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/FloodDurationState.java Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/FloodDurationState.java Tue Jun 26 20:04:56 2018 +0200 @@ -14,19 +14,23 @@ import org.dive4elements.artifacts.CallContext; import org.dive4elements.river.artifacts.ChartArtifact; import org.dive4elements.river.artifacts.D4EArtifact; -import org.dive4elements.river.artifacts.common.AbstractCalculationExportableResult; +import org.dive4elements.river.artifacts.model.Calculation; import org.dive4elements.river.artifacts.model.CalculationResult; import org.dive4elements.river.artifacts.model.DataFacet; import org.dive4elements.river.artifacts.model.EmptyFacet; import org.dive4elements.river.artifacts.model.FacetTypes; +import org.dive4elements.river.artifacts.model.ReportFacet; import org.dive4elements.river.artifacts.sinfo.SINFOArtifact; +import org.dive4elements.river.artifacts.sinfo.common.FloodDurationProcessor; import org.dive4elements.river.artifacts.states.DefaultState; -/** State in which a waterlevel has been calculated. */ +/** + * Last state of the S-Info flood duration workflow that calculates and outputs the result + */ public class FloodDurationState extends DefaultState { /// ** The log that is used in this state. */ - // private static Logger log = Logger.getLogger(FlowDepthState.class); + // private static Logger log = Logger.getLogger(FloodDurationState.class); private static final long serialVersionUID = 1L; @@ -44,7 +48,6 @@ facets.add(new EmptyFacet()); return null; } - return compute((SINFOArtifact) artifact, context, hash, facets, old); } @@ -71,32 +74,21 @@ return res; final FloodDurationCalculationResults results = (FloodDurationCalculationResults) res.getData(); - - /* add themes for chart, for each result */ - final List<AbstractCalculationExportableResult<FloodDurationCalculationResults>> resultList = results.getResults(); - for (int index = 0; index < resultList.size(); index++) { + final FloodDurationCalculationResult result = results.getResult(); + if (result != null) { + // add themes for chart + final int index = 0; - final AbstractCalculationExportableResult<FloodDurationCalculationResults> result = resultList.get(0); + facets.add(FloodDurationProcessor.createFloodDurationFacet(context, hash, this.id, result, index)); + facets.add(FloodDurationProcessor.createMainValueDurationFacet(context, hash, this.id, result, index)); - /* filtered (zoom dependent mean) flow depth TODO: */ - // facets.add(FloodDurationProcessor.createFlowDepthFilteredFacet(context, hash, this.id, result, index)); - // facets.add(FloodDurationProcessor.createFlowDepthRawFacet(context, hash, this.id, result, index)); - + facets.add(new DataFacet(FacetTypes.CSV, "CSV data", ComputeType.ADVANCE, hash, this.id)); + facets.add(new DataFacet(FacetTypes.PDF, "PDF data", ComputeType.ADVANCE, hash, this.id)); } - if (!resultList.isEmpty()) { - final Facet csv = new DataFacet(FacetTypes.CSV, "CSV data", ComputeType.ADVANCE, hash, this.id); - final Facet pdf = new DataFacet(FacetTypes.PDF, "PDF data", ComputeType.ADVANCE, hash, this.id); - - facets.add(csv); - facets.add(pdf); - } - - // final Calculation report = res.getReport(); - // - // if (report.hasProblems()) { - // facets.add(new ReportFacet(ComputeType.ADVANCE, hash, this.id)); - // } + final Calculation report = res.getReport(); + if (report.hasProblems()) + facets.add(new ReportFacet(ComputeType.ADVANCE, hash, this.id)); return res; }
--- a/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/RiversideRadioChoice.java Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/sinfo/flood_duration/RiversideRadioChoice.java Tue Jun 26 20:04:56 2018 +0200 @@ -13,23 +13,62 @@ import org.dive4elements.artifacts.Artifact; import org.dive4elements.artifacts.CallMeta; import org.dive4elements.river.artifacts.states.RadioSelect; +import org.dive4elements.river.model.Attribute.AttributeKey; /** * @author <a href="mailto:ingo.weinzierl@intevation.de">Ingo Weinzierl</a> */ public class RiversideRadioChoice extends RadioSelect { + private static final long serialVersionUID = 1L; + /***** TYPES *****/ + + public enum RiversideChoiceKey { + NONE("", AttributeKey.NONE), // + LEFT("state.sinfo.riverside.left", AttributeKey.LEFT), // + RIGHT("state.sinfo.riverside.right", AttributeKey.RIGHT), // + BOTH("state.sinfo.riverside.both", AttributeKey.UNKNOWN); + + private final String key; + private final AttributeKey attributeKey; + + RiversideChoiceKey(final String key, final AttributeKey attributeKey) { + this.key = key; + this.attributeKey = attributeKey; + } + + public static RiversideChoiceKey fromKey(final String key) { + for (final RiversideChoiceKey v : values()) { + if (key.equalsIgnoreCase(v.key)) + return v; + } + return NONE; + } + + public String getKey() { + return this.key; + } + + public AttributeKey getAttributeKey() { + return this.attributeKey; + } + } + + /***** CONSTRUCTORS *****/ + public RiversideRadioChoice() { super(); } + /***** METHODS *****/ + @Override protected LinkedHashMap<String, String> makeEntries(final CallMeta meta, final Artifact artifact) { final LinkedHashMap<String, String> entries = new LinkedHashMap<>(); - entries.put("state.sinfo.riverside.left", null); - entries.put("state.sinfo.riverside.right", null); - entries.put("state.sinfo.riverside.both", null); + entries.put(RiversideChoiceKey.LEFT.getKey(), null); + entries.put(RiversideChoiceKey.RIGHT.getKey(), null); + entries.put(RiversideChoiceKey.BOTH.getKey(), null); return entries; } } \ No newline at end of file
--- a/artifacts/src/main/resources/messages.properties Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/src/main/resources/messages.properties Tue Jun 26 20:04:56 2018 +0200 @@ -922,11 +922,11 @@ sinfo.export.flow_depth.csv.header.location = Lage sinfo.export.flood_duration.csv.header.riverside = Uferseite sinfo.export.flood_duration.csv.header.infrastructure.height = H\u00f6he der Infrastruktur -sinfo.export.flood_duration.csv.header.inundation_duration = \u00dcberflutungsdauer [d/a] -sinfo.export.flood_duration.csv.header.inundation_duration_q = \u00dcberflutungsdauerabfluss Q[m\u00b3/s] +sinfo.export.flood_duration.csv.header.duration = \u00dcberflutungsdauer [d/a] +sinfo.export.flood_duration.csv.header.discharge = \u00dcberflutungsdauerabfluss Q sinfo.export.flood_duration.csv.header.infrastructure_type = Infrastrukturtyp -sinfo.export.flood_duration.pdf.header.inundation_duration = \u00dcberflu-tungs-dauer [d/a] -sinfo.export.flood_duration.pdf.header.inundation_duration_q = \u00dcberflu-tungs-dauer-abfluss Q[m\u00b3/s] +sinfo.export.flood_duration.pdf.header.duration = \u00dcber-flutungs-dauer [d/a] +sinfo.export.flood_duration.pdf.header.discharge = \u00dcber-flutungs-dauer-abfluss Q [m\u00b3/s] sinfo.export.flood_duration.pdf.header.infrastructure_type = Infra-struktur-typ sinfo.export.flood_duration.pdf.header.infrastructure.height = H\u00f6he der Infra-struktur @@ -1113,7 +1113,7 @@ sinfo.export.csv.header.collision.count = Anzahl der Grundber\u00fchrungen collision.count.title = Grundber\u00fchrungen {0} chart.collision_count.section.yaxis.label = H\u00e4ufigkeit -sinfo.export.csv.header.collision.gaugew = W am Pegel +sinfo.export.csv.header.collision.gaugew = Pegelstand collision.gaugew.title = W am Pegel {0} sinfo.export.csv.header.discharge.zone = Abflusszustand @@ -1123,6 +1123,17 @@ sinfo.chart.collision.section.title = Grundber\u00fchrungen +sinfo.chart.flood_duration.section.title = \u00dcberflutungsdauer Infrastrukturen BWaStr +sinfo.chart.flood_duration.section.yaxis.label = \u00dcberflutungsdauer [d/a] +sinfo_facet_flood_duration = \u00dcberflutungsdauern +sinfo_facet_flood_duration.description = \u00dcberflutungsdauern ({0}) +gauge_duration.missing = Keine Dauerzahlen vorhanden am Pegel {0} +gauge_discharge_table.missing = No discharge table available for gauge {0} +gauge_main_values.missing = No named main values available for gauge {0} +wq_base_data.missing = No base waterlevel/discharge available +mainvalue.duration = \u00dcberflutungsdauer +mainvalue.duration.description = \u00dcberflutungsdauer ({0}) + bundu_bezugswst = Bezugswasserst\u00e4nde bundu_analysis = Fixinganalysis bundu_vollmer = relocated Waterlevel Calculation
--- a/artifacts/src/main/resources/messages_de.properties Tue Jun 26 19:48:35 2018 +0200 +++ b/artifacts/src/main/resources/messages_de.properties Tue Jun 26 20:04:56 2018 +0200 @@ -922,11 +922,11 @@ sinfo.export.flow_depth.csv.header.location = Lage sinfo.export.flood_duration.csv.header.riverside = Uferseite sinfo.export.flood_duration.csv.header.infrastructure.height = H\u00f6he der Infrastruktur -sinfo.export.flood_duration.csv.header.inundation_duration = \u00dcberflutungsdauer [d/a] -sinfo.export.flood_duration.csv.header.inundation_duration_q = \u00dcberflutungsdauerabfluss Q[m\u00b3/s] +sinfo.export.flood_duration.csv.header.duration = \u00dcberflutungsdauer [d/a] +sinfo.export.flood_duration.csv.header.discharge = \u00dcberflutungsdauerabfluss Q sinfo.export.flood_duration.csv.header.infrastructure_type = Infrastrukturtyp -sinfo.export.flood_duration.pdf.header.inundation_duration = \u00dcberflu-tungs-dauer [d/a] -sinfo.export.flood_duration.pdf.header.inundation_duration_q = \u00dcberflu-tungs-dauer-abfluss Q[m\u00b3/s] +sinfo.export.flood_duration.pdf.header.duration = \u00dcber-flutungs-dauer [d/a] +sinfo.export.flood_duration.pdf.header.discharge = \u00dcber-flutungs-dauer-abfluss Q [m\u00b3/s] sinfo.export.flood_duration.pdf.header.infrastructure_type = Infra-struktur-typ sinfo.export.flood_duration.pdf.header.infrastructure.height = H\u00f6he der Infra-struktur @@ -1113,7 +1113,7 @@ sinfo.export.csv.header.collision.count = Anzahl der Grundber\u00fchrungen collision.count.title = Grundber\u00fchrungen {0} chart.collision_count.section.yaxis.label = H\u00e4ufigkeit -sinfo.export.csv.header.collision.gaugew = Pegelstand [cm] +sinfo.export.csv.header.collision.gaugew = Pegelstand collision.gaugew.title = W am Pegel {0} sinfo.export.csv.header.discharge.zone = Abflusszustand @@ -1123,6 +1123,17 @@ sinfo.chart.collision.section.title = Grundber\u00fchrungen +sinfo.chart.flood_duration.section.title = \u00dcberflutungsdauer Infrastrukturen BWaStr +sinfo.chart.flood_duration.section.yaxis.label = \u00dcberflutungsdauer [d/a] +sinfo_facet_flood_duration = \u00dcberflutungsdauern +sinfo_facet_flood_duration.description = \u00dcberflutungsdauern ({0}) +gauge_duration.missing = Dauerzahlen fehlen am Pegel {0} +gauge_discharge_table.missing = Abflusstafel fehlt am Pegel {0} +gauge_main_values.missing = Hauptwerte fehlen am Pegel {0} +wq_base_data.missing = W/Q-Daten fehlen oder sind ung\00fcltig +mainvalue.duration = \u00dcberflutungsdauer +mainvalue.duration.description = \u00dcberflutungsdauer ({0}) + bundu_bezugswst = Bezugswasserst\u00e4nde bundu_analysis = Fixierungsanalyse bundu_vollmer = ausgelagerte Wasserspiegellage
--- a/backend/src/main/java/org/dive4elements/river/model/Annotation.java Tue Jun 26 19:48:35 2018 +0200 +++ b/backend/src/main/java/org/dive4elements/river/model/Annotation.java Tue Jun 26 20:04:56 2018 +0200 @@ -10,15 +10,18 @@ import java.io.Serializable; +import javax.persistence.Column; import javax.persistence.Entity; -import javax.persistence.Id; -import javax.persistence.Table; import javax.persistence.GeneratedValue; -import javax.persistence.Column; +import javax.persistence.GenerationType; +import javax.persistence.Id; +import javax.persistence.JoinColumn; +import javax.persistence.OneToOne; import javax.persistence.SequenceGenerator; -import javax.persistence.GenerationType; -import javax.persistence.OneToOne; -import javax.persistence.JoinColumn; +import javax.persistence.Table; +import javax.persistence.Transient; + +import org.dive4elements.river.model.Attribute.AttributeKey; @Entity @Table(name = "annotations") @@ -36,12 +39,12 @@ } public Annotation( - Range range, - Attribute attribute, - Position position, - Edge edge, - AnnotationType type - ) { + final Range range, + final Attribute attribute, + final Position position, + final Edge edge, + final AnnotationType type + ) { this.range = range; this.attribute = attribute; this.position = position; @@ -51,68 +54,73 @@ @Id @SequenceGenerator( - name = "SEQUENCE_ANNOTATIONS_ID_SEQ", - sequenceName = "ANNOTATIONS_ID_SEQ", - allocationSize = 1) + name = "SEQUENCE_ANNOTATIONS_ID_SEQ", + sequenceName = "ANNOTATIONS_ID_SEQ", + allocationSize = 1) @GeneratedValue( - strategy = GenerationType.SEQUENCE, - generator = "SEQUENCE_ANNOTATIONS_ID_SEQ") + strategy = GenerationType.SEQUENCE, + generator = "SEQUENCE_ANNOTATIONS_ID_SEQ") @Column(name = "id") public Integer getId() { - return id; + return this.id; } - public void setId(Integer id) { + public void setId(final Integer id) { this.id = id; } @OneToOne @JoinColumn(name = "range_id") public Range getRange() { - return range; + return this.range; } - public void setRange(Range range) { + public void setRange(final Range range) { this.range = range; } @OneToOne @JoinColumn(name = "attribute_id") public Attribute getAttribute() { - return attribute; + return this.attribute; } - public void setAttribute(Attribute attribute) { + public void setAttribute(final Attribute attribute) { this.attribute = attribute; } + @Transient + public AttributeKey getAttributeKey() { + return this.getAttribute().getKey(); + } + @OneToOne @JoinColumn(name = "position_id") public Position getPosition() { - return position; + return this.position; } - public void setPosition(Position position) { + public void setPosition(final Position position) { this.position = position; } @OneToOne @JoinColumn(name = "edge_id") public Edge getEdge() { - return edge; + return this.edge; } - public void setEdge(Edge edge) { + public void setEdge(final Edge edge) { this.edge = edge; } @OneToOne @JoinColumn(name = "type_id") public AnnotationType getType() { - return type; + return this.type; } - public void setType(AnnotationType type) { + public void setType(final AnnotationType type) { this.type = type; } }
--- a/backend/src/main/java/org/dive4elements/river/model/Attribute.java Tue Jun 26 19:48:35 2018 +0200 +++ b/backend/src/main/java/org/dive4elements/river/model/Attribute.java Tue Jun 26 20:04:56 2018 +0200 @@ -9,20 +9,124 @@ package org.dive4elements.river.model; import java.io.Serializable; +import java.util.List; +import javax.persistence.Column; import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; import javax.persistence.Id; +import javax.persistence.SequenceGenerator; import javax.persistence.Table; -import javax.persistence.GeneratedValue; -import javax.persistence.Column; -import javax.persistence.SequenceGenerator; -import javax.persistence.GenerationType; +import javax.persistence.Transient; + +import org.dive4elements.river.backend.SessionHolder; +import org.hibernate.Query; +import org.hibernate.Session; @Entity @Table(name = "attributes") public class Attribute implements Serializable { + + /***** TYPES *****/ + + /** + * River attribute (river side or range type) + * + */ + public enum AttributeKey { + NONE(""), STRECKE(">>>>>>>>>>>>>>>"), LEFT("links"), RIGHT("rechts"), UNKNOWN("?"); + + private final String name; + private int id; + private boolean ready; + + AttributeKey(final String name) { + this.name = name; + this.id = 0; + this.ready = false; + } + + /** + * Type name in the database + */ + public String getName() { + return this.name; + } + + /** + * Type id in the database + */ + public int getId() { + initFromDatabase(); + return this.id; + } + + /** + * Set the type id + */ + public void setId(final int id) { + this.id = id; + } + + protected boolean getReady() { + return this.ready; + } + + protected void setReady(final boolean ready) { + this.ready = ready; + } + + /** + * Main value type key for a database name value + */ + public static AttributeKey forDbName(final String dbname) { + initFromDatabase(); + for (final AttributeKey k : AttributeKey.values()) { + if (k.getName().equalsIgnoreCase(dbname)) + return k; + } + return UNKNOWN; + } + + /** + * Main value type key for a database id value + */ + public static AttributeKey forDbId(final int dbid) { + initFromDatabase(); + for (final AttributeKey k : AttributeKey.values()) { + if (k.getId() == dbid) + return k; + } + return UNKNOWN; + } + + /** + * Initially queries the database ids + */ + private static void initFromDatabase() { + if (STRECKE.getReady()) + return; + // Avoid recursion + for (final AttributeKey k : AttributeKey.values()) + k.setReady(true); + // Select database ids + final Session session = SessionHolder.HOLDER.get(); + final Query query = session.createQuery("FROM Attribute"); + final List<Attribute> rows = query.list(); + if (!rows.isEmpty()) { + for (int i = 0; i <= rows.size() - 1; i++) { + if (forDbName(rows.get(i).getValue()) != UNKNOWN) + forDbName(rows.get(i).getValue()).setId(rows.get(i).getId()); + } + } + } + } + + /***** FIELDS *****/ + private Integer id; private String value; @@ -30,34 +134,43 @@ public Attribute() { } - public Attribute(String value) { + /***** CONSTRUCTORS *****/ + + public Attribute(final String value) { this.value = value; } + /***** METHODS *****/ + @Id @SequenceGenerator( - name = "SEQUENCE_ATTRIBUTES_ID_SEQ", - sequenceName = "ATTRIBUTES_ID_SEQ", - allocationSize = 1) + name = "SEQUENCE_ATTRIBUTES_ID_SEQ", + sequenceName = "ATTRIBUTES_ID_SEQ", + allocationSize = 1) @GeneratedValue( - strategy = GenerationType.SEQUENCE, - generator = "SEQUENCE_ATTRIBUTES_ID_SEQ") + strategy = GenerationType.SEQUENCE, + generator = "SEQUENCE_ATTRIBUTES_ID_SEQ") @Column(name = "id") public Integer getId() { - return id; + return this.id; } - public void setId(Integer id) { + public void setId(final Integer id) { this.id = id; } @Column(name = "value") public String getValue() { - return value; + return this.value; } - public void setValue(String value) { + public void setValue(final String value) { this.value = value; } + + @Transient + public AttributeKey getKey() { + return AttributeKey.forDbId(this.getId()); + } } // vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :
--- a/backend/src/main/java/org/dive4elements/river/model/MainValue.java Tue Jun 26 19:48:35 2018 +0200 +++ b/backend/src/main/java/org/dive4elements/river/model/MainValue.java Tue Jun 26 20:04:56 2018 +0200 @@ -128,5 +128,19 @@ query.setParameter("typeid", typekey.getId()); return query.list(); } + + /** + * Selects from the database the discharge-duration main values of a gauge sorted by duration + */ + public static List<MainValue> getDurationDischargesOfGauge(final Gauge gauge) { + final Session session = SessionHolder.HOLDER.get(); + final Query query = session.createQuery("SELECT mv" + + " FROM MainValue AS mv JOIN mv.mainValue AS nmv" + + " WHERE mv.gauge.id=:gaugeid AND nmv.type.id=:typeid" + + " ORDER BY CAST(nmv.name AS int)"); + query.setParameter("gaugeid", gauge.getId()); + query.setParameter("typeid", MainValueTypeKey.DURATION.getId()); + return query.list(); + } } // vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :
--- a/backend/src/main/java/org/dive4elements/river/model/sinfo/Infrastructure.java Tue Jun 26 19:48:35 2018 +0200 +++ b/backend/src/main/java/org/dive4elements/river/model/sinfo/Infrastructure.java Tue Jun 26 20:04:56 2018 +0200 @@ -199,4 +199,18 @@ query.setParameter("id", id); return (Infrastructure) query.list().get(0); } + + /** + * Get first data series of a river + */ + public static Infrastructure getSeries(final River river) { + final Session session = SessionHolder.HOLDER.get(); + final Query query = session.createQuery("FROM Infrastructure WHERE (river=:river)"); + query.setParameter("river", river); + final List rows = query.list(); + if (!rows.isEmpty()) + return (Infrastructure) rows.get(0); + else + return null; + } } \ No newline at end of file
--- a/backend/src/main/java/org/dive4elements/river/model/sinfo/InfrastructureValue.java Tue Jun 26 19:48:35 2018 +0200 +++ b/backend/src/main/java/org/dive4elements/river/model/sinfo/InfrastructureValue.java Tue Jun 26 20:04:56 2018 +0200 @@ -22,9 +22,12 @@ import javax.persistence.OneToOne; import javax.persistence.SequenceGenerator; import javax.persistence.Table; +import javax.persistence.Transient; import org.dive4elements.river.backend.SessionHolder; import org.dive4elements.river.model.Attribute; +import org.dive4elements.river.model.Attribute.AttributeKey; +import org.dive4elements.river.model.River; import org.hibernate.Query; import org.hibernate.Session; @@ -117,6 +120,11 @@ this.attribute = attribute; } + @Transient + public AttributeKey getAttributeKey() { + return this.getAttribute().getKey(); + } + @Column(name = "height") public Double getHeight() { return this.height; @@ -127,7 +135,7 @@ } /** - * Selects the infrastructure values of a data series in a km range from the database + * Selects from the database the infrastructure values of a data series in a km range */ public static List<InfrastructureValue> getValues(final Infrastructure parent, final double kmLo, final double kmHi) { final Session session = SessionHolder.HOLDER.get(); @@ -138,4 +146,25 @@ query.setParameter("kmHi", new Double(kmHi)); return query.list(); } + + /** + * Selects from the database the infrastructure values of a km range of a river and a river side + */ + public static List<InfrastructureValue> getValues(final River river, final double kmLo, final double kmHi, final AttributeKey riverside) { + final Session session = SessionHolder.HOLDER.get(); + String riversideClause = ""; + if ((riverside == AttributeKey.LEFT) || (riverside == AttributeKey.RIGHT)) + riversideClause = " AND (v.attribute.id=:attr_id)"; + final Query query = session.createQuery("FROM InfrastructureValue v" + + " WHERE (v.infrastructure.river=:river)" + + " AND (v.station BETWEEN :kmLo - 0.0001 AND :kmHi + 0.0001)" + + riversideClause + + " ORDER BY v.station, v.attribute.id"); + query.setParameter("river", river); + query.setParameter("kmLo", new Double(kmLo)); + query.setParameter("kmHi", new Double(kmHi)); + if (!riversideClause.isEmpty()) + query.setParameter("attr_id", riverside.getId()); + return query.list(); + } }
--- a/gwt-client/src/main/java/org/dive4elements/river/client/client/FLYSConstants.java Tue Jun 26 19:48:35 2018 +0200 +++ b/gwt-client/src/main/java/org/dive4elements/river/client/client/FLYSConstants.java Tue Jun 26 20:04:56 2018 +0200 @@ -1538,4 +1538,6 @@ String waterlevel_ground_state(); String error_river_inundationdur_file_not_found(); + + String sinfo_flood_duration(); } \ No newline at end of file
--- a/gwt-client/src/main/java/org/dive4elements/river/client/client/FLYSConstants.properties Tue Jun 26 19:48:35 2018 +0200 +++ b/gwt-client/src/main/java/org/dive4elements/river/client/client/FLYSConstants.properties Tue Jun 26 20:04:56 2018 +0200 @@ -810,6 +810,8 @@ sinfo_collisions = Grundber\u00fchrungen sinfo_collision = Grundber\u00fchrungen +sinfo_flood_duration = \u00dcberflutungsdauer Infrastruktur BWaStr + uinfo = U-INFO uinfo_inundation_duration_export = \u00dcberflutungsdauern Export uinfo_salix_line_export = Salix-Linie Export
--- a/gwt-client/src/main/java/org/dive4elements/river/client/client/FLYSConstants_de.properties Tue Jun 26 19:48:35 2018 +0200 +++ b/gwt-client/src/main/java/org/dive4elements/river/client/client/FLYSConstants_de.properties Tue Jun 26 20:04:56 2018 +0200 @@ -810,6 +810,8 @@ sinfo_collisions = Grundber\u00fchrungen sinfo_collision = Grundber\u00fchrungen +sinfo_flood_duration = \u00dcberflutungsdauer Infrastruktur BWaStr + uinfo = U-INFO uinfo_inundation_duration_export = \u00dcberflutungsdauern Export uinfo_salix_line_export = Salix-Linie Export