CustomNode.java

/*

* CustomNode.java
*
* Created on January 22, 2005, 2:41 PM
* Modified on June 14, 2006
*
* This class contains the parameters and methods
*  for an agent acting on the network
*/

package CoopNetBlue; import uchicago.src.sim.gui.NetworkDrawable; import uchicago.src.sim.network.DefaultDrawableNode; import uchicago.src.sim.gui.DrawableNonGridNode; import uchicago.src.sim.util.Random; import uchicago.src.sim.gui.OvalNetworkItem; import java.awt.Color; import uchicago.src.sim.gui.ColorMap; import uchicago.src.sim.engine.CustomProbeable; import java.util.ArrayList;

/**

*
* @author Jack Waddell
*
*/

// DefaultDrawableNode lets us draw it in the GUI // CustomProbeable lets us define which attributes appear when // probed in the GUI public class CustomNode extends DefaultDrawableNode implements CustomProbeable {

   //***********************************
   // Static Parameters

   // tracks next unique id
   public static int                   nextID = 0;      
   
   public static GUIModel              guiModel = null;
   public static CoopNetBlue           model;

   //********************************8**
   // Instance parameters

   // Two colormaps are generated for color-coding the nodes in GUI
   public static ColorMap              centerColorMap;    
   public static ColorMap              edgeColorMap;
   public static final int             colorMapSize = 16;
   public static final int             colorMapMax = colorMapSize - 1;
   

   private int   id;                   // uniquely ids node
   public Color  myColor;              // used to draw color in GUI
   public String myPajekColor = "Red"; // color to appear in Pajek output
   public int    utility;              // current wealth or stored utility
   public double    strategy;          // strategy parameter

   ///////////////////////////////////////////////////////////////
   // constructor
   // Inputs: NetworkDrawable drawable, to draw in GUI
   //         double strategy, the strategy parameter
   public CustomNode (NetworkDrawable drawable, double strategy) {

super(drawable); id = nextID++; // set id and iterate to next this.strategy = strategy; utility = 50; // Generalize. Currently hard-coded if (guiModel != null) setNodeEdgeColorFromStrategy();

   }
    
   ///////////////////////////////////////////////////////////
   // getProbedProperties
   // Required to implement CustomProbeable
   // Inputs: none
   // Outputs: array of strings holding parameter names
   public String[] getProbedProperties(){

return new String[] {"id", "utility", "strategy"};

   }
    
   //////////////////////////////////////////////////////////
   // step
   // Input:  none
   // Output: none
   // (Can be) Called by main model to have nodes execute a single step
   public void step(){
   }

   //////////////////////////////////////////////////////////
   // setNodeColorFromUtility
   // Input:  maxUtility, the highest utility from all agents
   // Output: none
   // Sets the node color to the colormap leval depending on utility
   public void setNodeColorFromUtility(int maxUtility){

int i = (int) Math.round(colorMapMax*((double)utility)/ ((double) maxUtility)); this.setColor(centerColorMap.getColor(i)); /*if (rDebug > 1){ double rat = ((double) getUtility())/((double) maxUtility); int ival = (int) Math.round(rat*colorMapSize); System.out.printf("%d/%d = %f -> %d\n", getUtility(), maxUtility, rat, ival); }*/

   }
   
   //////////////////////////////////////////////////////////
   // setNodeEdgeColorFromStrategy
   // Input:  none
   // Output: none
   // Sets the node edge color to the colormap level depending on strategy
   public void setNodeEdgeColorFromStrategy(){

int i = (int) Math.round(colorMapMax*strategy); this.setBorderColor(edgeColorMap.getColor(i)); this.setBorderWidth(3); /*if (rDebug > 1){ double rat = ((double) getUtility())/((double) maxUtility); int ival = (int) Math.round(rat*colorMapSize); System.out.printf("%d/%d = %f -> %d\n", getUtility(), maxUtility, rat, ival); }*/

   }

   ////////////////////////////////////////////////////////////
   // bearChild
   // Input:  none
   // Output: node
   // Creates a child node
   public void bearChild(){

double deviation = model.getNormalDouble(0, 0.1); // mutate child double childStrategy = strategy + deviation; childStrategy = Math.min(1, Math.max(0, childStrategy));

OvalNetworkItem drawable = new OvalNetworkItem(0,0);

CustomNode child = new CustomNode(drawable, childStrategy); ArrayList<CustomNode> parentNeighbors = this.getOutNodes(); for (CustomNode neighbor : parentNeighbors){ CustomEdge edge1 = new CustomEdge(child, neighbor); CustomEdge edge2 = new CustomEdge(neighbor, child);

// I think you have to add edges in and out to make it // undirected. child.addOutEdge(edge1); neighbor.addInEdge(edge1); child.addInEdge(edge2); neighbor.addOutEdge(edge2); } CustomEdge edge1 = new CustomEdge(this, child); CustomEdge edge2 = new CustomEdge(child, this);

child.addOutEdge(edge2); this.addInEdge(edge2); child.addInEdge(edge1); this.addOutEdge(edge1);

if (guiModel!=null) guiModel.addAgent(child); else model.addAgent(child);

   }

   //////////////////////////////////////////////////////
   // die
   // Inputs: none
   // Outputs: none
   // Kills an agent
   public void die(){

// Go through neighbors, removing links to or from node // Make sure you get them all! ArrayList<CustomNode> neighbors = this.getOutNodes(); for (CustomNode neigh : neighbors){ neigh.removeEdgesFrom(this); neigh.removeEdgesTo(this); } if (guiModel != null) guiModel.delAgent(this); else model.delAgent(this);

   }

   ///////////////////////////////////////////////////////
   // getDegree
   // Input: none
   // Output: int degree
   // Calculates the degree of the node (assuming symmetric)
   public int getDegree(){	

return (this.getOutNodes()).size();

   }

   //***************************************************************
   // Getters and Setters
   public int      getID() {return id;}

   public void     setMyPajekColor(String i) {myPajekColor = i;}
   public String   getMyPajekColor() {return myPajekColor;}
   
   public int      getUtility() {return utility;}
   public void     setUtility(int i) {utility = i;}

   public int      incUtility() {return ++utility;}
   public int      decUtility() {return --utility;}

   public double   getStrategy() {return strategy;}
   public void     setStrategy(double i) {strategy = i;}
   
   //***************************************************************
   // Static Methods

   public static void setModel(CoopNetBlue m) {model = m;}

   //////////////////////////////////////////////////////////
   // setUpNodeDrawing
   // Input: GUIModel m, a pointer to the GUIModel
   // Output: none
   public static void setUpNodeDrawing (GUIModel m) {

guiModel = m; centerColorMap = new ColorMap(); edgeColorMap = new ColorMap(); double minColor = 0.1;

for (int i = 0; i < colorMapSize; i++){ double fracColor = minColor + ( (1.0-minColor)*i/colorMapMax );

centerColorMap.mapColor(i, 0, 0, fracColor); edgeColorMap.mapColor(i, 0, fracColor, 0); }

   }

   ///////////////////////////////////////////////////////////
   // resetNextID
   // Inputs:  none
   // Outputs: none
   // Resets nextID.  Called when the model is reset, and a 
   //  new set of nodes is generated
   public static void resetNextID(){

nextID = 0;

   }

}