Santa Fe Institute Events Wiki - User contributions [en]

CustomNode.java.2.wp

2006-06-27T04:20:46Z

AndrewStout:

[[WikiPeerCode]]
<pre>
/*
* CustomNode.java
*
* Created on January 22, 2005, 2:41 PM
* Modified on June 18, 2006, 13:55 by Jack
* Modified June 22, 2006 00:16 by Andrew
* Modified June 22, 2006 16:40 by Jack
* Modified June 26, 2006 22:14 by Andrew
*
* 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;

// voteType, whether to use democratic or meritocratic votes
// 0 = democratic
// 1 = meritocratic
// public static int voteType;

// intVoteValue, the intrinsic value of an agent's vote
// vote weight = intVoteValue + (1-intVoteValue)*reputation
// now have continuous scale between democratic and meritocratic,
// and also avoid divide by zero for zero rep agents voting.
// 1 = democratic
// 0 = complete meritocratic
public static double intVoteValue;

// the degree by which the historical opinion is weighted
public static double histWeight;
// weight of current reputation of focus when assigning new opinion
public static double repWeight;

// the (negative of) slope of skill vs variance of noise
public static double noiseSlope;

//********************************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 = 0.5; // 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"};
}

//////////////////////////////////////////////////////////
// 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();
}

///////////////////////////////////////////////////////
// formOpinion
// Input: double success, the focus' real skill
// Output: double vote, the voter's estimate of focus' skill
/*
public double formOpinion(double fSkill, double prevOp, double fRep){
double op = fSkill + model.getNormalDouble(0, getNoiseFromSkill(this.skill));
op = histWeight*prevOp + repWeight*fRep + (1 - histWeight- repWeight)*op;
return op;
}
*/
// it should /really/ be (arguably, of course):
// opinion = (1 - weight) * (focus' real skill + noise)
// + weight * [opinion-weighted average of common nbrs opinions of focus]
public double formOpinion(CustomEdge fEdge){
CustomNode focus = (CustomNode) fEdge.getTo();
double signal = focus.getSkill() +
model.getNormalDouble(0, getNoiseFromSkill(this.skill));
double myOpinion = histWeight*fEdge.getOpinion() + (1-histWeight)*signal;
double localWeightedOpFeedback = 0;
ArrayList nbrEdges = this.getOutEdges();
// form opinion-weighted average of common nbrs opinions of focus
for(int ni = 0; ni < nbrEdges.size(); ni++){
CustomEdge nbrEdge = (CustomEdge) nbrEdges.get(ni);
CustomNode nbr = (CustomNode) nbrEdge.getTo();
ArrayList nbrNbrEdges = nbr.getOutEdges();
boolean foundFocus = false;
for(int nni = 0; nni < nbrNbrEdges.size(); nni++){
CustomEdge nnEdge = (CustomEdge) nbrNbrEdges.get(nni);
if(((CustomNode)nnEdge.getTo()).getID() == focus.getID()) { // if nbr knows focus
// weight feedback by opinion; balance with own opinion
localWeightedOpFeedback +=
nbrEdge.getOpinion()*nnEdge.getOpinion() +
(1-nbrEdge.getOpinion())*myOpinion;
foundFocus = true;
break; // break the inner for loop--we're done with this common nbr
}
}
if(!foundFocus){
// this neighbor didn't know focus
localWeightedOpFeedback += myOpinion;
}
}
localWeightedOpFeedback =
localWeightedOpFeedback/(double)nbrEdges.size();
double op = repWeight*localWeightedOpFeedback + (1-repWeight)*myOpinion;
// here I truncate to [0,1] -- this is open to further discussion
if (op > 1) op = 1; // must...not...write...Python...
if (op < 0) op = 0; // too many languages in one head!
return op;
}

/*
///////////////////////////////////////////////////////
// formOpinion
// Input: double success, the focus' real skill
// Output: double vote, the voter's estimate of focus' skill
public double formOpinion(double fSkill, double prevOp){
double op = fSkill + model.getNormalDouble(0, getNoiseFromSkill(this.skill));
op = histWeight*prevOp + (1-histWeight)*op;
return op;
}

// new formOpinion
public double formOpinion2(double fSkill, double fRep){
// opinion = (1- repweight) * (focus' real skill + noise)
// + repweight * focus' reputation
double op = fSkill+model.getNormalDouble(0,getNoiseFromSkill(this.skill));
op = repWeight*fRep + (1-repWeight)*op;
// here I truncate to [0,1] -- this is open to further discussion
if (op > 1) op = 1; // must...not...write...Python...
if (op < 0) op = 0; // too many languages in one head!
return op;
}

*/
////////////////////////////////////////////////////////
// voteAll
/*
public void voteAll(){
ArrayList edgeList = this.getOutEdges();
double opinion = 0;
int vote = 0;
for (int i = 0; i < edgeList.size(); i++){
CustomEdge edge = (CustomEdge) edgeList.get(i);
CustomNode node = (CustomNode) edge.getTo();
opinion = formOpinion(node.getSkill(), edge.getOpinion(), node.getReputation());
edge.setOpinion(opinion);
if (opinion > 0.5)
vote = 1;
else
vote = 0;
edge.setVote(vote);
}
}
*/
// new voteAll
public void voteAll(){
ArrayList edgeList = this.getOutEdges();
double opinion = 0;
int vote = 0;
for (int i = 0; i < edgeList.size(); i++){
// for each neighbor
CustomEdge edge = (CustomEdge) edgeList.get(i);
CustomNode node = (CustomNode) edge.getTo();
// get opinion (truncated 0 to 1)
opinion = formOpinion(edge);
// set those opinions
edge.setOpinion(opinion);
// votes are opinions
edge.setVote(opinion); // Java lines get semicolons, dipshit.
}
}

////////////////////////////////////////////////////////
// calcReputation
// Input: none
// Ouput: none
public void calcReputation(){
ArrayList edgeList = this.getInEdges();
double repSum = 0;
double normSum = 0;
for (int i = 0; i < edgeList.size(); i++){
CustomEdge edge = (CustomEdge) edgeList.get(i);
CustomNode node = (CustomNode) edge.getFrom();
repSum += edge.getVote() *(intVoteValue + (1-intVoteValue)*node.getReputation());
normSum += (intVoteValue + (1-intVoteValue)*node.getReputation());
/*
if (voteType ==0){
repSum += edge.getVote();
normSum ++;
}
else if (voteType ==1){
repSum += edge.getVote() * node.getReputation();
normSum += node.getReputation();
}*/
}
reputation = repSum/normSum;
}

//***************************************************************
// 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;
}

///////////////////////////////////////////////////////////
// getNoiseFromSkill
// Inputs: double skill
// Outputs: double, the noise variance
public static double getNoiseFromSkill(double skill){
return (1-skill)*noiseSlope;
}

//public static int getVoteType() {return voteType;}
//public static void setVoteType(int i) {voteType = i;}

public static double getIntVoteValue() {return intVoteValue;}
public static void setIntVoteValue(double i) {intVoteValue = i;}

public static double getHistWeight() {return histWeight;}
public static void setHistWeight(double i) {histWeight = i;}

public static double getRepWeight() {return repWeight;}
public static void setRepWeight(double w) {repWeight = w;}

public static double getNoiseSlope() {return noiseSlope;}
public static void setNoiseSlope(double i) {noiseSlope = i;}
}

</pre>

RepMod.java.2.wp

2006-06-27T04:19:34Z

AndrewStout:

[[WikiPeerCode]]
<pre>
/*
* RepMod.java
*
* Created on January 22, 2005, 6:11 PM
* Modified June 19, 2006 18:20 by Jack
* Modified June 22, 2006 00:16 by Andrew
* Modified June 22, 2006 16:40 by Jack
* Modified June 26, 2006 22:14 by Andrew
*/

package RepMod;
import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import uchicago.src.sim.engine.BasicAction;
import uchicago.src.sim.engine.Schedule;
//import uchicago.src.sim.engine.SimModelImpl;
//import uchicago.src.sim.gui.DisplaySurface;
//import uchicago.src.sim.gui.Network2DDisplay;
import uchicago.src.sim.gui.OvalNetworkItem;
//import uchicago.src.sim.network.NetworkFactory;
//import uchicago.src.sim.network.NetworkRecorder;
//import uchicago.src.sim.network.Node;
//import uchicago.src.sim.util.Random;
import uchicago.src.sim.util.SimUtilities;
//import uchicago.src.sim.network.DefaultDrawableNode;
//import uchicago.src.sim.network.DefaultDrawableEdge;
//import uchicago.src.sim.gui.CircularGraphLayout;
//import uchicago.src.sim.gui.KamadaGraphLayout;
//import uchicago.src.sim.gui.AbstractGraphLayout;
//import uchicago.src.sim.space.Object2DGrid;
//import uchicago.src.sim.gui.Object2DDisplay;
import uchicago.src.sim.util.*;
import java.util.Collections;
import java.util.Comparator;

import uchicago.src.sim.network.NetUtilities;

/**
*
* @author Jack Waddell
*/

public class RepMod extends ModelParameters{

// model variables
public int numAgents = 16;
public ArrayList<CustomNode> agentList = new ArrayList<CustomNode> (numAgents);
public int worldXSize = 400;
public int worldYSize = 400;

public Schedule schedule; // Schedules Events
public CompNodeRep compNodes; // compares node reputations

// The P parameter for regular lattice -> small world rewiring
// Also used as the probability in the random network
public double reconnectProb;

// the connection radius of the regular lattice
public int connectRadius;

// selects which network type to use in Network.java
public int netType;

// Stores how frequently, in units of time steps, to update...
public int updateInterval; // The report file
public int pajekUpdateInterval; // The pajek files

Network net; // The network class

// The following class performs calculations on the network
NetUtilities netCalculator = new NetUtilities();

// the degree to weight the voter's historical opinion vs. new opinion
public double histWeight;

// weight of current reputation in new opinion
public double repWeight;

// voteType, whether to use democratic or meritocratic votes
// 0 = democratic
// 1 = meritocratic
//public int voteType;

// intVoteValue, the intrinsic value of an agent's vote
// vote weight = intVoteValue + (1-intVoteValue)*reputation
// now have continuous scale between democratic and meritocratic,
// and also avoid divide by zero for zero rep agents voting.
// 1 = democratic
// 0 = complete meritocratic
public double intVoteValue;

//public int opScheme; // opinion scheme: 1 = old, 2 = new (AS rep feedback)

// the (negative of) slope of skill vs variance of noise
public double noiseSlope;

public int numTopAgents = 5; // Andrew hacking TopRep calculation

/** Creates a new instance of RepMod */
public RepMod() {
}

/////////////////////////////////////////////////
// begin
// builds model-required elements
public void begin () {
buildModel ();
buildSchedule ();
}

///////////////////////////////////////////////////////
// addModelSpecificParameters
// Maps the input parameters.
public void addModelSpecificParameters () {
parametersMap.put( "size", "numAgents");
parametersMap.put( "ui", "updateInterval");
parametersMap.put( "rP", "reconnectProb");
parametersMap.put( "cR", "connectRadius");
parametersMap.put( "nT", "netType");
parametersMap.put( "pUI", "pajekUpdateInterval");
//parametersMap.put( "vT", "voteType");
parametersMap.put( "iVV", "intVoteValue");
//parametersMap.put( "oS", "opScheme");
parametersMap.put( "hW", "histWeight");
parametersMap.put( "rW", "repWeight"); // still not sure what this does...
parametersMap.put( "nS", "noiseSlope");
parametersMap.put( "nTA", "numTopAgents");
}

//////////////////////////////////////////////////////
// getInitParam
// Controls what appears the the GUI parameter panel
public String[] getInitParam () {
String[] params = { "numAgents", "connectRadius",
"reconnectProb", "netType", "voteType",
"histWeight", "noiseSlope",
"numTopAgents", // AS added for top agents param
/*"opScheme", // AS for new opinion scheme*/
"repWeight", // AS for new opinion scheme
"intVoteValue",
// these are from the super class:
"rDebug", "seed"};
return params;
}

//////////////////////////////////////////////////////////
// getters and setters
// ******************** Note *************************
// Specific format required if using inputted parameters
// (either through batch or gui)
public int getWorldXSize () {return worldXSize;}
public void setWorldXSize (int size) {worldXSize = size;}
public int getWorldYSize () {return worldYSize;}
public void setWorldYSize (int size) {worldYSize = size;}

public int getNumAgents() {return numAgents;}
public void setNumAgents(int i) {numAgents = i;}

public double getReconnectProb() {return reconnectProb;}
public void setReconnectProb(double i) {reconnectProb = i;}
public int getConnectRadius() {return connectRadius;}
public void setConnectRadius(int i) {connectRadius = i;}

public void setNetType(int i) {netType = i;}
public int getNetType() {return netType;}

/*
public void setVoteType(int i) {
voteType = i;
CustomNode.setVoteType(i);
}
public int getVoteType() {return voteType;}

*/
public void setIntVoteValue(double i) {
intVoteValue = i;
CustomNode.setIntVoteValue(i);
}

public double getIntVoteValue() {return intVoteValue;}

//public void setOpScheme(int i) {opScheme = i;}
//public int getOpScheme() { return opScheme;}

public void setHistWeight(double i) {
histWeight = i;
CustomNode.setHistWeight(i);
}
public double getHistWeight() {return histWeight;}

public void setRepWeight(double w) {
repWeight = w;
CustomNode.setRepWeight(w);
}
public double getRepWeight() {return repWeight;}

public void setNoiseSlope(double i) {
noiseSlope = i;
CustomNode.setNoiseSlope(i);
}
public double getNoiseSlope() {return noiseSlope;}

public int getUpdateInterval() {return updateInterval;}
public void setUpdateInterval(int i) {updateInterval = i;}
public int getPajekUpdateInterval() {return pajekUpdateInterval;}
public void setPajekUpdateInterval(int i) {pajekUpdateInterval = i;}
// AS added for top agents param
public int getNumTopAgents() {return numTopAgents;}
public void setNumTopAgents(int n) {numTopAgents = n;}

//////////////////////////////////////////////////////////
// buildModel
// Does what it says
public void buildModel(){
if(rDebug > 0)
System.out.printf("Build Model Begin\n");

// CALL FIRST -- defined in super class -- it starts RNG, etc
buildModelStart();

// set static parameters in node class
CustomNode.setHistWeight(histWeight);
CustomNode.setRepWeight(repWeight); // AS for new op scheme
//CustomNode.setVoteType(voteType);
CustomNode.setIntVoteValue(intVoteValue);
CustomNode.setNoiseSlope(noiseSlope);
CustomNode.setModel(this);

// setup the network class
net = new Network(numAgents, connectRadius, reconnectProb);
net.setModel(this);

// have the network class build the network
net.buildAdjacencyMatrix(netType); // first build the adjacency matrix

net.buildAgentList(); // then the agent list
agentList = net.getAgentList();

// setup the gamemaster
compNodes = new CompNodeRep();

// prepare pajek file
net.startPajekFile(0);

System.out.printf("Build Model End\n");

// some post-load finishing touches
startReportFile();

// you probably don't want to remove any of the following
// calls to process parameter changes and write the
// initial state to the report file.
// NB -> you might remove/add more agentChange processing
applyAnyStoredChanges();
//stepReport();
//getPlaintextReportFile().flush();
}

//////////////////////////////////////////////////////////
// buildSchedule
// Sets what is to happen, when.
public void buildSchedule () {

// schedule the current BatchModel's step() function
// to execute every time step starting with time step 0
schedule.scheduleActionBeginning( 0, this, "step" );

// Schedule to stop at a particular time, StopT. Rem out
// to run indefinitely
schedule.scheduleActionAt(getStopT(), this, "processEndOfRun");

// Only run every updateInterval steps
schedule.scheduleActionAtInterval(updateInterval, new BasicAction() {
public void execute() {
System.gc(); // garbage collect
stepReport(); // write step report
}
}, Schedule.LAST);

// Only run every pajekUpdateInterval steps
schedule.scheduleActionAtInterval(pajekUpdateInterval, new BasicAction() {
public void execute() {
nextPajekNetwork(); // write pajek file and open new one
}
}, Schedule.LAST);

// Execute at step 1 only
schedule.scheduleActionAt(1, new BasicAction() {
public void execute() {
stepReport();
nextPajekNetwork();
}
}, Schedule.LAST);
}

/////////////////////////////////////////////////////////////////////////
// printProjectHelp
// this could be filled in with some help to get from running with
// -help parameter
public void printProjectHelp() {
// print project help

System.out.printf( "\n%s -- \n", getName() );

System.out.printf( "\n **** Add more info here!! **** \n" );

System.out.printf( "\n" );

printParametersMap();

System.exit( 0 );

}

//////////////////////////////////////////////////////////////
// Setup
// Prepares the model, or resets it after the reset button is pressed
// in GUI model
public void setup () {
if ( rDebug > 0 )
System.out.printf( "<== Model setup() done.\n" );
// Clean up previous instances
schedule = null;
System.gc ();

// Set default values
// These are overwritten by inputted values, if any
numAgents = 64;
updateInterval = 1;
pajekUpdateInterval = 1000000;
worldXSize = 400;
worldYSize = 400;

netType = 0;
connectRadius = 2;
reconnectProb = 0.1;

//voteType = 0;
intVoteValue = 1;
histWeight = 0;
noiseSlope = 1;
repWeight = 0;

// AS added for top agents param
numTopAgents = 5;

CustomNode.resetNextID();
agentList = new ArrayList (numAgents);

super.setup(); // Reads in input values
schedule = new Schedule (1);
}

/////////////////////////////////////////////////////////////
// step
// governs what happens at each step
public void step(){
stepNodes();
}

////////////////////////////////////////////////////////////////
// stepNodes
// Steps each node.
// Has each vote for neighbors, then has each calculation
// own reputation.
public void stepNodes(){
/*if (opScheme == 2) { // new opinion scheme
for(CustomNode node : agentList) { // that's syntax I don't know...
node.voteAll2();
}
for(CustomNode node : agentList) {
node.calcReputation();
}
} else {*/
for(CustomNode node : agentList){
node.voteAll();
}
for(CustomNode node : agentList){
node.calcReputation();
}
//}
}

/////////////////////////////////////////////////////////////
// addAgent
// Input: CustomNode agent
// Output: none
// Adds a new agent to the agent list
public void addAgent(CustomNode agent){
agentList.add(agent);
}

/////////////////////////////////////////////////////////////
// delAgent
// Input: CustomNode agent
// Output: none
// Deletes an agent from the agent list
public void delAgent(CustomNode agent){
agentList.remove(agentList.indexOf(agent));
System.gc();
}

//////////////////////////////////////////////////////////////////////
// calcAvgReputation()
public double calcAvgReputation(){
double sum = 0;
for(int i = 0; i < numAgents; i++){
CustomNode node = (CustomNode) agentList.get(i);
sum += (double) node.getReputation();
}
return sum/(double) numAgents;
}

/////////////////////////////////////////////////////////////
// calcTopRepSkills
// inputs: int x, the number of top agents include
// outputs: double, the reputation of the top x agents
// This calculates the sum of the skils of the top x agents
// AS: could be changed to just use numTopAgents directly,
// but I'm gonna change it at call time only--
// lower impact if I fuck something up.
public double calcTopRepSkills(int x){
ArrayList<CustomNode> tempList = new ArrayList<CustomNode>();
tempList.addAll(agentList);
Collections.sort(tempList, compNodes);
double skillSum = 0;
CustomNode node;
for (int i = numAgents -x; i < numAgents; i++){
node = tempList.get(i);
skillSum += node.getSkill();
}
return skillSum;
}

//////////////////////////////////////////////////////////////
// calcRepSkillMatch
// inputs: none
// outputs: double, the fraction of cases that a Rep and Skill match
// (High/Low)
public double calcRepSkillMatch(){
double count = 0;
for(CustomNode node : agentList){
if (node.getReputation() <= 0.5 & node.getSkill() <= 0.5){
count ++;
}
else if (node.getReputation() > 0.5 & node.getSkill() > 0.5){
count ++;
}
}
return count / ((double) numAgents);
}

///////////////////////////////////////////////////////////////////////
// stepReport
// each step write out:
// time expectivity
//
// Note: update the writeHeaderCommentsToReportFile() to print
// lines of text describing the data written to the report file.

public void stepReport () {
String s;
s = String.format("%f %f %f",
schedule.getCurrentTimeDouble(), calcTopRepSkills(numTopAgents),
calcRepSkillMatch());

//writeLineToReportFile ( "<stepreport>" + s + "</stepreport>" );
writeLineToPlaintextReportFile( s );
// flush the buffers so the data is not lost in a "crash"
//getReportFile().flush();
getPlaintextReportFile().flush();
}

/////////////////////////////////////////////////////////////////////////
// writeHeaderCommentsToReportFile
// customize to match what you are writing to the report files in
// stepReport.

public void writeHeaderCommentsToReportFile () {
writeLineToReportFile( "<comment>" );
writeLineToReportFile( " " );
writeLineToReportFile( " time expectivity " );
writeLineToReportFile( "</comment>" );

writeLineToPlaintextReportFile( " #time topSkill RepSkillMatch" );
}

public Schedule getSchedule () {
return schedule;
}

public String getName () {
return "Network";
}

public ArrayList<CustomNode> getAgentList() {return agentList;}

public static void main (String[] args) {
uchicago.src.sim.engine.SimInit init = new uchicago.src.sim.engine.SimInit ();
RepMod model = new RepMod ();
init.loadModel (model, null, false);
}

// The following are some debugging methods
public static void printVector(double[] vector){
System.out.printf("\n");
for(int i = 0; i < vector.length; i++){
System.out.printf("%f ", vector[i]);
}
System.out.printf("\n");
}

public static void printVector(int[] vector){
System.out.printf("\n");
for(int i = 0; i < vector.length; i++){
System.out.printf("%d ", vector[i]);
}
System.out.printf("\n");
}

public void printAgentList(){
System.out.printf("Printing agentList, size = %d\n", agentList.size());
CustomNode node;
CustomNode inode;
for(int i = 0; i < (agentList.size()); i++){
node = (CustomNode) agentList.get(i);
ArrayList <CustomNode> outNodes = node.getToNodes();
System.out.printf("Node %d points to (%d objects): ", node.getID(),
outNodes.size());
for(int j = 0; j < (outNodes.size()); j++){
inode = (CustomNode) outNodes.get(j);
System.out.printf(" %d ", inode.getID());
}
System.out.printf("\n");
}
System.out.printf("\n");
}

/////////////////////////////////////////////////////////
// nextPajekNetwork
// closes the current pajek file and opens the new one.
public void nextPajekNetwork(){
net.writePajekNetwork(agentList);
net.endPajekFile();
net.startPajekFile((int) schedule.getCurrentTime()/pajekUpdateInterval + 1);
}

/////////////////////////////////////////////////////////////////////
// processEndOfRun
// ends process
public void processEndOfRun ( ) {
long finalStep = (long) schedule.getCurrentTime();
if ( rDebug > 0 )
System.out.printf("\n\n===== Model processEndOfRun =====\n\n" );
applyAnyStoredChanges();
stepReport();
endReportFile(finalStep);
net.writePajekNetwork(agentList);
net.endPajekFile();
this.fireStopSim();
}

//*******************************************************************
// Inner classes

private class CompNodeRep implements Comparator{

public CompNodeRep(){
}
public int compare(Object o1, Object o2){
CustomNode nodei = (CustomNode) o1;
CustomNode nodej = (CustomNode) o2;
if (nodei.getReputation() < nodej.getReputation())
return -1;
else if (nodei.getReputation() > nodej.getReputation())
return 1;
else
return 0;
}
}

}

</pre>

WikiPeerCode

2006-06-27T04:18:23Z

AndrewStout:

Back to [[WikiPeer Group]]

The code for our model. Last modifications indicated in green.
Jack Waddell at June 17, at 5:20pm, for instance, is indicated (JNW:0617-1720).

* [[RepMod.java.wp]] : The main model (JNW:0622-1640)
* [[CustomNode.java.wp]] : The agent class. (JNW:0622-1640)
* [[CustomEdge.java.wp]] : The edge class. (JNW:0622-1640)
* [[Network.java.wp]] : The class that initializes the network. (JNW:0617-1720)
* [[GUIModel.java.wp]] : The GUI for the model (APBS:0618-2315)
* [[BatchModel.java.wp]] : The batch organizer for the model (JNW:0618-1355)
* [[ModelParameters.java.wp]] :The base for the model (slightly modified from Rick's) (JNW:0612-0000)

Local ("subjective") opinion feedback fork:

* [[RepMod.java.2.wp]] : The main model (APBS:0626-2214)
* [[CustomNode.java.2.wp]] : The agent class (APBS:0626-2214)
* (rest are the same)

* --CompNodeRep.java-- : Out moded. The comparator for sorting by reputation. Absorbed as inner class into RepMod
* --GameMaster.java.wp-- : Out moded. The class that organizes the votes. Methods absorbed into CustomNode and RepMod.

WikiPeerCode

2006-06-22T06:19:59Z

AndrewStout:

Back to [[WikiPeer Group]]

The code for our model. Last modifications indicated in green.
Jack Waddell at June 17, at 5:20pm, for instance, is indicated (JNW:0617-1720).

* [[RepMod.java.wp]] : The main model (APBS:0622-0016)
* [[CustomNode.java.wp]] : The agent class. (APBS:0622-0016)
* [[CustomEdge.java.wp]] : The edge class. (APBS:0622-0016)
* [[Network.java.wp]] : The class that initializes the network. (JNW:0617-1720)
* [[GUIModel.java.wp]] : The GUI for the model (APBS:0618-2315)
* [[BatchModel.java.wp]] : The batch organizer for the model (JNW:0618-1355)
* [[ModelParameters.java.wp]] :The base for the model (slightly modified from Rick's) (JNW:0612-0000)

* --CompNodeRep.java-- : Out moded. The comparator for sorting by reputation. Absorbed as inner class into RepMod
* --GameMaster.java.wp-- : Out moded. The class that organizes the votes. Methods absorbed into CustomNode and RepMod.

CustomEdge.java.wp

2006-06-22T06:19:00Z

AndrewStout:

[[WikiPeerCode]]
<pre>
/*
* CustomEdge.java
*
* Created on January 22, 2005, 5:55 PM
* Modified on June 19 2006, 08:50 by Jack
* Modified June 22, 2006 00:16 by Andrew
*
* This class is for the edges in a netwok
* It points from a voter to the subject
*/

package RepMod;
import java.awt.Color;
import uchicago.src.sim.gui.ColorMap;

import uchicago.src.sim.gui.DrawableEdge;
import uchicago.src.sim.gui.SimGraphics;
import uchicago.src.sim.network.DefaultEdge;
import uchicago.src.sim.network.Node;
/**
*
* @author Jack Waddell
*/

// DefaultEdge gives us the standard edge methods
// DrawableEdge lets us draw it in the GUI
public class CustomEdge extends DefaultEdge implements DrawableEdge {
//*************************************************************
// Static Parameters

// These are for drawing the edge in GUI
public static GUIModel guiModel = null;
public static ColorMap redColorMap, blueColorMap;
public static final int colorMapSize = 64;
public static final int colorMapMax = colorMapSize - 1;

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

private Color color = Color.red; // Edge color
//public int vote = 0;
public double vote = 0; // AS for [0-1] voting
public double opinion = 0.5;

//***********************************************************
// Methods

//////////////////////////////////////////////////
// Constructor
public CustomEdge() {
}

//////////////////////////////////////////////////
// Constructor (overloaded)
// Inputs: Node from, the (generic class) Node from which the edge emerges
// Node to, the (generic) Node to which the edge points
public CustomEdge(Node from, Node to) {
super(from, to, ""); // Calls DefaultEdge constructor
}

////////////////////////////////////////////////////////
// draw
// Inputs: SimGraphics g
// int fromX, toX, fromY, toY
// Outputs: none
// Required to implement DrawableEdge.
public void draw(SimGraphics g, int fromX, int toX, int fromY, int toY) {
g.drawDirectedLink(color, fromX, toX, fromY, toY);
}

//getters and setters
public void setColor(Color c) {color = c;}
public Color getColor() {return color;}

//public void setVote(int i) {vote = i;}
//public int getVote() {return vote;}
public void setVote(double i) {vote = i;}
public double getVote() {return vote;}

public void setOpinion(double i) {opinion = i;}
public double getOpinion() {return opinion;}

//******************************************************
// Static Methods

////////////////////////////////////////////////////
// setUpEdgeDrawing
// Inputs: GUIModel m, a pointer to the GUIModel instance
// Outputs: none
// Prepares the edge to be drawn in the GUI
public static void setUpEdgeDrawing (GUIModel m) {
//System.out.printf("Setting up Edge Color Map\n");
guiModel = m;
redColorMap = new ColorMap();
double minRed = 0.5;

for (int i = 0; i < colorMapSize; i++){
double fracR = minRed + ( (1.0-minRed)*i/colorMapMax );
fracR = 1.0 + minRed - fracR;
//System.out.printf("Edge Color Map: i = %d, fR = %f\n", i, fracR);
redColorMap.mapColor(i, fracR, 0, 0);
}

blueColorMap = new ColorMap();
double minBlue = 0.5;
for (int i = 0; i < colorMapSize; i++){
double fracB = minBlue + ( (1.0-minBlue)*i/colorMapMax );
fracB = 1.0 + minBlue - fracB;
//System.out.printf("Edge Color Map: i = %d, fR = %f\n", i, fracR);
blueColorMap.mapColor(i, 0, 0, fracB);
}
}
}

</pre>

CustomNode.java.wp

2006-06-22T06:18:08Z

AndrewStout:

[[WikiPeerCode]]
<pre>
/*
* CustomNode.java
*
* Created on January 22, 2005, 2:41 PM
* Modified on June 18, 2006, 13:55 by Jack
* Modified June 22, 2006 00:16 by Andrew
*
* 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;

// voteType, whether to use democratic or meritocratic votes
// 0 = democratic
// 1 = meritocratic
public static int voteType;

// the degree by which the historical opinion is weighted
public static double histWeight;
// weight of current reputation of focus when assigning new opinion
public static double repWeight;

// the (negative of) slope of skill vs variance of noise
public static double noiseSlope;

//********************************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 = 0.5; // 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"};
}

//////////////////////////////////////////////////////////
// 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();
}

///////////////////////////////////////////////////////
// formOpinion
// Input: double success, the focus' real skill
// Output: double vote, the voter's estimate of focus' skill
public double formOpinion(double fSkill, double prevOp){
double op = fSkill + model.getNormalDouble(0, getNoiseFromSkill(this.skill));
op = histWeight*prevOp + (1-histWeight)*op;
return op;
}

// new formOpinion
public double formOpinion2(double fSkill, double fRep){
// opinion = (1- repweight) * (focus' real skill + noise)
// + repweight * focus' reputation
double op = fSkill+model.getNormalDouble(0,getNoiseFromSkill(this.skill));
op = repWeight*fRep + (1-repWeight)*op;
// here I truncate to [0,1] -- this is open to further discussion
if (op > 1) op = 1; // must...not...write...Python...
if (op < 0) op = 0; // too many languages in one head!
return op;
}

// it should /really/ be (arguably, of course):
// opinion = (1 - weight) * (focus' real skill + noise)
// + weight * [opinion-weighted average of common nbrs opinions of focus]

////////////////////////////////////////////////////////
// voteAll
public void voteAll(){
ArrayList edgeList = this.getOutEdges();
double opinion = 0;
int vote = 0;
for (int i = 0; i < edgeList.size(); i++){
CustomEdge edge = (CustomEdge) edgeList.get(i);
CustomNode node = (CustomNode) edge.getTo();
opinion = formOpinion(node.getSkill(), edge.getOpinion());
edge.setOpinion(opinion);
if (opinion > 0.5)
vote = 1;
else
vote = 0;
edge.setVote(vote);
}
}

// new voteAll
public void voteAll2(){
ArrayList edgeList = this.getOutEdges();
double opinion = 0;
int vote = 0;
for (int i = 0; i < edgeList.size(); i++){
// for each neighbor
CustomEdge edge = (CustomEdge) edgeList.get(i);
CustomNode node = (CustomNode) edge.getTo();
// get opinion (truncated 0 to 1)
opinion = formOpinion2(node.getSkill(), node.getReputation());
// (optionally) locally normalize - omitted for now
// set those opinions
edge.setOpinion(opinion);
// votes are opinions
edge.setVote(opinion); // Java lines get semicolons, dipshit.
}
}

////////////////////////////////////////////////////////
// calcReputation
// Input: none
// Ouput: none
public void calcReputation(){
ArrayList edgeList = this.getInEdges();
double repSum = 0;
double normSum = 0;
for (int i = 0; i < edgeList.size(); i++){
CustomEdge edge = (CustomEdge) edgeList.get(i);
CustomNode node = (CustomNode) edge.getFrom();
if (voteType ==0){
repSum += edge.getVote();
normSum ++;
}
else if (voteType ==1){
repSum += edge.getVote() * node.getReputation();
normSum += node.getReputation();
}
}
reputation = repSum/normSum;
}

//***************************************************************
// 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;
}

///////////////////////////////////////////////////////////
// getNoiseFromSkill
// Inputs: double skill
// Outputs: double, the noise variance
public static double getNoiseFromSkill(double skill){
return (1-skill)*noiseSlope;
}

public static int getVoteType() {return voteType;}
public static void setVoteType(int i) {voteType = i;}

public static double getHistWeight() {return histWeight;}
public static void setHistWeight(double i) {histWeight = i;}

public static double getRepWeight() {return repWeight;}
public static void setRepWeight(double w) {repWeight = w;}

public static double getNoiseSlope() {return noiseSlope;}
public static void setNoiseSlope(double i) {noiseSlope = i;}
}

</pre>

RepMod.java.wp

2006-06-22T06:17:23Z

AndrewStout:

[[WikiPeerCode]]
<pre>
/*
* RepMod.java
*
* Created on January 22, 2005, 6:11 PM
* Modified June 19, 2006 18:20 by Jack
* Modified June 22, 2006 00:16 by Andrew
*/

package RepMod;
import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import uchicago.src.sim.engine.BasicAction;
import uchicago.src.sim.engine.Schedule;
//import uchicago.src.sim.engine.SimModelImpl;
//import uchicago.src.sim.gui.DisplaySurface;
//import uchicago.src.sim.gui.Network2DDisplay;
import uchicago.src.sim.gui.OvalNetworkItem;
//import uchicago.src.sim.network.NetworkFactory;
//import uchicago.src.sim.network.NetworkRecorder;
//import uchicago.src.sim.network.Node;
//import uchicago.src.sim.util.Random;
import uchicago.src.sim.util.SimUtilities;
//import uchicago.src.sim.network.DefaultDrawableNode;
//import uchicago.src.sim.network.DefaultDrawableEdge;
//import uchicago.src.sim.gui.CircularGraphLayout;
//import uchicago.src.sim.gui.KamadaGraphLayout;
//import uchicago.src.sim.gui.AbstractGraphLayout;
//import uchicago.src.sim.space.Object2DGrid;
//import uchicago.src.sim.gui.Object2DDisplay;
import uchicago.src.sim.util.*;
import java.util.Collections;
import java.util.Comparator;

import uchicago.src.sim.network.NetUtilities;

/**
*
* @author Jack Waddell
*/

public class RepMod extends ModelParameters{

// model variables
public int numAgents = 16;
public ArrayList<CustomNode> agentList = new ArrayList<CustomNode> (numAgents);
public int worldXSize = 400;
public int worldYSize = 400;

public Schedule schedule; // Schedules Events
public CompNodeRep compNodes; // compares node reputations

// The P parameter for regular lattice -> small world rewiring
// Also used as the probability in the random network
public double reconnectProb;

// the connection radius of the regular lattice
public int connectRadius;

// selects which network type to use in Network.java
public int netType;

// Stores how frequently, in units of time steps, to update...
public int updateInterval; // The report file
public int pajekUpdateInterval; // The pajek files

Network net; // The network class

// The following class performs calculations on the network
NetUtilities netCalculator = new NetUtilities();

// the degree to weight the voter's historical opinion vs. new opinion
public double histWeight;
// weight of current reputation in new opinion
public double repWeight;

// voteType, whether to use democratic or meritocratic votes
// 0 = democratic
// 1 = meritocratic
public int voteType;
public int opScheme; // opinion scheme: 1 = old, 2 = new (AS rep feedback)

// the (negative of) slope of skill vs variance of noise
public double noiseSlope;

public int numTopAgents = 5; // Andrew hacking TopRep calculation

/** Creates a new instance of RepMod */
public RepMod() {
}

/////////////////////////////////////////////////
// begin
// builds model-required elements
public void begin () {
buildModel ();
buildSchedule ();
}

///////////////////////////////////////////////////////
// addModelSpecificParameters
// Maps the input parameters.
public void addModelSpecificParameters () {
parametersMap.put( "size", "numAgents");
parametersMap.put( "ui", "updateInterval");
parametersMap.put( "rP", "reconnectProb");
parametersMap.put( "cR", "connectRadius");
parametersMap.put( "nT", "netType");
parametersMap.put( "pUI", "pajekUpdateInterval");
parametersMap.put( "vT", "voteType");
parametersMap.put( "oS", "opScheme");
parametersMap.put( "hW", "histWeight");
parametersMap.put( "rW", "repWeight"); // still not sure what this does...
parametersMap.put( "nS", "noiseSlope");
parametersMap.put( "nTA", "numTopAgents");
}

//////////////////////////////////////////////////////
// getInitParam
// Controls what appears the the GUI parameter panel
public String[] getInitParam () {
String[] params = { "numAgents", "connectRadius",
"reconnectProb", "netType", "voteType",
"histWeight", "noiseSlope",
"numTopAgents", // AS added for top agents param
"opScheme", // AS for new opinion scheme
"repWeight", // AS for new opinion scheme
// these are from the super class:
"rDebug", "seed"};
return params;
}

//////////////////////////////////////////////////////////
// getters and setters
// ******************** Note *************************
// Specific format required if using inputted parameters
// (either through batch or gui)
public int getWorldXSize () {return worldXSize;}
public void setWorldXSize (int size) {worldXSize = size;}
public int getWorldYSize () {return worldYSize;}
public void setWorldYSize (int size) {worldYSize = size;}

public int getNumAgents() {return numAgents;}
public void setNumAgents(int i) {numAgents = i;}

public double getReconnectProb() {return reconnectProb;}
public void setReconnectProb(double i) {reconnectProb = i;}
public int getConnectRadius() {return connectRadius;}
public void setConnectRadius(int i) {connectRadius = i;}

public void setNetType(int i) {netType = i;}
public int getNetType() {return netType;}

public void setVoteType(int i) {
voteType = i;
CustomNode.setVoteType(i);
}
public int getVoteType() {return voteType;}

public void setOpScheme(int i) {opScheme = i;}
public int getOpScheme() { return opScheme;}

public void setHistWeight(double i) {
histWeight = i;
CustomNode.setHistWeight(i);
}
public double getHistWeight() {return histWeight;}

public void setRepWeight(double w) {
repWeight = w;
CustomNode.setRepWeight(w);
}
public double getRepWeight() {return repWeight;}

public void setNoiseSlope(double i) {
noiseSlope = i;
CustomNode.setNoiseSlope(i);
}
public double getNoiseSlope() {return noiseSlope;}

public int getUpdateInterval() {return updateInterval;}
public void setUpdateInterval(int i) {updateInterval = i;}
public int getPajekUpdateInterval() {return pajekUpdateInterval;}
public void setPajekUpdateInterval(int i) {pajekUpdateInterval = i;}
// AS added for top agents param
public int getNumTopAgents() {return numTopAgents;}
public void setNumTopAgents(int n) {numTopAgents = n;}

//////////////////////////////////////////////////////////
// buildModel
// Does what it says
public void buildModel(){
if(rDebug > 0)
System.out.printf("Build Model Begin\n");

// CALL FIRST -- defined in super class -- it starts RNG, etc
buildModelStart();

// set static parameters in node class
CustomNode.setHistWeight(histWeight);
CustomNode.setRepWeight(repWeight); // AS for new op scheme
CustomNode.setVoteType(voteType);
CustomNode.setNoiseSlope(noiseSlope);

// setup the network class
net = new Network(numAgents, connectRadius, reconnectProb);
net.setModel(this);

CustomNode.setModel(this);

// have the network class build the network
net.buildAdjacencyMatrix(netType); // first build the adjacency matrix

net.buildAgentList(); // then the agent list
agentList = net.getAgentList();

// setup the gamemaster
compNodes = new CompNodeRep();

// prepare pajek file
net.startPajekFile(0);

System.out.printf("Build Model End\n");

// some post-load finishing touches
startReportFile();

// you probably don't want to remove any of the following
// calls to process parameter changes and write the
// initial state to the report file.
// NB -> you might remove/add more agentChange processing
applyAnyStoredChanges();
//stepReport();
//getPlaintextReportFile().flush();
}

//////////////////////////////////////////////////////////
// buildSchedule
// Sets what is to happen, when.
public void buildSchedule () {

// schedule the current BatchModel's step() function
// to execute every time step starting with time step 0
schedule.scheduleActionBeginning( 0, this, "step" );

// Schedule to stop at a particular time, StopT. Rem out
// to run indefinitely
schedule.scheduleActionAt(getStopT(), this, "processEndOfRun");

// Only run every updateInterval steps
schedule.scheduleActionAtInterval(updateInterval, new BasicAction() {
public void execute() {
System.gc(); // garbage collect
stepReport(); // write step report
}
}, Schedule.LAST);

// Only run every pajekUpdateInterval steps
schedule.scheduleActionAtInterval(pajekUpdateInterval, new BasicAction() {
public void execute() {
nextPajekNetwork(); // write pajek file and open new one
}
}, Schedule.LAST);

// Execute at step 1 only
schedule.scheduleActionAt(1, new BasicAction() {
public void execute() {
stepReport();
nextPajekNetwork();
}
}, Schedule.LAST);
}

/////////////////////////////////////////////////////////////////////////
// printProjectHelp
// this could be filled in with some help to get from running with
// -help parameter
public void printProjectHelp() {
// print project help

System.out.printf( "\n%s -- \n", getName() );

System.out.printf( "\n **** Add more info here!! **** \n" );

System.out.printf( "\n" );

printParametersMap();

System.exit( 0 );

}

//////////////////////////////////////////////////////////////
// Setup
// Prepares the model, or resets it after the reset button is pressed
// in GUI model
public void setup () {
if ( rDebug > 0 )
System.out.printf( "<== Model setup() done.\n" );
// Clean up previous instances
schedule = null;
System.gc ();

// Set default values
// These are overwritten by inputted values, if any
numAgents = 64;
updateInterval = 1;
pajekUpdateInterval = 1000000;
worldXSize = 400;
worldYSize = 400;

netType = 0;
connectRadius = 2;
reconnectProb = 0.1;

voteType = 0;
histWeight = 0;
noiseSlope = 1;

// AS added for top agents param
numTopAgents = 5;

CustomNode.resetNextID();
agentList = new ArrayList (numAgents);

super.setup(); // Reads in input values
schedule = new Schedule (1);
}

/////////////////////////////////////////////////////////////
// step
// governs what happens at each step
public void step(){
stepNodes();
}

////////////////////////////////////////////////////////////////
// stepNodes
// Steps each node.
// Has each vote for neighbors, then has each calculation
// own reputation.
public void stepNodes(){
if (opScheme == 2) { // new opinion scheme
for(CustomNode node : agentList) { // that's syntax I don't know...
node.voteAll2();
}
for(CustomNode node : agentList) {
node.calcReputation();
}
} else {
for(CustomNode node : agentList){
node.voteAll();
}
for(CustomNode node : agentList){
node.calcReputation();
}
}
}

/////////////////////////////////////////////////////////////
// addAgent
// Input: CustomNode agent
// Output: none
// Adds a new agent to the agent list
public void addAgent(CustomNode agent){
agentList.add(agent);
}

/////////////////////////////////////////////////////////////
// delAgent
// Input: CustomNode agent
// Output: none
// Deletes an agent from the agent list
public void delAgent(CustomNode agent){
agentList.remove(agentList.indexOf(agent));
System.gc();
}

//////////////////////////////////////////////////////////////////////
// calcAvgReputation()
public double calcAvgReputation(){
double sum = 0;
for(int i = 0; i < numAgents; i++){
CustomNode node = (CustomNode) agentList.get(i);
sum += (double) node.getReputation();
}
return sum/(double) numAgents;
}

/////////////////////////////////////////////////////////////
// calcTopRepSkills
// inputs: int x, the number of top agents include
// outputs: double, the reputation of the top x agents
// This calculates the sum of the skils of the top x agents
// AS: could be changed to just use numTopAgents directly,
// but I'm gonna change it at call time only--
// lower impact if I fuck something up.
public double calcTopRepSkills(int x){
ArrayList<CustomNode> tempList = new ArrayList<CustomNode>();
tempList.addAll(agentList);
Collections.sort(tempList, compNodes);
double skillSum = 0;
CustomNode node;
for (int i = numAgents -x; i < numAgents; i++){
node = tempList.get(i);
skillSum += node.getSkill();
}
return skillSum;
}

//////////////////////////////////////////////////////////////
// calcRepSkillMatch
// inputs: none
// outputs: double, the fraction of cases that a Rep and Skill match
// (High/Low)
public double calcRepSkillMatch(){
double count = 0;
for(CustomNode node : agentList){
if (node.getReputation() <= 0.5 & node.getSkill() <= 0.5){
count ++;
}
else if (node.getReputation() > 0.5 & node.getSkill() > 0.5){
count ++;
}
}
return count / ((double) numAgents);
}

///////////////////////////////////////////////////////////////////////
// stepReport
// each step write out:
// time expectivity
//
// Note: update the writeHeaderCommentsToReportFile() to print
// lines of text describing the data written to the report file.

public void stepReport () {
String s;
s = String.format("%f %f %f",
schedule.getCurrentTimeDouble(), calcTopRepSkills(numTopAgents),
calcRepSkillMatch());

//writeLineToReportFile ( "<stepreport>" + s + "</stepreport>" );
writeLineToPlaintextReportFile( s );
// flush the buffers so the data is not lost in a "crash"
//getReportFile().flush();
getPlaintextReportFile().flush();
}

/////////////////////////////////////////////////////////////////////////
// writeHeaderCommentsToReportFile
// customize to match what you are writing to the report files in
// stepReport.

public void writeHeaderCommentsToReportFile () {
writeLineToReportFile( "<comment>" );
writeLineToReportFile( " " );
writeLineToReportFile( " time expectivity " );
writeLineToReportFile( "</comment>" );

writeLineToPlaintextReportFile( " #time topSkill RepSkillMatch" );
}

public Schedule getSchedule () {
return schedule;
}

public String getName () {
return "Network";
}

public ArrayList<CustomNode> getAgentList() {return agentList;}

public static void main (String[] args) {
uchicago.src.sim.engine.SimInit init = new uchicago.src.sim.engine.SimInit ();
RepMod model = new RepMod ();
init.loadModel (model, null, false);
}

// The following are some debugging methods
public static void printVector(double[] vector){
System.out.printf("\n");
for(int i = 0; i < vector.length; i++){
System.out.printf("%f ", vector[i]);
}
System.out.printf("\n");
}

public static void printVector(int[] vector){
System.out.printf("\n");
for(int i = 0; i < vector.length; i++){
System.out.printf("%d ", vector[i]);
}
System.out.printf("\n");
}

public void printAgentList(){
System.out.printf("Printing agentList, size = %d\n", agentList.size());
CustomNode node;
CustomNode inode;
for(int i = 0; i < (agentList.size()); i++){
node = (CustomNode) agentList.get(i);
ArrayList <CustomNode> outNodes = node.getToNodes();
System.out.printf("Node %d points to (%d objects): ", node.getID(),
outNodes.size());
for(int j = 0; j < (outNodes.size()); j++){
inode = (CustomNode) outNodes.get(j);
System.out.printf(" %d ", inode.getID());
}
System.out.printf("\n");
}
System.out.printf("\n");
}

/////////////////////////////////////////////////////////
// nextPajekNetwork
// closes the current pajek file and opens the new one.
public void nextPajekNetwork(){
net.writePajekNetwork(agentList);
net.endPajekFile();
net.startPajekFile((int) schedule.getCurrentTime()/pajekUpdateInterval + 1);
}

/////////////////////////////////////////////////////////////////////
// processEndOfRun
// ends process
public void processEndOfRun ( ) {
long finalStep = (long) schedule.getCurrentTime();
if ( rDebug > 0 )
System.out.printf("\n\n===== Model processEndOfRun =====\n\n" );
applyAnyStoredChanges();
stepReport();
endReportFile(finalStep);
net.writePajekNetwork(agentList);
net.endPajekFile();
this.fireStopSim();
}

//*******************************************************************
// Inner classes

private class CompNodeRep implements Comparator{

public CompNodeRep(){
}
public int compare(Object o1, Object o2){
CustomNode nodei = (CustomNode) o1;
CustomNode nodej = (CustomNode) o2;
if (nodei.getReputation() < nodej.getReputation())
return -1;
else if (nodei.getReputation() > nodej.getReputation())
return 1;
else
return 0;
}
}

}

</pre>

SFSS 2006 After Hours

2006-06-21T22:52:52Z

AndrewStout: /* Farther Away Hiking/Sightseeing trips */

{{CSSS 2006 Santa Fe}}
Please keep a roughly chronological order, delete postings after the activity is finished, and post dates and times.

==Music==
* Bela Fleck and the Flecktones will be in concert in Santa Fe on Wednesday night (21 June). 5 30 PM. Check out the forum [http://www.santafe.edu/forums/showthread.php?t=300 thread]
Tickets available [http://purchase.tickets.com/buy/TicketPurchase?organ_val=2274&agency=tdc&schedule=list here]

Contact : Ryan Woodard

* Thur. June 22, the group Ferintosh will be in Santa Fe. They play mostly Scottish Baroque and Cape Breton music.

The GiG 8:00 PM
1808 Second Street (next to the Second Street Brewery)
Suggested contribution $15 at the door.
Checkout the forum [http://www.santafe.edu/forums/showthread.php?t=239 thread]

Contact : Ryan Leary

==Basketball==
* Thursday, 7pm in the gym

==Taos & Corn Dance Festival==
* June 24th (Saturday) - Taos & Corn Dance Festival
w/ car: Hana (4)

wo/ car?: Andreaa, Ryan, Elham, Harry, Sam, Sandra, Cornelia, Andrew, Alessandro, Fabrice, Nikhil, Patrick, Valentin, Heinz, Andrea, Jorge, Greg.

==Other trips==

* June 23/24-25th - Grand Canyon (suggested trip) [interested?: let saskia.werners know at wur.nl]

==Provisioning==
* Grocery & Supply run to town

==Farther Away Hiking/Sightseeing trips==
Sometime in the near future...
The [http://kevingong.com/Hiking/TentRocks.html Tent Rocks] trip on June 11 was awesome!!! Hiking folks, you would love it! And it is 40min away! (Andreea)

(Andrew would be interested, if anyone with wheels is planning a trip...)

==Hiking locally==
Recommended:
'''Deception Point, Lake Peak & Penitente summit Loop.''' Starts from Santa Fe ski bowl (car required). Day hike up Winsor trail and Raven's Ridge with serious views, some scrambling along minimally exposed ridge from Deception to Lake Peak. Various return legs including skipping Lake and direct back down ski slopes, skipping Penitente for off-piste scramble to Nambe Lake and ramble over Penitente summit wildflower meadow then reconnect with the Skyline Trail and on back down an easy cruise through forest shade. Boots strongly recommended for scrambling; 2+ liters minimum water/person.

[16 June 06] "Day Hikes in the Santa Fe Area," by the Sierra club, is available in the Fireside room...

WikiPeerCode

2006-06-19T05:17:48Z

AndrewStout:

Back to [[WikiPeer Group]]

The code for our model. Last modifications indicated in green.
Jack Waddell at June 17, at 5:20pm, for instance, is indicated (JNW:0617-1720).

* [[RepMod.java.wp]] : The main model (APBS:0618-2315)
* [[CustomNode.java.wp]] : The agent class. (JNW:0618-1355)
* [[CustomEdge.java.wp]] : The edge class. (JNW:0617-1720)
* [[Network.java.wp]] : The class that initializes the network. (JNW:0617-1720)
* [[GUIModel.java.wp]] : The GUI for the model (APBS:0618-2315)
* [[BatchModel.java.wp]] : The batch organizer for the model (JNW:0618-1355)
* [[ModelParameters.java.wp]] :The base for the model (slightly modified from Rick's) (JNW:0612-0000)

* --CompNodeRep.java-- : Out moded. The comparator for sorting by reputation. Absorbed as inner class into RepMod
* --GameMaster.java.wp-- : Out moded. The class that organizes the votes. Methods absorbed into CustomNode and RepMod.

RepMod.java.wp

2006-06-19T05:16:40Z

AndrewStout:

[[WikiPeerCode]]
<pre>
/*
* RepMod.java
*
* Created on January 22, 2005, 6:11 PM
* Modified June 18, 2006 13:55 by Jack
* Modified slightly 6-18-06 23:10 by Andrew
*/

package RepMod;
import java.awt.Color;
import java.util.ArrayList;
import java.util.List;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import uchicago.src.sim.engine.BasicAction;
import uchicago.src.sim.engine.Schedule;
//import uchicago.src.sim.engine.SimModelImpl;
//import uchicago.src.sim.gui.DisplaySurface;
//import uchicago.src.sim.gui.Network2DDisplay;
import uchicago.src.sim.gui.OvalNetworkItem;
//import uchicago.src.sim.network.NetworkFactory;
//import uchicago.src.sim.network.NetworkRecorder;
//import uchicago.src.sim.network.Node;
//import uchicago.src.sim.util.Random;
import uchicago.src.sim.util.SimUtilities;
//import uchicago.src.sim.network.DefaultDrawableNode;
//import uchicago.src.sim.network.DefaultDrawableEdge;
//import uchicago.src.sim.gui.CircularGraphLayout;
//import uchicago.src.sim.gui.KamadaGraphLayout;
//import uchicago.src.sim.gui.AbstractGraphLayout;
//import uchicago.src.sim.space.Object2DGrid;
//import uchicago.src.sim.gui.Object2DDisplay;
import uchicago.src.sim.util.*;
import java.util.Collections;
import java.util.Comparator;

import uchicago.src.sim.network.NetUtilities;

/**
*
* @author Jack Waddell
*/

public class RepMod extends ModelParameters{

// model variables
public int numAgents = 16;
public ArrayList<CustomNode> agentList = new ArrayList<CustomNode> (numAgents);
public int worldXSize = 400;
public int worldYSize = 400;

public Schedule schedule; // Schedules Events
public CompNodeRep compNodes; // compares node reputations

// The P parameter for regular lattice -> small world rewiring
// Also used as the probability in the random network
public double reconnectProb;

// the connection radius of the regular lattice
public int connectRadius;

// selects which network type to use in Network.java
public int netType;

// Stores how frequently, in units of time steps, to update...
public int updateInterval; // The report file
public int pajekUpdateInterval; // The pajek files

Network net; // The network class

// The following class performs calculations on the network
NetUtilities netCalculator = new NetUtilities();

// the degree to weight the voter's historical opinion vs. new opinion
public double histWeight;

// voteType, whether to use democratic or meritocratic votes
// 0 = democratic
// 1 = meritocratic
public int voteType;

// the (negative of) slope of skill vs variance of noise
public double noiseSlope;

public int numTopAgents = 5; // Andrew hacking TopRep calculation

/** Creates a new instance of RepMod */
public RepMod() {
}

/////////////////////////////////////////////////
// begin
// builds model-required elements
public void begin () {
buildModel ();
buildSchedule ();
}

///////////////////////////////////////////////////////
// addModelSpecificParameters
// Maps the input parameters.
public void addModelSpecificParameters () {
parametersMap.put( "size", "numAgents");
parametersMap.put( "ui", "updateInterval");
parametersMap.put( "rP", "reconnectProb");
parametersMap.put( "cR", "connectRadius");
parametersMap.put( "nT", "netType");
parametersMap.put( "pUI", "pajekUpdateInterval");
parametersMap.put( "vT", "voteType");
parametersMap.put( "hW", "histWeight");
parametersMap.put( "nS", "noiseSlope");
// Andrew wonders if something needs to go here for top agents param,
// but doesn't know what this is for
}

//////////////////////////////////////////////////////
// getInitParam
// Controls what appears the the GUI parameter panel
public String[] getInitParam () {
String[] params = { "numAgents", "connectRadius",
"reconnectProb", "netType", "voteType",
"histWeight", "noiseSlope",
"numTopAgents", // AS added for top agents param
// these are from the super class:
"rDebug", "seed"};
return params;
}

//////////////////////////////////////////////////////////
// getters and setters
// ******************** Note *************************
// Specific format required if using inputted parameters
// (either through batch or gui)
public int getWorldXSize () {return worldXSize;}
public void setWorldXSize (int size) {worldXSize = size;}
public int getWorldYSize () {return worldYSize;}
public void setWorldYSize (int size) {worldYSize = size;}

public int getNumAgents() {return numAgents;}
public void setNumAgents(int i) {numAgents = i;}

public double getReconnectProb() {return reconnectProb;}
public void setReconnectProb(double i) {reconnectProb = i;}
public int getConnectRadius() {return connectRadius;}
public void setConnectRadius(int i) {connectRadius = i;}

public void setNetType(int i) {netType = i;}
public int getNetType() {return netType;}

public void setVoteType(int i) {
voteType = i;
CustomNode.setVoteType(i);
}
public int getVoteType() {return voteType;}

public void setHistWeight(double i) {
histWeight = i;
CustomNode.setHistWeight(i);
}
public double getHistWeight() {return histWeight;}

public void setNoiseSlope(double i) {
noiseSlope = i;
CustomNode.setNoiseSlope(i);
}
public double getNoiseSlope() {return noiseSlope;}

public int getUpdateInterval() {return updateInterval;}
public void setUpdateInterval(int i) {updateInterval = i;}
public int getPajekUpdateInterval() {return pajekUpdateInterval;}
public void setPajekUpdateInterval(int i) {pajekUpdateInterval = i;}
// AS added for top agents param
public int getNumTopAgents() {return numTopAgents;}
public void setNumTopAgents(int n) {numTopAgents = n;}

//////////////////////////////////////////////////////////
// buildModel
// Does what it says
public void buildModel(){
if(rDebug > 0)
System.out.printf("Build Model Begin\n");

// CALL FIRST -- defined in super class -- it starts RNG, etc
buildModelStart();

// set static parameters in node class
CustomNode.setHistWeight(histWeight);
CustomNode.setVoteType(voteType);
CustomNode.setNoiseSlope(noiseSlope);

// setup the network class
net = new Network(numAgents, connectRadius, reconnectProb);
net.setModel(this);

CustomNode.setModel(this);

// have the network class build the network
net.buildAdjacencyMatrix(netType); // first build the adjacency matrix

net.buildAgentList(); // then the agent list
agentList = net.getAgentList();

// setup the gamemaster
compNodes = new CompNodeRep();

// prepare pajek file
net.startPajekFile(0);

System.out.printf("Build Model End\n");
}

//////////////////////////////////////////////////////////
// buildSchedule
// Sets what is to happen, when.
public void buildSchedule () {

// schedule the current BatchModel's step() function
// to execute every time step starting with time step 0
schedule.scheduleActionBeginning( 0, this, "step" );

// Schedule to stop at a particular time, StopT. Rem out
// to run indefinitely
schedule.scheduleActionAt(getStopT(), this, "processEndOfRun");

// Only run every updateInterval steps
schedule.scheduleActionAtInterval(updateInterval, new BasicAction() {
public void execute() {
System.gc(); // garbage collect
stepReport(); // write step report
}
}, Schedule.LAST);

// Only run every pajekUpdateInterval steps
schedule.scheduleActionAtInterval(pajekUpdateInterval, new BasicAction() {
public void execute() {
nextPajekNetwork(); // write pajek file and open new one
}
}, Schedule.LAST);

// Execute at step 1 only
schedule.scheduleActionAt(1, new BasicAction() {
public void execute() {
stepReport();
nextPajekNetwork();
}
}, Schedule.LAST);
}

/////////////////////////////////////////////////////////////////////////
// printProjectHelp
// this could be filled in with some help to get from running with
// -help parameter
public void printProjectHelp() {
// print project help

System.out.printf( "\n%s -- \n", getName() );

System.out.printf( "\n **** Add more info here!! **** \n" );

System.out.printf( "\n" );

printParametersMap();

System.exit( 0 );

}

//////////////////////////////////////////////////////////////
// Setup
// Prepares the model, or resets it after the reset button is pressed
// in GUI model
public void setup () {
if ( rDebug > 0 )
System.out.printf( "<== Model setup() done.\n" );
// Clean up previous instances
schedule = null;
System.gc ();

// Set default values
// These are overwritten by inputted values, if any
numAgents = 64;
updateInterval = 1;
pajekUpdateInterval = 1000000;
worldXSize = 400;
worldYSize = 400;

netType = 0;
connectRadius = 2;
reconnectProb = 0.1;

voteType = 0;
histWeight = 0;
noiseSlope = 1;

// AS added for top agents param
numTopAgents = 5;

CustomNode.resetNextID();
agentList = new ArrayList (numAgents);

super.setup(); // Reads in input values
schedule = new Schedule (1);

// some post-load finishing touches
startReportFile();

// you probably don't want to remove any of the following
// calls to process parameter changes and write the
// initial state to the report file.
// NB -> you might remove/add more agentChange processing
applyAnyStoredChanges();
//stepReport();
//getPlaintextReportFile().flush();
}

/////////////////////////////////////////////////////////////
// step
// governs what happens at each step
public void step(){
stepNodes();
}

////////////////////////////////////////////////////////////////
// stepNodes
// Steps each node.
// Has each vote for neighbors, then has each calculation
// own reputation.
public void stepNodes(){
for(CustomNode node : agentList){
node.voteAll();
}
for(CustomNode node : agentList){
node.calcReputation();
}
}

/////////////////////////////////////////////////////////////
// addAgent
// Input: CustomNode agent
// Output: none
// Adds a new agent to the agent list
public void addAgent(CustomNode agent){
agentList.add(agent);
}

/////////////////////////////////////////////////////////////
// delAgent
// Input: CustomNode agent
// Output: none
// Deletes an agent from the agent list
public void delAgent(CustomNode agent){
agentList.remove(agentList.indexOf(agent));
System.gc();
}

//////////////////////////////////////////////////////////////////////
// calcAvgReputation()
public double calcAvgReputation(){
double sum = 0;
for(int i = 0; i < numAgents; i++){
CustomNode node = (CustomNode) agentList.get(i);
sum += (double) node.getReputation();
}
return sum/(double) numAgents;
}

/////////////////////////////////////////////////////////////
// calcTopRepSkills
// inputs: int x, the number of top agents include
// outputs: double, the reputation of the top x agents
// This calculates the sum of the skils of the top x agents
// AS: could be changed to just use numTopAgents directly,
// but I'm gonna change it at call time only--
// lower impact if I fuck something up.
public double calcTopRepSkills(int x){
ArrayList<CustomNode> tempList = new ArrayList<CustomNode>();
tempList.addAll(agentList);
Collections.sort(tempList, compNodes);
double skillSum = 0;
CustomNode node;
for (int i = numAgents -x; i < numAgents; i++){
node = tempList.get(i);
skillSum += node.getSkill();
}
return skillSum;
}

//////////////////////////////////////////////////////////////
// calcRepSkillMatch
// inputs: none
// outputs: double, the fraction of cases that a Rep and Skill match
// (High/Low)
public double calcRepSkillMatch(){
double count = 0;
for(CustomNode node : agentList){
if (node.getReputation() <= 0.5 & node.getSkill() <= 0.5){
count ++;
}
else if (node.getReputation() > 0.5 & node.getSkill() > 0.5){
count ++;
}
}
return count / ((double) numAgents);
}

///////////////////////////////////////////////////////////////////////
// stepReport
// each step write out:
// time expectivity
//
// Note: update the writeHeaderCommentsToReportFile() to print
// lines of text describing the data written to the report file.

public void stepReport () {
String s;
s = String.format("%f %f %f",
schedule.getCurrentTimeDouble(), calcTopRepSkills(5),
calcRepSkillMatch());

//writeLineToReportFile ( "<stepreport>" + s + "</stepreport>" );
writeLineToPlaintextReportFile( s );
// flush the buffers so the data is not lost in a "crash"
//getReportFile().flush();
getPlaintextReportFile().flush();
}

/////////////////////////////////////////////////////////////////////////
// writeHeaderCommentsToReportFile
// customize to match what you are writing to the report files in
// stepReport.

public void writeHeaderCommentsToReportFile () {
writeLineToReportFile( "<comment>" );
writeLineToReportFile( " " );
writeLineToReportFile( " time expectivity " );
writeLineToReportFile( "</comment>" );

writeLineToPlaintextReportFile( " #time topSkill RepSkillMatch" );
}

public Schedule getSchedule () {
return schedule;
}

public String getName () {
return "Network";
}

public ArrayList<CustomNode> getAgentList() {return agentList;}

public static void main (String[] args) {
uchicago.src.sim.engine.SimInit init = new uchicago.src.sim.engine.SimInit ();
RepMod model = new RepMod ();
init.loadModel (model, null, false);
}

// The following are some debugging methods
public static void printVector(double[] vector){
System.out.printf("\n");
for(int i = 0; i < vector.length; i++){
System.out.printf("%f ", vector[i]);
}
System.out.printf("\n");
}

public static void printVector(int[] vector){
System.out.printf("\n");
for(int i = 0; i < vector.length; i++){
System.out.printf("%d ", vector[i]);
}
System.out.printf("\n");
}

public void printAgentList(){
System.out.printf("Printing agentList, size = %d\n", agentList.size());
CustomNode node;
CustomNode inode;
for(int i = 0; i < (agentList.size()); i++){
node = (CustomNode) agentList.get(i);
ArrayList <CustomNode> outNodes = node.getToNodes();
System.out.printf("Node %d points to (%d objects): ", node.getID(),
outNodes.size());
for(int j = 0; j < (outNodes.size()); j++){
inode = (CustomNode) outNodes.get(j);
System.out.printf(" %d ", inode.getID());
}
System.out.printf("\n");
}
System.out.printf("\n");
}

/////////////////////////////////////////////////////////
// nextPajekNetwork
// closes the current pajek file and opens the new one.
public void nextPajekNetwork(){
net.writePajekNetwork(agentList);
net.endPajekFile();
net.startPajekFile((int) schedule.getCurrentTime()/pajekUpdateInterval + 1);
}

/////////////////////////////////////////////////////////////////////
// processEndOfRun
// ends process
public void processEndOfRun ( ) {
long finalStep = (long) schedule.getCurrentTime();
if ( rDebug > 0 )
System.out.printf("\n\n===== Model processEndOfRun =====\n\n" );
applyAnyStoredChanges();
stepReport();
endReportFile(finalStep);
net.writePajekNetwork(agentList);
net.endPajekFile();
this.fireStopSim();
}

//*******************************************************************
// Inner classes

private class CompNodeRep implements Comparator{

public CompNodeRep(){
}
public int compare(Object o1, Object o2){
CustomNode nodei = (CustomNode) o1;
CustomNode nodej = (CustomNode) o2;
if (nodei.getReputation() < nodej.getReputation())
return -1;
else if (nodei.getReputation() > nodej.getReputation())
return 1;
else
return 0;
}
}

}

</pre>

GUIModel.java.wp

2006-06-19T05:14:42Z

AndrewStout:

[[WikiPeerCode]]
<pre>
/*
* GUIModel.java
*
* Created on January 30, 2005, 12:21 PM
* Modified June 18, 2006 13:55 by Jack
* Modified slightly 6-18-06 23:10 by Andrew
* This runs the graphical interface for the RepMod model
*/

package RepMod;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Formatter;
import java.util.HashSet;

import uchicago.src.sim.engine.Schedule;
import uchicago.src.sim.engine.SimModelImpl;
import uchicago.src.sim.engine.*;
import uchicago.src.sim.util.*;
import uchicago.src.sim.gui.*;
import uchicago.src.sim.gui.ColorMap;
import uchicago.src.sim.gui.DisplaySurface;
import uchicago.src.sim.gui.Object2DDisplay;
import uchicago.src.sim.gui.Value2DDisplay;
import uchicago.src.sim.space.Object2DTorus;
import uchicago.src.sim.engine.AbstractGUIController;
import uchicago.src.sim.analysis.*;
import java.util.Collections;
import java.util.Comparator;

/**
*
* @author Jack Waddell
*/
public class GUIModel extends RepMod{

//*******************************************************
// Instance Parameters

// The actual display surface, where things are put on the screen
private DisplaySurface surface;

// A layout, which tells the surface where to put nodes and edges
private AbstractGraphLayout layout;

// A graph of the agreement between rep and skill
private OpenSequenceGraph repSkillGraph;

// A graph of the running sum of the skill of the top repped agents
private OpenSequenceGraph topSkillGraph;

// A plot
private Plot histPlot;

// A Histogram
// private OpenHistogram wealthHist;

// A Histogram
// private OpenHistogram degreeHist;

//*******************************************************************
// Methods

/////////////////////////////////////////////////////////////////////
// setup
//
// This runs automatically when the model starts
// and when you click the reload button, to "tear down" any
// existing display objects, and get ready to initialize
// them at the start of the next 'run'.
//
public void setup() {
// the super class does conceptual-model setup (RepMod)
super.setup();

if ( rDebug > 0 )
System.out.printf( "<== GUIModel setup() begin.\n" );

// NOTE: you may want to set these next two to 'true'
// if you are on a windows machine. that would tell repast
// to by default send System.out and .err output to
// a special repast output window.
AbstractGUIController.CONSOLE_ERR = false;
AbstractGUIController.CONSOLE_OUT = false;

// For restart purposes, dispose of any displays
if ( surface != null ) surface.dispose();
if ( repSkillGraph != null ) repSkillGraph.dispose();
if ( topSkillGraph != null ) topSkillGraph.dispose();
//if ( wealthHist != null) wealthHist.dispose();
//if ( degreeHist != null) degreeHist.dispose();

// Create and register the abstract surface
surface = null;
surface = new DisplaySurface( this, "Network Display" );
registerDisplaySurface( "Main Display", surface );

// Add Custom Buttons
modelManipulator.init();
modelManipulator.addButton("Layout - Circular",
new ActionListener(){
public void actionPerformed(ActionEvent evt){
changeLayoutCircular();
}
}
);
modelManipulator.addButton("Layout - Kamada",
new ActionListener(){
public void actionPerformed(ActionEvent evt){
changeLayoutKamada();
}
}
);

modelManipulator.addButton("Print Nodes",
new ActionListener(){
public void actionPerformed(ActionEvent evt){
printNodes();
}
}
);

modelManipulator.addButton("Print Rep Sorted Nodes",
new ActionListener(){
public void actionPerformed(ActionEvent evt){
printRepSortedNodes();
}
}
);

modelManipulator.addButton("Kill All Edges",
new ActionListener(){
public void actionPerformed(ActionEvent evt){
killAllEdges();
}
}
);

modelManipulator.addButton("Plot Reputation vs. Skill",
new ActionListener(){
public void actionPerformed(ActionEvent evt){
plotRepSkill();
}
}
);

if ( rDebug > 0 )
System.out.printf( "<== GUIModel setup() done.\n" );
}

/////////////////////////////////////////////////////////////////////
// begin
//
// This runs when you click the "initialize" button
// (the button with the single arrow that goes around in a circle)
// or at the first step
public void begin() {
DMSG(1, "==> enter GUIModel-begin()" );
// Set up drawables
CustomNode.setUpNodeDrawing(this);
CustomEdge.setUpEdgeDrawing(this);

buildModel(); // Calls in the base model (RepMod)

buildDisplay(); // Constructs the displays
if (rDebug > 0)
System.out.printf("Display Built Successfully. \n");

// Constructs the schedule; If defined in GUIModel, ignores buildSchedule in base model
buildSchedule();

surface.display(); // displays the surface on the display

writeHeaderCommentsToReportFile();

DMSG(1, "<== leave GUIModel-begin() done." );
}

/////////////////////////////////////////////////////////////////////
// buildDisplay
//
// builds the display and display related things
//
public void buildDisplay() {
if ( rDebug > 0 )
System.out.printf( "==> GUIModel buildDisplay...\n" );

// Layout specifies the arrangement of nodes and edges
// This specifically uses the Kamada-Kawai method
layout = new KamadaGraphLayout(agentList, worldXSize, worldYSize);
Network2DDisplay display = new Network2DDisplay(layout);

layout.updateLayout(); // actually execute the laying out

// Register the layout with the display surface for drawing
surface.addDisplayableProbeable(display, "Network Display");
surface.addZoomable (display);
surface.setBackground (java.awt.Color.black);

addSimEventListener (surface);

// Makes a graph
repSkillGraph = new OpenSequenceGraph("RepSkillMatch", this); // constructs graph
repSkillGraph.setXRange(0, 2000); // sets ranges
repSkillGraph.setYRange(-1.1, 1.1);
repSkillGraph.setAxisTitles("time", "frac. match"); // sets axis lables

// This generates a sequence, which is read into the graph
// To generalize, change sequence class name, and what it returns
class repSkillSequence implements Sequence {
public double getSValue(){
return calcRepSkillMatch();
}
}

// Add the above sequence to the graph.
// You can add several sequences to plot simultaneously
repSkillGraph.addSequence("frace. match", new repSkillSequence());
// Display the graph. It will need to be updated in Step
repSkillGraph.display();

topSkillGraph = new OpenSequenceGraph("Top Rep Skills", this); // constructs graph
topSkillGraph.setXRange(0, 2000); // sets ranges
topSkillGraph.setYRange(0, 5);
topSkillGraph.setAxisTitles("time", "Skills"); // sets axis lables

// This generates a sequence, which is read into the graph
// To generalize, change sequence class name, and what it returns
class topSkillSequence implements Sequence {
public double getSValue(){
// AS: changed to use numTopAgents
//return calcTopRepSkills(5);
return calcTopRepSkills(numTopAgents);
}
}

// Add the above sequence to the graph.
// You can add several sequences to plot simultaneously
topSkillGraph.addSequence("Skill of Top Rep Agents", new topSkillSequence());
// Display the graph. It will need to be updated in Step
topSkillGraph.display();

// Generate a histogram of agent wealth
/*
wealthHist = new OpenHistogram("Agent Wealth Distribution", 10, 0);
wealthHist.setYRange(0, 100.0);
BinDataSource histSource = new BinDataSource(){
public double getBinValue(Object o){
CustomNode node = (CustomNode) o;
return node.getReputation();
}
};

wealthHist.createHistogramItem("Wealth", agentList, histSource);
wealthHist.display();
*/

// Generate a histogram of agent degree
/*
degreeHist = new OpenHistogram("Agent Degree Distribution", 10, 0);
degreeHist.setYRange(0, 100.0);
BinDataSource degreeSource = new BinDataSource(){
public double getBinValue(Object o){
CustomNode node = (CustomNode) o;
return node.getDegree();
}
};

degreeHist.createHistogramItem("Degree", agentList, degreeSource);
degreeHist.display();
*/

}

////////////////////////////////////////////////////////////////
// buildSchedule
// Adds to buildSchedule in main model
// Note, model-type changes should also be included in
// batchmodel's buildSchedule if one wants to ever run in batch

public void buildSchedule() {

schedule = new Schedule(1);
super.buildSchedule(); // Get base model schedule

}

//////////////////////////////////////////////////////////////////
// step
//
// Ask the super-class (RepMod) to do its step() method,
// and then this does display related activities.
public void step() {

super.step(); // the base model does whatever it does

// add things after this for all displays (graphs, etc)
drawNodes();
surface.updateDisplay();
repSkillGraph.step();
topSkillGraph.step();
//wealthHist.step();
}

////////////////////////////////////////////////////////////////
// drawNodes
// has nodes re-draw themselves based on Reputation
public void drawNodes(){
CustomNode node;
double maxReputation = 0;
for(int i = 0; i < numAgents; i++){
node = (CustomNode) agentList.get(i);
if (node.getReputation() > maxReputation)
maxReputation = node.getReputation();
}
for(int i = 0; i < numAgents; i++){
node = (CustomNode) agentList.get(i);
node.setNodeColorFromReputation(maxReputation);
}
}

//////////////////////////////////////////////////////////////////
// processEndOfRun
// called once, at end of run.
public void processEndOfRun ( ) {
long finalStep = (long) schedule.getCurrentTime();
if ( rDebug > 0 )
System.out.printf("\n\n===== GUIModel processEndOfRun =====\n\n" );
applyAnyStoredChanges();
endReportFile(finalStep);
this.fireStopSim();
}

/////////////////////////////////////////////////////////////
// addAgent
// Input: CustomNode agent
// Output: none
// Adds a new agent to the agent list
public void addAgent(CustomNode agent){
super.addAgent(agent);
updateLayoutAgentList();
}

/////////////////////////////////////////////////////////////
// delAgent
// Input: CustomNode agent
// Output: none
// Deletes an agent from the agent list
public void delAgent(CustomNode agent){
super.delAgent(agent);
updateLayoutAgentList();
}

////////////////////////////////////////////////////////////
// updateLayoutAgentList
// Input: none
// Output: none
// Update layout's agentList. Model's agentlist
// is updated with gm's (since they both point to
// the same object). Layout is dumb, and evidently
// re-stores pointers to objects in list, rather than
// the list.
public void updateLayoutAgentList(){

layout.setList(agentList);
// update the layout, re-executing layout method (e.g. Kamada)
layout.updateLayout();
}

///////////////////////////////////////////////////////////////////
// changeLayoutCircular
// Uses circular rather than Kamada layout
public void changeLayoutCircular(){
layout = new CircularGraphLayout(agentList, worldXSize, worldYSize);
layout.updateLayout();
}

///////////////////////////////////////////////////////////////////
// changeLayoutKamada
// Uses kamada-kawai layout, rather than circular
public void changeLayoutKamada(){
layout = new KamadaGraphLayout(agentList, worldXSize, worldYSize);
layout.updateLayout();
}

///////////////////////////////////////////////////////////////////
// printNodes
// print node properties to terminal window
// Mainly used for debugging
public void printNodes(){
System.out.printf("\nAt time = %f\n", schedule.getCurrentTimeDouble());
for(int i = 0; i < agentList.size(); i++){
CustomNode aNode = (CustomNode) agentList.get(i);
String s = String.format("#%d has %1.3f rep with skill %1.3f.\n",
aNode.getID(), aNode.getReputation(), aNode.getSkill());

System.out.printf(s);
}
System.out.printf("\n");
}

///////////////////////////////////////////////////////////////////
// printRepSortedNodes
// print node properties to terminal window
// Mainly used for debugging

public void printRepSortedNodes(){
ArrayList<CustomNode> tempList = new ArrayList<CustomNode>();
tempList.addAll(agentList);
Collections.sort(tempList, compNodes);
System.out.printf("\nAt time = %f\n", schedule.getCurrentTimeDouble());
for(CustomNode agent : tempList){
String s = String.format("#%d has %1.3f rep with skill %1.3f.\n",
agent.getID(), agent.getReputation(), agent.getSkill());

System.out.printf(s);
}
System.out.printf("\n");

}

//////////////////////////////////////////////////////////////////////
// killAllEdges
// deletes all edges
// Mainly used for debugging, or being a bastard
public void killAllEdges(){
for(int i = 0; i < agentList.size(); i++){
CustomNode node = (CustomNode) agentList.get(i);
node.clearInEdges();
node.clearOutEdges();
}
}

////////////////////////////////////////////////////////////////////
// plotRepSkill()
public void plotRepSkill(){
Plot repSkillPlot = new Plot("Reputation v. Skill");
repSkillPlot.display();
repSkillPlot.setConnected(false);

for (int i = 0; i < numAgents; i++) {
CustomNode node = (CustomNode) agentList.get(i);
repSkillPlot.plotPoint(node.getSkill(), node.getReputation(), 0);
}
repSkillPlot.updateGraph();
repSkillPlot.setXRange(0, 1);
repSkillPlot.setYRange(0, 1);
//aPlot.fillPlot();
}

/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
// **** NO NEEd TO CHANGE THE REST OF THIS *****

////////////////////////////////////////////////////////////////////
// main entry point
public static void main( String[] args ) {

uchicago.src.sim.engine.SimInit init =
new uchicago.src.sim.engine.SimInit();
GUIModel model = new GUIModel();

//System.out.printf("==> GUIMOdel main...\n" );

// set the type of model class, this is necessary
// so the parameters object knows whether or not
// to do GUI related updates of panels,etc when a
// parameter is changed
model.setModelType("GUIModel");

// Do this to set the Update Probes option to true in the
// Repast Actions panel
Controller.UPDATE_PROBES = true;

model.setCommandLineArgs( args );
init.loadModel( model, null, false ); // does setup()

// this new function calls ProbeUtilities.updateProbePanels() and
// ProbeUtilities.updateModelProbePanel()
model.updateAllProbePanels();

}

/** Creates a new instance of GUIModel */
public GUIModel() {
}

}

</pre>

Andrew Stout

2006-06-10T22:42:21Z

AndrewStout:

[[Image:andrewstout.jpg]]

----
CSSS contact info:
*Polyhymnia #20, ext 4224
*[my last name] @ cs.umass.edu
*cell 413 695 3814 (reception is terrible)
----

I am a PhD student in Computer Science at the University of Massachusetts.

The general unifying theme of my research interests is to understand-by-building systems that continually adapt, building on previous adaptations, driven not (or not only) by external pressures, but by forces within the system: systems that display bootstrapping, unbounded, intrinsic adaptation.
My driving interest is in discovering representations and algorithms for constructive, grounded, long-term, domain-general cognitive development in robots. I have a sustained secondary interest in evolutionary computation, self-organization, and artificial life.

I have a [http://www.cs.umass.edu/~stout/ webpage], but it's pretty minimal...

When I'm not pursuing these interests, I enjoy ultimate frisbee and volleyball; I'm a news junkie and a religious watcher of The Daily Show; I'm in for some World Cup watching.

Dan's questions:

# What topics do you have some expertise in and would you be willing to help others learn them?
#*I'm a competent programmer, although not the code ninja a CS grad student ought to be: my go-to language is Python, I'm learning OCaml, I dabble in Matlab when forced to, and I have less recent experience with Java, C++, and others.
#*I'm comfortable at the Unix/Linux command-line.
#*My graduate background is in Machine Learning, if any of that will be useful. This semester I took a seminar that examined some ML applications of spectral graph theory, which I can imagine being of interest to others.
# What do you want to learn?
#*My formal training in complex systems science has been quite limited, so I'm looking forward to a rigorous treatment of the whole spectrum and finding out what the current state of the art and agenda are. I'm curious about agent-based modeling, network theory, biology, geosystems, economics, etc.
#*More specifically, I'm interested in acquiring tools for identifying phase changes and the "edge of chaos" in "learning space"--the fertile region between what an agent has already learned and what it is not yet ready to learn.
# Do you have any projects that would benefit from interdisciplinary approach?
#*In addition to the above, I've got a reproduction of Fontana's AlChemy system I've been having a little trouble with.
#*I'm interested in the role of motivation in learning, which is a topic that could no doubt benefit from conversations with psychologists or anyone else who thinks about such things.
#*And I'd love to find ways to apply my skills and ideas to problems people outside of my immediate field would care about.
# Do you have any ideas for what sort of project you would like to attack this summer?
#*Not really--I can imagine pursuing something related to one of the topics mentioned above, or something totally different.
# What's your favorite "big problem"?
#*Embodied Intelligence--understanding the mechanisms that allow humans and animals to use such a complicated body so effectively in such a complicated world. I'm particularly interested in this problem at the computational and algorithmic levels of analysis, although the implementational level is also very interesting, and I'm particularly interested in learning and cognitive development.
#*An obvious second "big problem" is self-organization and emergence in complex adaptive systems--that's why I'm coming to the CSSS, of course, and I don't think the second is unrelated to the first.
# If you were given the opportunity to see where we were in one hundred years with respect to progress on one problem/subject, what would it be?
#*Those mentioned in #5, naturally.
#*Although I am also very curious to see how we will deal with the many problems facing society today: alleviating the crushing poverty in much of the world, environmentally sustainable energy demands, combating {race|class|sex|tribal|...}-ism, etc.

File:Andrewstout.jpg

2006-05-26T04:56:00Z

AndrewStout:

Andrew Stout

2006-05-26T04:55:18Z

AndrewStout:

[[Image:andrewstout.jpg]]

I am a PhD student in Computer Science at the University of Massachusetts.

The general unifying theme of my research interests is to understand-by-building systems that continually adapt, building on previous adaptations, driven not (or not only) by external pressures, but by forces within the system: systems that display bootstrapping, unbounded, intrinsic adaptation.
My driving interest is in discovering representations and algorithms for constructive, grounded, long-term, domain-general cognitive development in robots. I have a sustained secondary interest in evolutionary computation, self-organization, and artificial life.

I have a [http://www.cs.umass.edu/~stout/ webpage], but it's pretty minimal...

When I'm not pursuing these interests, I enjoy ultimate frisbee and volleyball; I'm a news junkie and a religious watcher of The Daily Show; I'm in for some World Cup watching.

Dan's questions:

# What topics do you have some expertise in and would you be willing to help others learn them?
#*I'm a competent programmer, although not the code ninja a CS grad student ought to be: my go-to language is Python, I'm learning OCaml, I dabble in Matlab when forced to, and I have less recent experience with Java, C++, and others.
#*I'm comfortable at the Unix/Linux command-line.
#*My graduate background is in Machine Learning, if any of that will be useful. This semester I took a seminar that examined some ML applications of spectral graph theory, which I can imagine being of interest to others.
# What do you want to learn?
#*My formal training in complex systems science has been quite limited, so I'm looking forward to a rigorous treatment of the whole spectrum and finding out what the current state of the art and agenda are. I'm curious about agent-based modeling, network theory, biology, geosystems, economics, etc.
#*More specifically, I'm interested in acquiring tools for identifying phase changes and the "edge of chaos" in "learning space"--the fertile region between what an agent has already learned and what it is not yet ready to learn.
# Do you have any projects that would benefit from interdisciplinary approach?
#*In addition to the above, I've got a reproduction of Fontana's AlChemy system I've been having a little trouble with.
#*I'm interested in the role of motivation in learning, which is a topic that could no doubt benefit from conversations with psychologists or anyone else who thinks about such things.
#*And I'd love to find ways to apply my skills and ideas to problems people outside of my immediate field would care about.
# Do you have any ideas for what sort of project you would like to attack this summer?
#*Not really--I can imagine pursuing something related to one of the topics mentioned above, or something totally different.
# What's your favorite "big problem"?
#*Embodied Intelligence--understanding the mechanisms that allow humans and animals to use such a complicated body so effectively in such a complicated world. I'm particularly interested in this problem at the computational and algorithmic levels of analysis, although the implementational level is also very interesting, and I'm particularly interested in learning and cognitive development.
#*An obvious second "big problem" is self-organization and emergence in complex adaptive systems--that's why I'm coming to the CSSS, of course, and I don't think the second is unrelated to the first.
# If you were given the opportunity to see where we were in one hundred years with respect to progress on one problem/subject, what would it be?
#*Those mentioned in #5, naturally.
#*Although I am also very curious to see how we will deal with the many problems facing society today: alleviating the crushing poverty in much of the world, environmentally sustainable energy demands, combating {race|class|sex|tribal|...}-ism, etc.