Actions

ModelParameters.java.wp

From Santa Fe Institute Events Wiki

WikiPeerCode


package RepMod;

import java.io.*;
import java.util.*;
import java.util.Formatter;  // import this class lib
import java.util.Scanner;
import java.util.regex.*;  // for MatchResult
import java.awt.Color;
import java.awt.FileDialog;
import javax.swing.JFrame;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

import java.text.NumberFormat;
import java.text.DecimalFormat;
import java.text.DateFormat;
import java.sql.Time;

import java.lang.reflect.*;

import uchicago.src.sim.engine.*;
import uchicago.src.sim.gui.*;
import uchicago.src.sim.space.*;
import uchicago.src.sim.network.*;
import uchicago.src.sim.util.SimUtilities;
import uchicago.src.reflector.ListPropertyDescriptor;
import uchicago.src.sim.util.Random;
import uchicago.src.sim.analysis.*;
import uchicago.src.collection.RangeMap;
import uchicago.src.sim.event.SliderListener;

import uchicago.src.sim.util.*;

//for the xml parsing of input files
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Attr;
import org.w3c.dom.Element;

import java.util.TreeMap;

import rlriolo.ioutils.*;

public class ModelParameters extends SimModelImpl {

        
    long startTime = System.currentTimeMillis();
    
    // setup
    // this should be called *last* in the Model setup() that
    // extends this class.
    public void setup() {
	changesVector = new Vector();
	setupParametersMap();
	// this might be kind of kludgy?
	// only process command line arguments if it is the first run
	// if it is the first run then schedule is null,
	// if not then schedule is initialized (and is set to null
	// on the next line)
	if( schedule == null ) 
	    processCommandLinePars( commandLineArgs );
	schedule = null;
	
	if ( rDebug > 0 )
	    System.out.printf( "<--- ModelParameters setup() done.\n" );
    }
    
    public void begin() {
	// this must be declared in the class that 'extends' this one
    }
    
    // buildModelStart
    // this should be called first by the buildModel in the extending class.
    public void buildModelStart() {
	if ( getSeed() == 1234567 || getSeed() == 0) {
	    long s = System.currentTimeMillis();
	    setSeed( s );
	    if ( rDebug > 1 )
		System.out.printf( "\nseed was 1234567 or 0, now ==> s=%d\n", s );
	}
	if( rDebug > 1 )
	    System.out.printf( "\nabout to setSeed(%d)\n", getSeed() );
	resetRNGenerators();
    }
    
    
    // buildSchedule
    // the extending classes must fill this in
    public void buildSchedule() {
	//if ( rDebug > 0 )
	//	System.err.printf( "-> ModelParameters buildSchedule...\n" );
	schedule = new Schedule();
    }
    
    
    
    public String[] getInitParam() {
	// this must be declared in the class that 'extends' this one
	return null;
    }
    
    // Generic parameters
    protected String		initialParametersFileName = "";
    protected String		initialAgentsFileName = "";
    protected String		reportFileName = "report";
    protected String		outputDirName =  "./";
    protected int	       	reportFrequency = 1;
    protected int	       	runNumber = 0;
    protected int	       	stopT = 100000; //100
    protected int	       	rDebug = 0;
    protected int	       	saveRunEndState = 0;
    protected long    		seed = 1234567;
    protected PrintWriter      	reportFile, plaintextReportFile;
    protected PrintWriter      	changesFile;
    
    // other utilities
    protected String[] commandLineArgs;
    protected String modelType = "Model";
    
    //for input file 
    protected boolean 	STRICT_FILE_FORMAT = true;
    protected Vector 		changesVector;
    
    // variables for processing run-time changes that are
    // read in from the input file
    protected int 	numberOfChanges = 0;
    protected int 	nextChangeToDo  = 0;
    protected int[] 	changeSteps     = new int[64];
    protected int[] 	changeIDs       = new int[64];
    protected ArrayList changeSpecs     = new ArrayList(16);
    
    // required by SimModelImpl
    protected BasicAction	stepMethods;
    protected Schedule	schedule = null;
    
    // setupParametersMap
    // this implements the mapping from aliases to long names,
    // for the 'base' parameters common to all models.
    // For parameters for a particular model, add lines
    // to addToParametersMap().
    protected   TreeMap parametersMap;
    public void setupParametersMap () {
	DMSG( 1, "setupParametersMap()" );
	
	parametersMap = null;
	parametersMap = new TreeMap();
	// generic model parameters
	parametersMap.put( "D", "rDebug" );
	parametersMap.put( "S", "seed" );
	parametersMap.put( "iPFN", "initialParametersFileName" );
	parametersMap.put( "iAFN", "initialAgentsFileName" );
	parametersMap.put( "rFN", "reportFileName" );
	parametersMap.put( "T", "stopT" );
	parametersMap.put( "sRES", "saveRunEndState" );
	parametersMap.put( "oDN", "outputDirName" );
	parametersMap.put( "rF", "reportFrequency" );
	parametersMap.put( "rN", "runNumber" );
	
	addModelSpecificParameters();
    }
    
    // addModelSpecificParameters
    // a subclass should override this. 
    public void addModelSpecificParameters() {
    }
    
    public void printParametersMap () {
	
	ArrayList parameterNames = new ArrayList( parametersMap.values() );
	ArrayList parameterAliases = new ArrayList( parametersMap.keySet() );
	
	for( int i = 0; i < parameterAliases.size(); i++ ) {
	    Method getmethod = null;
	    String parAlias = (String)  parameterAliases.get(i);
	    String parName = (String) parametersMap.get( parAlias );
	    
	    getmethod = findGetMethodFor( parName );
	    
	    if( getmethod != null ) {
		try {
		    Object returnVal = getmethod.invoke( this, new Object[] {} );
		    String s =  parName + " (" + parAlias + ") = " + returnVal;
		    System.out.printf( "%s\n", s );
		} catch( Exception e ) { e.printStackTrace(); }
	    }
	    else {
		System.err.printf ( "COULD NOT FIND SET METHOD FOR:  %s\n", 
				    parameterNames.get( i ) );
		System.err.printf ( "Is the entry in the parametersMap for this correct?" );
	    }
	}
	
    }
    
    ////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////
    
    
    // generic setters/getters
    
    public String[] getCommandLineArgs () { return commandLineArgs; }
    public void setCommandLineArgs ( String[] arguments ) {
	// for( int i = 0; i < arguments.length; i++ ) {
	//	System.out.println( "setCommandLineArgs: " + arguments[i] );
	// }
	commandLineArgs = arguments;
    }
    
    public String getModelType() { return modelType; }
    public void setModelType( String s ) {
	modelType = s;
    }
    
    public String getInitialParametersFileName () { 
	return initialParametersFileName; }
    public void setInitialParametersFileName ( String s ) {
	initialParametersFileName = s;
    }
    
    public String getInitialAgentsFileName () { 
	return initialAgentsFileName; }
    public void setInitialAgentsFileName ( String s ) {
	initialAgentsFileName = s;
    }
    
    public String getReportFileName () { return reportFileName; }
    public void setReportFileName ( String s ) {
	reportFileName = s;
    }
    
    public String getOutputDirName () { return outputDirName; }
    public void setOutputDirName ( String s ) {
	outputDirName = s;
    }
    
    public int getReportFrequency () { return reportFrequency; }
    public void setReportFrequency ( int i ) {
	reportFrequency = i;
    }
    
    public int getRunNumber () { return runNumber; }
    public void setRunNumber ( int i ) {
	runNumber = i;
    }
    
    public int getStopT () { return stopT; }
    public void setStopT ( int i ) {
	stopT = i;
    }
    
    public int getSaveRunEndState () { return saveRunEndState; }
    public void setSaveRunEndState ( int i ) {
	saveRunEndState = i;
    }
    
    public int getRDebug () { return rDebug; }
    public void setRDebug ( int i ) {
	if( rDebug == i ) {
	    // System.out.printf( "setRDebug called, but value unchanged, returning" );
	    return;
	}
	// System.out.println( "setRDebug ( " + i + " ) called" );
	rDebug = i;
	if( modelType.equals( "GUIModel" ) ) {
	    updateAllProbePanels();
	}
	if( modelType.equals( "GUIModel" ) && schedule != null )
	    writeChangeToReportFile ( "rDebug", String.valueOf( i ) );
    }
    
    public long getSeed () { return seed; }
    public void setSeed ( long i ) {
	if( rDebug > 0 )
	    System.out.println( "setSeed ( " + i + " ) called" );
	seed = i;
	
	resetRNGenerators();
	
	if( modelType.equals( "GUIModel" ) ) {
	    updateAllProbePanels();
	}
	if( modelType.equals( "GUIModel" ) && schedule != null)
	    writeChangeToReportFile ( "seed", String.valueOf( i ) );
    }
    
    public void resetRNGenerators ( ) {
	if ( rDebug > 0 )
	    System.out.printf( "\nresetRNGenerators with %d\n", getSeed() );
	
	// this is required because once you change the seed you invalidate
	// any previously created distributions
	uchicago.src.sim.util.Random.setSeed( seed );
	uchicago.src.sim.util.Random.createUniform();
	uchicago.src.sim.util.Random.createNormal( 0.0, 1.0 );
    }
    
    // NOTE: these are class methods!
    static public int getUniformIntFromTo ( int low, int high ) {
	int randNum = Random.uniform.nextIntFromTo( low, high );
	// System.out.println( "getUniformIntFromTo:  " + randNum );
	return randNum;
    }
    
    static public double getNormalDouble ( double mean, double var ) {
	double randNum =  Random.normal.nextDouble ( mean, var );
	// System.out.println( "getNormalDouble:  " + randNum );
	return randNum;
    }
    static public double getUniformDoubleFromTo( double low, double high ) {
	double randNum = Random.uniform.nextDoubleFromTo( low, high );
	// System.out.println( "getUniformDoubleFromTo:  " + randNum );
	return randNum;
    }
    
    // loop until a number between 0 and 1 is generated,
    // if mean and var are set correctly the loop will rarely happen
    static public double getNormalDoubleProb ( double mean, double var ) {
	if ( mean < 0 || mean > 1 ) {
	    System.out.println ( "Invalid value set for normal distribution mean" );
	    return -1;
	}
	double d = Random.normal.nextDouble ( mean, var );
	while ( d < 0 || d > 1 )
	    d = Random.normal.nextDouble ( mean, var );
	
	// System.out.println( "getNormalDoubleProb:  " + d );
	
	return d;
    }
    
    public void setRngSeed ( long i ) {
	System.out.println( "setRngSeed ( " + i + " ) called" );
	setSeed( i );
    }
    
    public PrintWriter getReportFile () { return reportFile; }
    public PrintWriter getPlaintextReportFile () { return plaintextReportFile; }
    public Schedule getSchedule() { return schedule; }
    
    // rePast needs this (i guess...)
    public String getName() { return "ModelParameters"; }
    
    // some generic utilities
    public void updateAllProbePanels() {
	DMSG ( 2, "updateAllProbePanels()" );
	ProbeUtilities.updateProbePanels();
	
	// kludge...
	// need this in case updateAllProbePanels gets called
	// before the probe panel is created (if it is called
	// before, then a RuntimeException occurs)
	// did have if(schedule != null), but that means panels
	// do not update at all during time=0, so people get confused.
	try {
	    ProbeUtilities.updateModelProbePanel();
	}
	catch (RuntimeException e) {
	    // ignore exception
	    DMSG( 3, "RuntimeException when updating model probe panel, ignoring ..." );
	}
    }
    
    // captialize first character of s
    protected String capitalize( String s ) {
	char c = s.charAt( 0 );
	char upper = Character.toUpperCase( c );
	return upper + s.substring( 1, s.length() );
	}
    
    
    // REPORT FILE PROCESSING ------------------------------
    //
    // startReportFile
    // opens two report files
    // one XML report file and one plaintext report file
    // call writeLineToReportFile to write to XML report file
    // and writeLineToPlaintextReportFile to write to plaintext file
    
    public PrintWriter startReportFile ( ) {
	if ( rDebug > 0 )
	    System.out.println( "startReportFile called!" );
	reportFile = null;
	plaintextReportFile = null;
	String fullFileName = reportFileName + String.format( ".%02d", runNumber );
	String xmlFullFileName = reportFileName + ".xml" 
	    + String.format( ".%02d", runNumber );
	
	// BufferedReader inFile = IOUtils.openFileToRead(initialParametersFileName);
	
	//reportFile = IOUtils.openFileToWrite( outputDirName, xmlFullFileName, "r" );
	plaintextReportFile = IOUtils.openFileToWrite( outputDirName, fullFileName, "r" );
	
	// the first line you have to write is the XML version line
	// DO NOT WRITE THIS LINE USING writeLineToReportFile()!
	//reportFile.println( "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" );
	
	//writeLineToReportFile( "<reportfile>" );
	writeLineToPlaintextReportFile( "# begin reportfile" );
	
	//  write the initial parameters to the report file
	writeParametersToReportFile();
	
	writeHeaderCommentsToReportFile();  // the user must define this!
	
	return reportFile;
    }
    
    public void writeLineToReportFile ( String line ) {
	if ( reportFile == null ) {
	    DMSG( 3, "report file not opened yet" );
	    // click the initialize button to open it! 
	    // returning w/o writing to report file ...");
	    return;
	}
	else {
	    reportFile.println( line );
	}
    }
    
    public void writeLineToPlaintextReportFile ( String line ) {
	if ( plaintextReportFile == null ) {
	    DMSG( 3, "report file not opened yet" );
	    // click the initialize button to open it! 
	    // returning w/o writing to report file ...");
	    return;
	}
	else {
	    plaintextReportFile.println( line );
	}
    }
    
    public void writeChangeToReportFile( String varname, String value ) {
	DMSG( 1, "writeChangeToReportFile(): write change to report file: " 
	      + varname + " changed to " + value );
	
	//writeLineToReportFile( "<change>" );
	writeLineToReportFile( "\t<" + varname + ">" + value 
			       + "</" + varname + ">" );
	String s = String.format(  "\t<time>%.0f</time>", getTickCount() );
	//writeLineToReportFile( s );
	//writeLineToReportFile( "</change>" );
	
	writeLineToPlaintextReportFile( "# change:  " + varname + "=" + value );
    }
    
    /*public void endReportFile ( ) {
      writeLineToReportFile( "</reportfile>" );
      String s = String.format("# end report file");//: ran %f steps in %f seconds.", schedule.getCurrentTime(), ((double)(System.currentTimeMillis() - startTime))/1000.0 );
      writeLineToPlaintextReportFile( s );
      IOUtils.closePWFile( reportFile );
      IOUtils.closePWFile( plaintextReportFile );
      }*/
    
    public void endReportFile (long steps ) {
	//writeLineToReportFile( "</reportfile>" );
	String s = String.format("# end report file: ran %d steps in %f seconds.", steps,  ((double)(System.currentTimeMillis() - startTime))/1000.0 );
	writeLineToPlaintextReportFile( s );
	//IOUtils.closePWFile( reportFile );
	IOUtils.closePWFile( plaintextReportFile );
    }
    
    
    // this iterates through the values stored in the parametersMap, 
    // calls the getter on each parameter, and outputs the 
    // parameter and its value to the report file.
    // this is called right before the model run starts (after all 
    // initial parameters are changed!) so 
    // the initial parameters are in the report file.
    public void writeParametersToReportFile() {
	DMSG( 1, "writeParametersToReportFile()" );
	
	System.out.printf("Begin Writing Parameters.\n");
	//writeLineToReportFile( "<parameters>" );
	writeLineToPlaintextReportFile( "# begin parameters" );
	
	ArrayList parameterNames = new ArrayList( parametersMap.values() );
	System.out.printf("parametersMap size = %d\n", parameterNames.size());
	for( int i = 0; i < parameterNames.size(); i++ ) {
	    System.out.printf("Printing %s\n", (String) parameterNames.get(i));
	    Method getmethod = null;
	    getmethod = findGetMethodFor( (String) parameterNames.get( i ) );
	    
	    if( getmethod != null ) {
		try {
		    Object returnVal = getmethod.invoke( this, new Object[] {} );
		    
		    /*writeLineToReportFile( "\t<" + parameterNames.get(i) + ">"
		      + returnVal 
		      + "</" + parameterNames.get(i) + ">" );*/
		    
		    writeLineToPlaintextReportFile( parameterNames.get(i)
						    + "="
						    + returnVal );
		    
		} catch( Exception e ) { e.printStackTrace(); }
	    }
	    else {
		System.err.printf ( "COULD NOT FIND SET METHOD FOR:  %s\n", 
				    parameterNames.get( i ) );
		System.err.printf ( "Is the entry in the parametersMap for this correct?" );
	    }
	}
	//writeLineToReportFile( "</parameters>" );
	writeLineToPlaintextReportFile( "# end parameters" );
    }
    
    
    //////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////
    // parseParametersFile
    //
    public void parseParametersFile() {
	// a klunky way to see if the parameters file exists
	try {
	    BufferedReader inFile = 
		IOUtils.openFileToRead(initialParametersFileName );
	    IOUtils.closeBRFile( inFile );
	}
	catch(Exception e) { // not an error, just not there!
	    if ( rDebug > 0 )
		System.err.printf( "  -- no initialParametersFileName '%s' to parse.\n", 
				   initialParametersFileName );
	    return;
	}
	
	try {
	    //setup the input file
	    DocumentBuilderFactory myDBF = DocumentBuilderFactory.newInstance();
	    DocumentBuilder myDB = myDBF.newDocumentBuilder();
	    Document myDocument = myDB.parse(initialParametersFileName);
	    
	    if ( rDebug > 0 )
		System.out.println("Parsing parameter file: "+initialParametersFileName);
	    
	    NodeList tmpList = myDocument.getElementsByTagName("parameters");
	    Element tmpElement = (Element)tmpList.item(0);
	    NodeList parameterList = tmpElement.getElementsByTagName("*");
	    
	    for(int i = 0; i < parameterList.getLength(); i++) {
		if ( parameterList.item(i).getChildNodes().item(0) == null)
		    continue;
		DMSG( 1, "name:  " + parameterList.item(i).getNodeName()
		      + "  value:  "
		      + parameterList.item(i).getChildNodes().item(0).getNodeValue() );
		set( parameterList.item(i).getNodeName(), 
		     parameterList.item(i).getChildNodes().item(0).getNodeValue() );
	    }
	    
	    // process changes
	    NodeList parameterChangeList = myDocument.getElementsByTagName( "change" );
	    processChangeList( parameterChangeList );
	    
	    DMSG( 1, "Done parsing file:  " + initialParametersFileName );
	}
	catch(Exception e) {
	    System.out.println("Exception when parsing parameters file:  "
			       + initialParametersFileName);
	    System.out.println("Is the file in the correct format?");
	    e.printStackTrace();
	}
    }
    
    
    /////////////////////////////////////////////////////////////////////////
    // processCommandLinePars
    // storeParameter
    //
    //
    public void processCommandLinePars ( String[] args ) {
	int r;
	if( args.length > 0 
	    && ( args[0].equals( "--help" ) || args[0].equals( "-h" ) ) ) {
	    printProjectHelp();
	}
	
	for ( int i = 0; i < args.length; ++i ) {
	    r = storeParameter( args[i] );
	    if( r != 0 )  {
		System.out.println( "Error processing cmdLine par:  " + args[i] );
	    }
	}
    }
    
    // storeParameter
    // format:  parname=value
    // parse out parname, and find method for setParname
    // if not found, return -1
    // otherwise set the value and return 0.
    // to set the value, we have to get the setMethod, and its par type.
    // then convert the string value to the appropriate object, and
    // use invoke to do the setting!
    
    public int storeParameter ( String line ) {
	int r = 0;
	String pname, pvalue;
	StringTokenizer st = new StringTokenizer( line, "=;," );
	Method setm = null;
	
	if ( ( pname = st.nextToken() ) == null ) {
	    System.err.printf("\n** storeParameter -- couldn't find pname on '%s'.\n",
			      line );
	    return -1;
	}
	if ( ( pvalue = st.nextToken() ) == null ) {
	    System.err.printf("\n** storeParameter -- couldn't find value on '%s'.\n",
			      line );
	    return -1;
	}
	pname = pname.trim();
	pvalue = pvalue.trim();
	
	pname = aliasToParameterName ( pname );
	
	// if this is a scheduledChange, create the change
	// and insert it into the changesVector
	if( pname.equals ( "sC" ) ) {
	    String changetime = pvalue;
	    String changepname, changepvalue;
	    
	    if ( ( changepname = st.nextToken() ) == null ) {
		System.out.println( "\n** storeParameter -- couldn't find "
				    + "scheduleChange pname on:  " + line );
		return -1;
	    }
	    
	    if ( ( changepvalue = st.nextToken() ) == null ) {
		System.out.println( "\n** storeParameter -- couldn't find "
				    + "scheduleChange pvalue on:  " + line );
		return -1;
	    }
	    
	    changepname = changepname.trim();
	    changepvalue = changepvalue.trim();
	    
	    changepname = aliasToParameterName ( changepname );
	    
	    ChangeObj newChange = new ChangeObj( Integer.parseInt( changetime ),
						 changepname, changepvalue );
	    
	    DMSG ( 1, "scheduledChange from command line created:  "
		   + "  Time:  " + changetime + "  pname:  "
		   + changepname + "  pvalue:  " + changepvalue );
	    changesVector.add ( newChange );
	    
	    return 0;
	}
	
	setm = findSetMethodFor( pname );
	String ptype = getParTypeOfSetMethod( setm );
	
	try {
	    setm.invoke( this, new Object[] { valToObject( ptype, pvalue ) } );
	} catch ( Exception  e ) {
	    System.err.printf( "\n storeParameter: '%s'='%s' invoke exception!\n", 
			       pname, pvalue );
	    
	    System.err.printf( "  --> %s\n", e.toString() );
	    e.printStackTrace();
	    return -1;
	}
	
	if( pname.equals ( "initialParametersFileName" ) ) {
	    DMSG( 1, "Processing initial parameters file:  " + pvalue );
	    parseParametersFile();
	}
	
	return r;
    }
    
    // returns the long parameter name if the parameter passed in is
    // an alias.  if it is not an alias, the name sent to it is returned.
    public String aliasToParameterName ( String alias ) {
	// check to see if "alias" is an alias in the parametersMap
	// if it is then "alias" is a valid alias, so set "alias" to the 
	// actual parameter name that is in the map
	if( parametersMap.containsKey( alias ) ) {
	    DMSG( 1, "Converting alias " + alias + " to " + parametersMap.get( alias ) );
	    alias = (String) parametersMap.get( alias );
	}
	
	return alias;
    }
    
    // getParTypeOfSetMethod
    // get type of setPar method parameter
    public String getParTypeOfSetMethod ( Method m ) {
	Class[] parTypes = m.getParameterTypes();
	String s = parTypes[0].getName();
	return s;
    }
    
    // findGetMethodFor
    // find get<ParName> method for specified parameter name 
    protected Method findGetMethodFor( String varname ) {
	String methodname = new String( "get" + capitalize( varname ) );
	Class c = getClass();
	Method[] methods = c.getMethods();
	Method getmethod = null;
	
	for ( int j = 0; j < methods.length; j++ ) {
	    if ( methods[j].getName().equals( methodname ) ) {
		getmethod = methods[j];
		break;
	    }
	}
	if ( getmethod == null ) {
	    System.err.printf( "\n** findGetMethodFor -- couldn't find '%s'\n",
			       methodname );
	    return getmethod;
	}
	
	return getmethod;
    }
    
    // findSetMethodFor
    // find set<ParName> method for specified parameter name 
    public Method findSetMethodFor ( String pname ) {
	Class c = this.getClass();
	Method[] methods = c.getMethods();
	int nf = methods.length;
	String setmethodname = "set" + capitalize( pname );
	String mname;
	Method method = null;
	for ( int i = 0; i < nf; ++i ) {
	    mname = methods[i].getName();
	    if ( mname.equals( setmethodname ) ) {
		method = methods[i];
		break;
	    }
	}
	if ( method == null ) {
	    System.err.printf( "\n** findSetMethodFor -- couldn't fine '%s'\n",
			       setmethodname );
	    return method;
	}
	return method;
    }
    
    // valToObject
    // return value stored in object of appropriate type
    private Object valToObject( String type, String val ) {
	if ( type.equals( "int" ) ) {
	    return Integer.valueOf( val );
	} else if ( type.equals( "double" ) ) {
	    return Double.valueOf( val );
	} else if ( type.equals( "float" ) ) {
	    return Float.valueOf( val );
	} else if ( type.equals( "long" ) ) {
	    return Long.valueOf(val);
	} else if ( type.equals( "boolean" ) ) {
	    return Boolean.valueOf(val);
	} else if ( type.equals( "java.lang.String" ) ) {
	    return val;
	} else {
	    throw new IllegalArgumentException( "illegal type" );
	}
    }
    
    public String skipCommentLines ( BufferedReader inFile ) {
	String line;
	while ( ( line = IOUtils.readBRLine ( inFile ) ) != null ) {
	    if ( line.charAt(0) != '#' )
		break;
	}
	return line;
    }
    
    /////////////////////////////////////////////////////////////////////////////
    /////////////////////////////////////////////////////////////////////////////
    // applyAnyStoredChanges
    // look through all of the changes, if any have time of this time 
    // step execute the change
    public void applyAnyStoredChanges () {
	if ( rDebug > 0 ) {
	    System.out.println( "applyAnyStoredChanges called at time step: " 
				+ getTickCount() );
	}
	
	for( int i = 0; i < changesVector.size(); i++ ) {
	    ChangeObj tmpObj = (ChangeObj) changesVector.get( i );
	    if( tmpObj.time == getTickCount() ) {
		if ( rDebug > 0 ) {
		    System.out.println( "applyAnyStoredChanges():  Changing " 
					+ tmpObj.varname + " to " +tmpObj.value );
		}
		set( tmpObj.varname, tmpObj.value );
	    }
	}
    }
    
    ///////////////////////////////////////////////////////////////////////
    ///////////////////////////////////////////////////////////////////////
    // reputation methods for accessing parts of model
    
    private void setObjectParameter( Object inObject, String varname, String value ) {
	String methodname = new String( "set" + capitalize( varname ) );
	Class c = inObject.getClass();
	Method[] methods = c.getMethods();
	Method setmethod = null;
	
	for ( int j = 0; j < methods.length; j++ ) {
	    if ( methods[j].getName().equals( methodname ) ) {
		setmethod = methods[j];
		break;
	    }
	}
	
	if(setmethod != null) {
	    try {
		Class[] parameterTypes = setmethod.getParameterTypes();
		if( parameterTypes[0].getName().equals( "int" ) ) {
		    DMSG( 3, "int parameter type" );
		    setmethod.invoke( inObject, new Object[] { Integer.valueOf( value ) } );
		}
		else if( parameterTypes[0].getName().equals( "long" ) ) {
		    DMSG( 3, "long parameter type" );
		    setmethod.invoke( inObject, new Object[] { Long.valueOf( value ) } );
		}
		else if( parameterTypes[0].getName().equals( "double" ) ) {
		    DMSG( 3, "double parameter type" );
		    setmethod.invoke( inObject, new Object[] { Double.valueOf( value ) } );
		}
		else if( parameterTypes[0].getName().equals( "float" ) ) {
		    DMSG( 3, "float parameter type" );
		    setmethod.invoke( inObject, new Object[] { Float.valueOf( value ) } );
		}
		else if( parameterTypes[0].getName().equals( "java.lang.String" ) ) {
		    DMSG( 3, "String parameter type" );
		    setmethod.invoke( inObject, new Object[] { value } );
		}
		else {
		    System.out.println( "COULD NOT DETERMINE PARAMETER TYPE" );
		}
		DMSG( 1, "setObjectParameter():  " + varname + " changed to " + value );
	    } catch( Exception e ) { e.printStackTrace(); }
	}
	else {
	    System.out.println( "COULD NOT FIND SET METHOD FOR:  " + varname );
	}
    }
    
    private void processChange(Element c) {
	
	
	DMSG(3, "Processing A Change");
	
	NodeList tmpList = c.getElementsByTagName("*");
	
	ChangeObj newChange = new ChangeObj(0,"","");
	
	for(int i = 0; i < tmpList.getLength(); i++)  {
	    Element tmpElement = (Element)tmpList.item(i);
	    // System.out.println("tmpElement.getTagName(): " + tmpElement.getTagName());
	    if(tmpElement.getTagName().equals("time")) {
		newChange.time = Integer.parseInt(tmpElement.getChildNodes().item(0).getNodeValue());
	    }
	    else {
		newChange.varname = tmpElement.getTagName();
		newChange.value = tmpElement.getChildNodes().item(0).getNodeValue();
	    }
	}
	
	changesVector.add(newChange);

	DMSG(3,"Done processing a Change");
    }
    
    private void processChangeList( NodeList c ) {
	
	DMSG(3, "Processing " + c.getLength() + " changes ..." );
	for( int i = 0; i < c.getLength(); i++ )
	    processChange( (Element) c.item( i ) );
	
	for( int i = 0; i < changesVector.size(); i++ ) {
	    ChangeObj tmpObj = (ChangeObj) changesVector.get( i );
	    DMSG( 3, "Time:  " + tmpObj.time + "  VarName:  " 
		  + tmpObj.varname + "  Value:  " + tmpObj.value );
	}
    }
    
    private void set( String varname, String value ) {
	
	// first convert varname to the alias, if it is an alias
	varname = aliasToParameterName ( varname );
	
	Method setmethod = findSetMethodFor ( varname );
	
	if( setmethod != null ) {
	    try {
		Class[] parameterTypes = setmethod.getParameterTypes();
		if ( parameterTypes[0].getName().equals( "int" ) ) {
		    DMSG( 3, "int parameter type" );
		    setmethod.invoke( this, new Object[] { Integer.valueOf( value ) } );
		}
		else if ( parameterTypes[0].getName().equals( "long" ) ) {
		    DMSG( 3, "long parameter type" );
		    setmethod.invoke( this, new Object[] { Long.valueOf( value ) } );
		}
		else if( parameterTypes[0].getName().equals( "float" ) ) {
		    DMSG( 3, "float parameter type" );
		    setmethod.invoke( this, new Object[] { Float.valueOf( value ) } );
		}
		else if ( parameterTypes[0].getName().equals( "double" ) ) {
		    DMSG( 3, "double parameter type" );
		    setmethod.invoke( this, new Object[] { Double.valueOf( value ) } );
		}
		else if ( parameterTypes[0].getName().equals( "java.lang.String" ) ) {
		    DMSG( 3, "String parameter type" );
		    setmethod.invoke( this, new Object[] { value } );
		}
		else {
		    System.out.println( "COULD NOT DETERMINE PARAMETER TYPE" );
		}
		DMSG( 1, "set():  " + varname + " changed to " + value );
	    } catch( Exception e ) { e.printStackTrace(); }
	}
	else {
	    System.out.println( "COULD NOT FIND SET METHOD FOR:  " + varname );
	    System.out.println( "Is the parameter name correct?" );
	}
    }
    
    // loadChangeParameters
    // we expect to see
    //   @changeParameters
    //   step=<timeStep>
    //   parName=parValue
    //   ...
    //   @endChangeParameters
    //   <timeStep> is time step changes are to occur.
    //   store in changeSteps[numberOfChanges]
    //   store number of parameters to change in changeIDs[numberOfChanges]
    //   increment 	 numberOfChanges
    // Return 0 if ok, 1 if not.  next line will be after @endChangeParameters
    public int loadChangeParameters( BufferedReader inFile ) {
	ArrayList lines = new ArrayList(16);
	String line, ends = "@endChangeParameters";
	int r,  step = 0, numPars = 0, done = 0;
	if ( rDebug > 0 )
	    System.out.printf( "\n\n*** loadChangeParameters \n\n" );
	
	// first get the step= line, and the time and ID values
	line = skipCommentLines( inFile );
	if ( rDebug > 0 )
	    System.out.printf("0: %s\n", line );
	
	/* was
	   r = Format.sscanf( line, "step=%i", p.add(iV) );
	   step = iV.intValue();
	*/
	Scanner scanner = new Scanner( line );
	scanner.findInLine( "step=(\\d+)");
	MatchResult result = scanner.match();
	try { step = Integer.parseInt( result.group() ); }
	catch(NumberFormatException e) { }
	
	// get lines into a bunch of strings, add to list of these sets of lines.
	while ( done == 0 ) {
	    line = skipCommentLines( inFile );
	    if ( line.equals( ends ) )
		done = 1;
	    else {
		// *** It would be nice to check these here...
		lines.add( line );
		++numPars;
	    }
	}
	changeSpecs.add( lines );
	
	if ( numPars == 0 ) {  // oops!
	    System.err.printf( "\n*** loadChangeParameters found 0 changes! Last line='%s'\n",
			       line );
	    return -1;
	}
	
	// store time and id in next place in arrays.
	changeSteps[numberOfChanges] = step;
	changeIDs[numberOfChanges] = 0 - numPars;
	++numberOfChanges;
	
	for ( int c = 0; c < numberOfChanges; ++c ) {
	    if ( changeIDs[c] >= 0 )
		continue;
	    lines = (ArrayList) changeSpecs.get(c);
	    System.out.printf( "Change %d at t=%d, ID=%d:\n", 
			       c, changeSteps[c], changeIDs[c] );
	    for ( int i = 0; i < numPars; ++i ) {
		System.out.printf("%d: %s\n", i+1, (String)lines.get(i) );
	    }
	}
	
	return 0;
    }
    
    public void DMSG(int debugLevel, String debugStr) {
	if(rDebug >= debugLevel) {
	    System.out.println("debug:\t" + debugStr);
	}
    }
    
    ////////////////////////////////////////////////////////////////////
    // printProjectHelp
    // this could be filled in with some help to get from running with -help parameter
    //
    public void printProjectHelp() {
	// this is declared in the class that 'extends' this one
    }
    
    ////////////////////////////////////////////////////////////////////
    // writeHeaderCommentsToReportFile
    // include comments to be written just after the list of parameter 
    // values and just before the step-by-step data lines.
    
    public void writeHeaderCommentsToReportFile () {
	// this is declared in the class that 'extends' this one
    }
    
}

////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// auxilliary classes for processing changes
//
//

class ChangeObj {
    public ChangeObj() {}
    public ChangeObj(int in_time, String in_varname, String in_value) {
	time = in_time;
	varname = in_varname;
	value = in_value;
    }
    public int time;
    public String varname;
    public String value;
}

class ACChangeObj {
    public ACChangeObj() {}
    public ACChangeObj(int in_time, int in_id, String in_varname, String in_value) {
	time = in_time;
	id = in_id;
	varname = in_varname;
	value = in_value;
    }
    public int time;
    public int id;
    public String varname;
    public String value;
}