Re: [Swarm-Support] Multiple Agents in One Cell

[Ken Cline]

>    printf ("Scanning through file for data points\n");
>    for (incy=0; incy <numRows; incy++) {
>      for (incx=0; incx < numCols; incx++) {
>        // scan the datapoint - datapoint is the elevation value
>        // from the ascii file
>        float datapoint;
>        int datapoint2;
>        datapoint = [self getDataPoint];
>        // printf("datapoint = %f\n", datapoint);
>        // datapoint2 = (int) datapoint;
>        // printf("datapoint2 = %d\n", datapoint2);
>        // if its within the space, convert the coords to swarm
>        // and input the data
> 
>        if (fileID == 0)
>          [ [cellSurface getCellAtX: x Y: y] setElevLevel: dataPoint];
>
>        data2 = [[cellSurface getCellAtX: x Y: y] getElevLevel]; 
>
>        // more diagnostics here
>        // printf("Elevation here (data2) = %f\n", data2); 
>        // This currently returning "NaN"
>        // Testing out list creation here instead of in
>        // Cell: -createEnd
>        // list = [List create: [self getZone]];
>        // implmenting this here hasn't helped
>      }
>      // else if not within space, do nothing but scan the
>      // next datapoint
>      // move ahead one cell
>      // printf ("Still in the inputData method...");
>      nzmgX = nzmgX + cellSize;
>      // printf("x = %f, y = %f\n", nzmgX, nzmgY);
>    }

Your problem might be that the for-loop indexes are 'incx' and 'incy'
yet you are using (un-initialized) local variables named 'x' and 'y'
to access the cell.

Also, you only set the elevation value if fileID == 0.  Is that
intentional?

Hope that helps.
Ken


--- Crile Doscher <address@hidden> wrote:
>
> Thanks for that, Steve.  That's an excellent point about using two separate 
> space objects.  That might be a relatively easy way around this.  Below I'll 
> try to post some of the code that *I think* is relevant - I'll admit to 
> being a bit unsure about what will be most helpful to post.  Is there a 
> better way to post this?  A tarball perhaps?  Nonetheless, a brief summary 
> of what's below:
> 
> Selection from Cell.m: -createEnd and -createCollection - a la Opinion, the 
> list is created here at the end of cell creation.  Plus -set 
> and -getElevLevel, elevlevel being the elevation value, and -insertItem, 
> borrowed from MultiGrid2d to insert an agent into a cell's list.
> 
> Selections from CellSurface.m: -fillWithCells (adds data to cells) 
> and -findSteepestSlope (determines the best cell for the primary agent to 
> move to - where the current failure seems to occur)
> 
> Selection from DataFile.m: -inputData (reads in elevation values from an 
> ascii raster grid file)
> 
> Selected code from Cell.m:
> //Cell.m a swarmobject that fills in each point in the cellSurface lattice 
> //cell objects hold variables for GIS data layers. They can change these
> //variables as well as communicate with neighboring cells in the lattice.
> //cells can also implement cellular automata-like functions.
> //Cell.m is based on Paul Box's Biox model
> //changes made by Crile Doscher, September 04, for Drop
> #import "Cell.h"
> #import "ModelSwarm.h"
> 
> @implementation Cell
> - createEnd
> {
>     [self createCollection];  //This creates the list
>     return [super createEnd];
> }
> 
> - (id) createCollection
> {
>     //Borrowed from MulitGrid2d
>     list = [List create: [self getZone]];
>     return list;
> }
> 
> -step {
>     // here put things that all cells do at each time step. Especially,
>     // place here functions that involve doing things and sending
>     // messages to neighbor cells
>     return self;
> }
> 
> /////////////////////////////////////////////////////////////////////////
> //here is where we put methods for setting and retrieving variables
> //specific to our model. Replace these with your own
> 
> -setElevLevel: (float) e { //ElevLevel is the elevation value in each cell
>   elevLevel = e;
>   //printf("Cell.m: elevLevel = %f\n", elevLevel);
>   return self;
> }
> 
> -(float) getElevLevel {
>   return elevLevel;
> }
> 
> ///////////////////////////////////////////////////////////////////////////
> 
> - (BOOL) insertItem: obj //19 August 05 - CD added to get agents into lists
> {
>   [list addFirst: obj];
>   return YES;
> }
>
> @end
> 
> >From CellSurface.m - this method creates the cells
> 
> -fillWithCells {
>   int incx, incy;
>   Cell * cell;
> 
>   printf ("Initializing the lattice...\n\n ");
>   cellList = [List create: [self getZone]];
>   //first create empty cell objects and place them in the lattice
>   for (incy = 0; incy < ysize; incy++)
>     for (incx = 0; incx < xsize; incx++) {
>       // allocate memory for a temporary cell
>       cell = [Cell createBegin: [self getZone]];
>       // tell the cell where it is
>       [cell setModel: modelSwarm andCellSurface: self];
>       [cell setX: incx Y: incy];
>       cell = [cell createEnd];
>       //place the cell at its point in the lattice
>       [self putObject: cell atX: incx Y: incy];
>       [cellList addLast: cell];
>     }
> 
>   printf("cellSurface, created %d x %d cells.\n", ysize, xsize);
>   return self;
> }
> 
> Also from CellSurface.m - this method determines which cell is the best one 
> to move to - roughly based on HeatBugs movement
> 
> // New method to find the steepest slope adapted from Heatbugs.
> // Search the 9 cell neighbourhood for the steepest slope.
> - (ElevValue)findSteepestSlopeAtX: (int *) px Y: (int *) py
> {
>   float maxSlope;
>   float elevHere;
>   int x, y;
>   id <List>slopeList;
>   id cell, bestCell;
>   int offset;
>   printf("Inside findSteepestSlopeAtX now\n");
>   elevHere = [[self getCellAtX: *px Y: *py] getElevLevel];
>   printf("CellSurface.m: x = %d, y = %d\n", *px, *py);
>   printf("CellSurface.m: elevHere = %f\n\n", elevHere);
>   maxSlope = 0; //not sure if this is the best place to do this...
>   // Now scan through the world, finding the slopes to the 8 cell
>   // neighbours, determing the best, or the best equal
>   slopeList = [List create: [self getZone]];
>   for (y = *py -1; y <= *py + 1; y++) {
>     for (x = *px - 1; x <= *px + 1; x++) {
>       float elevThere;
>       float slopeValue;
>       elevThere = [[self getCellAtX: x Y: y] getElevLevel];
>       // elevThere = (int) elevThere;
>       // elevThere = [self getValueAtX: (x+xsize)%xsize Y: (y+ysize)%ysize];
>       printf ("@ (%d, %d) = %f ", x, y, elevThere);
>       if (x == *px || y == *py) {
>         // if the cell we're in is N,S,E or W, don't divide by 1.414
>         slopeValue = elevHere - elevThere;
>         printf("CellSurface.m:slopeValue = %f (loop1)\n", slopeValue);
>       } else {
>         slopeValue = (elevHere - elevThere)/1.414;
>         // if the cell is on the diagonal, divide by 1.414
>         printf("CellSurface.m:slopeValue = %f (loop2)\n", slopeValue);
>       }
>
>       if (slopeValue > maxSlope) {
>         cell = [[[ElevCell create: [self getZone]] setX:x] setY:y];
>         [slopeList deleteAll];
>         [slopeList addLast: cell];
>         maxSlope = slopeValue;
>       }
> 
>       printf("CellSuface.m:maxSlope = %f\n", maxSlope);
>       if (slopeValue == maxSlope) {
>         cell = [[[ElevCell create: [self getZone]] setX: x] setY: y];
>         [slopeList addLast: cell];
>       } // close else loop
>     } // close x loop
> } // close y loop
> 
> Code below deleted for brevity...
> 
> >From DataFile.m - this method imports elevation values from the
> >ascii raster grid file
> 
> -inputData: (int) f {
>   int incx, incy, x, y;
>   int data1, result; //for debugging
>   // float data2;
>   float nzmgX, nzmgY;  //nzmg = New Zealand Map Grid - local coordinate
system
>   // id list; //needed to create list in this method 24/8/05
>   fileID = f;
> 
>   printf ("Importing data from fileID:%d %s..\n", fileID, fileName);
> 
>   // first put nodatavalues in all the cells. Can be overwritten in
>   // the next steps if a cell contains information
>   printf("Putting nodata values in all the cells. fileID = %d\n", fileID);
>   // printf("cellSurface = %s\n",[cellSurface getInstanceName]);
> 
>   for (incy = 0; incy < ysize; incy++){
>     for (incx = 0; incx < xsize; incx++) {
>       if (fileID == 0)
>       [[cellSurface getCellAtX: incx Y: incy]
>          setElevLevel: noDataValue];   //defined in cell.hm
>       data1 = [[cellSurface getCellAtX: incx Y: incy] getElevLevel]; 
>       // next three lines her for diagnostics
>       printf("Elevation here (data1) = %d\n", data1); //This returns
2147483648 consistently
>       printf("noDataValue = %d\n", noDataValue);
>     }
>   }
> 
>   printf ("Scanning through file for data points\n");
>   for (incy=0; incy <numRows; incy++) {
>     for (incx=0; incx < numCols; incx++) {
>       // scan the datapoint - datapoint is the elevation value
>       // from the ascii file
>       float datapoint;
>       int datapoint2;
>       datapoint = [self getDataPoint];
>       // printf("datapoint = %f\n", datapoint);
>       // datapoint2 = (int) datapoint;
>       // printf("datapoint2 = %d\n", datapoint2);
>       // if its within the space, convert the coords to swarm
>       // and input the data
>
>       if (fileID == 0)
>         [ [cellSurface getCellAtX: x Y: y] setElevLevel: dataPoint];
>
>       data2 = [[cellSurface getCellAtX: x Y: y] getElevLevel]; 
>
>       // more diagnostics here
>       // printf("Elevation here (data2) = %f\n", data2); 
>       // This currently returning "NaN"
>       // Testing out list creation here instead of in
>       // Cell: -createEnd
>       // list = [List create: [self getZone]];
>       // implmenting this here hasn't helped
>     }
>     // else if not within space, do nothing but scan the
>     // next datapoint
>     // move ahead one cell
>     // printf ("Still in the inputData method...");
>     nzmgX = nzmgX + cellSize;
>     // printf("x = %f, y = %f\n", nzmgX, nzmgY);
>   }
> }
> // end else (data overlaps main data set)
> 
> printf ("successfully scanned data file\n\n");
> return self;
> }
>
> 
> ----- Original Message ----- 
> From: "Steve Railsback" <address@hidden>
> To: "Swarm Support" <address@hidden>
> Sent: Thursday, August 25, 2005 11:24 AM
> Subject: Re: [Swarm-Support] Multiple Agents in One Cell
> 
> > Crile Doscher wrote:
> >> Hi there SwarmList,
> > ...
> >
> >>   So, have I been sloppy in creating my lists?  My gut feeling is that my 
> >> cells should be able to hold both elevations and lists and I simply 
> >> haven't implemented this well.  Could the order in which the list is 
> >> added and elevation values read in be causing a problem?  Any thoughts?
> >
> > Crile: I think you will have to post your cell code and the methods that 
> > call it for anyone to help.
> >
> > Also: Remember that you can use two separate space objects. If your 
> > Discrete2D holding elevations works already, you could just leave it alone 
> > and create a separate MultiGrid2d to keep the agents. The agents would 
> > then look in the elevation space to get their elevation.
> >
> > Steve R.
> > -- 
> > Lang Railsback & Assoc.
> > 250 California Ave.
> > Arcata, California 95521
> > (707) 822-0453



_________________________________________________________
 Ken Cline                             W: (443) 287-2636
 address@hidden