# HG changeset patch # User Felix Wolfsteller # Date 1352103539 -3600 # Node ID 0dace49f89a0281fb53a594cee78b3f01091f6bc # Parent 19ab9e23bc214a183e2f4d335ed7bf09fbd9bccf# Parent 0f93da7690821ead02f3f5f326f5e15d2bba2a43 Merged diff -r 19ab9e23bc21 -r 0dace49f89a0 .hgtags --- a/.hgtags Fri Nov 02 15:13:49 2012 +0100 +++ b/.hgtags Mon Nov 05 09:18:59 2012 +0100 @@ -16,3 +16,6 @@ 8a75cf0841b1e4a361cb547dd02616e7c1015a5b pre2.7-2012-03-16 e1691b74f3aa888fe7b2cf78a4be3678abe6da45 flys-2.9.2 ff74ff82f2d421c7ab1efc404828d1316d19adb7 flys-2.9.3 +651b93c10dc5aef887efef5026e87ddd5da67dee flys-2.9.4 +651b93c10dc5aef887efef5026e87ddd5da67dee flys-2.9.4 +10e277c2fe0f800f170e849c285574af6fe64ceb flys-2.9.4 diff -r 19ab9e23bc21 -r 0dace49f89a0 flys-artifacts/doc/conf/artifacts/minfo.xml --- a/flys-artifacts/doc/conf/artifacts/minfo.xml Fri Nov 02 15:13:49 2012 +0100 +++ b/flys-artifacts/doc/conf/artifacts/minfo.xml Mon Nov 05 09:18:59 2012 +0100 @@ -187,6 +187,12 @@ + + + + + + @@ -196,6 +202,12 @@ + + + + + + @@ -204,6 +216,12 @@ + + + + + + @@ -355,8 +373,8 @@ - - + + @@ -393,8 +411,15 @@ - + + + + + + + + diff -r 19ab9e23bc21 -r 0dace49f89a0 flys-artifacts/doc/conf/conf.xml --- a/flys-artifacts/doc/conf/conf.xml Fri Nov 02 15:13:49 2012 +0100 +++ b/flys-artifacts/doc/conf/conf.xml Mon Nov 05 09:18:59 2012 +0100 @@ -341,6 +341,8 @@ de.intevation.flys.exports.WaterlevelExporter

de.intevation.flys.exports.fixings.FixWQCurveGenerator

de.intevation.flys.exports.fixings.FixWQCurveInfoGenerator + de.intevation.flys.exports.minfo.SedimentLoadLSGenerator + de.intevation.flys.exports.minfo.SedimentLoadLSInfoGenerator

de.intevation.flys.exports.ReportGenerator

de.intevation.flys.exports.ReportGenerator diff -r 19ab9e23bc21 -r 0dace49f89a0 flys-artifacts/doc/conf/meta-data.xml --- a/flys-artifacts/doc/conf/meta-data.xml Fri Nov 02 15:13:49 2012 +0100 +++ b/flys-artifacts/doc/conf/meta-data.xml Mon Nov 05 09:18:59 2012 +0100 @@ -1939,6 +1939,49 @@ + + MINFO bedheight difference + + + + + + + + SELECT m.id AS a_id, m.state AS a_state, m.gid AS a_gid, m.creation AS a_creation + FROM master_artifacts m + WHERE m.collection_id = ${collection_id} AND m.gid <> CAST(${artifact-id} AS uuid) + AND EXISTS ( + SELECT id FROM artifact_data ad WHERE ad.artifact_id = m.id AND k = 'river' AND v = ${river}) + + + + + SELECT a.gid as aid, f.id AS fid, f.name AS facet_name, f.num AS facet_num, f.description as facet_description + FROM outs as o, facets as f, artifacts as a + WHERE (f.name = 'fix_sector_average_ls_0' or f.name = 'fix_sector_average_ls_1' or f.name = 'fix_sector_average_ls_2' + or f.name = 'fix_sector_average_ls_3' or f.name = 'fix_analysis_events_ls' or f.name = 'fix_reference_events_ls') + and f.out_id = o.id and o.artifact_id = ${a_id} and a.id = ${a_id} + + + + + + + + + + + + + + + + + + + + diff -r 19ab9e23bc21 -r 0dace49f89a0 flys-artifacts/src/main/java/de/intevation/flys/artifacts/access/SedimentLoadAccess.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/flys-artifacts/src/main/java/de/intevation/flys/artifacts/access/SedimentLoadAccess.java Mon Nov 05 09:18:59 2012 +0100 @@ -0,0 +1,103 @@ +package de.intevation.flys.artifacts.access; + +import gnu.trove.TIntArrayList; + +import org.apache.log4j.Logger; + +import de.intevation.flys.artifacts.FLYSArtifact; + + +public class SedimentLoadAccess +extends RiverAccess +{ + private static final Logger logger = Logger.getLogger(BedHeightAccess.class); + + private int[] singleIDs; + private int[] epochIDs; + + private Double lowerKM; + private Double upperKM; + + private String time; + private String unit; + + public SedimentLoadAccess(FLYSArtifact artifact) { + super(artifact); + } + + public Double getLowerKM() { + if (lowerKM == null) { + lowerKM = getDouble("ld_from"); + } + + return lowerKM; + } + + public Double getUpperKM() { + if (upperKM == null) { + upperKM = getDouble("ld_to"); + } + + return upperKM; + } + + public String getYearEpoch() { + if (time == null) { + time = getString("ye_select"); + } + return time; + } + + public int[] getPeriod() { + if (getYearEpoch().equals("year") ) { + Integer start = getInteger("start"); + Integer end = getInteger("end"); + if (start == null || end == null) { + logger.warn("No 'start' or 'end' parameter specified!"); + return null; + } + + return new int[]{start.intValue(), end.intValue()}; + } + return null; + } + + public int[][] getEpochs() { + if (getYearEpoch().equals("epoch")) { + String data = getString("epochs"); + + if (data == null) { + logger.warn("No 'epochs' parameter specified!"); + return null; + } + + String[] parts = data.split(";"); + + int[][] list = new int[parts.length][]; + + for (int i = 0; i < parts.length; i++) { + String[] values = parts[i].split(","); + TIntArrayList ints = new TIntArrayList(); + try { + ints.add(Integer.parseInt(values[0])); + ints.add(Integer.parseInt(values[1])); + list[i] = ints.toNativeArray(); + } + catch (NumberFormatException nfe) { + logger.warn("Cannot parse int from string: '" + values + "'"); + } + } + return list; + } + + return null; + } + + public String getUnit () { + if (unit == null) { + unit = getString("unit"); + } + return unit; + } +} +// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 : diff -r 19ab9e23bc21 -r 0dace49f89a0 flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/FacetTypes.java --- a/flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/FacetTypes.java Fri Nov 02 15:13:49 2012 +0100 +++ b/flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/FacetTypes.java Mon Nov 05 09:18:59 2012 +0100 @@ -251,6 +251,14 @@ String BED_DIFFERENCE_EPOCH_HEIGHT1 = "bedheight_difference.epoch.height1"; String BED_DIFFERENCE_EPOCH_HEIGHT2 = "bedheight_difference.epoch.height2"; + String SEDIMENT_LOAD_COARSE = "sedimentload.coarse"; + String SEDIMENT_LOAD_SAND = "sedimentload.sand"; + String SEDIMENT_LOAD_FINEMIDDLE = "sedimentload.finemiddle"; + String SEDIMENT_LOAD_SUSP_SAND = "sedimentload.susp_sand"; + String SEDIMENT_LOAD_SUSP_SAND_BED = "sedimentload.susp_sand_bed"; + String SEDIMENT_LOAD_SUSP_SEDIMENT = "sedimentload.susp_sediment"; + String SEDIMENT_LOAD_TOTAL = "sediemntload.total"; + String SQ_OVERVIEW = "sq_overview"; String SQ_A_CURVE = "sq_a_curve"; diff -r 19ab9e23bc21 -r 0dace49f89a0 flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/StaticSedimentLoadCacheKey.java --- a/flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/StaticSedimentLoadCacheKey.java Fri Nov 02 15:13:49 2012 +0100 +++ b/flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/StaticSedimentLoadCacheKey.java Mon Nov 05 09:18:59 2012 +0100 @@ -1,7 +1,5 @@ package de.intevation.flys.artifacts.model; -import java.util.Date; - import org.apache.commons.lang.builder.HashCodeBuilder; @@ -12,29 +10,35 @@ private String river; private double startKm; private double endKm; - private Date date; + private int sYear; + private int eYear; public StaticSedimentLoadCacheKey( String river, double startKm, double endKm, - Date date + int sYear, + int eYear ) { this.river = river; this.startKm = startKm; this.endKm = endKm; - this.date = date; + this.sYear = sYear; + this.eYear = eYear; } + @Override public int hashCode() { HashCodeBuilder builder = new HashCodeBuilder(); builder.append(river); builder.append(startKm); builder.append(endKm); - builder.append(date); + builder.append(sYear); + builder.append(eYear); return builder.toHashCode(); } + @Override public boolean equals(Object other) { if (!(other instanceof StaticBedHeightCacheKey)) { return false; @@ -43,6 +47,7 @@ return this.river == o.river && this.startKm == o.startKm && this.endKm == o.endKm && - this.date == o.date; + this.sYear == o.sYear && + this.eYear == o.eYear; } } diff -r 19ab9e23bc21 -r 0dace49f89a0 flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/extreme/ExtremeCalculation.java --- a/flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/extreme/ExtremeCalculation.java Fri Nov 02 15:13:49 2012 +0100 +++ b/flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/extreme/ExtremeCalculation.java Mon Nov 05 09:18:59 2012 +0100 @@ -12,7 +12,7 @@ import de.intevation.flys.artifacts.access.ExtremeAccess; import de.intevation.flys.artifacts.math.Linear; -import de.intevation.flys.artifacts.math.Utils; +//import de.intevation.flys.artifacts.math.Utils; import de.intevation.flys.artifacts.math.fitting.Function; import de.intevation.flys.artifacts.math.fitting.FunctionFactory; @@ -34,6 +34,8 @@ import java.util.List; +import java.awt.geom.Line2D; + /** Calculate extrapolated W. */ public class ExtremeCalculation extends Calculation @@ -185,46 +187,55 @@ KMIndex curves = new KMIndex(); WQKms [] wqkms = allocWQKms(); - for (double km = from; km <= to; km += step) { - double currentKm = DoubleUtil.round(km); + boolean debug = log.isDebugEnabled(); - if (range == null || !range.inside(currentKm)) { + from = DoubleUtil.round(from); + to = DoubleUtil.round(to); + + for (double km = from; km <= to; km = DoubleUtil.round(km+step)) { + + if (debug) { + log.debug("km: " + km); + } + + if (range == null || !range.inside(km)) { for (RangeWithValues r: ranges) { - if (r.inside(currentKm)) { + if (r.inside(km)) { range = r; break; } } // TODO: i18n - addProblem(currentKm, "extreme.no.range.inner"); + addProblem(km, "extreme.no.range.inner"); continue; } - double [][] wqs = wst.interpolateTabulated(currentKm); + double [][] wqs = wst.interpolateTabulated(km); if (wqs == null) { // TODO: i18n - addProblem(currentKm, "extreme.no.raw.data"); + addProblem(km, "extreme.no.raw.data"); continue; } // XXX: This should not be necessary for model data. if (!DoubleUtil.isValid(wqs)) { // TODO: i18n - addProblem(currentKm, "extreme.invalid.data"); + addProblem(km, "extreme.invalid.data"); continue; } double [][] fitWQs = extractPointsToFit(wqs); if (fitWQs == null) { // TODO: i18n - addProblem(currentKm, "extreme.too.less.points"); + addProblem(km, "extreme.too.less.points"); continue; } - double [] coeffs = doFitting(function, wqs, chiSqr); + double [] coeffs = doFitting(function, fitWQs, chiSqr); if (coeffs == null) { // TODO: i18n - addProblem(currentKm, "extreme.fitting.failed"); + addProblem(km, "extreme.fitting.failed"); + continue; } Curve curve = new Curve( @@ -233,7 +244,7 @@ coeffs, chiSqr[0]); - curves.add(currentKm, curve); + curves.add(km, curve); double [] values = range.getValues(); @@ -243,10 +254,10 @@ double w = curve.value(q); if (Double.isNaN(w)) { // TODO: i18n - addProblem(currentKm, "extreme.evaluate.failed", values[i]); + addProblem(km, "extreme.evaluate.failed", values[i]); } else { - wqkms[i].add(w, q, currentKm); + wqkms[i].add(w, q, km); } } } @@ -275,7 +286,7 @@ CurveFitter cf = new CurveFitter(lmo); - for (int i = ws.length-1; i >= 0; --i) { + for (int i = 0; i < ws.length; ++i) { cf.addObservedPoint(qs[i], ws[i]); } @@ -289,16 +300,13 @@ } } } - if (coeffs == null) { - return null; + if (coeffs != null) { + chiSqr[0] = lmo.getChiSquare(); } - chiSqr[0] = lmo.getChiSquare(); return coeffs; } protected double [][] extractPointsToFit(double [][] wqs) { - TDoubleArrayList ows = new TDoubleArrayList(); - TDoubleArrayList oqs = new TDoubleArrayList(); double [] ws = wqs[0]; double [] qs = wqs[1]; @@ -315,48 +323,63 @@ double q1 = qs[N-2]; double w1 = ws[N-2]; + boolean ascending = w2 > w1; + + TDoubleArrayList ows = new TDoubleArrayList(); + TDoubleArrayList oqs = new TDoubleArrayList(); + oqs.add(q2); oqs.add(q1); ows.add(w2); ows.add(w1); - int orientation = Utils.epsilonEquals(w1, w1) - ? 0 - : w1 > w2 - ? -1 - : +1; + int lastDir = -2; for (int i = N-3; i >= 0; --i) { - double cq = qs[i]; - double cw = qs[i]; - int newOrientation = Utils.relativeCCW( - q2, w2, - q1, w1, - cq, cw); + double q = qs[i]; + double w = ws[i]; - if (newOrientation != 0 && newOrientation != orientation) { + if ((ascending && w > w1) || (!ascending && w < w1)) { break; } - oqs.add(cq); - ows.add(cw); - if (newOrientation != 0) { - // rotate last out - q2 = q1; - w2 = w1; + int dir = Line2D.relativeCCW(q2, w2, q1, w1, q, w); + //int dir = Utils.relativeCCW(q2, w2, q1, w1, q, w); + if (lastDir == -2) { + lastDir = dir; } - q1 = cq; - w1 = cw; + else if (lastDir != dir) { + break; + } + + oqs.add(q); + ows.add(w); + w2 = w1; + q2 = q1; + w1 = w; + q1 = q; } oqs.reverse(); ows.reverse(); + + boolean debug = log.isDebugEnabled(); + if (debug) { + log.debug("from table: " + N); + log.debug("after trim: " + oqs.size()); + } + cutPercent(ows, oqs); + if (debug) { + log.debug("after percent cut: " + oqs.size()); + } + return new double [][] { ows.toNativeArray(), oqs.toNativeArray() }; } + protected void cutPercent(TDoubleArrayList ws, TDoubleArrayList qs) { int N = qs.size(); if (percent <= 0d || N == 0) { diff -r 19ab9e23bc21 -r 0dace49f89a0 flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/minfo/SedimentLoad.java --- a/flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/minfo/SedimentLoad.java Fri Nov 02 15:13:49 2012 +0100 +++ b/flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/minfo/SedimentLoad.java Mon Nov 05 09:18:59 2012 +0100 @@ -1,8 +1,8 @@ package de.intevation.flys.artifacts.model.minfo; -import gnu.trove.TDoubleArrayList; - import java.util.Date; +import java.util.HashMap; +import java.util.Set; import org.apache.log4j.Logger; @@ -12,21 +12,15 @@ public class SedimentLoad extends NamedObjectImpl { - private static Logger log = Logger.getLogger(BedHeight.class); - protected String description; protected Date start; protected Date end; protected boolean isEpoch; - protected TDoubleArrayList sand_values; - protected TDoubleArrayList fine_middle_values; - protected TDoubleArrayList coarse_values; - protected TDoubleArrayList susp_sediment_values; - protected TDoubleArrayList susp_sand_bed_values; - + protected HashMap kms; public SedimentLoad() { + kms = new HashMap(); } public SedimentLoad( @@ -35,6 +29,7 @@ Date end, boolean isEpoch ) { + this(); this.description = description; this.start = start; this.end = end; @@ -73,63 +68,95 @@ this.isEpoch = isEpoch; } - public void addSandValue(double value) { - this.sand_values.add(value); - } - - public void addSandValues(TDoubleArrayList values) { - this.sand_values.add(values.toNativeArray()); - } - - public TDoubleArrayList getSandValues() { - return this.sand_values; - } - - public void addFineMiddleValue(double value) { - this.fine_middle_values.add(value); - } - - public void addFineMiddleValues(TDoubleArrayList values) { - this.fine_middle_values.add(values.toNativeArray()); - } - - public TDoubleArrayList getFineMiddleValues() { - return this.fine_middle_values; - } - - public void addCoarseValue(double value) { - this.coarse_values.add(value); + public Set getKms() { + return kms.keySet(); } - public void addCoarseValues(TDoubleArrayList values) { - this.coarse_values.add(values.toNativeArray()); - } - - public TDoubleArrayList getCoarseValues() { - return this.coarse_values; - } - - public void addSuspSedimentValue(double value) { - this.susp_sediment_values.add(value); - } - - public void addSuspSedimentValues(TDoubleArrayList values) { - this.susp_sediment_values.add(values.toNativeArray()); + public void addKm(double km, SedimentLoadFraction fraction) { + kms.put(km, fraction); } - public TDoubleArrayList getSuspSedimentValues() { - return this.susp_sediment_values; - } - - public void addSuspSandBedValue(double value) { - this.susp_sand_bed_values.add(value); + public SedimentLoadFraction getFraction(double km) { + if (kms.get(km) == null) { + return new SedimentLoadFraction(); + } + return kms.get(km); } - public void addSuspSandBedValues(TDoubleArrayList values) { - this.susp_sand_bed_values.add(values.toNativeArray()); + public void setCoarse(double km, double coarse) { + if (kms.containsKey(km)) { + kms.get(km).setCoarse(coarse); + } + else { + SedimentLoadFraction f = new SedimentLoadFraction(); + f.setCoarse(coarse); + kms.put(km, f); + } } - public TDoubleArrayList getSuspSandBedValues() { - return this.susp_sand_bed_values; + public void setFineMiddle(double km, double fine_middle) { + if (kms.containsKey(km)) { + kms.get(km).setFine_middle(fine_middle); + } + else { + SedimentLoadFraction f = new SedimentLoadFraction(); + f.setFine_middle(fine_middle); + kms.put(km, f); + } + } + + public void setSand(double km, double sand) { + if (kms.containsKey(km)) { + kms.get(km).setSand(sand); + } + else { + SedimentLoadFraction f = new SedimentLoadFraction(); + f.setSand(sand); + kms.put(km, f); + } + } + + public void setSuspSand(double km, double susp_sand) { + if (kms.containsKey(km)) { + kms.get(km).setSusp_sand(susp_sand); + } + else { + SedimentLoadFraction f = new SedimentLoadFraction(); + f.setSusp_sand(susp_sand); + kms.put(km, f); + } + } + + public void setSuspSandBed(double km, double susp_sand_bed) { + if (kms.containsKey(km)) { + kms.get(km).setSusp_sand_bed(susp_sand_bed); + } + else { + SedimentLoadFraction f = new SedimentLoadFraction(); + f.setSusp_sand_bed(susp_sand_bed); + kms.put(km, f); + } + } + + public void setSuspSediment(double km, double susp_sediment) { + if (kms.containsKey(km)) { + kms.get(km).setSusp_sediment(susp_sediment); + } + else { + SedimentLoadFraction f = new SedimentLoadFraction(); + f.setSusp_sediment(susp_sediment); + kms.put(km, f); + } + } + + public void setTotal(double km, double total) { + if (kms.containsKey(km)) { + kms.get(km).setTotal(total); + } + else { + SedimentLoadFraction f = new SedimentLoadFraction(); + f.setTotal(total); + kms.put(km, f); + } } } diff -r 19ab9e23bc21 -r 0dace49f89a0 flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/minfo/SedimentLoadCalculation.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/minfo/SedimentLoadCalculation.java Mon Nov 05 09:18:59 2012 +0100 @@ -0,0 +1,261 @@ +package de.intevation.flys.artifacts.model.minfo; + +import gnu.trove.TDoubleArrayList; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Set; + +import org.apache.log4j.Logger; +import org.jfree.util.Log; + +import de.intevation.flys.artifacts.access.SedimentLoadAccess; +import de.intevation.flys.artifacts.model.Calculation; +import de.intevation.flys.artifacts.model.CalculationResult; + + +public class SedimentLoadCalculation +extends Calculation +{ + + private static final Logger logger = Logger + .getLogger(SedimentLoadCalculation.class); + + protected String river; + protected String yearEpoch; + protected double kmUp; + protected double kmLow; + protected int[] period; + protected int[][] epoch; + protected String unit; + + public SedimentLoadCalculation() { + } + + public CalculationResult calculate(SedimentLoadAccess access) { + logger.info("SedimentLoadCalculation.calculate"); + + String river = access.getRiver(); + String yearEpoch = access.getYearEpoch(); + String unit = access.getUnit(); + int[] period = null; + int[][] epoch = null; + double kmUp = access.getUpperKM(); + double kmLow = access.getLowerKM(); + if (yearEpoch.equals("year")) { + period = access.getPeriod(); + epoch = null; + } + else if (yearEpoch.equals("epoch")) { + epoch = access.getEpochs(); + period = null; + } + else { + addProblem("minfo.missing.year_epoch"); + } + + if (river == null) { + // TODO: i18n + addProblem("minfo.missing.river"); + } + + if (period == null && epoch == null) { + addProblem("minfo.missing.time"); + } + + if (!hasProblems()) { + this.river = river; + this.yearEpoch = yearEpoch; + this.unit = unit; + this.period = period; + this.epoch = epoch; + this.kmUp = kmUp; + this.kmLow = kmLow; + return internalCalculate(); + } + + return new CalculationResult(); + } + + private CalculationResult internalCalculate() { + logger.debug("internalCalulate; mode:" + yearEpoch); + if (yearEpoch.equals("year")) { + List results = + new ArrayList(); + for (int i = period[0]; i <= period[1]; i++) { + logger.debug("calculating for year: " + i); + SedimentLoadResult res = calculateYear(i); + results.add(res); + } + return new CalculationResult( + results.toArray(new SedimentLoadResult[results.size()]), this); + } + else if (yearEpoch.equals("epoch")) { + List results = + new ArrayList(); + for (int i = 0; i < epoch.length; i++) { + SedimentLoadResult res = calculateEpoch(i); + results.add(res); + } + return new CalculationResult( + results.toArray(new SedimentLoadResult[results.size()]), this); + } + else if (yearEpoch.equals("off_epoch")) { + List results = + new ArrayList(); + for (int i = 0; i < epoch.length; i++) { + SedimentLoadResult res = calculateOffEpoch(i); + results.add(res); + } + return new CalculationResult( + results.toArray(new SedimentLoadResult[results.size()]), this); + } + return null; + } + + private SedimentLoadResult calculateEpoch(int i) { + List epochLoads = new ArrayList(); + for (int j = epoch[i][0]; j < epoch[i][1]; j++) { + epochLoads.add(SedimentLoadFactory.getLoadwithData( + this.river, + this.yearEpoch, + this.kmLow, + this.kmUp, + j, + j)); + } + + SedimentLoad resLoad = new SedimentLoad(); + TDoubleArrayList kms = new TDoubleArrayList(); + + for (SedimentLoad load : epochLoads) { + for (double km : load.getKms()) { + if (!kms.contains(km)) { + kms.add(km); + } + } + } + + for (int j = 0; j < kms.size(); j++) { + int cSum = 0; + int fmSum = 0; + int sSum = 0; + int ssSum = 0; + int ssbSum = 0; + int sseSum = 0; + double km = kms.get(j); + for (SedimentLoad load : epochLoads) { + SedimentLoadFraction f = load.getFraction(km); + if (f.getCoarse() > 0d) { + double c = resLoad.getFraction(km).getCoarse(); + resLoad.setCoarse(km, c + f.getCoarse()); + cSum++; + } + if (f.getFine_middle() > 0d) { + double fm = resLoad.getFraction(km).getFine_middle(); + resLoad.setFineMiddle(km, fm + f.getFine_middle()); + fmSum++; + } + if (f.getSand() > 0d) { + double s = resLoad.getFraction(km).getSand(); + resLoad.setSand(km, s + f.getSand()); + sSum++; + } + if (f.getSusp_sand() > 0d) { + double s = resLoad.getFraction(km).getSand(); + resLoad.setSuspSand(km, s + f.getSusp_sand()); + ssSum++; + } + if (f.getSusp_sand_bed() > 0d) { + double s = resLoad.getFraction(km).getSusp_sand_bed(); + resLoad.setSuspSandBed(km, s + f.getSusp_sand_bed()); + ssbSum++; + } + if (f.getSusp_sediment() > 0d) { + double s = resLoad.getFraction(km).getSusp_sediment(); + resLoad.setSuspSediment(km, s + f.getSusp_sediment()); + sseSum++; + } + } + SedimentLoadFraction fr = resLoad.getFraction(km); + resLoad.setCoarse(km, fr.getCoarse()/cSum); + resLoad.setFineMiddle(km, fr.getFine_middle()/fmSum); + resLoad.setSand(km, fr.getSand()/sSum); + resLoad.setSuspSand(km, fr.getSusp_sand()/ssSum); + resLoad.setSuspSandBed(km, fr.getSusp_sand_bed()/ssbSum); + resLoad.setSuspSediment(km, fr.getSusp_sediment()/sseSum); + } + resLoad.setDescription(""); + resLoad.setEpoch(true); + + SedimentLoad sl = calculateTotalLoad(resLoad); + return new SedimentLoadResult(epoch[i][0], epoch[i][1], sl); + } + + private SedimentLoadResult calculateOffEpoch(int i) { + return null; + } + + private SedimentLoadResult calculateYear(int y) { + SedimentLoad load = SedimentLoadFactory.getLoadwithData( + this.river, + this.yearEpoch, + this.kmLow, + this.kmUp, + y, + y); + + SedimentLoad sl = calculateTotalLoad(load); + if (unit.equals("m3_per_a")) { + SedimentLoad slu = calculateUnit(sl); + } + + SedimentLoadResult result = new SedimentLoadResult( + y, + 0, + sl); + return result; + } + + private SedimentLoad validateData(SedimentLoad load) { + SedimentLoad clean = new SedimentLoad(); + Set kms = load.getKms(); + for (double km : kms) { + SedimentLoadFraction fraction = load.getFraction(km); + if (fraction.getCoarse() > 0 && + fraction.getFine_middle() > 0 && + fraction.getSand() > 0 && + fraction.getSusp_sand() > 0&& + fraction.getSusp_sand_bed() > 0 && + fraction.getSusp_sediment() > 0) { + clean.addKm(km, fraction); + } + } + return clean; + } + + private SedimentLoad calculateTotalLoad(SedimentLoad load) { + Log.debug("calculateTotalLoad"); + SedimentLoad clean = validateData(load); + if (clean.getKms().size() > 0) { + Iterator iter = clean.getKms().iterator(); + while (iter.hasNext()) { + double km = iter.next(); + SedimentLoadFraction f =clean.getFraction(km); + double total = f.getCoarse() + + f.getFine_middle() + + f.getSand() + + f.getSusp_sand() + + f.getSusp_sediment(); + load.setTotal(km, total); + } + } + return load; + } + + private SedimentLoad calculateUnit(SedimentLoad load) { + //TODO implement me! + return load; + } +} diff -r 19ab9e23bc21 -r 0dace49f89a0 flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/minfo/SedimentLoadFacet.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/minfo/SedimentLoadFacet.java Mon Nov 05 09:18:59 2012 +0100 @@ -0,0 +1,52 @@ +package de.intevation.flys.artifacts.model.minfo; + +import org.apache.log4j.Logger; + +import de.intevation.artifactdatabase.state.Facet; +import de.intevation.artifacts.Artifact; +import de.intevation.artifacts.CallContext; +import de.intevation.flys.artifacts.FLYSArtifact; +import de.intevation.flys.artifacts.model.CalculationResult; +import de.intevation.flys.artifacts.model.DataFacet; +import de.intevation.flys.artifacts.states.DefaultState.ComputeType; + + +public class SedimentLoadFacet +extends DataFacet +{ + private static Logger logger = Logger.getLogger(SedimentLoadFacet.class); + + public SedimentLoadFacet() { + } + + public SedimentLoadFacet(int idx, String name, String description, + ComputeType type, String stateId, String hash) { + super(idx, name, description, type, hash, stateId); + } + + public Object getData(Artifact artifact, CallContext context) { + logger.debug("Get data for sediment load at index: " + index); + + FLYSArtifact flys = (FLYSArtifact) artifact; + + CalculationResult res = (CalculationResult) flys.compute(context, hash, + stateId, type, false); + + Object[] data = + (SedimentLoadResult[]) res.getData(); // TODO CAST TO SPECIFIC CLASS + + return data != null && data.length > index ? data[index] : null; + } + + /** Copy deeply. */ + @Override + public Facet deepCopy() { + SedimentLoadFacet copy = new SedimentLoadFacet(); + copy.set(this); + copy.type = type; + copy.hash = hash; + copy.stateId = stateId; + return copy; + } +} +// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 : diff -r 19ab9e23bc21 -r 0dace49f89a0 flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/minfo/SedimentLoadFactory.java --- a/flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/minfo/SedimentLoadFactory.java Fri Nov 02 15:13:49 2012 +0100 +++ b/flys-artifacts/src/main/java/de/intevation/flys/artifacts/model/minfo/SedimentLoadFactory.java Mon Nov 05 09:18:59 2012 +0100 @@ -58,32 +58,34 @@ "SELECT" + " sy.description AS description, " + " ti.start_time AS year, " + - " syv.value AS load " + + " syv.value AS load, " + + " syv.station AS km " + " FROM sediment_yield sy " + " JOIN rivers r ON sy.river_id = r.id " + " JOIN time_intervals ti ON sy.time_interval_id = ti.id " + - " JOIN sediment_yield_vales syv ON sy.id = syv.sediment_yield_id " + + " JOIN sediment_yield_values syv ON sy.id = syv.sediment_yield_id " + " JOIN grain_fraction gf ON sy.grain_fraction_id = gf.id " + " WHERE r.name = :name " + " AND ti.start_time BETWEEN :begin AND :end " + - " AND ti_stop_time IS NULL " + + " AND ti.stop_time IS NULL " + " AND gf.name = :grain " + " AND syv.station BETWEEN :startKm AND :endKm"; public static final String SQL_SELECT_EPOCHS_DATA = "SELECT" + - " sy.description AS description," + - " ti.start_time AS year," + - " syv.value AS load" + + " sy.description AS description, " + + " ti.start_time AS year, " + + " syv.value AS load, " + + " syv.station AS km " + " FROM sediment_yield sy" + " JOIN rivers r ON sy.river_id = r.id " + " JOIN time_intervals ti ON sy.time_interval_id = ti.id" + - " JOIN sediment_yield_vales syv ON sy.id = syv.sediment_yield_id" + + " JOIN sediment_yield_values syv ON sy.id = syv.sediment_yield_id" + " JOIN grain_fraction gf ON sy.grain_fraction_id = gf.id" + " WHERE r.name = :name" + " AND ti.start_time BETWEEN :sbegin AND :send" + - " AND ti_stop_time IS NOT NULL" + - " AND ti_stop_time BETWEEN :ebegin AND :eend" + + " AND ti.stop_time IS NOT NULL" + + " AND ti.stop_time BETWEEN :ebegin AND :eend" + " AND gf.name = :grain " + " AND syv.station BETWEEN :startKm AND :endKm"; @@ -108,7 +110,7 @@ } StaticSedimentLoadCacheKey key = - new StaticSedimentLoadCacheKey(river, startKm, endKm, null); + new StaticSedimentLoadCacheKey(river, startKm, endKm, 0, 0); Element element = cache.get(key); @@ -121,7 +123,7 @@ getSedimentLoadsUncached(river, type, startKm, endKm); if (values != null && key != null) { - log.debug("Store static sediment loads values in cache."); + log.debug("Store static sediment load values in cache."); element = new Element(key, values); cache.put(element); } @@ -133,8 +135,8 @@ String type, double startKm, double endKm, - Date startDate, - Date endDate + int syear, + int eyear ) { log.debug("SedimentLoadFactory.getLoadWithData"); Cache cache = CacheFactory.getCache(LOAD_DATA_CACHE_NAME); @@ -146,12 +148,12 @@ type, startKm, endKm, - startDate, - endDate); + syear, + eyear); } StaticSedimentLoadCacheKey key = - new StaticSedimentLoadCacheKey(river, startKm, endKm, startDate); + new StaticSedimentLoadCacheKey(river, startKm, endKm, syear, eyear); Element element = cache.get(key); @@ -160,8 +162,13 @@ return (SedimentLoad)element.getValue(); } - SedimentLoad values = - getSedimentLoadWithDataUncached(river, type, startKm, endKm, startDate, endDate); + SedimentLoad values = getSedimentLoadWithDataUncached( + river, + type, + startKm, + endKm, + syear, + eyear); if (values != null && key != null) { log.debug("Store static bed height values in cache."); @@ -243,58 +250,52 @@ String type, double startKm, double endKm, - Date sdate, - Date edate + int syear, + int eyear ) { - log.debug("SedimentLoadFactory.getBedHeightUncached"); + log.debug("SedimentLoadFactory.getSedimentLoadWithDataUncached"); Session session = SessionHolder.HOLDER.get(); SQLQuery sqlQuery = null; - Calendar cal = Calendar.getInstance(); - cal.setTime(sdate); - int year = cal.get(Calendar.YEAR); - cal.set(year, 1, 1); + Calendar start = Calendar.getInstance(); + start.set(syear, 1, 1); Calendar end = Calendar.getInstance(); - end.set(year, 12, 31); + end.set(syear, 12, 31); - if (type.equals("single")) { + if (type.equals("year") || type.equals("epoch")) { sqlQuery = session.createSQLQuery(SQL_SELECT_SINGLES_DATA) .addScalar("description", StandardBasicTypes.STRING) .addScalar("year", StandardBasicTypes.DATE) - .addScalar("load", StandardBasicTypes.DOUBLE); + .addScalar("load", StandardBasicTypes.DOUBLE) + .addScalar("km", StandardBasicTypes.DOUBLE); sqlQuery.setString("name", river); sqlQuery.setDouble("startKm", startKm); sqlQuery.setDouble("endKm", endKm); - sqlQuery.setDate("begin", cal.getTime()); + sqlQuery.setDate("begin", start.getTime()); sqlQuery.setDate("end", end.getTime()); sqlQuery.setString("grain", "total"); List