GenericStrategyManagerImpl.java

Go to the documentation of this file.

/* *********************************************************************** *
 * project: org.matsim.*                                                   *
 *                                                                         *
 * *********************************************************************** *
 *                                                                         *
 * copyright       : (C) 2008 by the members listed in the COPYING,        *
 *                   LICENSE and WARRANTY file.                            *
 * email           : info at matsim dot org                                *
 *                                                                         *
 * *********************************************************************** *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *   See also COPYING, LICENSE and WARRANTY file                           *
 *                                                                         *
 * *********************************************************************** */
package org.matsim.core.replanning;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.population.*;
import org.matsim.core.population.PopulationUtils;
import org.matsim.core.replanning.choosers.StrategyChooser;
import org.matsim.core.replanning.choosers.WeightedStrategyChooser;
import org.matsim.core.replanning.selectors.PlanSelector;
import org.matsim.core.replanning.selectors.GenericWorstPlanForRemovalSelector;
import org.matsim.core.replanning.selectors.RandomPlanSelector;
import org.matsim.core.replanning.selectors.WorstPlanForRemovalSelector;

public class GenericStrategyManagerImpl<PL extends BasicPlan, AG extends HasPlansAndId<? extends BasicPlan, AG>> implements GenericStrategyManager<PL, AG>{
    // the "I extends ... <, I>" is correct, although it feels odd.  kai, nov'15

    private static final Logger log = LogManager.getLogger( GenericStrategyManagerImpl.class );


    static class StrategyWeights<T extends BasicPlan, I> implements StrategyChooser.Weights<T, I> {
        final List<GenericPlanStrategy<T, I>> strategies = new ArrayList<>();
        final List<GenericPlanStrategy<T, I>> unmodifiableStrategies = Collections.unmodifiableList( strategies );
        final List<Double> weights = new ArrayList<>();
        final List<Double> unmodifiableWeights = Collections.unmodifiableList(weights);
        double totalWeights = 0.0;
        final Map<Integer, Map<GenericPlanStrategy<T, I>, Double>> changeRequests = new TreeMap<>();

        @Override public int size() {
            return weights.size();
        }

        @Override public double getWeight(int idx) {
            return weights.get(idx);
        }

        @Override public GenericPlanStrategy<T, I> getStrategy(int idx) {
            return strategies.get(idx);
        }

        @Override public double getTotalWeights() {
            return totalWeights;
        }
    }

    private final Map<String, StrategyWeights<PL, AG>> weightsPerSubpopulation = new HashMap<>();

    private int maxPlansPerAgent = 0;

    private PlanSelector<PL, AG> removalPlanSelector = new GenericWorstPlanForRemovalSelector<>();

    private final StrategyChooser<PL, AG> strategyChooser;


//  private String subpopulationAttributeName = null;

    public GenericStrategyManagerImpl() {
        this(new WeightedStrategyChooser<>());
    }

    public GenericStrategyManagerImpl( StrategyChooser<PL, AG> strategyChooser ) {
        this.strategyChooser = strategyChooser;
    }

    //  /**
//   * @param name the name of the subpopulation attribute
//   * in the person's object attributes.
//   */
//  public final void setSubpopulationAttributeName(final String name) {
//      this.subpopulationAttributeName = name;
//  }

    @Override public final void addStrategy(
            final GenericPlanStrategy<PL, AG> strategy,
            final String subpopulation,
            final double weight )
    {
        final StrategyWeights<PL, AG> weights = getStrategyWeights( subpopulation );
        if ( weights.strategies.contains( strategy ) ) {
            log.error( "Strategy "+strategy+" is already defined for subpopulation "+subpopulation  );
            log.error( "This can lead to undefined behavior. Please only specify each strategy once" );
            throw new IllegalStateException( "Strategy "+strategy+" is already defined for subpopulation "+subpopulation  );
        }
        weights.strategies.add(strategy);
        weights.weights.add(weight);
        weights.totalWeights += weight;
    }

    final boolean removeStrategy(
            final GenericPlanStrategy<PL, AG> strategy,
            final String subpopulation)
    {
        final StrategyWeights<PL, AG> weights = getStrategyWeights( subpopulation );
        int idx = weights.strategies.indexOf(strategy);
        if (idx != -1) {
            weights.strategies.remove(idx);
            double weight = weights.weights.remove(idx);
            weights.totalWeights -= weight;
            return true;
        }
        return false;
    }



    private StrategyWeights<PL, AG> getStrategyWeights(final String subpop) {
        StrategyWeights<PL, AG> weights = weightsPerSubpopulation.get(subpop);

        if ( weights == null ) {
            weights = new StrategyWeights<>();
            weightsPerSubpopulation.put(subpop, weights);
        }

        return weights;
    }

    final boolean changeWeightOfStrategy(
            final GenericPlanStrategy<PL, AG> strategy,
            final String subpopulation,
            final double newWeight) {
        final StrategyWeights<PL, AG> weights = getStrategyWeights(subpopulation);
        int idx = weights.strategies.indexOf(strategy);
        if (idx != -1) {
            double oldWeight = weights.weights.set(idx, newWeight);
            weights.totalWeights += (newWeight - oldWeight);
            LogManager.getLogger(this.getClass()).info( strategy.toString() + ": oldWeight=" + oldWeight + " newWeight=" + newWeight );
            return true;
        }
        return false;
    }

    @Override public final void run(
            final Iterable<? extends HasPlansAndId<PL, AG>> persons,
            final int iteration,
            final ReplanningContext replanningContext ) {
        handleChangeRequests(iteration);
        run(persons, replanningContext );
    }

    final void run(
            final Iterable<? extends HasPlansAndId<PL, AG>> persons,
            final ReplanningContext replanningContext )
    {
        this.strategyChooser.beforeReplanning(replanningContext);

        // initialize all strategies
        for (GenericPlanStrategy<PL, AG> strategy : distinctStrategies()) {
            strategy.init(replanningContext);
        }

        // then go through the population and ...
        for (HasPlansAndId<PL, AG> person : persons ) {

            // ... reduce the number of plans to the allowed maximum (in evol comp lang this is "selection")
            if ((this.maxPlansPerAgent > 0) && (person.getPlans().size() > this.maxPlansPerAgent)) {
                removePlans( person, this.maxPlansPerAgent);
            }

            // ... choose the strategy to be used for this person (in evol comp lang this would be the choice of the mutation operator)
//          String subpopName = null;
//          if (this.subpopulationAttributeName != null) {
//              subpopName = (String) PopulationUtils.getPersonAttribute( person, this.subpopulationAttributeName) ;
//          }
            String subpopName = PopulationUtils.getSubpopulation( person );
            GenericPlanStrategy<PL, AG> strategy = this.chooseStrategy(person, subpopName, replanningContext);

            if (strategy==null) {
                throw new RuntimeException("No strategy found! Have you defined at least one replanning strategy per subpopulation? Current subpopulation = " + subpopName);
            }

            // ... and run the strategy:
            strategy.run(person);
        }

        // finally make sure all strategies have finished there work
        for (GenericPlanStrategy<PL, AG> strategy : distinctStrategies()) {
            strategy.finish();
        }

    }

    private Collection<GenericPlanStrategy<PL, AG>> distinctStrategies() {
        // Leaving out duplicate strategies in different subpopulations
        Collection<GenericPlanStrategy<PL, AG>> strategies = new LinkedHashSet<>();
        for (StrategyWeights<PL, AG> weights : weightsPerSubpopulation.values()) {
            strategies.addAll(weights.strategies);
        }
        return strategies;
    }

    private void removePlans(final HasPlansAndId<PL, AG> person, final int maxNumberOfPlans) {
        while (person.getPlans().size() > maxNumberOfPlans) {
            PL plan = this.removalPlanSelector.selectPlan(person);
            person.removePlan(plan);
            if (plan == person.getSelectedPlan()) {
                final PL newPlanToSelect = new RandomPlanSelector<PL, AG>().selectPlan(person) ;
                if ( newPlanToSelect == null ) {
                    throw new IllegalStateException( "could not find a plan to select for person "+person );
                }
                person.setSelectedPlan( newPlanToSelect );
            }
        }
    }

    final void handleChangeRequests(final int iteration) {
        for ( int ii = 0 ; ii <= iteration ; ii++ ) {
            // (playing back history for those installations which recreate the strategy manager in every iteration)
            for ( Map.Entry<String, StrategyWeights<PL, AG>> wentry : weightsPerSubpopulation.entrySet() ) {
                final String subpop = wentry.getKey();
                final StrategyWeights<PL, AG> weights = wentry.getValue();
                Map<GenericPlanStrategy<PL, AG>, Double> changes = weights.changeRequests.remove(ii);
                if (changes != null) {
                    for (Map.Entry<GenericPlanStrategy<PL, AG>, Double> entry : changes.entrySet()) {
                        changeWeightOfStrategy( entry.getKey(), subpop, entry.getValue());
                    }
                }
            }
        }
    }

    /* deliberately package */ GenericPlanStrategy<PL, AG> chooseStrategy(HasPlansAndId<PL, AG> person, final String subpopulation, ReplanningContext replanningContext) {
        return strategyChooser.chooseStrategy(person, subpopulation, replanningContext, this.getStrategyWeights(subpopulation)) ;
    }

    @Override public final void setMaxPlansPerAgent( final int maxPlansPerAgent ) {
        this.maxPlansPerAgent = maxPlansPerAgent;
    }

    @Override public final void addChangeRequest(
            final int iteration,
            final GenericPlanStrategy<PL, AG> strategy,
            final String subpopulation,
            final double newWeight ) {
        final StrategyWeights<PL, AG> weights = getStrategyWeights( subpopulation );
        Integer iter = iteration;
        Map<GenericPlanStrategy<PL, AG>, Double> iterationRequests = weights.changeRequests.get(iter);
        if (iterationRequests == null) {
            iterationRequests = new HashMap<>(3);
            weights.changeRequests.put(iter, iterationRequests);
        }
        iterationRequests.put(strategy, newWeight);
        LogManager.getLogger(this.getClass()).info( "added change request: "
                + " iteration=" + iter + " newWeight=" + newWeight + " strategy=" + strategy.toString() );
    }

    @Override public final void setPlanSelectorForRemoval( final PlanSelector<PL, AG> planSelector ) {
        LogManager.getLogger(this.getClass()).info("setting PlanSelectorForRemoval to " + planSelector.getClass() ) ;
        this.removalPlanSelector = planSelector;
    }

    final int getMaxPlansPerAgent() {
        return this.maxPlansPerAgent ;
    }

    @Override public final List<GenericPlanStrategy<PL, AG>> getStrategies( String subpopulation ) {
        return getStrategyWeights( subpopulation ).unmodifiableStrategies;
    }

    @Override public final List<Double> getWeights( String subpopulation ) {
        return getStrategyWeights( subpopulation ).unmodifiableWeights;
    }

}