changeset 8085:75e62ea0e307

Added the broken calculation state of the new sediment load calc.
author Sascha L. Teichmann <teichmann@intevation.de>
date Mon, 11 Aug 2014 17:18:36 +0200
parents 640fffb0ad60
children 7ede7904c8a5
files artifacts/src/main/java/org/dive4elements/river/artifacts/states/minfo/SedimentLoadDataCalculate.java
diffstat 1 files changed, 625 insertions(+), 0 deletions(-) [+]
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/states/minfo/SedimentLoadDataCalculate.java	Mon Aug 11 17:18:36 2014 +0200
@@ -0,0 +1,625 @@
+/* Copyright (C) 2011, 2012, 2013 by Bundesanstalt für Gewässerkunde
+ * Software engineering by Intevation GmbH
+ *
+ * This file is Free Software under the GNU AGPL (>=v3)
+ * and comes with ABSOLUTELY NO WARRANTY! Check out the
+ * documentation coming with Dive4Elements River for details.
+ */
+
+package org.dive4elements.river.artifacts.states.minfo;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import org.apache.log4j.Logger;
+import org.dive4elements.artifactdatabase.state.Facet;
+import org.dive4elements.artifactdatabase.state.FacetActivity;
+import org.dive4elements.artifacts.Artifact;
+import org.dive4elements.artifacts.CallContext;
+import org.dive4elements.artifacts.CallMeta;
+import org.dive4elements.river.artifacts.D4EArtifact;
+import org.dive4elements.river.artifacts.access.SedimentLoadAccess;
+import org.dive4elements.river.artifacts.model.CalculationResult;
+import org.dive4elements.river.artifacts.model.DataFacet;
+import org.dive4elements.river.artifacts.model.FacetTypes;
+import org.dive4elements.river.artifacts.model.ReportFacet;
+import org.dive4elements.river.artifacts.model.minfo.SedimentLoadDataCalculation;
+import org.dive4elements.river.artifacts.model.minfo.SedimentLoadLSData;
+import org.dive4elements.river.artifacts.model.minfo.SedimentLoadFacet;
+import org.dive4elements.river.artifacts.model.minfo.SedimentLoadFactory;
+import org.dive4elements.river.artifacts.model.minfo.SedimentLoadResult;
+import org.dive4elements.river.artifacts.model.minfo.SedimentLoadUnknownFacet;
+import org.dive4elements.river.artifacts.resources.Resources;
+import org.dive4elements.river.artifacts.states.DefaultState;
+
+/** State in which Sediment Load(s) are calculated/retrieved. */
+public class SedimentLoadDataCalculate
+extends DefaultState
+implements FacetTypes
+{
+
+    private static final long serialVersionUID = 1L;
+
+    private static final Logger logger = Logger
+        .getLogger(SedimentLoadCalculate.class);
+
+    public static final String I18N_FACET_SEDIMENTLOAD_COARSE = "facet.sedimentload.coarse";
+    public static final String I18N_FACET_SEDIMENTLOAD_SAND = "facet.sedimentload.sand";
+    public static final String I18N_FACET_SEDIMENTLOAD_FINE_MIDDLE = "facet.sedimentload.fine_middle";
+    public static final String I18N_FACET_SEDIMENTLOAD_SUSPSAND = "facet.sedimentload.susp_sand";
+    public static final String I18N_FACET_SEDIMENTLOAD_SUSPSANDBED = "facet.sediemntload.susp_sand_bed";
+    public static final String I18N_FACET_SEDIMENTLOAD_SUSPSEDIMENT = "facet.sedimentload.susp_sediment";
+    public static final String I18N_FACET_SEDIMENTLOAD_TOTAL_LOAD = "facet.sedimentload.total_load";
+    public static final String I18N_FACET_SEDIMENTLOAD_TOTAL = "facet.sedimentload.total";
+
+    static {
+        // Active/deactivate facets.
+        FacetActivity.Registry.getInstance().register(
+            "minfo",
+            new FacetActivity() {
+                @Override
+                public Boolean isInitialActive(
+                    Artifact artifact,
+                    Facet    facet,
+                    String   output
+                ) {
+                    return null;
+                    //XXX: This is all broken.
+                    /*
+                    String name = facet.getName();
+                    if (name.equals(SEDIMENT_LOAD_TA_COARSE) ||
+                        name.equals(SEDIMENT_LOAD_TA_FINEMIDDLE) ||
+                        name.equals(SEDIMENT_LOAD_TA_SAND) ||
+                        name.equals(SEDIMENT_LOAD_TA_SUSP_SAND) ||
+                        name.equals(SEDIMENT_LOAD_TA_SUSP_SEDIMENT) ||
+                        name.equals(SEDIMENT_LOAD_TA_SUSP_SAND_BED) ||
+                        name.equals(SEDIMENT_LOAD_M3A_COARSE) ||
+                        name.equals(SEDIMENT_LOAD_M3A_FINEMIDDLE) ||
+                        name.equals(SEDIMENT_LOAD_M3A_SAND) ||
+                        name.equals(SEDIMENT_LOAD_M3A_SUSP_SAND) ||
+                        name.equals(SEDIMENT_LOAD_M3A_SUSP_SEDIMENT) ||
+                        name.equals(SEDIMENT_LOAD_M3A_SUSP_SAND_BED)){
+                        return Boolean.FALSE;
+                    }
+                    else if (name.equals(SEDIMENT_LOAD_TA_UNKNOWN)
+                        || name.equals(SEDIMENT_LOAD_M3A_UNKNOWN)) {
+                        D4EArtifact d4e = (D4EArtifact)artifact;
+                        SedimentLoadUnknownFacet f =
+                            (SedimentLoadUnknownFacet)
+                                d4e.getNativeFacet(facet, null);
+                        SedimentLoadLSData load =
+                            (SedimentLoadLSData)f.getData(artifact, null);
+                        SedimentLoadAccess access =
+                            new SedimentLoadAccess(d4e);
+                        List<int[]> dates = new ArrayList<int[]>();
+                        if (access.getYearEpoch().equals("year")) {
+                            dates.add(access.getPeriod());
+                        }
+                        else {
+                            int[][] epochs = access.getEpochs();
+                            for (int i = 0; i < epochs.length; i++) {
+                                dates.add(epochs[i]);
+                            }
+                        }
+                        for (int[] date: dates) {
+                            try {
+                                Date s =
+                                    DateUtil.getStartDateFromYear(date[0]);
+                                Date e =
+                                    DateUtil.getEndDateFromYear(date[1]);
+                                if (!(s.after(load.getEnd()) ||
+                                      e.before(load.getStart()))) {
+                                    return Boolean.TRUE;
+                                }
+                            }
+                            catch (IllegalArgumentException iae) {
+                                return Boolean.FALSE;
+                            }
+                        }
+                        return Boolean.FALSE;
+                    }
+                    else {
+                        return null;
+                    }
+                    */
+                }
+            });
+    }
+
+    public SedimentLoadDataCalculate() {
+    }
+
+    @Override
+    public Object computeAdvance(D4EArtifact artifact, String hash,
+        CallContext context, List<Facet> facets, Object old) {
+        logger.debug("SedimentLoadDataCalculate.computeAdvance");
+
+        List<Facet> newFacets = new ArrayList<Facet>();
+
+        SedimentLoadAccess access = new SedimentLoadAccess(artifact);
+
+        CalculationResult res = old instanceof CalculationResult
+            ? (CalculationResult) old
+            : new SedimentLoadDataCalculation().calculate(access);
+
+        if (facets == null || res == null) {
+            return res;
+        }
+
+        /* XXX: THIS IS ALL BROKEN
+
+        SedimentLoadResult[] results = (SedimentLoadResult[]) res.getData();
+
+        if (results == null || results.length == 0) {
+            logger.warn("Calculation computed no results!");
+            return res;
+        }
+
+        String type = access.getYearEpoch();
+        if (type.equals("year")) {
+            generateYearFacets(context, newFacets, results, getID(), hash, access);
+        }
+        else if (type.equals("epoch")) {
+            generateEpochFacets(context, newFacets, results, getID(), hash, access);
+        }
+        else if (type.equals("off_epoch")) {
+            generateOffEpochFacets(context, newFacets, results, getID(), hash, access);
+        }
+        logger.debug("Created " + newFacets.size() + " new Facets.");
+
+        String river = access.getRiverName();
+        SedimentLoadLSData[] unknown =
+            SedimentLoadFactory.getSedimentLoadUnknown(river,
+                access.getUnit().replace("_per_","/"), type);
+
+        boolean isUnitTA = access.getUnit().startsWith("t");
+
+        if (res.getReport().hasProblems()) {
+            newFacets.add(new ReportFacet(ComputeType.ADVANCE, hash, id));
+        }
+
+        for (int i = 0; i < unknown.length; i++) {
+            newFacets.add(new SedimentLoadUnknownFacet(
+                i,
+                (isUnitTA)? SEDIMENT_LOAD_TA_UNKNOWN:SEDIMENT_LOAD_M3A_UNKNOWN,
+                unknown[i].getDescription(),
+                ComputeType.ADVANCE,
+                getID(),
+                hash));
+        }
+
+        newFacets.add(
+            new DataFacet(CSV, "CSV data", ComputeType.ADVANCE, hash, id));
+
+        facets.addAll(newFacets);
+
+        */
+
+        return res;
+    }
+
+    /*
+    private String facetNameInfo(SedimentLoadResult result, String unit) {
+        return " - " + result.getStartYear() + " " + unit;
+    }
+
+    protected void generateYearFacets(CallContext context,
+        List<Facet> newFacets,
+        SedimentLoadResult[] results,
+        String stateId,
+        String hash,
+        SedimentLoadAccess access
+    ) {
+        logger.debug("SedimentLoadCalculate.generateFacets " + access.getUnit());
+
+        CallMeta meta = context.getMeta();
+        boolean isUnitTA = access.getUnit().startsWith("t");
+        String unit = (isUnitTA)
+            ? Resources.getMsg(context.getMeta(), "state.minfo.sediment.load.t_per_a", "(t/a)")
+            : Resources.getMsg(context.getMeta(), "state.minfo.sediment.load.m3_per_a", "(m^3/a)");
+
+//      newFacets.add(new DataFacet(CSV, "CSV data", ComputeType.ADVANCE, hash, id));
+        for (int idx = 0; idx < results.length; idx++) {
+            SedimentLoadResult res = results[idx];
+            if (res.hasCoarseData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_COARSE
+                    :SEDIMENT_LOAD_M3A_COARSE,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_COARSE,
+                        I18N_FACET_SEDIMENTLOAD_COARSE) +
+                        facetNameInfo(res, unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasSandData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_SAND
+                    :SEDIMENT_LOAD_M3A_SAND,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_SAND,
+                        I18N_FACET_SEDIMENTLOAD_SAND) +
+                        facetNameInfo(res, unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasFineMiddleData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_FINEMIDDLE
+                    :SEDIMENT_LOAD_M3A_FINEMIDDLE,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_FINE_MIDDLE,
+                        I18N_FACET_SEDIMENTLOAD_FINE_MIDDLE) +
+                        facetNameInfo(res, unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasSuspSandData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_SUSP_SAND
+                    :SEDIMENT_LOAD_M3A_SUSP_SAND,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSAND,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSAND) +
+                        facetNameInfo(res, unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasSuspSandBedData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_SUSP_SAND_BED
+                    :SEDIMENT_LOAD_M3A_SUSP_SAND_BED,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSANDBED,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSANDBED) +
+                        facetNameInfo(res, unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasSuspSedimentData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_SUSP_SEDIMENT
+                    :SEDIMENT_LOAD_M3A_SUSP_SEDIMENT,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSEDIMENT,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSEDIMENT) +
+                        facetNameInfo(res, unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+
+            }
+            if (res.hasTotalData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_TOTAL
+                    :SEDIMENT_LOAD_M3A_TOTAL,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_TOTAL,
+                        I18N_FACET_SEDIMENTLOAD_TOTAL) +
+                        facetNameInfo(res, unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+        }
+    }
+
+    private String epochFacetNameInfo(SedimentLoadResult result, String unit) {
+        return " - " + result.getStartYear() + "-" + result.getEndYear() + " " + unit;
+    }
+
+    protected void generateEpochFacets(
+        CallContext context,
+        List<Facet> newFacets,
+        SedimentLoadResult[] results,
+        String stateId,
+        String hash,
+        SedimentLoadAccess access
+    ) {
+        logger.debug("SedimentLoadCalculate.generateEpochFacets ");
+
+        CallMeta meta = context.getMeta();
+        boolean isUnitTA = access.getUnit().startsWith("t");
+        String unit = (isUnitTA)
+            ? Resources.getMsg(context.getMeta(), "state.minfo.sediment.load.t_per_a", "(t/a)")
+            : Resources.getMsg(context.getMeta(), "state.minfo.sediment.load.m3_per_a", "(m^3/a)");
+
+//      newFacets.add(new DataFacet(CSV, "CSV data", ComputeType.ADVANCE, hash, id));
+        for (int idx = 0; idx < results.length; idx++) {
+            SedimentLoadResult res = results[idx];
+            if (res.hasCoarseData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_COARSE
+                    :SEDIMENT_LOAD_M3A_COARSE,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_COARSE,
+                        I18N_FACET_SEDIMENTLOAD_COARSE) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasSandData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_SAND
+                    :SEDIMENT_LOAD_M3A_SAND,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_SAND,
+                        I18N_FACET_SEDIMENTLOAD_SAND) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasFineMiddleData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_FINEMIDDLE
+                    :SEDIMENT_LOAD_M3A_FINEMIDDLE,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_FINE_MIDDLE,
+                        I18N_FACET_SEDIMENTLOAD_FINE_MIDDLE) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasSuspSandData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_SUSP_SAND
+                    :SEDIMENT_LOAD_M3A_SUSP_SAND,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSAND,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSAND) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasSuspSandBedData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_SUSP_SAND_BED
+                    :SEDIMENT_LOAD_M3A_SUSP_SAND,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSANDBED,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSANDBED) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasSuspSedimentData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_SUSP_SEDIMENT
+                    :SEDIMENT_LOAD_M3A_SUSP_SEDIMENT,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSEDIMENT,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSEDIMENT) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+
+            }
+            if (res.hasTotalLoadData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_TOTAL_LOAD
+                    :SEDIMENT_LOAD_M3A_TOTAL_LOAD,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_TOTAL_LOAD,
+                        I18N_FACET_SEDIMENTLOAD_TOTAL_LOAD) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasTotalData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_TOTAL
+                    :SEDIMENT_LOAD_M3A_TOTAL,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_TOTAL,
+                        I18N_FACET_SEDIMENTLOAD_TOTAL) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+        }
+    }
+
+    protected void generateOffEpochFacets(
+        CallContext context,
+        List<Facet> newFacets,
+        SedimentLoadResult[] results,
+        String stateId,
+        String hash,
+        SedimentLoadAccess access
+    ) {
+        logger.debug("SedimentLoadCalculate.generateOffEpochFacets");
+
+        CallMeta meta = context.getMeta();
+        boolean isUnitTA = access.getUnit().startsWith("t");
+        String unit = (isUnitTA)
+            ? Resources.getMsg(context.getMeta(), "state.minfo.sediment.load.t_per_a", "(t/a)")
+            : Resources.getMsg(context.getMeta(), "state.minfo.sediment.load.m3_per_a", "(m^3/a)");
+
+//      newFacets.add(new DataFacet(CSV, "CSV data", ComputeType.ADVANCE, hash, id));
+        for (int idx = 0; idx < results.length; idx++) {
+            SedimentLoadResult res = results[idx];
+            if (res.hasCoarseData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_COARSE
+                    :SEDIMENT_LOAD_M3A_COARSE,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_COARSE,
+                        I18N_FACET_SEDIMENTLOAD_COARSE) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasSandData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_SAND
+                    :SEDIMENT_LOAD_M3A_SAND,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_SAND,
+                        I18N_FACET_SEDIMENTLOAD_SAND) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasFineMiddleData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_FINEMIDDLE
+                    :SEDIMENT_LOAD_M3A_FINEMIDDLE,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_FINE_MIDDLE,
+                        I18N_FACET_SEDIMENTLOAD_FINE_MIDDLE) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasSuspSandData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_SUSP_SAND
+                    :SEDIMENT_LOAD_M3A_SUSP_SAND,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSAND,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSAND) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasSuspSandBedData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_SUSP_SAND_BED
+                    :SEDIMENT_LOAD_M3A_SUSP_SAND_BED,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSANDBED,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSANDBED) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasSuspSedimentData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_SUSP_SEDIMENT
+                    :SEDIMENT_LOAD_M3A_SUSP_SEDIMENT,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSEDIMENT,
+                        I18N_FACET_SEDIMENTLOAD_SUSPSEDIMENT) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+
+            }
+            if (res.hasTotalLoadData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_TOTAL_LOAD
+                    :SEDIMENT_LOAD_M3A_TOTAL_LOAD,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_TOTAL_LOAD,
+                        I18N_FACET_SEDIMENTLOAD_TOTAL_LOAD) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+            if (res.hasTotalData()) {
+                newFacets.add(new SedimentLoadFacet(
+                    idx,
+                    (isUnitTA)
+                    ?SEDIMENT_LOAD_TA_TOTAL
+                    :SEDIMENT_LOAD_M3A_TOTAL,
+                    Resources.getMsg(
+                        meta,
+                        I18N_FACET_SEDIMENTLOAD_TOTAL,
+                        I18N_FACET_SEDIMENTLOAD_TOTAL) +
+                        epochFacetNameInfo(res,unit),
+                    ComputeType.ADVANCE,
+                    stateId,
+                    hash));
+            }
+        }
+    }
+*/
+}
+// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf-8 :

http://dive4elements.wald.intevation.org