GitLab

at 2018-03-23T13:30:48Z

[N2][N3] Gestion des catégories de poids -10/+10kg dans la stratification N2 et N3 (See #263) - mise en place des filtres sur les strates

 import com.google.common.collect.HashMultimap;

 import com.google.common.collect.Multimap;

 import com.google.common.collect.SetMultimap;

-import fr.ird.t3.T3IOUtil;

 import fr.ird.t3.actions.stratum.CatchStratum;

-import fr.ird.t3.actions.stratum.CatchStratumLoader;

-import fr.ird.t3.actions.stratum.StratumConfiguration;

 import fr.ird.t3.entities.data.Activity;

 import fr.ird.t3.entities.data.CorrectedElementaryCatch;

-import fr.ird.t3.entities.data.WeightCategoryTreatmentAware;

 import fr.ird.t3.entities.reference.Species;

 import fr.ird.t3.entities.reference.WeightCategoryTreatment;

 import fr.ird.t3.models.WeightCompositionAggregateModel;

 import java.io.IOException;

 import java.util.Collection;

-import java.util.HashMap;

 import java.util.List;

 import java.util.Locale;

 import java.util.Map;

 import java.util.Set;

-import java.util.function.Function;

 import static org.nuiton.i18n.I18n.l;

  * @author Tony Chemit - dev@tchemit.fr

  * @since 1.3

  */

-public class L2CatchStratum extends CatchStratum<Level2Configuration, Level2Action> {

+public class L2CatchStratum extends CatchStratum<Level2Configuration, Level2Action, L2StratumConfiguration> {

     private static final Log log = LogFactory.getLog(L2CatchStratum.class);

     /**

      */

     private WeightCompositionAggregateModel inputModelForSpeciesToFix;

-    private L2CatchStratum(StratumConfiguration<Level2Configuration> stratumConfiguration, Collection<Species> speciesToFix) {

+    private L2CatchStratum(L2StratumConfiguration stratumConfiguration, Collection<Species> speciesToFix) {

         super(stratumConfiguration, speciesToFix);

         weightCategoriesForSpecies = HashMultimap.create();

         inputModelForAllSpecies = new WeightCompositionAggregateModel();

         outputModelForAllSpecies = new WeightCompositionAggregateModel();

     }

-    static L2CatchStratum newCatchStratum(StratumConfiguration<Level2Configuration> stratumConfiguration,

+    static L2CatchStratum newCatchStratum(L2StratumConfiguration stratumConfiguration,

                                           List<WeightCategoryTreatment> weightCategories,

                                           Collection<Species> species,

                                           Level2Action action) throws Exception {

         return catchStratum;

     }

-    private static <X extends WeightCategoryTreatmentAware> void fillWeights(

-            WeightCategoryTreatment weightCategory,

-            Collection<X> data,

-            Map<Species, Float> weights,

-            Function<X, Float> function,

-            WeightCompositionAggregateModel model,

-            int divideFactor) {

-        if (weights == null) {

-            weights = new HashMap<>();

-        }

-        for (X setSpeciesCatWeight : data) {

-            Species species = setSpeciesCatWeight.getSpecies();

-            Float weight = weights.get(species);

-            if (weight == null) {

-                weight = 0f;

-            }

-            weight += function.apply(setSpeciesCatWeight) / divideFactor;

-            weights.put(species, weight);

-        }

-        if (model != null) {

-            model.addModel(weightCategory, weights);

-        }

-    }

     @Override

     public void close() throws IOException {

     }

     @Override

-    public L2StratumConfiguration getConfiguration() {

-        return (L2StratumConfiguration) super.getConfiguration();

-    }

-    @Override

-    protected CatchStratumLoader<Level2Configuration> newLoader() {

+    protected L2CatchStratumLoader newLoader() {

         return new L2CatchStratumLoader();

     }

     WeightCompositionAggregateModel sampleWeightModelForAllSpecies(Activity activity) {

         WeightCompositionAggregateModel sampleWeightModelFroAllSpecies = new WeightCompositionAggregateModel();

-        L2SampleStratum.fillWeightsFromSetSpeciesCatWeight(activity, null, sampleWeightModelFroAllSpecies);

+        fillWeightsFromSamplesWeight(activity, null, sampleWeightModelFroAllSpecies);

         return sampleWeightModelFroAllSpecies;

     }

-    private void fillWeightsFromCatchesWeight(Activity activity, WeightCompositionAggregateModel model, int dividerFactor) {

-        Map<WeightCategoryTreatment, Map<Species, Float>> weights = new HashMap<>();

-        Multimap<WeightCategoryTreatment, CorrectedElementaryCatch> data = getCorrectedElementaryCatchByCategory(activity);

-        T3IOUtil.fillMapWithDefaultValue(weights, data.keySet(), HashMap::new);

-        for (WeightCategoryTreatment weightCategory : data.keySet()) {

-            Map<Species, Float> speciesFloatMap = weights.get(weightCategory);

-            Collection<CorrectedElementaryCatch> correctedElementaryCatches = data.get(weightCategory);

-            fillWeights(weightCategory,

-                    correctedElementaryCatches,

-                    speciesFloatMap,

-                    CorrectedElementaryCatch::getCatchWeight,

-                    model,

-                    dividerFactor);

-        }

-    }

 }
  */

 package fr.ird.t3.actions.data.level2;

-import com.google.common.base.Preconditions;

 import fr.ird.t3.actions.stratum.CatchStratumLoader;

-import fr.ird.t3.actions.stratum.StratumConfiguration;

 import fr.ird.t3.entities.data.Activity;

 import fr.ird.t3.entities.data.ActivityTopiaDao;

-import fr.ird.t3.entities.data.Trip;

-import fr.ird.t3.entities.reference.Vessel;

-import fr.ird.t3.entities.reference.WeightCategoryTreatment;

 import fr.ird.t3.services.ioc.InjectDAO;

-import java.util.HashMap;

 import java.util.Map;

-import java.util.Set;

 /**

  * To load a {@link L2CatchStratum} for a given stratum configuration.

  * @author Tony Chemit - dev@tchemit.fr

  * @since 1.3

  */

-public class L2CatchStratumLoader extends CatchStratumLoader<Level2Configuration> {

+public class L2CatchStratumLoader extends CatchStratumLoader<Level2Configuration, Level2Action, L2StratumConfiguration> {

     @InjectDAO(entityType = Activity.class)

     private ActivityTopiaDao activityDAO;

     @Override

-    public Map<Activity, Integer> loadData(StratumConfiguration<Level2Configuration> configuration) {

+    public Map<Activity, Integer> loadData(L2StratumConfiguration configuration) {

         // on commence par récupérer les activités :

         // - dans la zone

         // - avec le bon type de banc

         // - maree.bateau dans la bonne flotte OK

         return filterActivities(configuration, activityIds);

     }

-

-    private Map<Activity, Integer> filterActivities(StratumConfiguration<Level2Configuration> configuration, Map<String, Integer> activityIds) {

-        Map<Activity, Integer> result = new HashMap<>();

-        if (activityIds != null && activityIds.size() > 0) {

-            Set<Vessel> possibleVessels = configuration.getPossibleCatchVessels();

-            WeightCategoryTreatment weightCategoryTreatment = configuration.getWeightCategoryTreatment();

-            for (Map.Entry<String, Integer> e : activityIds.entrySet()) {

-                String activityId = e.getKey();

-                // get activity

-                Activity activity = configuration.getActivity(activityId);

-                // get his trip

-                Trip trip = activity.getTrip();

-                if (!possibleVessels.contains(trip.getVessel())) {

-                    // not a matching boat

-                    continue;

-                }

-                // recheck activity have some catches.

-                Preconditions.checkState(activity.isCorrectedElementaryCatchNotEmpty(),

-                        String.format("Can not accept an activity (%s) with no catch", activity.getTopiaId()));

-                if (weightCategoryTreatment != null) {

-                    // weight category is in stratum, check there is catch using this category

-                    boolean foundWeightCategory = activity.withCorrectedElementaryCatch(weightCategoryTreatment);

-                    if (!foundWeightCategory) {

-                        // reject - the stratum weight category not found for this activity

-                        continue;

-                    }

-                }

-                result.put(activity, e.getValue());

-            }

-        }

-        return result;

-    }

-}
+}
  */

 package fr.ird.t3.actions.data.level2;

-import com.google.common.collect.ArrayListMultimap;

-import com.google.common.collect.Multimap;

-import com.google.common.collect.Multimaps;

-import fr.ird.t3.T3IOUtil;

 import fr.ird.t3.actions.stratum.SampleStratum;

-import fr.ird.t3.actions.stratum.StratumConfiguration;

 import fr.ird.t3.entities.data.Activity;

-import fr.ird.t3.entities.data.SetSpeciesCatWeight;

 import fr.ird.t3.entities.data.SetSpeciesFrequency;

-import fr.ird.t3.entities.data.WeightCategoryTreatmentAware;

 import fr.ird.t3.entities.reference.Species;

 import fr.ird.t3.entities.reference.WeightCategory;

 import fr.ird.t3.entities.reference.WeightCategoryTreatment;

 import fr.ird.t3.models.WeightCompositionAggregateModel;

 import fr.ird.t3.models.WeightCompositionModelHelper;

 import fr.ird.t3.services.T3ServiceContext;

-import org.apache.commons.collections4.CollectionUtils;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

-import org.nuiton.topia.persistence.TopiaException;

 import java.io.IOException;

 import java.util.Collection;

 import java.util.Locale;

 import java.util.Map;

 import java.util.Set;

-import java.util.function.Function;

 import static org.nuiton.i18n.I18n.l;

  * @author Tony Chemit - dev@tchemit.fr

  * @since 1.2

  */

-public class L2SampleStratum extends SampleStratum<Level2Configuration, Level2Action, L2SampleStratum> {

+public class L2SampleStratum extends SampleStratum<Level2Configuration, Level2Action, L2StratumConfiguration, L2SampleStratum> {

     private static final Log log = LogFactory.getLog(L2SampleStratum.class);

-

     /**

      * Total weight of the catch stratum.

      * <p/>

      * This is needed to test sample stratum quality when loading data.

      */

     private final float catchStratumTotalWeight;

-

     /** Weight composition for all species found in catches. */

     private final WeightCompositionAggregateModel modelsForAllSpecies;

-

     /** Weight composition model for only species to fix. */

     private WeightCompositionAggregateModel modelsForSpeciesToFix;

      */

     private float sampleStratumTotalWeight;

-    private L2SampleStratum(StratumConfiguration<Level2Configuration> configuration, Collection<Species> speciesToFix, float catchStratumTotalWeight) {

+    private L2SampleStratum(L2StratumConfiguration configuration, L2CatchStratum catchStratum, Collection<Species> speciesToFix) {

         super(configuration, speciesToFix);

-        this.catchStratumTotalWeight = catchStratumTotalWeight;

+        this.catchStratumTotalWeight = catchStratum.getTotalCatchWeightForSpeciesToFix();

         this.modelsForAllSpecies = new WeightCompositionAggregateModel();

     }

-    static L2SampleStratum newSampleStratum(StratumConfiguration<Level2Configuration> stratumConfiguration,

+    static L2SampleStratum newSampleStratum(L2StratumConfiguration stratumConfiguration,

+                                            L2CatchStratum catchStratum,

                                             List<WeightCategoryTreatment> weightCategories,

-                                            float totalCatchWeight,

                                             Collection<Species> species,

                                             Level2Action action) throws Exception {

-        L2SampleStratum sampleStratum = new L2SampleStratum(stratumConfiguration, species, totalCatchWeight);

+        L2SampleStratum sampleStratum = new L2SampleStratum(stratumConfiguration, catchStratum, species);

         sampleStratum.init(action.getServiceContext(), weightCategories, action);

         return sampleStratum;

     }

-    public static void fillWeightsFromSetSpeciesCatWeight(Activity activity,

-                                                          Map<WeightCategoryTreatment, Map<Species, Float>> weights,

-                                                          WeightCompositionAggregateModel model) {

-        if (weights == null) {

-            weights = new HashMap<>();

-        }

-        Multimap<WeightCategoryTreatment, SetSpeciesCatWeight> data = groupByWeightCategoryTreatment(activity.getSetSpeciesCatWeight());

-        T3IOUtil.fillMapWithDefaultValue(weights, data.keySet(), HashMap::new);

-        for (WeightCategoryTreatment weightCategory : data.keySet()) {

-            Map<Species, Float> speciesFloatMap = weights.get(weightCategory);

-            Collection<SetSpeciesCatWeight> setSpeciesCatWeights = data.get(weightCategory);

-            fillWeights(weightCategory, setSpeciesCatWeights, speciesFloatMap, SetSpeciesCatWeight::getWeight, model);

-        }

-    }

-

-    private static <X extends WeightCategoryTreatmentAware> Multimap<WeightCategoryTreatment, X> groupByWeightCategoryTreatment(Collection<X> activity) {

-        Multimap<WeightCategoryTreatment, X> index;

-        if (CollectionUtils.isEmpty(activity)) {

-            index = ArrayListMultimap.create();

-        } else {

-            index = Multimaps.index(activity, WeightCategoryTreatmentAware::getWeightCategoryTreatment);

-        }

-        return index;

-    }

-

-    private static <X extends WeightCategoryTreatmentAware> void fillWeights(

-            WeightCategoryTreatment weightCategory,

-            Collection<X> data,

-            Map<Species, Float> weights,

-            Function<X, Float> function,

-            WeightCompositionAggregateModel model) {

-        if (weights == null) {

-            weights = new HashMap<>();

-        }

-        for (X setSpeciesCatWeight : data) {

-            Species species = setSpeciesCatWeight.getSpecies();

-            Float weight = weights.get(species);

-            if (weight == null) {

-                weight = 0f;

-            }

-            weight += function.apply(setSpeciesCatWeight);

-            weights.put(species, weight);

-        }

-        if (model != null) {

-            model.addModel(weightCategory, weights);

-        }

-    }

-

     @Override

     public void close() throws IOException {

         super.close();

         return sampleStratumTotalWeight;

     }

-    //FIXME-263 si la categorie de poids que faire ?

     @Override

-    protected void mergeNewActivities(T3ServiceContext serviceContext, Set<Activity> activities) throws TopiaException {

+    protected void mergeNewActivities(T3ServiceContext serviceContext, Set<Activity> activities) {

         Set<Species> species = getSpeciesToFix();

         // all weights (for each species) for all weight categories found

         Map<WeightCategoryTreatment, Map<Species, Float>> weights = new HashMap<>();

         for (Activity activity : activities) {

             // split cat weight by weight category

-            fillWeightsFromSetSpeciesCatWeight(activity, weights, null);

+            fillWeightsFromSamplesWeight(activity, weights, null);

             // obtain the set species frequencies for the current activity

-            Collection<SetSpeciesFrequency> setSpeciesFrequencies = activity.getSetSpeciesFrequency();

-            if (activity.isSetSpeciesFrequencyNotEmpty()) {

-                // compute sample count for this activity

-                int newCount = computeSampleCount(setSpeciesFrequencies, species);

-                // merge it with final total count

-                sampleStratumTotalCount += newCount;

-            }

+            Collection<SetSpeciesFrequency> setSpeciesFrequencies = getSetSpeciesFrequency(activity);

+            // compute sample count for this activity

+            int newCount = computeSampleCount(setSpeciesFrequencies, species);

+            // merge it with final total count

+            sampleStratumTotalCount += newCount;

         }

         // add all weights to model

         for (Map.Entry<WeightCategoryTreatment, Map<Species, Float>> e : weights.entrySet()) {

         log.info(String.format("sampleStratumTotalCount  = %d / sampleStratumTotalWeight = %f", getSampleStratumTotalCount(), getSampleStratumTotalWeight()));

     }

-    //FIXME-263 si la categorie de poids que faire ?

-    private int computeSampleCount(Collection<SetSpeciesFrequency> setSpeciesFrequencies, Collection<Species> speciesToFix) {

-        int newCount = 0;

-        for (SetSpeciesFrequency setSpeciesFrequency : setSpeciesFrequencies) {

-            Species species = setSpeciesFrequency.getSpecies();

-            if (speciesToFix.contains(species)) {

-                newCount += setSpeciesFrequency.getNumber();

-            }

-        }

-        return newCount;

-    }

-

     @Override

     public String logSampleStratumLevel(int substitutionLevel, Level2Action messager) {

         Locale l = messager.getLocale();

                 modelsForSpeciesToFix);

     }

-    @Override

-    public L2StratumConfiguration getConfiguration() {

-        return (L2StratumConfiguration) super.getConfiguration();

+    private int computeSampleCount(Collection<SetSpeciesFrequency> setSpeciesFrequencies, Collection<Species> speciesToFix) {

+        int newCount = 0;

+        for (SetSpeciesFrequency setSpeciesFrequency : setSpeciesFrequencies) {

+            Species species = setSpeciesFrequency.getSpecies();

+            if (speciesToFix.contains(species)) {

+                newCount += setSpeciesFrequency.getNumber();

+            }

+        }

+        return newCount;

     }

 }
 import fr.ird.t3.entities.data.Trip;

 import fr.ird.t3.entities.reference.SchoolType;

 import fr.ird.t3.entities.reference.Vessel;

+import fr.ird.t3.entities.reference.WeightCategoryTreatment;

 import fr.ird.t3.entities.type.T3Date;

 import fr.ird.t3.services.ioc.InjectDAO;

 import org.apache.commons.logging.Log;

  * @author Tony Chemit - dev@tchemit.fr

  * @since 1.3

  */

-public abstract class L2SampleStratumLoader extends SampleStratumLoader<Level2Configuration, Level2Action, L2SampleStratum> {

+public abstract class L2SampleStratumLoader extends SampleStratumLoader<Level2Configuration, Level2Action, L2StratumConfiguration, L2SampleStratum> {

     private static final Log log = LogFactory.getLog(L2SampleStratumLoader.class);

     /**

     @Override

     protected Set<String> findActivityIds(String schoolTypeId, T3Date beginDate, T3Date endDate, String... zoneIds) {

-        StratumConfiguration<Level2Configuration> configuration = getSampleStratum().getConfiguration();

+        StratumConfiguration<Level2Configuration, Level2Action> configuration = getSampleStratum().getConfiguration();

         Set<String> result = new HashSet<>();

         for (String zoneId : zoneIds) {

             // on commence par récupérer les activités :

     }

     @Override

-    protected Set<Activity> filterActivities(Set<String> activityIds) {

-        Set<Activity> result = new HashSet<>();

-        StratumConfiguration<Level2Configuration> configuration = getSampleStratum().getConfiguration();

-        Set<Vessel> possibleVessels = configuration.getPossibleSampleVessels();

-        for (String activityId : activityIds) {

-            Activity activity = configuration.getActivity(activityId);

-            // recheck activity have some samples.

-            Preconditions.checkState(

-                    !activity.isSetSpeciesCatWeightEmpty(),

-                    String.format("Can not accept an activity (%s) with no sample", activity.getTopiaId()));

-            // get his trip

-            Trip trip = activity.getTrip();

-            if (!possibleVessels.contains(trip.getVessel())) {

-                // not a matching boat

-                continue;

-            }

-            result.add(activity);

-        }

-        return result;

-    }

-

-    @Override

     public boolean isStratumOk() {

         // test if we have enough sample weight

         L2SampleStratum sampleStratum = getSampleStratum();

     @Override

     protected Set<String> findActivityIds(int level) {

-

-        StratumConfiguration<Level2Configuration> configuration = getSampleStratum().getConfiguration();

+        StratumConfiguration<Level2Configuration, Level2Action> configuration = getSampleStratum().getConfiguration();

         String schoolTypeId = configuration.getSchoolType().getTopiaId();

         String zoneId = configuration.getZone().getTopiaId();

         T3Date beginDate = configuration.getBeginDate();

     @Override

     protected Set<String> findActivityIds(int level) {

-        StratumConfiguration<Level2Configuration> configuration = getSampleStratum().getConfiguration();

+        StratumConfiguration<Level2Configuration, Level2Action> configuration = getSampleStratum().getConfiguration();

         String schoolTypeId = configuration.getSchoolType().getTopiaId();

         String zoneId = configuration.getZone().getTopiaId();

         T3Date beginDate = configuration.getBeginDate();

  *

  * @author Tony Chemit - dev@tchemit.fr

  */

-public class L2StratumConfiguration extends StratumConfiguration<Level2Configuration> {

-

-    private final List<WeightCategoryTreatment> weightCategoryTreatments;

+class L2StratumConfiguration extends StratumConfiguration<Level2Configuration, Level2Action> {

     L2StratumConfiguration(Level2InputContext inputContext,

                            SchoolType schoolType,

                            Collection<ZoneStratumAware> zones,

                            List<WeightCategoryTreatment> weightCategoryTreatments) {

         super(

-                inputContext.getConfiguration(),

-                inputContext.getZoneMeta(),

+                inputContext,

                 zone,

                 schoolType,

                 weightCategoryTreatment,

                 beginDate,

                 beginDate.incrementsMonths(inputContext.getConfiguration().getTimeStep() - 1),

                 zones,

-                inputContext.getPossibleCatchVessels(),

-                inputContext.getPossibleSampleVessels(),

                 null,

-                inputContext.getActivityCache(),

+                weightCategoryTreatments,

                 stratumIndex);

-        this.weightCategoryTreatments = weightCategoryTreatments;

-    }

-

-    public List<WeightCategoryTreatment> getWeightCategoryTreatments() {

-        return weightCategoryTreatments;

     }

 }
  * it under the terms of the GNU Affero General Public License as published by

  * the Free Software Foundation, either version 3 of the License, or

  * (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU Affero General Public License

  * along with this program.  If not, see <http://www.gnu.org/licenses/>.

  * #L%

 import fr.ird.t3.actions.stratum.StratumConfiguration;

 import fr.ird.t3.actions.stratum.StratumResult;

-import java.io.IOException;

-

 /**

  * Result of a level 2 Stratum.

  *

  */

 public class L2StratumResult extends StratumResult<Level2Configuration> {

-    public L2StratumResult(StratumConfiguration<Level2Configuration> configuration, String label) {

+    public L2StratumResult(StratumConfiguration<Level2Configuration, Level2Action> configuration, String label) {

         super(configuration, label);

     }

                 incrementsProgression();

             } else {

                 // compute sample stratum

-                try (L2SampleStratum sampleStratum = L2SampleStratum.newSampleStratum(stratumConfiguration, weightCategories, catchStratum.getTotalCatchWeightForSpeciesToFix(), species, this)) {

+                try (L2SampleStratum sampleStratum = L2SampleStratum.newSampleStratum(stratumConfiguration, catchStratum, weightCategories, species, this)) {

                     incrementsProgression();

                     // get the substitution level for the sample stratum

                     Integer level = sampleStratum.getSubstitutionLevel();

  */

 public class Level2OutputContext extends LevelOutputContext<Level2Configuration, Level2Action, Level2InputContext, L2StratumResult> {

-    private long totalCatchWeightForSpeciesFoFix;

-    private long totalCatchWeight;

     /**

      * Input Weight composition (based on {@link CorrectedElementaryCatch#getCatchWeight()}) for all species found in catches.

      */

-    private WeightCompositionAggregateModel inputCatchModelForAllSpecies;

+    private final WeightCompositionAggregateModel inputCatchModelForAllSpecies;

     /**

      * Output Weight composition (based on {@link CorrectedElementaryCatch#getCorrectedCatchWeight()}) for all species found in catches.

      */

-    private WeightCompositionAggregateModel outputCatchModelForAllSpecies;

+    private final WeightCompositionAggregateModel outputCatchModelForAllSpecies;

+    private long totalCatchWeightForSpeciesFoFix;

+    private long totalCatchWeight;

     public Level2OutputContext(Level2Action action, Level2InputContext inputContext) {

         super(action, inputContext);

         this.outputCatchModelForAllSpecies = new WeightCompositionAggregateModel();

     }

+    @SuppressWarnings("unused")

     public long getTotalCatchWeightForSpeciesFoFix() {

         return totalCatchWeightForSpeciesFoFix;

     }

+    @SuppressWarnings("unused")

     public long getTotalCatchWeight() {

         return totalCatchWeight;

     }

         mergeResult(stratumResult);

     }

+    @SuppressWarnings("unused")

     public WeightCompositionAggregateModel getInputCatchModelForAllSpecies() {

         return inputCatchModelForAllSpecies;

     }

-    public void setInputCatchModelForAllSpecies(WeightCompositionAggregateModel inputCatchModelForAllSpecies) {

-        this.inputCatchModelForAllSpecies = inputCatchModelForAllSpecies;

-    }

-

+    @SuppressWarnings("unused")

     public WeightCompositionAggregateModel getOutputCatchModelForAllSpecies() {

         return outputCatchModelForAllSpecies;

     }

-    public void setOutputCatchModelForAllSpecies(WeightCompositionAggregateModel outputCatchModelForAllSpecies) {

-        this.outputCatchModelForAllSpecies = outputCatchModelForAllSpecies;

-    }

-

+    @SuppressWarnings("unused")

     public String getInputCatchStratumLog() {

         Collection<Species> species = getSpecies();

         WeightCompositionAggregateModel inputCatchModelForSpeciesToFix = inputCatchModelForAllSpecies.extractForSpecies(species);

                 inputCatchModelForSpeciesToFix);

     }

+    @SuppressWarnings("unused")

     public String getOutputCatchStratumLog() {

         Collection<Species> species = getSpecies();

         WeightCompositionAggregateModel outputCatchModelForSpeciesToFix = outputCatchModelForAllSpecies.extractForSpecies(species);

 package fr.ird.t3.actions.data.level3;

 import fr.ird.t3.actions.stratum.CatchStratum;

-import fr.ird.t3.actions.stratum.CatchStratumLoader;

-import fr.ird.t3.actions.stratum.StratumConfiguration;

 import fr.ird.t3.entities.T3EntityHelper;

 import fr.ird.t3.entities.T3Suppliers;

 import fr.ird.t3.entities.data.Activity;

 import fr.ird.t3.entities.data.CorrectedElementaryCatch;

-import fr.ird.t3.entities.data.SpeciesAware;

 import fr.ird.t3.entities.reference.Species;

 import fr.ird.t3.entities.reference.WeightCategoryTreatment;

 import fr.ird.t3.services.T3ServiceContext;

 import java.util.Collection;

 import java.util.List;

 import java.util.Map;

-import java.util.function.Predicate;

 /**

  * Define a catch stratum for a given stratum of a level 2 treatment.

  * @author Tony Chemit - dev@tchemit.fr

  * @since 1.3

  */

-public class L3CatchStratum extends CatchStratum<Level3Configuration, Level3Action> {

+public class L3CatchStratum extends CatchStratum<Level3Configuration, Level3Action, L3StratumConfiguration> {

     /**

-     * Predicate to filter only species selected in configuration.

-     *

-     * @see #getSpeciesToFix()

-     * @since 1.4

-     */

-    private final Predicate<? super SpeciesAware> speciesToFixFilter;

-    /**

      * Keep the total weight of all the catches in the stratum.

      * <p/>

      * Used by sampleStratum for quality tests.

      */

     private float totalCatchWeight;

-    L3CatchStratum(StratumConfiguration<Level3Configuration> stratumConfiguration, Collection<Species> speciesToFix, Predicate<? super SpeciesAware> speciesToFixFilter) {

+    L3CatchStratum(L3StratumConfiguration stratumConfiguration, Collection<Species> speciesToFix) {

         super(stratumConfiguration, speciesToFix);

-        this.speciesToFixFilter = speciesToFixFilter;

-    }

-    @Override

-    public L3StratumConfiguration getConfiguration() {

-        return (L3StratumConfiguration) super.getConfiguration();

     }

     @Override

-    protected CatchStratumLoader<Level3Configuration> newLoader() {

+    protected L3CatchStratumLoader newLoader() {

         return new L3CatchStratumLoader();

     }

                     T3EntityHelper.getTotal(

                             getCorrectedElementaryCatch(activity),

                             CorrectedElementaryCatch::getCorrectedCatchWeight,

-                            speciesToFixFilter,

+                            getConfiguration().getSpeciesToFixFilter(),

                             T3Suppliers.newActivityDecorateSupplier(

                                     serviceContext,

                                     activity,

  */

 package fr.ird.t3.actions.data.level3;

-import com.google.common.base.Preconditions;

 import fr.ird.t3.actions.stratum.CatchStratumLoader;

-import fr.ird.t3.actions.stratum.StratumConfiguration;

 import fr.ird.t3.entities.data.Activity;

 import fr.ird.t3.entities.data.ActivityTopiaDao;

-import fr.ird.t3.entities.data.Trip;

-import fr.ird.t3.entities.reference.Vessel;

 import fr.ird.t3.services.ioc.InjectDAO;

-import java.util.HashMap;

 import java.util.Map;

-import java.util.Set;

 /**

  * To load a {@link L3CatchStratum} for a given stratum configuration.

  * @author Tony Chemit - dev@tchemit.fr

  * @since 1.3

  */

-public class L3CatchStratumLoader extends CatchStratumLoader<Level3Configuration> {

+public class L3CatchStratumLoader extends CatchStratumLoader<Level3Configuration, Level3Action, L3StratumConfiguration> {

     @InjectDAO(entityType = Activity.class)

     private ActivityTopiaDao activityDAO;

     @Override

-    public Map<Activity, Integer> loadData(StratumConfiguration<Level3Configuration> configuration) {

+    public Map<Activity, Integer> loadData(L3StratumConfiguration configuration) {

         // on commence par récupérer les activités :

         // - dans la zone

         // - avec le bon type de banc

         // - maree.bateau dans la bonne flotte OK

         return filterActivities(configuration, activityIds);

     }

-

-    private Map<Activity, Integer> filterActivities(StratumConfiguration<Level3Configuration> configuration, Map<String, Integer> activityIds) {

-

-        Set<Vessel> possibleVessels = configuration.getPossibleCatchVessels();

-

-        Map<Activity, Integer> result = new HashMap<>();

-        if (activityIds != null && activityIds.size() > 0) {

-            for (Map.Entry<String, Integer> e : activityIds.entrySet()) {

-                String activityId = e.getKey();

-                // get activity

-                Activity activity = configuration.getActivity(activityId);

-                // get his trip

-                Trip trip = activity.getTrip();

-                if (!possibleVessels.contains(trip.getVessel())) {

-                    // not a matching boat

-                    continue;

-                }

-                // recheck activity have some catches.

-                Preconditions.checkState(!activity.isCorrectedElementaryCatchEmpty(),

-                        String.format("Can not accept an activity (%s) with no catch", activity.getTopiaId()));

-                result.put(activity, e.getValue());

-            }

-        }

-        return result;

-    }

 }
 import com.google.common.collect.Multimaps;

 import fr.ird.t3.T3IOUtil;

 import fr.ird.t3.actions.stratum.SampleStratum;

-import fr.ird.t3.actions.stratum.StratumConfiguration;

 import fr.ird.t3.entities.T3EntityHelper;

 import fr.ird.t3.entities.T3Suppliers;

 import fr.ird.t3.entities.cache.LengthWeightConversionWithContextCache;

 import fr.ird.t3.entities.data.SetSpeciesCatWeight;

 import fr.ird.t3.entities.data.SetSpeciesFrequency;

 import fr.ird.t3.entities.data.SetSpeciesFrequencyTopiaDao;

-import fr.ird.t3.entities.data.SpeciesAware;

 import fr.ird.t3.entities.reference.LengthWeightConversion;

 import fr.ird.t3.entities.reference.Species;

 import fr.ird.t3.entities.reference.WeightCategoryTreatment;

 import java.util.Locale;

 import java.util.Map;

 import java.util.Set;

-import java.util.function.Predicate;

 import static org.nuiton.i18n.I18n.l;

  * @author Tony Chemit - dev@tchemit.fr

  * @since 1.2

  */

-public class L3SampleStratum extends SampleStratum<Level3Configuration, Level3Action, L3SampleStratum> {

+public class L3SampleStratum extends SampleStratum<Level3Configuration, Level3Action, L3StratumConfiguration, L3SampleStratum> {

     private static final Log log = LogFactory.getLog(L3SampleStratum.class);

      */

     private final LengthWeightConversionWithContextCache conversionHelper;

     /**

-     * Predicate to filter only species selected in configuration.

-     *

-     * @see #getSpeciesToFix()

-     * @since 1.4

-     */

-    private final Predicate<? super SpeciesAware> speciesToFixFilter;

-    /**

      * Total weight of the sample stratum.

      * <p/>

      * This is needed to test sample stratum quality when loading data.

      */

     private float sampleStratumTotalWeight;

-    L3SampleStratum(StratumConfiguration<Level3Configuration> configuration,

+    L3SampleStratum(L3StratumConfiguration configuration,

                     Collection<Species> speciesToFix,

                     float catchStratumTotalWeight,

-                    LengthWeightConversionWithContextCache conversionHelper,

-                    Predicate<? super SpeciesAware> speciesToFixFilter) {

+                    LengthWeightConversionWithContextCache conversionHelper) {

         super(configuration, speciesToFix);

         this.catchStratumTotalWeight = catchStratumTotalWeight;

         this.conversionHelper = conversionHelper;

         this.speciesCount = new HashMap<>();

         this.compositionModel = new HashMap<>();

         this.allSetSpeciesFrequenciesBySpecies = ArrayListMultimap.create();

-        this.speciesToFixFilter = speciesToFixFilter;

     }

     @Override

     }

     @Override

-    public L3StratumConfiguration getConfiguration() {

-        return (L3StratumConfiguration) super.getConfiguration();

-    }

-

-    @Override

     public void mergeNewActivities(T3ServiceContext serviceContext, Set<Activity> activities) {

         for (Activity activity : activities) {

             // add total weight of samples of the activity (only for selected species)

             float totalWeight = T3EntityHelper.getTotal(

                     activity.getSetSpeciesCatWeight(),

                     SetSpeciesCatWeight::getWeight,

-                    speciesToFixFilter,

+                    getConfiguration().getSpeciesToFixFilter(),

                     T3Suppliers.newActivityDecorateSupplier(

                             serviceContext,

                             activity,

  */

 package fr.ird.t3.actions.data.level3;

-import com.google.common.base.Preconditions;

 import fr.ird.t3.actions.stratum.SampleStratumLoader;

 import fr.ird.t3.actions.stratum.StratumConfiguration;

 import fr.ird.t3.entities.data.Activity;

 import fr.ird.t3.entities.data.ActivityTopiaDao;

-import fr.ird.t3.entities.data.Trip;

 import fr.ird.t3.entities.reference.Species;

-import fr.ird.t3.entities.reference.Vessel;

 import fr.ird.t3.entities.type.T3Date;

 import fr.ird.t3.services.ioc.InjectDAO;

 import org.apache.commons.logging.Log;

  * @author Tony Chemit - dev@tchemit.fr

  * @since 1.3

  */

-public abstract class L3SampleStratumLoader extends SampleStratumLoader<Level3Configuration, Level3Action, L3SampleStratum> {

+public abstract class L3SampleStratumLoader extends SampleStratumLoader<Level3Configuration, Level3Action, L3StratumConfiguration, L3SampleStratum> {

     private static final Log log = LogFactory.getLog(L3SampleStratumLoader.class);

     @Override

     protected Set<String> findActivityIds(String schoolTypeId, T3Date beginDate, T3Date endDate, String... zoneIds) {

         Set<String> result = new HashSet<>();

-        StratumConfiguration<Level3Configuration> configuration = getSampleStratum().getConfiguration();

+        StratumConfiguration<Level3Configuration, Level3Action> configuration = getSampleStratum().getConfiguration();

         for (String zoneId : zoneIds) {

             // on commence par récupérer les activités :

             // - dans la zone ET

     }

     @Override

-    protected Set<Activity> filterActivities(Set<String> activityIds) {

-        Set<Activity> result = new HashSet<>();

-        StratumConfiguration<Level3Configuration> configuration = getSampleStratum().getConfiguration();

-        Set<Vessel> possibleVessels = configuration.getPossibleSampleVessels();

-        for (String activityId : activityIds) {

-            Activity activity = configuration.getActivity(activityId);

-            // get his trip

-            Trip trip = activity.getTrip();

-            if (!possibleVessels.contains(trip.getVessel())) {

-                // not a matching boat

-                continue;

-            }

-            // recheck activity have some samples.

-            Preconditions.checkState(

-                    !activity.isSetSpeciesCatWeightEmpty(),

-                    String.format("Can not accept an activity (%s) with no sample", activity.getTopiaId()));

-            result.add(activity);

-        }

-        return result;

-    }

-

-    @Override

     public boolean isStratumOk() {

         L3SampleStratum stratum = getSampleStratum();

         // test if we have enough sample weight

     @Override

     protected Set<String> findActivityIds(int level) {

-        StratumConfiguration<Level3Configuration> configuration = getSampleStratum().getConfiguration();

+        StratumConfiguration<Level3Configuration, Level3Action> configuration = getSampleStratum().getConfiguration();

         String schoolTypeId = configuration.getSchoolType().getTopiaId();

         String zoneId = configuration.getZone().getTopiaId();

         T3Date beginDate = configuration.getBeginDate();

     @Override

     protected Set<String> findActivityIds(int level) {

-        StratumConfiguration<Level3Configuration> configuration = getSampleStratum().getConfiguration();

+        StratumConfiguration<Level3Configuration, Level3Action> configuration = getSampleStratum().getConfiguration();

         String schoolTypeId = configuration.getSchoolType().getTopiaId();

         String zoneId = configuration.getZone().getTopiaId();

         T3Date beginDate = configuration.getBeginDate();

  */

 import fr.ird.t3.actions.stratum.StratumConfiguration;

-import fr.ird.t3.entities.cache.LengthWeightConversionWithContextCache;

 import fr.ird.t3.entities.reference.SchoolType;

 import fr.ird.t3.entities.reference.WeightCategoryTreatment;

 import fr.ird.t3.entities.reference.zone.ZoneStratumAware;

  *

  * @author Tony Chemit - dev@tchemit.fr

  */

-public class L3StratumConfiguration extends StratumConfiguration<Level3Configuration> {

+class L3StratumConfiguration extends StratumConfiguration<Level3Configuration, Level3Action> {

-    private final List<WeightCategoryTreatment> weightCategoryTreatments;

     private final Map<String, Integer> stratumMinimumSampleCount;

-    private final LengthWeightConversionWithContextCache conversionHelper;

     L3StratumConfiguration(Level3InputContext inputContext,

                            SchoolType schoolType,

                            List<WeightCategoryTreatment> weightCategoryTreatments,

                            Map<String, Integer> stratumMinimumSampleCount) {

         super(

-                inputContext.getConfiguration(),

-                inputContext.getZoneMeta(),

+                inputContext,

                 zone,

                 schoolType,

                 weightCategoryTreatment,

                 beginDate,

                 beginDate.incrementsMonths(inputContext.getConfiguration().getTimeStep() - 1),

                 zones,

-                inputContext.getPossibleCatchVessels(),

-                inputContext.getPossibleSampleVessels(),

                 stratumMinimumSampleCount,

-                inputContext.getActivityCache(),

+                weightCategoryTreatments,

                 stratumIndex);

-        this.weightCategoryTreatments = weightCategoryTreatments;

         this.stratumMinimumSampleCount = stratumMinimumSampleCount;

-        this.conversionHelper = inputContext.newLengthWeightConversionWithContextCache(zone.getOcean(), beginDate.toBeginDate());

-    }

-

-    public List<WeightCategoryTreatment> getWeightCategoryTreatments() {

-        return weightCategoryTreatments;

     }

     public Map<String, Integer> getStratumMinimumSampleCount() {

         return stratumMinimumSampleCount;

     }

-

-    public LengthWeightConversionWithContextCache getConversionHelper() {

-        return conversionHelper;

-    }

 }
  * it under the terms of the GNU Affero General Public License as published by

  * the Free Software Foundation, either version 3 of the License, or

  * (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU Affero General Public License

  * along with this program.  If not, see <http://www.gnu.org/licenses/>.

  * #L%

 import fr.ird.t3.actions.stratum.StratumResult;

 import fr.ird.t3.models.SpeciesCountAggregateModel;

-import java.io.IOException;

-

 /**

  * Result of a level 3 Stratum.

  *

      */

     private final SpeciesCountAggregateModel totalFishesCount;

-    public L3StratumResult(StratumConfiguration<Level3Configuration> configuration, String label) {

+    public L3StratumResult(StratumConfiguration<Level3Configuration, Level3Action> configuration, String label) {

         super(configuration, label);

         totalFishesCount = new SpeciesCountAggregateModel();

     }

     }

     @Override

-    public void close() throws IOException {

+    public void close() {

         totalFishesCount.close();

     }

     }

     private L3CatchStratum newCatchStratum(L3StratumConfiguration stratumConfiguration) throws Exception {

-        L3CatchStratum catchStratum = new L3CatchStratum(stratumConfiguration, inputContext.getSpecies(), inputContext.getSpeciesToFixFilter());

+        L3CatchStratum catchStratum = new L3CatchStratum(stratumConfiguration, inputContext.getSpecies());

         catchStratum.init(serviceContext, stratumConfiguration.getWeightCategoryTreatments(), this);

         // get the total weight of the catch stratum

         float catchStratumWeight = catchStratum.getTotalCatchWeight();

                 new L3SampleStratum(stratumConfiguration,

                         inputContext.getSpecies(),

                         totalCatchWeight,

-                        stratumConfiguration.getConversionHelper(),

-                        inputContext.getSpeciesToFixFilter());

+                        stratumConfiguration.getConversionHelper()

+                );

         sampleStratum.init(serviceContext, stratumConfiguration.getWeightCategoryTreatments(), this);

         return sampleStratum;

     }

  */

 package fr.ird.t3.actions.stratum;

-import com.google.common.collect.Multimap;

-import com.google.common.collect.Multimaps;

 import fr.ird.t3.actions.T3Action;

 import fr.ird.t3.entities.data.Activity;

-import fr.ird.t3.entities.data.CorrectedElementaryCatch;

-import fr.ird.t3.entities.data.WeightCategoryTreatmentAware;

 import fr.ird.t3.entities.reference.Species;

 import fr.ird.t3.entities.reference.WeightCategoryTreatment;

 import fr.ird.t3.services.IOCService;

 import fr.ird.t3.services.ioc.InjectDAO;

 import java.util.Collection;

+import java.util.LinkedHashSet;

 import java.util.List;

 import java.util.Map;

-import java.util.stream.Collectors;

+import java.util.Set;

 /**

  * Base catch stratum.

  * @author Tony Chemit - dev@tchemit.fr

  * @since 1.3

  */

-public abstract class CatchStratum<C extends LevelConfigurationWithStratum, A extends T3Action<C>> extends Stratum<C, A> {

+public abstract class CatchStratum<C extends LevelConfigurationWithStratum, A extends T3Action<C>, S extends StratumConfiguration<C, A>> extends Stratum<C, A, S> {

-    private int nbActivitiesWithSample;

+    private final Set<String> activityWithSampleIds;

-    protected CatchStratum(StratumConfiguration<C> configuration, Collection<Species> speciesToFix) {

+    protected CatchStratum(S configuration, Collection<Species> speciesToFix) {

         super(configuration, speciesToFix);

+        activityWithSampleIds = new LinkedHashSet<>();

     }

     /**

      *

      * @return new instance of a catch stratum loader

      */

-    protected abstract CatchStratumLoader<C> newLoader();

+    protected abstract CatchStratumLoader<C, A, S> newLoader();

     @Override

     public void init(T3ServiceContext serviceContext, List<WeightCategoryTreatment> weightCategories, A messager) throws Exception {

-        CatchStratumLoader<C> stratumLoader = newLoader();

+        CatchStratumLoader<C, A, S> stratumLoader = newLoader();

         // inject transaction in loader

         stratumLoader.setTransaction(serviceContext.getT3TopiaPersistenceContext());

         // inject dao in loader

         // get all catches usable in this stratum grouped by their owing activity

         Map<Activity, Integer> activities = stratumLoader.loadData(getConfiguration());

         setActivities(activities);

-        nbActivitiesWithSample = (int) activities.keySet().stream().filter(Activity::isSetSpeciesCatWeightNotEmpty).count();

+        //FIXME- Ca doit etre dans SampleStratum ?

+        for (Activity activity : activities.keySet()) {

+            boolean withSample = !getSetSpeciesCatWeight(activity).isEmpty();

+            if (withSample) {

+                activityWithSampleIds.add(activity.getTopiaId());

+            }

+        }

     }

     /**

     }

     public int getNbActivitiesWithSample() {

-        return nbActivitiesWithSample;

+        return activityWithSampleIds.size();

     }

-    public Collection<CorrectedElementaryCatch> getCorrectedElementaryCatch(Activity activity) {

-        WeightCategoryTreatment stratumWeightCategoryTreatment = getConfiguration().getWeightCategoryTreatment();

-        if (stratumWeightCategoryTreatment == null) {

-            return activity.getCorrectedElementaryCatch();

-        }

-        return activity.getCorrectedElementaryCatch().stream().filter(c -> stratumWeightCategoryTreatment.equals(c.getWeightCategoryTreatment())).collect(Collectors.toList());

-    }

-

-    public Multimap<WeightCategoryTreatment, CorrectedElementaryCatch> getCorrectedElementaryCatchByCategory(Activity activity) {

-        return Multimaps.index(getCorrectedElementaryCatch(activity), WeightCategoryTreatmentAware::getWeightCategoryTreatment);

-    }

 }
  * it under the terms of the GNU Affero General Public License as published by

  * the Free Software Foundation, either version 3 of the License, or

  * (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU Affero General Public License

  * along with this program.  If not, see <http://www.gnu.org/licenses/>.

  * #L%

  */

 package fr.ird.t3.actions.stratum;

+import com.google.common.base.Preconditions;

+import fr.ird.t3.actions.T3Action;

 import fr.ird.t3.entities.T3TopiaPersistenceContext;

 import fr.ird.t3.entities.data.Activity;

+import fr.ird.t3.entities.data.Trip;

+import fr.ird.t3.entities.reference.Vessel;

+import fr.ird.t3.entities.reference.WeightCategoryTreatment;

 import fr.ird.t3.services.T3TopiaPersistenceContextAware;

+import org.nuiton.topia.persistence.TopiaException;

+

+import java.util.HashMap;

 import java.util.Map;

+import java.util.Set;

 import java.util.function.Supplier;

-import org.nuiton.topia.persistence.TopiaException;

 /**

  * To loader a catch stratum.

  * @see CatchStratum

  * @since 1.3

  */

-public abstract class CatchStratumLoader<C extends LevelConfigurationWithStratum> implements T3TopiaPersistenceContextAware {

+public abstract class CatchStratumLoader<C extends LevelConfigurationWithStratum, A extends T3Action<C>, S extends StratumConfiguration<C, A>> implements T3TopiaPersistenceContextAware {

     protected Supplier<T3TopiaPersistenceContext> transaction;

      * To obtain all activities of the catch stratum.

      *

      * @param configuration stratum configuration

-     * @return the activites to use for the catch stratum

+     * @return activities to use for the catch stratum

      * @throws TopiaException if any pb while quering db

      */

-    public abstract Map<Activity, Integer> loadData(StratumConfiguration<C> configuration) throws TopiaException;

+    public abstract Map<Activity, Integer> loadData(S configuration);

     @Override

     public Supplier<T3TopiaPersistenceContext> getT3TopiaPersistenceContext() {

     public void setTransaction(Supplier<T3TopiaPersistenceContext> transaction) {

         this.transaction = transaction;

     }

+

+    protected Map<Activity, Integer> filterActivities(S configuration, Map<String, Integer> activityIds) {

+        Map<Activity, Integer> result = new HashMap<>();

+        if (activityIds != null && activityIds.size() > 0) {

+            Set<Vessel> possibleVessels = configuration.getPossibleCatchVessels();

+            WeightCategoryTreatment weightCategoryTreatment = configuration.getWeightCategoryTreatment();

+            for (Map.Entry<String, Integer> e : activityIds.entrySet()) {

+                String activityId = e.getKey();

+                // get activity

+                Activity activity = configuration.getActivity(activityId);

+                // get his trip

+                Trip trip = activity.getTrip();

+                if (!possibleVessels.contains(trip.getVessel())) {

+                    // not a matching boat

+                    continue;

+                }

+                // recheck activity have some catches.

+                Preconditions.checkState(!activity.isCorrectedElementaryCatchEmpty(),

+                        String.format("Can not accept an activity (%s) with no catch", activity.getTopiaId()));

+                // weight category is in stratum, check there is catch using this category

+                if (weightCategoryTreatment != null && !activity.withCorrectedElementaryCatch(weightCategoryTreatment)) {

+                    // reject - the stratum weight category not found for this activity

+                    continue;

+                }

+                result.put(activity, e.getValue());

+            }

+        }

+        return result;

+    }

 }
  * @author Tony Chemit - dev@tchemit.fr

  * @since 1.3

  */

-public abstract class SampleStratum<C extends LevelConfigurationWithStratum, A extends T3Action<C>, S extends SampleStratum<C, A, S>> extends Stratum<C, A> {

+public abstract class SampleStratum<C extends LevelConfigurationWithStratum, A extends T3Action<C>, T extends StratumConfiguration<C, A>, S extends SampleStratum<C, A, T, S>> extends Stratum<C, A, T> {

     /**

      * Number of merged activites (counted when passing through method

      */

     private Integer substitutionLevel;

-    protected SampleStratum(StratumConfiguration<C> configuration, Collection<Species> speciesToFix) {

+    protected SampleStratum(T configuration, Collection<Species> speciesToFix) {

         super(configuration, speciesToFix);

     }

-    protected abstract SampleStratumLoader<C, A, S> newLoader();

+    protected abstract SampleStratumLoader<C, A, T, S> newLoader();

     protected abstract String logSampleStratumLevel(int substitutionLevel, A messager);

     @Override

     public void init(T3ServiceContext serviceContext, List<WeightCategoryTreatment> weightCategories, A messager) throws Exception {

-        SampleStratumLoader<C, A, S> stratumLoader = newLoader();

+        SampleStratumLoader<C, A, T, S> stratumLoader = newLoader();

         // inject transaction in loader

         stratumLoader.setTransaction(serviceContext.getT3TopiaPersistenceContext());

     public final int getNbMergedActivities() {

         return nbMergedActivities;

     }

+

 }
  */

 package fr.ird.t3.actions.stratum;

+import com.google.common.base.Preconditions;

 import fr.ird.t3.actions.T3Action;

 import fr.ird.t3.entities.T3TopiaPersistenceContext;

 import fr.ird.t3.entities.data.Activity;

+import fr.ird.t3.entities.data.Trip;

+import fr.ird.t3.entities.reference.Vessel;

+import fr.ird.t3.entities.reference.WeightCategoryTreatment;

 import fr.ird.t3.entities.type.T3Date;

 import fr.ird.t3.services.T3ServiceContext;

 import fr.ird.t3.services.T3TopiaPersistenceContextAware;

 import java.util.function.Supplier;

 /**

- * To loader a catch stratum.

+ * To loader a sample stratum.

  *

  * @author Tony Chemit - dev@tchemit.fr

- * @see CatchStratum

+ * @see SampleStratum

  * @since 1.3

  */

-public abstract class SampleStratumLoader<C extends LevelConfigurationWithStratum, A extends T3Action<C>, S extends SampleStratum<C, A, S>> implements T3TopiaPersistenceContextAware {

+public abstract class SampleStratumLoader<C extends LevelConfigurationWithStratum, A extends T3Action<C>, T extends StratumConfiguration<C, A>, S extends SampleStratum<C, A, T, S>> implements T3TopiaPersistenceContextAware {

     private static final Log log = LogFactory.getLog(SampleStratumLoader.class);

     private final C levelConfiguration;

     protected SampleStratumLoader(S sampleStratum) {

         this.sampleStratum = sampleStratum;

-        levelConfiguration = sampleStratum.getConfiguration().getConfiguration();

+        this.levelConfiguration = sampleStratum.getConfiguration().getConfiguration();

     }

     /**

     protected abstract Set<String> findActivityIds(String schoolTypeId, T3Date beginDate, T3Date endDate, String... zoneIds);

-    /**

-     * From a set of activity ids, filter the one that can be use in this

-     * stratum. This mainly means to filter some of them using the stratum

-     * configuration.

-     *

-     * @param activityIds ids of activities to filter

-     * @return the set of usable activities after having

-     * @throws TopiaException if any database problem while loading data

-     */

-    protected abstract Set<Activity> filterActivities(Set<String> activityIds);

-

     protected abstract boolean isStratumOk();

     @Override

         return levelConfiguration.getTimeStep();

     }

+    /**

+     * From a set of activity ids, filter the one that can be use in this

+     * stratum. This mainly means to filter some of them using the stratum

+     * configuration.

+     *

+     * @param activityIds ids of activities to filter

+     * @return the set of usable activities after having

+     * @throws TopiaException if any database problem while loading data

+     */

+    private Set<Activity> filterActivities(Set<String> activityIds) {

+        Set<Activity> result = new HashSet<>();

+        T configuration = getSampleStratum().getConfiguration();

+        Set<Vessel> possibleVessels = configuration.getPossibleSampleVessels();

+        WeightCategoryTreatment weightCategoryTreatment = configuration.getWeightCategoryTreatment();

+        for (String activityId : activityIds) {

+            Activity activity = configuration.getActivity(activityId);

+            // get his trip

+            Trip trip = activity.getTrip();

+            if (!possibleVessels.contains(trip.getVessel())) {

+                // not a matching boat

+                continue;

+            }

+            // recheck activity have some samples.

+            Preconditions.checkState(activity.isSetSpeciesCatWeightNotEmpty(),

+                    String.format("Can not accept an activity (%s) with no sample", activity.getTopiaId()));

+            if (weightCategoryTreatment != null) {

+                // weight category is in stratum, check there is catch using this category

+                boolean foundWeightCategory = activity.withSetSpeciesCatWeight(weightCategoryTreatment);

+                if (!foundWeightCategory) {

+                    // reject - the stratum weight category not found for this activity

+                    continue;

+                }

+            }

+            result.add(activity);

+        }

+        return result;

+    }

 }
  */

 package fr.ird.t3.actions.stratum;

+import com.google.common.collect.ArrayListMultimap;

 import com.google.common.collect.ImmutableSet;

+import com.google.common.collect.Multimap;

+import com.google.common.collect.Multimaps;

+import fr.ird.t3.T3IOUtil;

 import fr.ird.t3.actions.T3Action;

+import fr.ird.t3.entities.cache.LengthWeightConversionWithContextCache;

 import fr.ird.t3.entities.data.Activity;

+import fr.ird.t3.entities.data.CorrectedElementaryCatch;

+import fr.ird.t3.entities.data.SetSpeciesCatWeight;

+import fr.ird.t3.entities.data.SetSpeciesFrequency;

+import fr.ird.t3.entities.data.SetSpeciesFrequencyTopiaDao;

+import fr.ird.t3.entities.data.WeightCategoryTreatmentAware;

+import fr.ird.t3.entities.reference.LengthWeightConversion;

 import fr.ird.t3.entities.reference.Species;

+import fr.ird.t3.entities.reference.SpeciesTopiaDao;

 import fr.ird.t3.entities.reference.WeightCategoryTreatment;

+import fr.ird.t3.models.WeightCompositionAggregateModel;

 import fr.ird.t3.services.T3ServiceContext;

 import org.nuiton.topia.persistence.TopiaException;

 import java.io.Closeable;

 import java.io.IOException;

+import java.util.ArrayList;

 import java.util.Collection;

+import java.util.Collections;

+import java.util.HashMap;

 import java.util.Iterator;

+import java.util.LinkedList;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

+import java.util.function.Function;

+import java.util.stream.Collectors;

 /**

  * base class for any stratum.

  * @see CatchStratum

  * @since 1.0

  */

-public abstract class Stratum<C extends LevelConfigurationWithStratum, A extends T3Action<C>> implements Closeable, Iterable<Map.Entry<Activity, Integer>> {

+public abstract class Stratum<C extends LevelConfigurationWithStratum, A extends T3Action<C>, S extends StratumConfiguration<C, A>> implements Closeable, Iterable<Map.Entry<Activity, Integer>> {

     /**

      * Stratum configuration of this stratum.

      *

      * @see StratumConfiguration

      */

-    private final StratumConfiguration<C> configuration;

+    private final S configuration;

     /**

      * Selected set of species to fix.

      *

      */

     private Map<Activity, Integer> activities;

-    protected Stratum(StratumConfiguration<C> configuration, Collection<Species> speciesToFix) {

+    protected Stratum(S configuration, Collection<Species> speciesToFix) {

         this.configuration = configuration;

         this.speciesToFix = ImmutableSet.copyOf(speciesToFix);

     }

         return activities.entrySet().iterator();

     }

-    public StratumConfiguration<C> getConfiguration() {

+    public S getConfiguration() {

         return configuration;

     }

             throw new IllegalStateException("You must invoke the #init(tx) method before accessing stratum data.");

         }

     }

+

+    public Collection<CorrectedElementaryCatch> getCorrectedElementaryCatch(Activity activity) {

+        WeightCategoryTreatment stratumWeightCategoryTreatment = getConfiguration().getWeightCategoryTreatment();

+        if (stratumWeightCategoryTreatment == null) {

+            return activity.getCorrectedElementaryCatch();

+        }

+        return activity.getCorrectedElementaryCatch().stream().filter(c -> stratumWeightCategoryTreatment.equals(c.getWeightCategoryTreatment())).collect(Collectors.toList());

+    }

+

+    public Multimap<WeightCategoryTreatment, CorrectedElementaryCatch> getCorrectedElementaryCatchByCategory(Activity activity) {

+        return Multimaps.index(getCorrectedElementaryCatch(activity), WeightCategoryTreatmentAware::getWeightCategoryTreatment);

+    }

+

+    private Multimap<WeightCategoryTreatment, SetSpeciesCatWeight> getSetSpeciesCatWeightByCategory(Activity activity) {

+        return Multimaps.index(getSetSpeciesCatWeight(activity), WeightCategoryTreatmentAware::getWeightCategoryTreatment);

+    }

+

+    Collection<SetSpeciesCatWeight> getSetSpeciesCatWeight(Activity activity) {

+        WeightCategoryTreatment stratumWeightCategoryTreatment = getConfiguration().getWeightCategoryTreatment();

+        if (stratumWeightCategoryTreatment == null) {

+            return activity.getSetSpeciesCatWeight();

+        }

+        return activity.getSetSpeciesCatWeight().stream().filter(c -> stratumWeightCategoryTreatment.equals(c.getWeightCategoryTreatment())).collect(Collectors.toList());

+    }

+

+    public Collection<SetSpeciesFrequency> getSetSpeciesFrequency(Activity activity) {

+        WeightCategoryTreatment stratumWeightCategoryTreatment = getConfiguration().getWeightCategoryTreatment();

+        if (stratumWeightCategoryTreatment == null) {

+            return activity.getSetSpeciesFrequency();

+        }

+        LengthWeightConversionWithContextCache conversionHelper = getConfiguration().getConversionHelper();

+

+        Multimap<Species, SetSpeciesFrequency> setSpeciesFrequencyBySpecies = SpeciesTopiaDao.groupBySpecies(activity.getSetSpeciesFrequency());

+        Multimap<Species, Integer> lengthClassesBySpecies = ArrayListMultimap.create();

+        // collect all length classes by species

+        SetSpeciesFrequencyTopiaDao.collectLengthClasses(setSpeciesFrequencyBySpecies, lengthClassesBySpecies);

+        List<SetSpeciesFrequency> result = new LinkedList<>();

+        for (Map.Entry<Species, Collection<SetSpeciesFrequency>> entry : setSpeciesFrequencyBySpecies.asMap().entrySet()) {

+            Species species = entry.getKey();

+            LengthWeightConversion conversion = conversionHelper.getConversions(species);

+            Collection<SetSpeciesFrequency> setSizes = entry.getValue();

+            List<Integer> lengthClasses = new ArrayList<>(lengthClassesBySpecies.get(species));

+            Collections.sort(lengthClasses);

+            List<Integer> lengthClassesAccepted = conversionHelper.getLengthClasses(conversion, stratumWeightCategoryTreatment, lengthClasses);

+            result.addAll(setSizes.stream().filter(f -> lengthClassesAccepted.contains(f.getLfLengthClass())).collect(Collectors.toList()));

+        }

+        return result;

+    }

+

+    protected void fillWeightsFromCatchesWeight(Activity activity, WeightCompositionAggregateModel model, int dividerFactor) {

+        Map<WeightCategoryTreatment, Map<Species, Float>> weights = new HashMap<>();

+        Multimap<WeightCategoryTreatment, CorrectedElementaryCatch> data = getCorrectedElementaryCatchByCategory(activity);

+        T3IOUtil.fillMapWithDefaultValue(weights, data.keySet(), HashMap::new);

+        for (WeightCategoryTreatment weightCategory : data.keySet()) {

+            Map<Species, Float> speciesFloatMap = weights.get(weightCategory);

+            Collection<CorrectedElementaryCatch> correctedElementaryCatches = data.get(weightCategory);

+            fillWeights(weightCategory,

+                    correctedElementaryCatches,

+                    speciesFloatMap,

+                    CorrectedElementaryCatch::getCatchWeight,

+                    model,

+                    dividerFactor);

+        }

+    }

+

+    protected void fillWeightsFromSamplesWeight(Activity activity,

+                                                Map<WeightCategoryTreatment, Map<Species, Float>> weights,

+                                                WeightCompositionAggregateModel model) {

+        if (weights == null) {

+            weights = new HashMap<>();

+        }

+        Multimap<WeightCategoryTreatment, SetSpeciesCatWeight> data = getSetSpeciesCatWeightByCategory(activity);

+        T3IOUtil.fillMapWithDefaultValue(weights, data.keySet(), HashMap::new);

+        for (WeightCategoryTreatment weightCategory : data.keySet()) {

+            Map<Species, Float> speciesFloatMap = weights.get(weightCategory);

+            Collection<SetSpeciesCatWeight> setSpeciesCatWeights = data.get(weightCategory);

+            fillWeights(weightCategory, setSpeciesCatWeights, speciesFloatMap, SetSpeciesCatWeight::getWeight, model, 1);

+        }

+    }

+

+    protected <X extends WeightCategoryTreatmentAware> void fillWeights(WeightCategoryTreatment weightCategory,

+                                                                        Collection<X> data,

+                                                                        Map<Species, Float> weights,

+                                                                        Function<X, Float> function,

+                                                                        WeightCompositionAggregateModel model,

+                                                                        int divideFactor) {

+        if (weights == null) {

+            weights = new HashMap<>();

+        }

+        for (X datum : data) {

+            Species species = datum.getSpecies();

+            Float weight = weights.get(species);

+            if (weight == null) {

+                weight = 0f;

+            }

+            weight += function.apply(datum) / divideFactor;

+            weights.put(species, weight);

+        }

+        if (model != null) {

+            model.addModel(weightCategory, weights);

+        }

+    }

+

 }
  */

 package fr.ird.t3.actions.stratum;

-import com.google.common.cache.LoadingCache;

 import com.google.common.collect.ImmutableSet;

+import fr.ird.t3.actions.T3Action;

+import fr.ird.t3.entities.cache.LengthWeightConversionWithContextCache;

 import fr.ird.t3.entities.data.Activity;

-import fr.ird.t3.entities.reference.AbstractSchoolTypeTopiaDao;

+import fr.ird.t3.entities.data.SpeciesAware;

 import fr.ird.t3.entities.reference.SchoolType;

+import fr.ird.t3.entities.reference.SchoolTypeTopiaDao;

 import fr.ird.t3.entities.reference.Vessel;

 import fr.ird.t3.entities.reference.WeightCategoryTreatment;

 import fr.ird.t3.entities.reference.zone.ZoneStratumAware;

 import java.util.Collection;

 import java.util.Iterator;

+import java.util.List;

 import java.util.Map;

 import java.util.Objects;

 import java.util.Set;

 import java.util.concurrent.ExecutionException;

 import java.util.function.BiConsumer;

 import java.util.function.Function;

+import java.util.function.Predicate;

 /**

  * Configuration of a stratum.

  * @author Tony Chemit - dev@tchemit.fr

  * @since 1.0

  */

-public class StratumConfiguration<C extends LevelConfigurationWithStratum> {

+public class StratumConfiguration<C extends LevelConfigurationWithStratum, A extends T3Action<C>> {

-    private final C configuration;

+    private final LevelInputContext<C, A> inputContext;

     private final Collection<ZoneStratumAware> zones;

-    private final ZoneStratumAwareMeta zoneMeta;

     private final ZoneStratumAware zone;

     private final SchoolType schoolType;

     private final WeightCategoryTreatment weightCategoryTreatment;

     private final T3Date beginDate;

     private final T3Date endDate;

-    private final Set<Vessel> possibleCatchVessels;

-    private final Set<Vessel> possibleSampleVessels;

     private final Map<String, Integer> stratumMinimumCountBySpecie;

-    private final LoadingCache<String, Activity> activityCache;

+    private final List<WeightCategoryTreatment> weightCategoryTreatments;

     private final int stratumIndex;

+    private final LengthWeightConversionWithContextCache conversionHelper;

     private String[] zoneIds;

-    protected StratumConfiguration(C configuration,

-                                   ZoneStratumAwareMeta zoneMeta,

+    protected StratumConfiguration(LevelInputContext<C, A> inputContext,

                                    ZoneStratumAware zone,

                                    SchoolType schoolType,

                                    WeightCategoryTreatment weightCategoryTreatment,

                                    T3Date beginDate,

                                    T3Date endDate,

                                    Collection<ZoneStratumAware> zones,

-                                   Set<Vessel> possibleCatchVessels,

-                                   Set<Vessel> possibleSampleVessels,

                                    Map<String, Integer> stratumMinimumCountBySpecie,

-                                   LoadingCache<String, Activity> activityCache,

+                                   List<WeightCategoryTreatment> weightCategoryTreatments,

                                    int stratumIndex) {

-        this.configuration = configuration;

-        this.zoneMeta = zoneMeta;

+        this.inputContext = inputContext;

         this.zone = zone;

         this.schoolType = schoolType;

+        this.weightCategoryTreatments = weightCategoryTreatments;

         this.weightCategoryTreatment = weightCategoryTreatment;

         this.beginDate = beginDate;

         this.endDate = endDate;

         this.zones = zones;

-        this.possibleCatchVessels = possibleCatchVessels;

-        this.possibleSampleVessels = possibleSampleVessels;

         this.stratumMinimumCountBySpecie = stratumMinimumCountBySpecie;

-        this.activityCache = activityCache;

         this.stratumIndex = stratumIndex;

+        this.conversionHelper = inputContext.newLengthWeightConversionWithContextCache(zone.getOcean(), beginDate.toBeginDate());

+    }

+

+    public LengthWeightConversionWithContextCache getConversionHelper() {

+        return conversionHelper;

     }

     public C getConfiguration() {

-        return configuration;

+        return inputContext.getConfiguration();

     }

     private ZoneStratumAwareMeta getZoneMeta() {

-        return zoneMeta;

+        return inputContext.getZoneMeta();

     }

     public String getZoneTableName() {

     public Set<String> getSchoolTypeIds() {

         ImmutableSet.Builder<String> builder = ImmutableSet.<String>builder().add(getSchoolType().getTopiaId());

-        switch (configuration.getSchoolTypeIndeterminate()) {

+        switch (getConfiguration().getSchoolTypeIndeterminate()) {

             case ALL_IN_BO:

-                if (AbstractSchoolTypeTopiaDao.SCHOOL_TYPE_BO_ID.equals(getSchoolType().getTopiaId())) {

-                    builder.add(AbstractSchoolTypeTopiaDao.SCHOOL_TYPE_INDETERMINATE_ID);

+                if (SchoolTypeTopiaDao.SCHOOL_TYPE_BO_ID.equals(getSchoolType().getTopiaId())) {

+                    builder.add(SchoolTypeTopiaDao.SCHOOL_TYPE_INDETERMINATE_ID);

                 }

                 break;

             case ALL_IN_BL:

-                if (AbstractSchoolTypeTopiaDao.SCHOOL_TYPE_BL_ID.equals(getSchoolType().getTopiaId())) {

-                    builder.add(AbstractSchoolTypeTopiaDao.SCHOOL_TYPE_INDETERMINATE_ID);

+                if (SchoolTypeTopiaDao.SCHOOL_TYPE_BL_ID.equals(getSchoolType().getTopiaId())) {

+                    builder.add(SchoolTypeTopiaDao.SCHOOL_TYPE_INDETERMINATE_ID);

                 }

                 break;

             case IGNORE:

     }

     public Set<Vessel> getPossibleCatchVessels() {

-        return possibleCatchVessels;

+        return inputContext.getPossibleCatchVessels();

     }

     public Set<Vessel> getPossibleSampleVessels() {

-        return possibleSampleVessels;

+        return inputContext.getPossibleSampleVessels();

     }

     public Map<String, Integer> getStratumMinimumCountBySpecie() {

         return stratumIndex;

     }

+    public List<WeightCategoryTreatment> getWeightCategoryTreatments() {

+        return weightCategoryTreatments;

+    }

+

+    public Predicate<? super SpeciesAware> getSpeciesToFixFilter() {

+        return inputContext.getSpeciesToFixFilter();

+    }

+

     public String[] getZoneIds() {

         if (zoneIds == null) {

             Collection<ZoneStratumAware> allZones = getZones();

     public Activity getActivity(String activityId) {

         try {

-            return activityCache.get(activityId);

+            return inputContext.getActivityCache().get(activityId);

         } catch (ExecutionException e) {

             throw new RuntimeException(String.format("Could not obtain activity %s", activityId), e);

         }

         if (currentLevel == null) {

             result = "";

         }

-        result += String.format("(%s;%s;%d)", zone.getLabel1(), configuration.isUseWeightCategoriesInStratum() ? weightCategoryTreatment.getLabel1() : "NA", level);

+        result += String.format("(%s;%s;%d)", zone.getLabel1(), getConfiguration().isUseWeightCategoriesInStratum() ? weightCategoryTreatment.getLabel1() : "NA", level);

         Objects.requireNonNull(consumer).accept(activity, result);

     }

 }
  * it under the terms of the GNU Affero General Public License as published by

  * the Free Software Foundation, either version 3 of the License, or

  * (at your option) any later version.

- * 

+ *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

- * 

+ *

  * You should have received a copy of the GNU Affero General Public License

  * along with this program.  If not, see <http://www.gnu.org/licenses/>.

  * #L%

  */

 public abstract class StratumResult<C extends LevelConfigurationWithStratum> implements Closeable {

-    private final StratumConfiguration<C> configuration;

+    private final StratumConfiguration<C, ?> configuration;

     private final String label;

     private int nbActivitiesWithSample;

-    protected StratumResult(StratumConfiguration<C> configuration, String label) {

+    protected StratumResult(StratumConfiguration<C, ?> configuration, String label) {

         this.configuration = configuration;

         this.label = label;

     }

-    public StratumConfiguration<C> getConfiguration() {

+    public StratumConfiguration<C, ?> getConfiguration() {

         return configuration;

     }

         return substitutionLevel;

     }

-    public int getNbActivities() {

-        return nbActivities;

-    }

-

-    public int getNbActivitiesWithSample() {

-        return nbActivitiesWithSample;

-    }

-

-    public int getNbActivitiesWithoutSample() {

-        return nbActivities - nbActivitiesWithSample;

-    }

-

     public void setSubstitutionLevel(int substitutionLevel) {

         this.substitutionLevel = substitutionLevel;

     }

+    public int getNbActivities() {

+        return nbActivities;

+    }

+

     public void setNbActivities(int nbActivities) {

         this.nbActivities = nbActivities;

     }

+    public int getNbActivitiesWithSample() {

+        return nbActivitiesWithSample;

+    }

+

     public void setNbActivitiesWithSample(int nbActivitiesWithSample) {

         this.nbActivitiesWithSample = nbActivitiesWithSample;

     }

+    public int getNbActivitiesWithoutSample() {

+        return nbActivities - nbActivitiesWithSample;

+    }

+

     public void addNbActivities(int nbActivities) {

         this.nbActivities += nbActivities;

     }

 import fr.ird.t3.entities.reference.Ocean;

 import fr.ird.t3.entities.reference.Species;

 import fr.ird.t3.entities.reference.WeightCategory;

+import fr.ird.t3.entities.reference.WeightCategoryTreatment;

 import fr.ird.t3.entities.type.T3Date;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import java.util.Date;

 import java.util.Iterator;

+import java.util.LinkedList;

 import java.util.List;

 import java.util.Map;

 import java.util.TreeMap;

         return result;

     }

+    public List<Integer> getLengthClasses(LengthWeightConversion conversion, WeightCategoryTreatment weightCategoryTreatment, List<Integer> lengthClasses) {

+        Integer min = weightCategoryTreatment.getMin();

+        Integer minLengthClass = null;

+        if (min != null) {

+            minLengthClass = getSpecieHighestLengthClass(conversion, min);

+        }

+        Integer max = weightCategoryTreatment.getMax();

+        Integer maxLengthClass = null;

+        if (max != null) {

+            maxLengthClass = getSpecieHighestLengthClass(conversion, max);

+        }

+        List<Integer> result = new LinkedList<>();

+        for (Integer lengthClass : lengthClasses) {

+            if (minLengthClass != null && lengthClass < minLengthClass || maxLengthClass != null && lengthClass > maxLengthClass) {

+                continue;

+            }

+            result.add(lengthClass);

+        }

+        return result;

+    }

 }
     public boolean withCorrectedElementaryCatch(WeightCategoryTreatment weightCategoryTreatment) {

         return isCorrectedElementaryCatchNotEmpty() && getCorrectedElementaryCatch().stream().map(CorrectedElementaryCatch::getWeightCategoryTreatment).anyMatch(c -> c.equals(weightCategoryTreatment));

     }

+

+    @Override

+    public boolean withSetSpeciesCatWeight(WeightCategoryTreatment weightCategoryTreatment) {

+        return isSetSpeciesCatWeightNotEmpty() && getSetSpeciesCatWeight().stream().map(SetSpeciesCatWeight::getWeightCategoryTreatment).anyMatch(c -> c.equals(weightCategoryTreatment));

+    }

 }

Tony CHEMIT pushed to branch develop at ultreiaio / ird-t3

Commits:

29 changed files:

Changes: