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

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

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

 import fr.ird.t3.services.DecoratorService;

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

 import org.apache.commons.logging.Log;

 import org.nuiton.util.TimeLog;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Map;

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

 /**

  *

  * @author Tony Chemit - dev@tchemit.fr

  * @since 1.0

     private LengthWeightConversionTopiaDao lengthWeightConversionDAO;

     @InjectDAO(entityType = SetSpeciesFrequency.class)

     private SetSpeciesFrequencyTopiaDao setSpeciesFrequencyDAO;

     private LengthWeightConversionHelper conversionHelper;

     public ExtrapolateSampleWeightToSetAction() {

         super(Level1Step.EXTRAPOLATE_SAMPLE_WEIGHT_TO_SET);

     }

     public int getNbTreatedSets() {

         return nbTreatedSets;

     }

         this.nbTreatedSets = nbTreatedSets;

     }

     public float getNbTreatedFishesInSamples() {

         return nbTreatedFishesInSamples;

     }

         this.nbTreatedFishesInSamples = nbTreatedFishesInSamples;

     }

     public float getNbCreatedFishesInSetSpeciesFrequency() {

         return nbCreatedFishesInSetSpeciesFrequency;

     }

     @Override

     protected void prepareAction() throws Exception {

         super.prepareAction();

         conversionHelper = lengthWeightConversionDAO.newConversionHelper();

     }

     private void doExecuteTrip(Trip trip, Collection<Sample> samples) {

         incrementsProgression();

         Set<Activity> tripActivities = new HashSet<>();

         // extrapolate for each sample set number to set

         for (Sample sample : samples) {

             long s0 = TimeLog.getTime();

             incrementsProgression();

             float nb = sample.getTotalStandardiseSampleSpeciesFrequencyNumber();

             addInfoMessage(l(locale, "t3.level1.extrapolateSampleWeightToSet.sample.nbFishes", sampleStr, nb));

             nbTreatedFishesInSamples += nb;

             for (SampleSet sampleSet : sample.getSampleSet()) {

                 Activity activity = sampleSet.getActivity();

                 boolean added = tripActivities.add(activity);

                 if (added) {

                     // remove all stuff from activity

     }

     /**

      * <ul>

      * <li>his total weight</<li>

      * <li>his weight of -10Kg category</<li>

      *

      * @param sampleWellStr           sampleSet decorate value

      * @param setWeight               the sampleSet weight computed

      * @param useRfMinus10AndRfPlus10 flag to try to use rf-10 and rf+10

      * @return the computed rf context for the given sample set

      */

         float pondt = setWeight.getTotalWeight();

         Float pondp = setWeight.getPlus10Weight();

         Float pondm = setWeight.getMinus10Weight();

         // compute rftot

         float rftot = pondt / pdecht;

         // compute rfMinus10

         Float rfMinus10 = null;

         if (pdechm != null && pdechm > 0 && pondm != null) {

             rfMinus10 = pondm / pdechm;

         }

         // compute rfPlus10

         Float rfPlus10 = null;

         if (pdechp != null && pdechp > 0 && pondp != null) {

             rfPlus10 = pondp / pdechp;

                 rfMinus10Status = RfUsageStatus.REJECTED_RF_NOT_DEFINED;

             } else {

                 int rfMinus10MinNumber = getConfiguration().getRfMinus10MinNumber();

                 if (Math.abs(rfMinus10) < 0.001f) {

                     addWarningMessage(l(locale, "t3.level1.extrapolateSampleWeightToSet.warning.rfMinus10.too.low",

                             sampleWellStr, rfMinus10, rftot));

                 rfPlus10Status = RfUsageStatus.REJECTED_RF_NOT_DEFINED;

             } else {

                 int rfPlus10MinNumber = getConfiguration().getRfPlus10MinNumber();

                 if (Math.abs(rfPlus10) < 0.001f) {

                     addWarningMessage(l(locale, "t3.level1.extrapolateSampleWeightToSet.warning.rfPlus10.too.low",

                             sampleWellStr, rfPlus10, rftot));

     }

     /**

      *

      * @return the universe of length class limits computed indexed by species

      */

         // for each of those species, found the length class which matches a weight > 10Kg

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

         for (Species specie : species) {

             if (conversion != null) {

                 // only add conversion for species if found

                 result.put(specie, lengthClass);

             }

         }

         return result;

     }

     /**

      * This object contains the sample weights (-10,+10 and total) for sample well.

      * <ul>

      */

     protected static class SampleWellSampleWeight {

         Float minus10Weight;

         Float plus10Weight;

         /** Number of fishes for length class > -10Kg. */

         private Float plus10Number;

     }

     /**

      * <ul>

      * <li>{@link #getMinus10Weight()} is legacy {@code pondm}</li>

      * <li>{@link #getPlus10Weight()}} is legacy {@code pondp}</li>

      */

     protected static class SampleWellSetWeight {

         Float totalWeight;

         Float minus10Weight;

         Float plus10Weight;

         protected static SampleWellSetWeight create(Float totalWeight, Float minus10Weight, Float plus10Weight) {

  * 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.models.WeightCompositionModelHelper;

 import fr.ird.t3.services.DecoratorService;

 import fr.ird.t3.services.T3ServiceContext;

 import java.io.IOException;

 import java.util.Collection;

  */

 public class L2CatchStratum extends CatchStratum<Level2Configuration, Level2Action> {

     /**

      * All species used by all weight categories found in all catches

      * for this stratum.

      */

     private WeightCompositionAggregateModel inputModelForSpeciesToFix;

         super(stratumConfiguration, speciesToFix);

         weightCategoriesForSpecies = HashMultimap.create();

         inputModelForAllSpecies = new WeightCompositionAggregateModel();

         outputModelForAllSpecies = new WeightCompositionAggregateModel();

     }

     @Override

     public void close() throws IOException {

         super.close();

             Integer nbZones = e.getValue();

             if (activity.isCorrectedElementaryCatchNotEmpty()) {

                 for (CorrectedElementaryCatch aCatch : activity.getCorrectedElementaryCatch()) {

                     weightCategoriesForSpecies.put(aCatch.getWeightCategoryTreatment(), aCatch.getSpecies());

                 }

             }

             Multimap<WeightCategoryTreatment, CorrectedElementaryCatch> correctedElementaryCatchesByCategory =

                     ActivityTopiaDao.groupByWeightCategoryTreatment(activity.getCorrectedElementaryCatch());

 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;

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

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

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

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

                 String activityId = e.getKey();

                 // get activity

                 // recheck activity have some catches.

                 Preconditions.checkState(activity.isCorrectedElementaryCatchNotEmpty(),

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

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

             }

         }

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

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

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

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

 import fr.ird.t3.models.WeightCompositionAggregateModel;

 import fr.ird.t3.models.WeightCompositionModelHelper;

 import fr.ird.t3.services.T3ServiceContext;

 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.HashMap;

 import java.util.Locale;

 import java.util.Map;

 import java.util.Set;

      */

     private float sampleStratumTotalWeight;

         super(configuration, speciesToFix);

         this.catchStratumTotalWeight = catchStratumTotalWeight;

         modelsForAllSpecies = new WeightCompositionAggregateModel();

     }

     @Override

     public void close() throws IOException {

         super.close();

     @Override

     protected L2SampleStratumLoader newLoader() {

         int oceanCode = getConfiguration().getZone().getOcean().getCode();

         switch (oceanCode) {

             case 1:

             case 2:

             default:

                 throw new IllegalStateException("Not implemented for ocean with code " + oceanCode);

         }

     }

     public WeightCompositionAggregateModel getModelsForSpeciesToFix() {

             ActivityTopiaDao.fillWeightsFromSetSpeciesCatWeight(activity, weights, null);

             // obtain the set species frequencies for the current activity

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

                 // compute sample count for this activity

                 int newCount = computeSampleCount(setSpeciesFrequencies, species);

                 // merge it with final total count

             }

         }

         // add all weights to model

         }

         // recompute the weight model for species to fix

         modelsForSpeciesToFix = modelsForAllSpecies.extractForSpecies(species);

         // recompute the total sample weight (for species to fix)

         sampleStratumTotalWeight = modelsForSpeciesToFix.getTotalModel().getTotalWeight();

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

     }

         int newCount = 0;

             if (speciesToFix.contains(species)) {

             }

         }

         return newCount;

 import fr.ird.t3.models.WeightCompositionModel;

 import fr.ird.t3.models.WeightCompositionModelHelper;

 import fr.ird.t3.services.DecoratorService;

 import fr.ird.t3.services.ZoneStratumService;

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

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

      *

      * @since 1.3

      */

     @InjectDAO(entityType = Activity.class)

     private ActivityTopiaDao activityDAO;

     @InjectDAO(entityType = WeightCategoryTreatment.class)

         this.possibleCatchVessels = vesselDAO.getPossibleCatchVessels(catchFleets);

         // get possible vessels for sample stratum

         this.possibleSampleVessels = vesselDAO.getPossibleSampleVessels(sampleFleets, sampleFlags);

         this.inputCatchModelForAllSpecies = new WeightCompositionAggregateModel();

         this.outputCatchModelForAllSpecies = new WeightCompositionAggregateModel();

     }

                             activityCache);

             try {

                 L2StratumResult result = doExecuteStratum(stratumConfiguration, weightCategories, stratumIndex, usedActivityIds);

             } finally {

                 flushTransaction("After stratum " + stratumIndex);

             }

         addInfoMessage(message);

         addInfoMessage("==============================================================================================");

         // compute the catch stratum

             incrementsProgression();

             if (catchStratum == null) {

                 // no catch in this stratum

                 incrementsProgression();

             } else {

                 // compute sample stratum

                     incrementsProgression();

                     // get the substitution level for the sample stratum

                     Integer level = sampleStratum.getSubstitutionLevel();

 //                                int nbZones = e.getValue();

                             // is activity was already treated ?

                             boolean newActivity = usedActivityIds.add(activity.getTopiaId());

                                     activity,

                                     activityIndex++,

                                     nbActivities,

         return oceanContext.values().stream().flatMap(o -> o.getZones(schoolType).stream()).distinct().collect(Collectors.toList());

     }

         }

     }

     }

     private void doExecuteActivityInCatchStratum(L2CatchStratum catchStratum,

         }

         // build a model for getting total of each weight category

         WeightCompositionAggregateModel catchWeightModelForAllSpecies = new WeightCompositionAggregateModel();

         ActivityTopiaDao.fillWeightsFromCatchesWeight(activity, catchWeightModelForAllSpecies, nbZones);

         WeightCompositionAggregateModel catchWeightModelForSpeciesToFix = catchWeightModelForAllSpecies.extractForSpecies(species);

         // log catches weight

         message = logCatchWeight(getDecoratorService(), catchWeightModelForAllSpecies, catchWeightModelForSpeciesToFix);

         log.info(message);

         addInfoMessage(message);

         boolean activityWithSample = catchStratum.isActivityWithSample(activity);

         boolean useAllSamplesOfStratum = getConfiguration().isUseAllSamplesOfStratum();

         WeightCompositionAggregateModel compositionModel;

         }

     }

     private void applySampleSpecificComposition(L2CatchStratum catchStratum,

                                                 Activity activity,

                                                 int nbZones,

                                                 WeightCompositionAggregateModel sampleCompositionModel,

                                                 WeightCompositionAggregateModel correctedCatchesForSpeciesToFix) {