Re: Initializing Hierarchical Swarms

[Sven Thommesen]

Manor, many thanks for this clarification!

Especially important and helpful was point (2), i.e. the explanation of the
resulting ordering of simultaneously scheduled actions as depending on the
order in which those actions (or their schedules) were *activated*.  I had
cobbled together a solution based on the hope that it might be so; glad to
see my guess was correct!

My 'broken apart' version of Heatbugs now seems to work ok.  I have included
below excerpts from three of the files to show how I attempted to solve my
own problems as described in my last 3 messages. 

Hope this is of use to someone who's not on vacation,
--Sven

----- from MultibugObserverSwarm.m ------------------------------

-buildObjects {
  id modelZone; 
  int i;
  Heatbug * heatbugToProbe;

  [super buildObjects];
 
  // NOTE: the next 4 steps have been re-arranged:
 
  // 1. build the model swarm
  modelZone = [Zone create: [self getZone]];
  multibugModelSwarm = [MultibugModelSwarm create: modelZone];
  
  // 4. ask model swarm to build its objects 
  // this should also build sub-swarms of model swarm
  [multibugModelSwarm buildObjects];

  // (5.) create probe display for sub-swarms of model swarm
  [probeDisplayManager createProbeDisplayFor:  
                           [multibugModelSwarm getHeatbugSwarm] ];
  
  // 2. create probe displays
  [probeDisplayManager createProbeDisplayFor: multibugModelSwarm];
  [probeDisplayManager createProbeDisplayFor: self];

  // 3. wait for user to set parameters and hit 'go'
  [controlPanel waitForControlEvent];
  if ([controlPanel getState] == ControlStateQuit)
    return self;

  colormap = [XColormap create: [self getZone]];

  ... stuff deleted ...

  }

-activateIn: (id) swarmContext {

  [super activateIn: swarmContext];
  [multibugModelSwarm activateIn: self];
  [displaySchedule activateIn: self];
  return [self getSwarmActivity];

}

----- end -----
 
----- from MultibugModelSwarm.m ----------------------------------

-buildObjects {
//  int i;

  [super buildObjects];
  
  world = [Grid2d createBegin: [self getZone]];
  [world setSizeX: worldXSize Y: worldYSize];
  world = [world createEnd];

// The heatspace agent represents the spatial property of heat.
  heat = [HeatSpace createBegin: [self getZone]];
  [heat setSizeX: worldXSize Y: worldYSize];
  [heat setDiffusionConstant: diffConstH];
  [heat setEvaporationRate: evapRateH];
  heat = [heat createEnd];

// The Heatbugs pay attention only to Heat in Heatspace
  heatbugs = [HeatbugSwarm createBegin: [self getZone]];
  [heatbugs setSizeX: worldXSize Y: worldYSize];
  [heatbugs setWorld: world];
  [heatbugs setHeat: heat];
  heatbugs = [heatbugs createEnd];

  [heatbugs buildObjects];

  ... stuff deleted ...

}

-buildActions {

  [super buildActions];

  [heatbugs buildActions];  // NEW: let subswarm build actions
  

//  modelActions = [ActionGroup create: [self getZone]];
//  [modelActions createActionTo:      heat        message: M(stepRule)];
//  [modelActions createActionForEach: heatbugList message: M(step)];  
//  [modelActions createActionTo:      heat        message: M(updateLattice)];

//  modelSchedule = [Schedule createBegin: [self getZone]];
//  [modelSchedule setRepeatInterval: 1];
//  modelSchedule = [modelSchedule createEnd];
//  [modelSchedule at: 0 createAction: modelActions];

  modelPreActions = [ActionGroup create: [self getZone]];
  [modelPreActions createActionTo: heat message: M(stepRule)];

  modelPreSchedule = [Schedule createBegin: [self getZone]];
  [modelPreSchedule setRepeatInterval: 1];
  modelPreSchedule = [modelPreSchedule createEnd];
  [modelPreSchedule at: 0 createAction: modelPreActions];

  modelPostActions = [ActionGroup create: [self getZone]];
  [modelPostActions createActionTo: heat message: M(updateLattice)];

  modelPostSchedule = [Schedule createBegin: [self getZone]];
  [modelPostSchedule setRepeatInterval: 1];
  modelPostSchedule = [modelPostSchedule createEnd];
  [modelPostSchedule at: 0 createAction: modelPostActions];

  return self;

}

-activateIn: (id) swarmContext {

  [super activateIn: swarmContext];

//  [modelSchedule activateIn: self];
//  New experimental version:
  [modelPreSchedule activateIn: self];
  [heatbugs activateIn: self];
  [modelPostSchedule activateIn: self];

  return [self getSwarmActivity];

}

----- end -----

----- from HeatbugSwarm.m ----------------------------------

-buildObjects {
  int i;

  [super buildObjects];
  
  heatbugList = [List create: [self getZone]];
  
  [world setOverwriteWarnings: 0];

  for (i = 0; i < numHeatBugs; i++) {
    Heatbug * hbug;
    int idealTemp, outputHeat;

    ... code to create the bugs ...

  }
  [world setOverwriteWarnings: 1];

  return self;
}

-buildActions {

  [super buildActions];
  
  modelActions = [ActionGroup create: [self getZone]];
  [modelActions createActionForEach: heatbugList message: M(step)];  

  modelSchedule = [Schedule createBegin: [self getZone]];
  [modelSchedule setRepeatInterval: 1];
  modelSchedule = [modelSchedule createEnd];
  [modelSchedule at: 0 createAction: modelActions];

  return self;
}

-activateIn: (id) swarmContext {

  [super activateIn: swarmContext];
  [modelSchedule activateIn: self];
  return [self getSwarmActivity];

}
----- end -----