Mercurial > dive4elements > river
comparison backend/src/main/java/org/dive4elements/river/importer/parsers/SedimentYieldParser.java @ 5838:5aa05a7a34b7
Rename modules to more fitting names.
author | Sascha L. Teichmann <teichmann@intevation.de> |
---|---|
date | Thu, 25 Apr 2013 15:23:37 +0200 |
parents | flys-backend/src/main/java/org/dive4elements/river/importer/parsers/SedimentYieldParser.java@18619c1e7c2a |
children | 4dd33b86dc61 |
comparison
equal
deleted
inserted
replaced
5837:d9901a08d0a6 | 5838:5aa05a7a34b7 |
---|---|
1 package org.dive4elements.river.importer.parsers; | |
2 | |
3 import java.io.File; | |
4 import java.io.IOException; | |
5 | |
6 import java.text.NumberFormat; | |
7 import java.text.ParseException; | |
8 | |
9 import java.util.ArrayList; | |
10 import java.util.List; | |
11 import java.util.regex.Matcher; | |
12 import java.util.regex.Pattern; | |
13 | |
14 import org.apache.log4j.Logger; | |
15 | |
16 import org.dive4elements.river.importer.ImportGrainFraction; | |
17 import org.dive4elements.river.importer.ImportSedimentYield; | |
18 import org.dive4elements.river.importer.ImportSedimentYieldValue; | |
19 import org.dive4elements.river.importer.ImportTimeInterval; | |
20 import org.dive4elements.river.importer.ImportUnit; | |
21 import org.dive4elements.river.model.GrainFraction; | |
22 | |
23 | |
24 public class SedimentYieldParser extends LineParser { | |
25 | |
26 private static final Logger log = | |
27 Logger.getLogger(SedimentYieldParser.class); | |
28 | |
29 | |
30 public static final NumberFormat nf = NumberFormat.getInstance(DEFAULT_LOCALE); | |
31 | |
32 | |
33 public static final String FRAKTION_START = "Fraktion:"; | |
34 | |
35 public static final String FRACTION_COARSE_STR = | |
36 ".*Grobkorn.*"; | |
37 | |
38 public static final String FRACTION_FINE_MIDDLE_STR = | |
39 ".*Fein-Mittel-Kies.*"; | |
40 | |
41 public static final String FRACTION_SAND = | |
42 ".*Sand.*"; | |
43 | |
44 public static final String FRACTION_SUSP_SAND = | |
45 ".*susp_Sand.*"; | |
46 | |
47 public static final String FRACTION_SUSP_SAND_BED = | |
48 ".*bettbild_Anteil_susp_Sand.*"; | |
49 | |
50 public static final String FRACTION_SUSP_SAND_BED_EPOCH = | |
51 ".*susp_Sand_bettbildAnteil.*"; | |
52 | |
53 public static final String FRACTION_SUSPENDED_SEDIMENT = | |
54 ".*Schwebstoff.*"; | |
55 | |
56 public static final String FRACTION_TOTAL = | |
57 ".*gesamt.*"; | |
58 | |
59 | |
60 public static final Pattern TIMEINTERVAL_SINGLE = | |
61 Pattern.compile("\\D*([0-9]+?)\\D*"); | |
62 | |
63 public static final Pattern TIMEINTERVAL_EPOCH = | |
64 Pattern.compile("\\D*([0-9]+?)\\s*-\\s*([0-9]+?)\\D*"); | |
65 | |
66 public static final Pattern META_FRACTION = | |
67 Pattern.compile("^Fraktion: (.*)"); | |
68 | |
69 public static final Pattern META_UNIT = | |
70 Pattern.compile("^Einheit: \\[(.*)\\].*"); | |
71 | |
72 public static final Pattern META_COLUMN_NAMES = | |
73 Pattern.compile("^Fluss-km.*"); | |
74 | |
75 public static final Pattern META_GRAIN_FRACTION_A = | |
76 Pattern.compile("\\D*(([0-9]+?,[0-9]+?)\\s*-|([0-9]++)\\s*-)(([0-9]+?,[0-9]+?)|([0-9]++))\\s*([a-zA-Z]+?)\\W*\\D*"); | |
77 | |
78 public static final Pattern META_GRAIN_FRACTION_B = | |
79 Pattern.compile("(<|>){1}\\s*(\\w++)\\s*(([0-9]+?,[0-9]+?)\\s*-|([0-9]++)\\s*-)(([0-9]+?,[0-9]+?)|([0-9]++))\\s*([a-zA-Z]+?)"); | |
80 | |
81 public static final Pattern META_GRAIN_FRACTION_C = | |
82 Pattern.compile("(<|>){1}\\s*((([0-9]+?,[0-9]+?)|([0-9]++))\\s*(\\w+))"); | |
83 | |
84 | |
85 protected List<ImportSedimentYield> sedimentYields; | |
86 | |
87 protected ImportSedimentYield[] current; | |
88 | |
89 protected ImportGrainFraction grainFraction; | |
90 | |
91 protected ImportUnit unit; | |
92 | |
93 protected String description; | |
94 | |
95 protected String[] columnNames; | |
96 | |
97 | |
98 public SedimentYieldParser() { | |
99 sedimentYields = new ArrayList<ImportSedimentYield>(); | |
100 } | |
101 | |
102 | |
103 @Override | |
104 public void parse(File file) throws IOException { | |
105 description = file.getName(); | |
106 | |
107 super.parse(file); | |
108 } | |
109 | |
110 | |
111 @Override | |
112 protected void reset() { | |
113 current = null; | |
114 grainFraction = null; | |
115 unit = null; | |
116 } | |
117 | |
118 | |
119 @Override | |
120 protected void finish() { | |
121 if (current != null) { | |
122 for (ImportSedimentYield isy: current) { | |
123 sedimentYields.add(isy); | |
124 } | |
125 } | |
126 | |
127 description = null; | |
128 } | |
129 | |
130 | |
131 @Override | |
132 protected void handleLine(int lineNum, String line) { | |
133 if (line.startsWith(START_META_CHAR)) { | |
134 handleMetaLine(stripMetaLine(line)); | |
135 } | |
136 else { | |
137 handleDataLine(line); | |
138 } | |
139 } | |
140 | |
141 | |
142 protected void handleMetaLine(String line) { | |
143 if (handleMetaUnit(line)) { | |
144 return; | |
145 } | |
146 else if (handleMetaFraction(line)) { | |
147 return; | |
148 } | |
149 else if (handleColumnNames(line)) { | |
150 return; | |
151 } | |
152 else { | |
153 log.warn("SYP: Unknown meta line: '" + line + "'"); | |
154 } | |
155 } | |
156 | |
157 | |
158 protected boolean handleMetaUnit(String line) { | |
159 Matcher m = META_UNIT.matcher(line); | |
160 | |
161 if (m.matches()) { | |
162 unit = new ImportUnit(m.group(1)); | |
163 return true; | |
164 } | |
165 | |
166 return false; | |
167 } | |
168 | |
169 | |
170 public boolean handleMetaFraction(String line) { | |
171 Matcher m = META_FRACTION.matcher(line); | |
172 | |
173 if (m.matches()) { | |
174 String tmp = m.group(1); | |
175 | |
176 this.grainFraction = buildGrainFraction(tmp); | |
177 | |
178 return true; | |
179 } | |
180 else if (line.startsWith(FRAKTION_START)) { | |
181 String newLine = line.replace(FRAKTION_START, "").trim(); | |
182 if (newLine.length() == 0) { | |
183 log.debug("Found total grain fraction."); | |
184 this.grainFraction = new ImportGrainFraction(GrainFraction.TOTAL); | |
185 | |
186 return true; | |
187 } | |
188 } | |
189 | |
190 return false; | |
191 } | |
192 | |
193 | |
194 public boolean handleColumnNames(String line) { | |
195 Matcher m = META_COLUMN_NAMES.matcher(line); | |
196 | |
197 if (m.matches()) { | |
198 columnNames = line.split(SEPERATOR_CHAR); | |
199 | |
200 initializeSedimentYields(); | |
201 | |
202 return true; | |
203 } | |
204 | |
205 return false; | |
206 } | |
207 | |
208 | |
209 protected void handleDataLine(String line) { | |
210 String[] vals = line.split(SEPERATOR_CHAR); | |
211 | |
212 if (vals == null || vals.length < columnNames.length-1) { | |
213 log.warn("SYP: skip invalid data line: '" + line + "'"); | |
214 return; | |
215 } | |
216 | |
217 try { | |
218 Double km = nf.parse(vals[0]).doubleValue(); | |
219 | |
220 for (int i = 1, n = columnNames.length-1; i < n; i++) { | |
221 String curVal = vals[i]; | |
222 | |
223 if (curVal != null && curVal.length() > 0) { | |
224 current[i-1].addValue(new ImportSedimentYieldValue( | |
225 km, nf.parse(vals[i]).doubleValue() | |
226 )); | |
227 } | |
228 } | |
229 } | |
230 catch (ParseException pe) { | |
231 log.warn("SYP: unparseable number in data row '" + line + "':", pe); | |
232 } | |
233 } | |
234 | |
235 | |
236 private void initializeSedimentYields() { | |
237 // skip first column (Fluss-km) and last column (Hinweise) | |
238 current = new ImportSedimentYield[columnNames.length-2]; | |
239 | |
240 for (int i = 0, n = columnNames.length; i < n-2; i++) { | |
241 current[i] = new ImportSedimentYield(this.description); | |
242 current[i].setTimeInterval(getTimeInterval(columnNames[i+1])); | |
243 current[i].setUnit(unit); | |
244 current[i].setGrainFraction(grainFraction); | |
245 } | |
246 } | |
247 | |
248 | |
249 private ImportTimeInterval getTimeInterval(String column) { | |
250 try { | |
251 Matcher a = TIMEINTERVAL_EPOCH.matcher(column); | |
252 if (a.matches()) { | |
253 int yearA = nf.parse(a.group(1)).intValue(); | |
254 int yearB = nf.parse(a.group(2)).intValue(); | |
255 | |
256 return new ImportTimeInterval( | |
257 getDateFromYear(yearA), | |
258 getDateFromYear(yearB) | |
259 ); | |
260 } | |
261 | |
262 Matcher b = TIMEINTERVAL_SINGLE.matcher(column); | |
263 if (b.matches()) { | |
264 int year = nf.parse(b.group(1)).intValue(); | |
265 | |
266 return new ImportTimeInterval(getDateFromYear(year)); | |
267 } | |
268 | |
269 log.warn("SYP: Unknown time interval string: '" + column + "'"); | |
270 } | |
271 catch (ParseException pe) { | |
272 log.warn("SYP: Could not parse years: " + column, pe); | |
273 } | |
274 | |
275 return null; | |
276 } | |
277 | |
278 | |
279 private ImportGrainFraction buildGrainFraction(String gfStr) { | |
280 Matcher a = META_GRAIN_FRACTION_A.matcher(gfStr); | |
281 if (a.matches()) { | |
282 String lowerA = a.group(2); | |
283 String lowerB = a.group(3); | |
284 | |
285 String upperA = a.group(4); | |
286 String upperB = a.group(5); | |
287 | |
288 String lower = lowerA != null ? lowerA : lowerB; | |
289 String upper = upperA != null ? upperA : upperB; | |
290 | |
291 try { | |
292 return new ImportGrainFraction( | |
293 getGrainFractionTypeName(this.description), | |
294 nf.parse(lower).doubleValue(), | |
295 nf.parse(upper).doubleValue() | |
296 ); | |
297 } | |
298 catch (ParseException pe) { | |
299 log.warn("SYP: Could not parse ranges of: '" + gfStr + "'"); | |
300 } | |
301 } | |
302 | |
303 Matcher b = META_GRAIN_FRACTION_B.matcher(gfStr); | |
304 if (b.matches()) { | |
305 String lowerA = b.group(4); | |
306 String lowerB = b.group(5); | |
307 String upperA = b.group(6); | |
308 String upperB = b.group(7); | |
309 | |
310 String lower = lowerA != null ? lowerA : lowerB; | |
311 String upper = upperA != null ? upperA : upperB; | |
312 | |
313 try { | |
314 return new ImportGrainFraction( | |
315 getGrainFractionTypeName(this.description), | |
316 nf.parse(lower).doubleValue(), | |
317 nf.parse(upper).doubleValue() | |
318 ); | |
319 } | |
320 catch (ParseException pe) { | |
321 log.warn("SYP: Could not parse ranges of: '" + gfStr + "'"); | |
322 } | |
323 } | |
324 | |
325 Matcher c = META_GRAIN_FRACTION_C.matcher(gfStr); | |
326 if (c.matches()) { | |
327 String oper = c.group(1); | |
328 String valueStr = c.group(3); | |
329 | |
330 try { | |
331 Double value = nf.parse(valueStr).doubleValue(); | |
332 | |
333 if (oper.equals(">")) { | |
334 return new ImportGrainFraction( | |
335 getGrainFractionTypeName(this.description), | |
336 value, | |
337 null | |
338 ); | |
339 } | |
340 else { | |
341 return new ImportGrainFraction( | |
342 getGrainFractionTypeName(this.description), | |
343 null, | |
344 value | |
345 ); | |
346 } | |
347 } | |
348 catch (ParseException pe) { | |
349 log.warn("SYP: Could not parse ranges of: '" + gfStr + "'"); | |
350 } | |
351 } | |
352 | |
353 log.warn("SYP: Unknown grain fraction: '" + gfStr + "'"); | |
354 | |
355 return null; | |
356 } | |
357 | |
358 | |
359 public static String getGrainFractionTypeName(String filename) { | |
360 if (Pattern.matches(FRACTION_COARSE_STR, filename)) { | |
361 return GrainFraction.COARSE; | |
362 } | |
363 else if (Pattern.matches(FRACTION_FINE_MIDDLE_STR, filename)) { | |
364 return GrainFraction.FINE_MIDDLE; | |
365 } | |
366 else if (Pattern.matches(FRACTION_SUSP_SAND_BED, filename) || | |
367 Pattern.matches(FRACTION_SUSP_SAND_BED_EPOCH, filename)) { | |
368 return GrainFraction.SUSP_SAND_BED; | |
369 } | |
370 else if (Pattern.matches(FRACTION_SUSP_SAND, filename)) { | |
371 return GrainFraction.SUSP_SAND; | |
372 } | |
373 else if (Pattern.matches(FRACTION_SAND, filename)) { | |
374 return GrainFraction.SAND; | |
375 } | |
376 else if (Pattern.matches(FRACTION_SUSPENDED_SEDIMENT, filename)) { | |
377 return GrainFraction.SUSPENDED_SEDIMENT; | |
378 } | |
379 else if (Pattern.matches(FRACTION_TOTAL, filename)) { | |
380 return GrainFraction.TOTAL; | |
381 } | |
382 else { | |
383 log.warn("SYP: Unknown grain fraction '" + filename + "'"); | |
384 return "unknown"; | |
385 } | |
386 } | |
387 | |
388 | |
389 public List<ImportSedimentYield> getSedimentYields() { | |
390 return sedimentYields; | |
391 } | |
392 } | |
393 // vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 : |