CustomNode.java.wp

/*
 * 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 RepMod;
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 RepMod           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 double reputation;              // current wealth or stored reputation
    public double skill;          // skill parameter
    public int    numVotes;              // the number of vote rounds 

    public double success;              // most recent success

    
    ///////////////////////////////////////////////////////////////
    // constructor
    // Inputs: NetworkDrawable drawable, to draw in GUI
    //         double skill, the skill parameter
    public CustomNode (NetworkDrawable drawable, double skill) {
	super(drawable);
	id = nextID++;              // set id and iterate to next
	this.skill = skill;
	reputation = 50;	            // Generalize.  Currently hard-coded
	if (guiModel != null)
	    setNodeEdgeColorFromSkill();
	numVotes = 0;
	success = 0;
    }
     
    ///////////////////////////////////////////////////////////
    // getProbedProperties
    // Required to implement CustomProbeable
    // Inputs: none
    // Outputs: array of strings holding parameter names
    public String[] getProbedProperties(){
	return new String[] {"id", "reputation", "skill", "success"};
    }
     
    //////////////////////////////////////////////////////////
    // step
    // Input:  none
    // Output: none
    // (Can be) Called by main model to have nodes execute a single step
    public void step(){
    }

    //////////////////////////////////////////////////////////
    // setNodeColorFromReputation
    // Input:  maxReputation, the highest reputation from all agents
    // Output: none
    // Sets the node color to the colormap leval depending on reputation
    public void setNodeColorFromReputation(double maxReputation){
	int i = (int) Math.round(colorMapMax*(reputation)/ (maxReputation));
	this.setColor(centerColorMap.getColor(i));
    }
    
    //////////////////////////////////////////////////////////
    // setNodeEdgeColorFromSkill
    // Input:  none
    // Output: none
    // Sets the node edge color to the colormap level depending on skill
    public void setNodeEdgeColorFromSkill(){
	int i = (int) Math.round(colorMapMax*skill);
	this.setBorderColor(edgeColorMap.getColor(i));
	this.setBorderWidth(3);
    }


    ///////////////////////////////////////////////////////
    // getDegree
    // Input: none
    // Output: int degree
    // Calculates the degree of the node (assuming symmetric)
    public int getDegree(){	
	return (this.getOutNodes()).size();
    }

    ///////////////////////////////////////////////////////
    // vote
    // Input: double success, the focus' real success
    // Output: double vote, the voter's estimate of focus' success
    public double vote(double fSuccess){
	if (fSuccess > skill)
	    return Math.min(1, 1.1*fSuccess);
	else
	    return fSuccess;
    }

    ///////////////////////////////////////////////////////
    // updateReputation
    // Input: double, rep Latest reputation vote
    // Output: none
    public void updateReputation(double rep){
	double preRep = reputation * (double) numVotes;
	numVotes ++;
	reputation = (preRep + rep) / ((double) numVotes);
    }

    ///////////////////////////////////////////////////////
    // challenge
    // Input: double difficulty
    // Output: none
    public void challenge(double difficulty){
	if (difficulty > skill)
	    success = 0;
	else 
	    success = skill - difficulty;
    }



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

    public void     setMyPajekColor(String i) {myPajekColor = i;}
    public String   getMyPajekColor() {return myPajekColor;}
    
    public double   getReputation() {return reputation;}
    public void     setReputation(double i) {reputation = i;}

    public double   getSkill() {return skill;}
    public void     setSkill(double i) {skill = i;}

    public double   getSuccess() {return success;}
    public void     setSuccess(double i) {success = i;}
    
    //***************************************************************
    // Static Methods

    public static void setModel(RepMod 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;
    }
}