Mercurial > dive4elements > river

comparison flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/minfo/SedimentLoadCalculation.java @ 4373:1fb224bb2c6b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added sediment load calculation.
author Raimund Renkert <rrenkert@intevation.de>
date Fri, 02 Nov 2012 14:54:29 +0100
parents
children cc6323401643
comparison
equal deleted inserted replaced
4372:19772b414d46 4373:1fb224bb2c6b
1 package de.intevation.flys.artifacts.model.minfo;
2
3 import gnu.trove.TDoubleArrayList;
4
5 import java.util.ArrayList;
6 import java.util.Iterator;
7 import java.util.List;
8 import java.util.Set;
9
10 import org.apache.log4j.Logger;
11 import org.jfree.util.Log;
12
13 import de.intevation.flys.artifacts.access.SedimentLoadAccess;
14 import de.intevation.flys.artifacts.model.Calculation;
15 import de.intevation.flys.artifacts.model.CalculationResult;
16
17
18 public class SedimentLoadCalculation
19 extends Calculation
20 {
21
22 private static final Logger logger = Logger
23 .getLogger(SedimentLoadCalculation.class);
24
25 protected String river;
26 protected String yearEpoch;
27 protected double kmUp;
28 protected double kmLow;
29 protected int[] period;
30 protected int[][] epoch;
31 protected String unit;
32
33 public SedimentLoadCalculation() {
34 }
35
36 public CalculationResult calculate(SedimentLoadAccess access) {
37 logger.info("SedimentLoadCalculation.calculate");
38
39 String river = access.getRiver();
40 String yearEpoch = access.getYearEpoch();
41 String unit = access.getUnit();
42 int[] period = null;
43 int[][] epoch = null;
44 double kmUp = access.getUpperKM();
45 double kmLow = access.getLowerKM();
46 if (yearEpoch.equals("year")) {
47 period = access.getPeriod();
48 epoch = null;
49 }
50 else if (yearEpoch.equals("epoch")) {
51 epoch = access.getEpochs();
52 period = null;
53 }
54 else {
55 addProblem("minfo.missing.year_epoch");
56 }
57
58 if (river == null) {
59 // TODO: i18n
60 addProblem("minfo.missing.river");
61 }
62
63 if (period == null && epoch == null) {
64 addProblem("minfo.missing.time");
65 }
66
67 if (!hasProblems()) {
68 this.river = river;
69 this.yearEpoch = yearEpoch;
70 this.unit = unit;
71 this.period = period;
72 this.epoch = epoch;
73 this.kmUp = kmUp;
74 this.kmLow = kmLow;
75 return internalCalculate();
76 }
77
78 return new CalculationResult();
79 }
80
81 private CalculationResult internalCalculate() {
82 logger.debug("internalCalulate; mode:" + yearEpoch);
83 if (yearEpoch.equals("year")) {
84 List<SedimentLoadResult> results =
85 new ArrayList<SedimentLoadResult>();
86 for (int i = period[0]; i <= period[1]; i++) {
87 logger.debug("calculating for year: " + i);
88 SedimentLoadResult res = calculateYear(i);
89 results.add(res);
90 }
91 return new CalculationResult(
92 results.toArray(new SedimentLoadResult[results.size()]), this);
93 }
94 else if (yearEpoch.equals("epoch")) {
95 List<SedimentLoadResult> results =
96 new ArrayList<SedimentLoadResult>();
97 for (int i = 0; i < epoch.length; i++) {
98 SedimentLoadResult res = calculateEpoch(i);
99 results.add(res);
100 }
101 return new CalculationResult(
102 results.toArray(new SedimentLoadResult[results.size()]), this);
103 }
104 else if (yearEpoch.equals("off_epoch")) {
105 List<SedimentLoadResult> results =
106 new ArrayList<SedimentLoadResult>();
107 for (int i = 0; i < epoch.length; i++) {
108 SedimentLoadResult res = calculateOffEpoch(i);
109 results.add(res);
110 }
111 return new CalculationResult(
112 results.toArray(new SedimentLoadResult[results.size()]), this);
113 }
114 return null;
115 }
116
117 private SedimentLoadResult calculateEpoch(int i) {
118 List<SedimentLoad> epochLoads = new ArrayList<SedimentLoad>();
119 for (int j = epoch[i][0]; j < epoch[i][1]; j++) {
120 epochLoads.add(SedimentLoadFactory.getLoadwithData(
121 this.river,
122 this.yearEpoch,
123 this.kmLow,
124 this.kmUp,
125 j,
126 j));
127 }
128
129 SedimentLoad resLoad = new SedimentLoad();
130 TDoubleArrayList kms = new TDoubleArrayList();
131
132 for (SedimentLoad load : epochLoads) {
133 for (double km : load.getKms()) {
134 if (!kms.contains(km)) {
135 kms.add(km);
136 }
137 }
138 }
139
140 for (int j = 0; j < kms.size(); j++) {
141 int cSum = 0;
142 int fmSum = 0;
143 int sSum = 0;
144 int ssSum = 0;
145 int ssbSum = 0;
146 int sseSum = 0;
147 double km = kms.get(j);
148 for (SedimentLoad load : epochLoads) {
149 SedimentLoadFraction f = load.getFraction(km);
150 if (f.getCoarse() > 0d) {
151 double c = resLoad.getFraction(km).getCoarse();
152 resLoad.setCoarse(km, c + f.getCoarse());
153 cSum++;
154 }
155 if (f.getFine_middle() > 0d) {
156 double fm = resLoad.getFraction(km).getFine_middle();
157 resLoad.setFineMiddle(km, fm + f.getFine_middle());
158 fmSum++;
159 }
160 if (f.getSand() > 0d) {
161 double s = resLoad.getFraction(km).getSand();
162 resLoad.setSand(km, s + f.getSand());
163 sSum++;
164 }
165 if (f.getSusp_sand() > 0d) {
166 double s = resLoad.getFraction(km).getSand();
167 resLoad.setSuspSand(km, s + f.getSusp_sand());
168 ssSum++;
169 }
170 if (f.getSusp_sand_bed() > 0d) {
171 double s = resLoad.getFraction(km).getSusp_sand_bed();
172 resLoad.setSuspSandBed(km, s + f.getSusp_sand_bed());
173 ssbSum++;
174 }
175 if (f.getSusp_sediment() > 0d) {
176 double s = resLoad.getFraction(km).getSusp_sediment();
177 resLoad.setSuspSediment(km, s + f.getSusp_sediment());
178 sseSum++;
179 }
180 }
181 SedimentLoadFraction fr = resLoad.getFraction(km);
182 resLoad.setCoarse(km, fr.getCoarse()/cSum);
183 resLoad.setFineMiddle(km, fr.getFine_middle()/fmSum);
184 resLoad.setSand(km, fr.getSand()/sSum);
185 resLoad.setSuspSand(km, fr.getSusp_sand()/ssSum);
186 resLoad.setSuspSandBed(km, fr.getSusp_sand_bed()/ssbSum);
187 resLoad.setSuspSediment(km, fr.getSusp_sediment()/sseSum);
188 }
189 resLoad.setDescription("");
190 resLoad.setEpoch(true);
191
192 SedimentLoad sl = calculateTotalLoad(resLoad);
193 return new SedimentLoadResult(epoch[i][0], epoch[i][1], sl);
194 }
195
196 private SedimentLoadResult calculateOffEpoch(int i) {
197 return null;
198 }
199
200 private SedimentLoadResult calculateYear(int y) {
201 SedimentLoad load = SedimentLoadFactory.getLoadwithData(
202 this.river,
203 this.yearEpoch,
204 this.kmLow,
205 this.kmUp,
206 y,
207 y);
208
209 SedimentLoad sl = calculateTotalLoad(load);
210 if (unit.equals("m3_per_a")) {
211 SedimentLoad slu = calculateUnit(sl);
212 }
213
214 SedimentLoadResult result = new SedimentLoadResult(
215 y,
216 0,
217 sl);
218 return result;
219 }
220
221 private SedimentLoad validateData(SedimentLoad load) {
222 SedimentLoad clean = new SedimentLoad();
223 Set<Double> kms = load.getKms();
224 for (double km : kms) {
225 SedimentLoadFraction fraction = load.getFraction(km);
226 if (fraction.getCoarse() > 0 &&
227 fraction.getFine_middle() > 0 &&
228 fraction.getSand() > 0 &&
229 fraction.getSusp_sand() > 0&&
230 fraction.getSusp_sand_bed() > 0 &&
231 fraction.getSusp_sediment() > 0) {
232 clean.addKm(km, fraction);
233 }
234 }
235 return clean;
236 }
237
238 private SedimentLoad calculateTotalLoad(SedimentLoad load) {
239 Log.debug("calculateTotalLoad");
240 SedimentLoad clean = validateData(load);
241 if (clean.getKms().size() > 0) {
242 Iterator<Double> iter = clean.getKms().iterator();
243 while (iter.hasNext()) {
244 double km = iter.next();
245 SedimentLoadFraction f =clean.getFraction(km);
246 double total = f.getCoarse() +
247 f.getFine_middle() +
248 f.getSand() +
249 f.getSusp_sand() +
250 f.getSusp_sediment();
251 load.setTotal(km, total);
252 }
253 }
254 return load;
255 }
256
257 private SedimentLoad calculateUnit(SedimentLoad load) {
258 //TODO implement me!
259 return load;
260 }
261 }
http://dive4elements.wald.intevation.org