net.sourceforge.jabm.report.StrategyExecutionFrequency.java Source code

Introduction

Here is the source code for net.sourceforge.jabm.report.StrategyExecutionFrequency.java

Source

/*
 * JABM - Java Agent-Based Modeling Toolkit
 * Copyright (C) 2013 Steve Phelps
 *
 * 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 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.
 */
package net.sourceforge.jabm.report;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import net.sourceforge.jabm.Population;
import net.sourceforge.jabm.agent.Agent;
import net.sourceforge.jabm.event.SimEvent;
import net.sourceforge.jabm.event.SimulationStartingEvent;
import net.sourceforge.jabm.event.StrategyExecutedEvent;
import net.sourceforge.jabm.strategy.Strategy;

import org.apache.commons.math3.stat.Frequency;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.annotation.Required;

/**
 * <p>
 * This class collects data on the frequency with which each strategy is
 * executed.
 * </p>
 * 
 * @see net.sourceforge.jabm.strategy.Strategy
 * @author Steve Phelps
 * 
 */
public class StrategyExecutionFrequency extends AbstractReportVariables implements InitializingBean {

    protected Frequency executionFrequency = new Frequency();

    //   protected Frequency reportedFrequency = new Frequency();

    protected List<String> keyList;

    /**
     * If agent is non-null then only track strategies executed by
     * the specified agent.
     */
    protected Agent agent = null;

    protected Population population;

    protected int agentIndex = -1;

    public static final String NAME = "frequency";

    static Logger logger = Logger.getLogger(StrategyExecutionFrequency.class);

    public StrategyExecutionFrequency() {
        super(NAME);
    }

    @Override
    @SuppressWarnings(value = "rawtypes")
    public Map<Object, Number> getVariableBindings() {
        Map<Object, Number> result = super.getVariableBindings();
        Iterator i = executionFrequency.valuesIterator();
        if (keyList != null) {
            i = keyList.iterator();
        }
        while (i.hasNext()) {
            String tag = (String) i.next();
            result.put(NAME + "." + tag, getPercentage(tag));
        }
        return result;
    }

    public double getPercentage(String tag) {
        double result = executionFrequency.getPct(tag);
        if (Double.isNaN(result)) {
            result = 0.0;
        }
        return result;
    }

    @Override
    public void eventOccurred(SimEvent event) {
        super.eventOccurred(event);
        if (event instanceof StrategyExecutedEvent) {
            onStrategyExecuted((StrategyExecutedEvent) event);
        } else if (event instanceof SimulationStartingEvent) {
            onSimulationStarting((SimulationStartingEvent) event);
        }
    }

    public void onSimulationStarting(SimulationStartingEvent event) {
        if (agentIndex >= 0) {
            Population population = event.getSimulation().getPopulation();
            this.agent = population.getAgentList().get(agentIndex);
        }
    }

    public void onStrategyExecuted(StrategyExecutedEvent event) {
        Strategy strategy = event.getStrategy();
        if ((this.agent == null) || (strategy.getAgent() == this.agent)) {
            String tag = tag(event.getStrategy());
            executionFrequency.addValue(tag);
        }
    }

    @Override
    public void initialise(SimEvent event) {
        logger.debug("Reseting on " + event);
        super.initialise(event);
        executionFrequency = new Frequency();
    }

    @Override
    public void compute(SimEvent event) {
        //      reportedFrequency = executionFrequency;
        //      executionFrequency = new Frequency();
        super.compute(event);
    }

    @SuppressWarnings(value = "rawtypes")
    public List getKeyList() {
        return keyList;
    }

    /**
     * Configure the list of the strategies which this report will track.
     * 
     * @param keySetObjects
     *            The list of strategies which will be tracked. These can be
     *            object factories, object instances, or strings denoting the
     *            tag of a strategy.
     */
    @Required
    @SuppressWarnings(value = "rawtypes")
    public void setKeyList(List keySetObjects) {
        this.keyList = new LinkedList<String>();
        for (Object object : keySetObjects) {
            if (object instanceof ObjectFactory) {
                object = ((ObjectFactory) object).getObject();
            }
            this.keyList.add(tag(object));
        }
    }

    public int getAgentIndex() {
        return agentIndex;
    }

    /**
     * The index of a particular agent within the population whose
     *  strategy executions we want to track.
     *  
     * @param agentIndex
     */
    public void setAgentIndex(int agentIndex) {
        this.agentIndex = agentIndex;
    }

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

    @Override
    public void afterPropertiesSet() throws Exception {
        for (String key : keyList) {
            yVariableNames.add(NAME + "." + key);
        }
    }

}