Mercurial > dive4elements > river

comparison flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/minfo/SedimentLoadCalculation.java @ 4522:a9753f717b3d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Completed and fixed sediment load calculation. * Now calculates with units. * Adds problems to error report. * Correctly calculates total loads.
author Raimund Renkert <rrenkert@intevation.de>
date Wed, 14 Nov 2012 17:18:44 +0100
parents cc6323401643
children e357716cf346
comparison
equal deleted inserted replaced
4521:71e6fe870c1d 4522:a9753f717b3d
1 package de.intevation.flys.artifacts.model.minfo; 1 package de.intevation.flys.artifacts.model.minfo;
2 2
3 import gnu.trove.TDoubleArrayList; 3 import gnu.trove.TDoubleArrayList;
4 4
5 import java.util.ArrayList; 5 import java.util.ArrayList;
6 import java.util.Iterator;
7 import java.util.List; 6 import java.util.List;
8 import java.util.Set;
9 7
10 import org.apache.log4j.Logger; 8 import org.apache.log4j.Logger;
11 import org.jfree.util.Log;
12 9
13 import de.intevation.flys.artifacts.access.SedimentLoadAccess; 10 import de.intevation.flys.artifacts.access.SedimentLoadAccess;
14 import de.intevation.flys.artifacts.model.Calculation; 11 import de.intevation.flys.artifacts.model.Calculation;
15 import de.intevation.flys.artifacts.model.CalculationResult; 12 import de.intevation.flys.artifacts.model.CalculationResult;
16 13
47 double kmLow = access.getLowerKM(); 44 double kmLow = access.getLowerKM();
48 if (yearEpoch.equals("year")) { 45 if (yearEpoch.equals("year")) {
49 period = access.getPeriod(); 46 period = access.getPeriod();
50 epoch = null; 47 epoch = null;
51 } 48 }
52 else if (yearEpoch.equals("epoch")) { 49 else if (yearEpoch.equals("epoch") || yearEpoch.equals("off_epoch")) {
53 epoch = access.getEpochs(); 50 epoch = access.getEpochs();
54 period = null; 51 period = null;
55 } 52 }
56 else { 53 else {
57 addProblem("minfo.missing.year_epoch"); 54 addProblem("minfo.missing.year_epoch");
163 double s = resLoad.getFraction(km).getSand(); 160 double s = resLoad.getFraction(km).getSand();
164 resLoad.setSand(km, s + f.getSand()); 161 resLoad.setSand(km, s + f.getSand());
165 sSum++; 162 sSum++;
166 } 163 }
167 if (f.getSusp_sand() > 0d) { 164 if (f.getSusp_sand() > 0d) {
168 double s = resLoad.getFraction(km).getSand(); 165 double s = resLoad.getFraction(km).getSusp_sand();
169 resLoad.setSuspSand(km, s + f.getSusp_sand()); 166 resLoad.setSuspSand(km, s + f.getSusp_sand());
170 ssSum++; 167 ssSum++;
171 } 168 }
172 if (f.getSusp_sand_bed() > 0d) { 169 if (f.getSusp_sand_bed() > 0d) {
173 double s = resLoad.getFraction(km).getSusp_sand_bed(); 170 double s = resLoad.getFraction(km).getSusp_sand_bed();
189 resLoad.setSuspSediment(km, fr.getSusp_sediment()/sseSum); 186 resLoad.setSuspSediment(km, fr.getSusp_sediment()/sseSum);
190 } 187 }
191 resLoad.setDescription(""); 188 resLoad.setDescription("");
192 resLoad.setEpoch(true); 189 resLoad.setEpoch(true);
193 190
194 SedimentLoad sl = calculateTotalLoad(resLoad); 191 SedimentLoadResult result;
195 return new SedimentLoadResult(epoch[i][0], epoch[i][1], sl); 192 SedimentLoad sl = calculateTotalLoad(resLoad, this.epoch[i][0]);
193 if (this.unit.equals("m3_per_a")) {
194 SedimentLoad slu = calculateUnit(sl, this.epoch[i][0]);
195 result = new SedimentLoadResult(
196 this.epoch[i][0],
197 this.epoch[i][1],
198 slu);
199 }
200 else {
201 result = new SedimentLoadResult(
202 this.epoch[i][0],
203 this.epoch[i][1],
204 sl);
205 }
206
207 return result;
196 } 208 }
197 209
198 private SedimentLoadResult calculateOffEpoch(int i) { 210 private SedimentLoadResult calculateOffEpoch(int i) {
199 return null; 211 SedimentLoad load = SedimentLoadFactory.getLoadwithData(
212 this.river,
213 this.yearEpoch,
214 kmLow,
215 kmUp,
216 this.epoch[i][0],
217 this.epoch[i][1]);
218 SedimentLoadResult result;
219 SedimentLoad sl = calculateTotalLoad(load, this.epoch[i][0]);
220 if (unit.equals("m3_per_a")) {
221 SedimentLoad slu = calculateUnit(sl, epoch[i][0]);
222 result = new SedimentLoadResult(
223 this.epoch[i][0],
224 this.epoch[i][1],
225 slu);
226 }
227 else {
228 result = new SedimentLoadResult(
229 this.epoch[i][0],
230 this.epoch[i][1],
231 sl);
232 }
233
234 return result;
200 } 235 }
201 236
202 private SedimentLoadResult calculateYear(int y) { 237 private SedimentLoadResult calculateYear(int y) {
203 SedimentLoad load = SedimentLoadFactory.getLoadwithData( 238 SedimentLoad load = SedimentLoadFactory.getLoadwithData(
204 this.river, 239 this.river,
206 this.kmLow, 241 this.kmLow,
207 this.kmUp, 242 this.kmUp,
208 y, 243 y,
209 y); 244 y);
210 245
211 SedimentLoad sl = calculateTotalLoad(load); 246 SedimentLoadResult result;
247 SedimentLoad sl = calculateTotalLoad(load, y);
212 if (unit.equals("m3_per_a")) { 248 if (unit.equals("m3_per_a")) {
213 SedimentLoad slu = calculateUnit(sl); 249 SedimentLoad slu = calculateUnit(sl, y);
214 } 250 result = new SedimentLoadResult(y, 0, slu);
215 251 }
216 SedimentLoadResult result = new SedimentLoadResult( 252 else {
217 y, 253 result = new SedimentLoadResult(y, 0, sl);
218 0, 254 }
219 sl);
220 return result; 255 return result;
221 } 256 }
222 257
223 private SedimentLoad validateData(SedimentLoad load) { 258 private SedimentLoad calculateTotalLoad(SedimentLoad load, int year) {
224 SedimentLoad clean = new SedimentLoad(); 259 logger.debug("calculateTotalLoad");
225 Set<Double> kms = load.getKms(); 260 if (!load.hasCoarse()) {
226 for (double km : kms) { 261 addProblem("missing.fraction.coarse" + " " + year);
262 }
263 if (!load.hasFineMiddle()) {
264 addProblem("missing.fraction.fine_middle" + " " + year);
265 }
266 if (!load.hasSand()) {
267 addProblem("missing.fraction.sand" + " " + year);
268 }
269 if (!load.hasSuspSand()) {
270 addProblem("missing.fraction.susp_sand" + " " + year);
271 }
272 if (!load.hasSuspSediment()) {
273 addProblem("missing.fraction.susp_sediment" + " " + year);
274 }
275 if (hasProblems()) {
276 return load;
277 }
278 for(double km : load.getKms()) {
279 logger.debug("total at km " + km);
227 SedimentLoadFraction fraction = load.getFraction(km); 280 SedimentLoadFraction fraction = load.getFraction(km);
228 if (fraction.getCoarse() > 0 && 281 double total = 0d;
229 fraction.getFine_middle() > 0 && 282 if ((fraction.getCoarse() <= 0d && load.hasCoarse())){
230 fraction.getSand() > 0 && 283 addProblem(km, "missing.data.coarse");
231 fraction.getSusp_sand() > 0&& 284 continue;
232 fraction.getSusp_sand_bed() > 0 && 285 }
233 fraction.getSusp_sediment() > 0) { 286 if (fraction.getFine_middle() <= 0d && load.hasFineMiddle()) {
234 clean.addKm(km, fraction); 287 addProblem(km, "missing.data.fine_middle");
235 } 288 continue;
236 } 289 }
237 return clean; 290 if (fraction.getSand() <= 0d && load.hasSand()) {
238 } 291 addProblem(km, "missing data.sand");
239 292 continue;
240 private SedimentLoad calculateTotalLoad(SedimentLoad load) { 293 }
241 Log.debug("calculateTotalLoad"); 294 if (fraction.getSusp_sand() <= 0d && load.hasSuspSand()) {
242 SedimentLoad clean = validateData(load); 295 addProblem(km, "missing.data.susp_sand");
243 if (clean.getKms().size() > 0) { 296 continue;
244 Iterator<Double> iter = clean.getKms().iterator(); 297 }
245 while (iter.hasNext()) { 298 if (fraction.getSusp_sediment() <= 0d && load.hasSuspSediment()) {
246 double km = iter.next(); 299 addProblem(km, "missing.data.susp_sediment");
247 SedimentLoadFraction f =clean.getFraction(km); 300 continue;
248 double total = f.getCoarse() + 301 }
249 f.getFine_middle() + 302 total += fraction.getCoarse() +
250 f.getSand() + 303 fraction.getFine_middle() +
251 f.getSusp_sand() + 304 fraction.getSand() +
252 f.getSusp_sediment(); 305 fraction.getSusp_sand() +
253 load.setTotal(km, total); 306 fraction.getSusp_sediment();
254 } 307 load.setTotal(km, total);
255 } 308 }
256 return load; 309 return load;
257 } 310 }
258 311
259 private SedimentLoad calculateUnit(SedimentLoad load) { 312 private SedimentLoad calculateUnit(SedimentLoad load, int year) {
260 //TODO implement me! 313 SedimentDensity density =
314 SedimentDensityFactory.getSedimentDensity(river, kmLow, kmUp, year);
315 for (double km: load.getKms()) {
316 double dens = density.getDensity(km, year);
317 logger.debug("factor: " + dens);
318 SedimentLoadFraction fraction = load.getFraction(km);
319 double coarse = fraction.getCoarse();
320 double fineMiddle = fraction.getFine_middle();
321 double sand = fraction.getSand();
322 double suspSand = fraction.getSusp_sand();
323 double bedSand = fraction.getSusp_sand_bed();
324 double sediment = fraction.getSusp_sediment();
325 double total = fraction.getTotal();
326 logger.debug("orig: " + coarse);
327 load.setCoarse(km, (coarse * dens));
328 load.setFineMiddle(km, (fineMiddle * dens));
329 load.setSand(km, (sand * dens));
330 load.setSuspSand(km, (suspSand * dens));
331 load.setSuspSandBed(km, (bedSand * dens));
332 load.setSuspSediment(km, (sediment * dens));
333 load.setTotal(km, (total * dens));
334 logger.debug("m3/a: " + load.getFraction(km).getCoarse());
335 }
261 return load; 336 return load;
262 } 337 }
263 } 338 }
264 // vim:set ts=4 sw=4 si et sta sts=4 fenc=utf-8 : 339 // vim:set ts=4 sw=4 si et sta sts=4 fenc=utf-8 :
http://dive4elements.wald.intevation.org