Implement partial random move

Author: romainreuillon

src/main/scala/eighties/h24/dynamic.scala

@@ -185,7 +185,7 @@ object dynamic {
       db.close()
     }
 
-    def load(file: java.io.File) = {
+    def load(file: java.io.File) =
       import org.mapdb._
 
       val thread = Thread.currentThread()
@@ -203,7 +203,6 @@ object dynamic {
 
         db.hashMap("moves").createOrOpen.asInstanceOf[HTreeMap[(Location, TimeSlice), Cell]]
       } finally thread.setContextClassLoader(cl)
-    }
 
 //      val os = new FileOutputStream((file / timeSlicesFileName).toJava)
 //      try os.getChannel.write(Pickle.intoBytes(moves.map(_._1)))
@@ -302,33 +301,40 @@ object dynamic {
 
     Focus[World[I]](_.individuals).set(newIndividuals)(world)
 
-  def assignRandomDayLocation[I: ClassTag](world: World[I], locatedCell: LocatedCell, stableDestination: Lens[I, Map[TimeSlice, Location]], location: I => Location, home: I => Location, socialCategory: I => AggregatedSocialCategory, rng: Random) =
+  def assignFixedLocationFromMoveMatrix[I: ClassTag](
+    world: World[I],
+    moveMatrixCell: LocatedCell,
+    stableDestination: Lens[I, Map[TimeSlice, Location]],
+    timeSlice: TimeSlice,
+    location: I => Location,
+    home: I => Location,
+    socialCategory: I => AggregatedSocialCategory, rng: Random) =
     val newIndividuals = Array.ofDim[I](world.individuals.length)
     var index = 0
 
     for
       (line, i) <- Focus[Index[I]](_.cells).get(Index.indexIndividuals(world, location)).zipWithIndex
       (individuals, j) <- line.zipWithIndex
     do
-      val workTimeMovesFromCell = locatedCell(dayTimeSlice, i, j)
+      val workTimeMovesFromCell = moveMatrixCell(timeSlice, i, j)
 
       assert(workTimeMovesFromCell != null)
 
       for
         individual <- individuals
       do
         def newIndividual =
-          dynamic.sampleDestinationInMoveMatrix(workTimeMovesFromCell, individual, socialCategory, rng) match {
-            case Some(d) => stableDestination.modify(_ + (dayTimeSlice -> d))(individual)
-            case None => stableDestination.modify(_ + (dayTimeSlice -> home(individual)))(individual)
-          }
+          dynamic.sampleDestinationInMoveMatrix(workTimeMovesFromCell, individual, socialCategory, rng) match
+            case Some(d) => stableDestination.modify(_ + (timeSlice -> d))(individual)
+            case None => stableDestination.modify(_ + (timeSlice -> home(individual)))(individual)
+
         newIndividuals(index) = newIndividual
         index += 1
 
     Focus[World[I]](_.individuals).set(newIndividuals)(world)
 
-  def assignFixNightLocation[I: ClassTag](world: World[I], stableDestination: Lens[I, Map[TimeSlice, Location]], home: I => Location) =
-    World.allIndividuals[I].modify { individual => stableDestination.modify(_ + (nightTimeSlice -> home(individual)))(individual) } (world)
+  def assignFixedLocation[I: ClassTag](world: World[I], stableDestination: Lens[I, Map[TimeSlice, Location]], timeSlice: TimeSlice, home: I => Location) =
+    World.allIndividuals[I].modify { individual => stableDestination.modify(_ + (timeSlice -> home(individual)))(individual) } (world)
 
   def randomiseLocation[I: ClassTag](world: World[I], location: I => Location, home: Lens[I, Location], random: Random) =
     val reach = reachable(Index[I](world.individuals.iterator, location, world.sideI, world.sideJ))

src/main/scala/eighties/h24/simulation.scala

@@ -18,8 +18,8 @@ package eighties.h24
  */
 
 import eighties.h24.dynamic.MoveMatrix.{LocatedCell, TimeSlice}
-import eighties.h24.dynamic.{MoveMatrix, assignFixNightLocation, assignRandomDayLocation}
-import eighties.h24.generation.{IndividualFeature, WorldFeature, timeSlices}
+import eighties.h24.dynamic.{MoveMatrix, assignFixedLocation, assignFixedLocationFromMoveMatrix, stableDestinationOrMoveInMoveMatrix}
+import eighties.h24.generation.{IndividualFeature, WorldFeature, dayTimeSlice, nightTimeSlice, timeSlices}
 import eighties.h24.social.AggregatedSocialCategory
 import eighties.h24.space.{BoundingBox, Location, World, generateWorld}
 import monocle.Lens
@@ -39,7 +39,7 @@ object simulation:
     world: () => space.World[I],
     bbox: BoundingBox,
     gridSize: Int,
-    locatedCell: LocatedCell,
+    moveMatrixCell: LocatedCell,
     moveType: MoveType,
     exchange: (World[I], Int, Int, Random) => World[I],
     stableDestinations: I => Map[TimeSlice, Location],
@@ -54,24 +54,23 @@ object simulation:
       bb: BoundingBox,
       gridSize: Int,
       timeSlices: List[TimeSlice],
-      locatedCell: LocatedCell,
+      moveMatrixCell: LocatedCell,
       day: Int,
       slice: Int = 0): World[I] =
       timeSlices match
         case Nil => world
         case time :: t =>
           def moved = moveType match
-            case MoveType.Data => dynamic.stableDestinationOrMoveInMoveMatrix(world, locatedCell, time, stableDestinations, location, home, socialCategory, 0.0, rng)
+            case MoveType.Data => dynamic.stableDestinationOrMoveInMoveMatrix(world, moveMatrixCell, time, stableDestinations, location, home, socialCategory, 0.0, rng)
             case MoveType.PartialRandom(p, s) =>
               val randomMoveProbability = if s.contains(time) then p else 0.0
-              dynamic.stableDestinationOrMoveInMoveMatrix(world, locatedCell, time, stableDestinations, location, home, socialCategory, randomMoveProbability, rng)
+              dynamic.stableDestinationOrMoveInMoveMatrix(world, moveMatrixCell, time, stableDestinations, location, home, socialCategory, randomMoveProbability, rng)
             case MoveType.Random => dynamic.stableDestinationOrRandomMove(world, time, location, stableDestinations, rng)
             case MoveType.No => world
 
           val convicted = exchange(moved, day, slice, rng)
           visitor.foreach(_(convicted, bb, gridSize, Some((day, slice))))
-          simulateOneDay(convicted, bb, gridSize, t, locatedCell, day, slice + 1)
-
+          simulateOneDay(convicted, bb, gridSize, t, moveMatrixCell, day, slice + 1)
 
     // Ensures the world is not retained in memory
     var currentWorld = world()
@@ -80,11 +79,29 @@ object simulation:
     for
       day <- 0 until days
     do
-      currentWorld = simulateOneDay(currentWorld, bbox, gridSize, timeSlices.toList, locatedCell, day)
+      currentWorld = simulateOneDay(currentWorld, bbox, gridSize, timeSlices.toList, moveMatrixCell, day)
 
     currentWorld
 
 
+  def assignStableMoves[I: ClassTag](
+    world: World[I],
+    moveMatrixCell: LocatedCell,
+    moveType: MoveType,
+    stableDestinations: Lens[I, Map[TimeSlice, Location]],
+    location: Lens[I, Location],
+    home: Lens[I, Location],
+    socialCategory: I => AggregatedSocialCategory,
+    rng: Random) =
+
+    moveType match
+      case MoveType.Data | _: MoveType.PartialRandom =>
+        val fixedDay = assignFixedLocationFromMoveMatrix(world, moveMatrixCell, stableDestinations, dayTimeSlice, location.get, home.get, socialCategory, rng)
+        assignFixedLocation(fixedDay, stableDestinations, nightTimeSlice, home.get)
+      case MoveType.Random => assignFixedLocation(world, stableDestinations, nightTimeSlice, home.get)
+      case MoveType.No => assignFixedLocation(world, stableDestinations, nightTimeSlice, home.get)
+
+
   def simulate[I: ClassTag](
     days: Int,
     population: java.io.File,
@@ -105,27 +122,16 @@ object simulation:
     val moveMatrix = MoveMatrix.load(moves)
 
     try
-      def locatedCell: LocatedCell = (timeSlice: TimeSlice, i: Int, j: Int) => moveMatrix.get((i, j), timeSlice)
       def world = generateWorld(worldFeature.individualFeatures, buildIndividual, location, home, rng)
-
-      def populationWithMoves =
-        moveType match
-          case MoveType.Data | _: MoveType.PartialRandom =>
-            val fixedDay = assignRandomDayLocation(world, locatedCell, stableDestinations, location.get, home.get, socialCategory, rng)
-            assignFixNightLocation(
-              fixedDay,
-              stableDestinations,
-              home.get
-            )
-          case MoveType.Random => assignFixNightLocation(world, stableDestinations, home.get)
-          case MoveType.No => assignFixNightLocation(world, stableDestinations, home.get)
+      def moveMatrixCell: LocatedCell = (timeSlice: TimeSlice, i: Int, j: Int) => moveMatrix.get((i, j), timeSlice)
+      def populationWithMoves = assignStableMoves(world, moveMatrixCell, moveType, stableDestinations, location, home, socialCategory, rng = rng)
 
       simulateWorld(
         days = days,
         world = () => populationWithMoves,
         bbox = bbox,
         gridSize = gridSize,
-        locatedCell = locatedCell,
+        moveMatrixCell = moveMatrixCell,
         moveType = moveType,
         exchange = exchange,
         stableDestinations = stableDestinations.get,