Mercurial > dive4elements > river

comparison flys-artifacts/src/main/java/org/dive4elements/river/artifacts/model/Calculation6.java @ 5831:bd047b71ab37

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Repaired internal references
author Sascha L. Teichmann <teichmann@intevation.de>
date Thu, 25 Apr 2013 12:06:39 +0200
parents flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/Calculation6.java@1b73b731f7bd
children
comparison
equal deleted inserted replaced
5830:160f53ee0870 5831:bd047b71ab37
1 package org.dive4elements.river.artifacts.model;
2
3 import java.util.ArrayList;
4 import java.util.Arrays;
5 import java.util.Date;
6 import java.util.List;
7
8 import org.apache.log4j.Logger;
9
10 import org.dive4elements.river.model.DischargeTable;
11 import org.dive4elements.river.model.Gauge;
12 import org.dive4elements.river.model.TimeInterval;
13
14
15 /**
16 * Historical Discharge Calculation.
17 * @author <a href="mailto:ingo.weinzierl@intevation.de">Ingo Weinzierl</a>
18 */
19 public class Calculation6 extends Calculation {
20
21 private static final Logger logger = Logger.getLogger(Calculation6.class);
22
23 private int mode;
24 private long[] timerange;
25 private double[] values;
26
27 public static final int MODE_W = 0;
28 public static final int MODE_Q = 1;
29
30 public static final double SCALE = 1d;
31
32 public Calculation6(int mode, long[] timerange, double[] values) {
33 this.mode = mode;
34 this.timerange = timerange;
35 this.values = values;
36 }
37
38 public CalculationResult calculate(Gauge gauge) {
39 if (!checkParameters() || gauge == null) {
40 logger.warn("Parameters not valid for calculation.");
41
42 return null;
43 }
44
45 if (logger.isDebugEnabled()) {
46 debug();
47 }
48
49 DischargeTable refTable = fetchReferenceTable(gauge);
50 List<DischargeTable> dts = fetchDischargeTables(gauge);
51
52 int numTables = dts.size();
53
54 logger.debug("Take " + numTables + " into account.");
55
56 if (numTables == 0) {
57 addProblem("cannot.find.hist.q.tables");
58 }
59
60 WQTimerange[] wqt = prepareTimerangeData(refTable, dts);
61 WQKms[] wqs = prepareWQData(dts);
62
63 logger.debug("Number of calculation results: " + wqt.length);
64
65 return new CalculationResult(new HistoricalDischargeData(wqt, wqs),
66 this);
67 }
68
69 protected boolean checkParameters() {
70 if (!(mode == MODE_W || mode == MODE_Q)) {
71 logger.warn("Invalid mode '" + mode + "' for calculation.");
72 return false;
73 }
74
75 if (timerange == null || timerange.length < 2) {
76 logger.warn("Invalid timerange for calculation.");
77 return false;
78 }
79
80 if (values == null || values.length == 0) {
81 logger.warn("No values for W or Q specified.");
82 return false;
83 }
84
85 return true;
86 }
87
88 protected DischargeTable fetchReferenceTable(Gauge gauge) {
89 return gauge.fetchMasterDischargeTable();
90 }
91
92 protected List<DischargeTable> fetchDischargeTables(Gauge gauge) {
93 List<DischargeTable> relevant = new ArrayList<DischargeTable>();
94 List<DischargeTable> all = gauge.getDischargeTables();
95
96 for (DischargeTable dt : all) {
97 if (isDischargeTableRelevant(dt)) {
98 relevant.add(dt);
99 }
100 }
101
102 return relevant;
103 }
104
105 /** True if timerange of given discharge table overlaps with timerange. */
106 protected boolean isDischargeTableRelevant(DischargeTable dt) {
107 TimeInterval ti = dt.getTimeInterval();
108
109 if (dt.getKind() == Gauge.MASTER_DISCHARGE_TABLE || ti == null) {
110 return false;
111 }
112
113 Date start = ti.getStartTime();
114 long startTime = start.getTime();
115
116 if (startTime >= timerange[0] && startTime <= timerange[1]) {
117 return true;
118 }
119
120 Date stop = ti.getStopTime();
121 long stopTime = stop != null ? stop.getTime() : -1l;
122
123 if (stopTime >= timerange[0] && stopTime <= timerange[1]) {
124 return true;
125 }
126
127 logger.debug("DischargeTable not in range: " + start + " -> " + stop);
128
129 return false;
130 }
131
132 protected WQTimerange[] prepareTimerangeData(DischargeTable refTable,
133 List<DischargeTable> dts) {
134 if (refTable == null) {
135 addProblem("cannot.find.hist.q.reftable");
136 return prepareSimpleData(dts);
137 }
138 else {
139 return prepareData(refTable, dts);
140 }
141 }
142
143 protected WQKms[] prepareWQData(List<DischargeTable> dts) {
144 WQKms[] wqs = new WQKms[dts.size()];
145
146 int idx = 0;
147
148 for (DischargeTable dt : dts) {
149 double[][] values = null;
150
151 if (dt.getKind() == DischargeTables.MASTER) {
152 values = DischargeTables.loadDischargeTableValues(dt,
153 DischargeTables.MASTER_SCALE);
154
155 }
156 else {
157 values = DischargeTables.loadDischargeTableValues(dt,
158 DischargeTables.HISTORICAL_SCALE);
159
160 }
161
162 wqs[idx++] = prepareWQ(dt, values);
163 }
164
165 return wqs;
166 }
167
168 protected WQKms prepareWQ(DischargeTable dt, double[][] values) {
169 double km = dt.getGauge().getStation().doubleValue();
170
171 double[] kms = new double[values[0].length];
172 Arrays.fill(kms, km);
173
174 return new HistoricalWQKms(kms, values[0], values[1],
175 String.valueOf(km), dt.getTimeInterval());
176 }
177
178 /** Without reference. */
179 protected WQTimerange[] prepareSimpleData(List<DischargeTable> dts) {
180 List<WQTimerange> wqts = new ArrayList<WQTimerange>(values.length);
181
182 for (double value : values) {
183 logger.debug("Prepare data for value: " + value);
184
185 String name = mode == MODE_W ? "W=" + value : "Q=" + value;
186 WQTimerange wqt = null;
187
188 for (DischargeTable dt : dts) {
189 Date[] ti = prepareTimeInterval(dt);
190 Timerange t = new Timerange(ti[0], ti[1]);
191 double w;
192 double q;
193
194 if (mode == MODE_W) {
195 w = value;
196 q = findValueForW(dt, w, DischargeTables.HISTORICAL_SCALE);
197
198 if (Double.isNaN(q)) {
199 logger.warn("Cannot find Q for W: " + w);
200 addProblem("cannot.find.hist.q.for.w", w, ti[0], ti[1]);
201 continue;
202 }
203 }
204 else {
205 q = value;
206 w = findValueForQ(dt, q, DischargeTables.HISTORICAL_SCALE);
207 }
208
209 logger.debug("Q=" + q + " | W=" + w);
210
211 if (wqt == null) {
212 wqt = new WQTimerange(name);
213 }
214
215 wqt.add(w, q, t);
216 }
217
218 if (wqt != null) {
219 wqts.add(wqt);
220 }
221 }
222
223 return wqts.toArray(new WQTimerange[wqts.size()]);
224 }
225
226 /** With reference. */
227 protected HistoricalWQTimerange[] prepareData(DischargeTable refTable,
228 List<DischargeTable> dts) {
229 List<HistoricalWQTimerange> wqts = new ArrayList<HistoricalWQTimerange>(
230 values.length);
231
232 for (double value : values) {
233 logger.debug("Prepare data plus diff for value: " + value);
234
235 String name = mode == MODE_W ? "W=" + value : "Q=" + value;
236 HistoricalWQTimerange wqt = null;
237
238 double ref;
239 double diff;
240
241 if (refTable != null && mode == MODE_W) {
242 ref = findValueForW(refTable, value,
243 DischargeTables.MASTER_SCALE);
244 }
245 else if (refTable != null) {
246 ref = findValueForQ(refTable, value,
247 DischargeTables.MASTER_SCALE);
248 }
249 else {
250 ref = Double.NaN;
251 }
252
253 for (DischargeTable dt : dts) {
254 Date[] ti = prepareTimeInterval(dt);
255
256 Timerange t = new Timerange(ti[0], ti[1]);
257 double w;
258 double q;
259
260 if (mode == MODE_W) {
261 w = value;
262 q = findValueForW(dt, w, DischargeTables.HISTORICAL_SCALE);
263
264 if (Double.isNaN(q)) {
265 logger.warn("Cannot find Q for W: " + w);
266 addProblem("cannot.find.hist.q.for.w", w, ti[0], ti[1]);
267 continue;
268 }
269
270 diff = ref - q;
271 }
272 else {
273 q = value;
274 w = findValueForQ(dt, q, DischargeTables.HISTORICAL_SCALE);
275
276 if (Double.isNaN(w)) {
277 logger.warn("Cannot find W for Q: " + q);
278 addProblem("cannot.find.hist.w.for.q", q, ti[0], ti[1]);
279 continue;
280 }
281 diff = ref - w;
282 }
283
284 logger.debug("Q=" + q + " | W=" + w + " | Ref = " + ref);
285
286 if (wqt == null) {
287 wqt = new HistoricalWQTimerange(name);
288 }
289
290 wqt.add(w, q, diff, t);
291 }
292
293 if (wqt != null) {
294 wqts.add(wqt);
295 }
296 }
297
298 return (HistoricalWQTimerange[]) wqts
299 .toArray(new HistoricalWQTimerange[wqts.size()]);
300 }
301
302 /** Returns discharge table interval as Date[]. */
303 protected Date[] prepareTimeInterval(DischargeTable dt) {
304 TimeInterval ti = dt.getTimeInterval();
305
306 Date start = ti.getStartTime();
307 Date end = ti.getStopTime();
308
309 if (end == null) {
310 logger.warn("TimeInterval has no stop time set!");
311
312 end = new Date();
313 }
314
315 return new Date[] { start, end };
316 }
317
318 protected double findValueForW(DischargeTable dt, double w, double scale) {
319 double[][] vs = DischargeTables.loadDischargeTableValues(dt, scale);
320 double[] qs = DischargeTables.getQsForW(vs, w);
321 return qs.length == 0 ? Double.NaN : qs[0];
322 }
323
324 protected double findValueForQ(DischargeTable dt, double q, double scale) {
325 double[][] vs = DischargeTables.loadDischargeTableValues(dt, scale);
326 double[] ws = DischargeTables.getWsForQ(vs, q);
327
328 return ws.length == 0 ? Double.NaN : ws[0];
329 }
330
331 /**
332 * Writes the parameters used for this calculation to logger.
333 */
334 public void debug() {
335 StringBuilder sb = new StringBuilder();
336 for (double value : values) {
337 sb.append(String.valueOf(value) + " ");
338 }
339
340 logger.debug("========== Calculation6 ==========");
341 logger.debug(" Mode: " + mode);
342 logger.debug(" Timerange: " + timerange[0] + " - " + timerange[1]);
343 logger.debug(" Input values: " + sb.toString());
344 logger.debug("==================================");
345 }
346 }
347 // vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :
http://dive4elements.wald.intevation.org