Merge branch 'Tadej-Review' into 'main'

Code Review

See merge request sami.hatna/crowd-simulation!11

Author: Sami Hatna

README.md

@@ -62,9 +62,10 @@ Below is an annotated example input file which creates a room containing two act
     "scale": 100,                                 
     "delay": 0,
     "bgColor": [0, 0, 0],                         
-    "wallColor": [255, 255, 255]
-  },                                              
-  
+    "wallColor": [255, 255, 255],
+    "heatmapEnabled": true                        <-- Flag denoting whether 
+  },                                                  the heatmap should be 
+                                                      applied to actors
   "room": {                                       
     "walls": [
       [0.5, 0.5, 8.5, 0.5],                       <-- Walls are defined via their
@@ -84,9 +85,9 @@ Below is an annotated example input file which creates a room containing two act
       "radius": 0.05,                             
       "atDestination": false,
       "color": [255, 0, 0],                       
-      "heatmapEnabled": true                      <-- Flag denoting whether the 
-    },                                                actor's colour should change
-    {                                                 with the heatmap
+      "heatmapEnabled": true 
+    },
+    {
       "pos": [0.7, 7.3],                          
       "velocity": [0.0789, 0.0444],
       "desiredSpeed": 0.6,                        

external/Actor.cpp

@@ -20,22 +20,22 @@
  *
  *  Description:
  *    Class denoting an actor in social force model
- * 
+ *
  **************************************************************************/
 
 #include "Actor.hpp"
 
-Actor::Actor(vecType pPos, vecType pVelocity, float pDesiredSpeed, int pPathId,
-             float pMass, float pRadius, bool pAtDestination,
-             std::array<int, 3> pColor, bool pHeatmapEnabled)
+Actor::Actor(sycl::float2 pPos, sycl::float2 pVelocity, float pDesiredSpeed,
+             int pPathId, float pMass, float pRadius, bool pAtDestination,
+             std::array<int, 3> pColor)
     : pos(pPos), velocity(pVelocity), desiredSpeed(pDesiredSpeed),
       pathId(pPathId), mass(pMass), radius(pRadius),
-      atDestination(pAtDestination), color(pColor),
-      heatmapEnabled(pHeatmapEnabled), destinationIndex(0), bBox({0, 0}) {}
+      atDestination(pAtDestination), color(pColor), destinationIndex(0),
+      bBox({0, 0}) {}
 
-SYCL_EXTERNAL vecType Actor::getPos() const { return pos; }
+SYCL_EXTERNAL sycl::float2 Actor::getPos() const { return pos; }
 
-SYCL_EXTERNAL vecType Actor::getVelocity() const { return velocity; }
+SYCL_EXTERNAL sycl::float2 Actor::getVelocity() const { return velocity; }
 
 SYCL_EXTERNAL float Actor::getDesiredSpeed() const { return desiredSpeed; }
 
@@ -53,17 +53,15 @@ SYCL_EXTERNAL bool Actor::getAtDestination() const { return atDestination; }
 
 SYCL_EXTERNAL std::array<int, 3> Actor::getColor() const { return color; }
 
-SYCL_EXTERNAL bool Actor::getHeatmapEnabled() const { return heatmapEnabled; }
-
 SYCL_EXTERNAL std::array<int, 2> Actor::getBBox() const { return bBox; }
 
 SYCL_EXTERNAL uint Actor::getSeed() const { return seed; }
 
 SYCL_EXTERNAL float Actor::getForce() const { return force; }
 
-SYCL_EXTERNAL void Actor::setPos(vecType newPos) { pos = newPos; }
+SYCL_EXTERNAL void Actor::setPos(sycl::float2 newPos) { pos = newPos; }
 
-SYCL_EXTERNAL void Actor::setVelocity(vecType newVelocity) {
+SYCL_EXTERNAL void Actor::setVelocity(sycl::float2 newVelocity) {
     velocity = newVelocity;
 }
 
@@ -87,8 +85,9 @@ SYCL_EXTERNAL void Actor::setSeed(uint newSeed) { seed = newSeed; }
 
 SYCL_EXTERNAL void Actor::setForce(float newForce) { force = newForce; }
 
-SYCL_EXTERNAL void Actor::checkAtDestination(std::array<vecType, 2> destination,
-                                             int pathSize) {
+SYCL_EXTERNAL void
+Actor::checkAtDestination(std::array<sycl::float2, 2> destination,
+                          int pathSize) {
     // Destinations are defined as rectangular regions
     if (pos[0] >= destination[0][0] && pos[0] <= destination[1][0] &&
         pos[1] >= destination[0][1] && pos[1] <= destination[1][1]) {

external/Actor.hpp

@@ -20,15 +20,14 @@
  *
  *  Description:
  *    Class denoting an actor in social force model
- * 
+ *
  **************************************************************************/
 
 #ifndef Actor_hpp
 #define Actor_hpp
 
 #include "Path.hpp"
 #include "RandomNumber.hpp"
-#include "VectorMaths.hpp"
 #include <array>
 #include <iostream>
 #include <random>
@@ -37,50 +36,48 @@
 
 class Actor {
   private:
-    vecType pos;
-    vecType velocity;
+    std::array<int, 3> color;
+    sycl::float2 pos;
+    sycl::float2 velocity;
+    std::array<int, 2> bBox;
     float desiredSpeed;
     int pathId;
     int destinationIndex;
     float mass;
     float radius;
-    bool atDestination;
-    std::array<int, 3> color;
-    bool heatmapEnabled;
-    std::array<int, 2> bBox;
     uint seed;
     float force;
+    bool atDestination;
 
   public:
-    Actor(vecType pPos, vecType pVelocity, float pdesiredSpeed, int pPathId,
-          float pMass, float pRadius, bool pAtDestination,
-          std::array<int, 3> pColor, bool pHeatmapEnabled);
+    Actor(sycl::float2 pPos, sycl::float2 pVelocity, float pdesiredSpeed,
+          int pPathId, float pMass, float pRadius, bool pAtDestination,
+          std::array<int, 3> pColor);
 
-    SYCL_EXTERNAL vecType getPos() const;
-    SYCL_EXTERNAL vecType getVelocity() const;
+    SYCL_EXTERNAL sycl::float2 getPos() const;
+    SYCL_EXTERNAL sycl::float2 getVelocity() const;
     SYCL_EXTERNAL float getDesiredSpeed() const;
     SYCL_EXTERNAL int getPathId() const;
     SYCL_EXTERNAL int getDestinationIndex() const;
     SYCL_EXTERNAL float getMass() const;
     SYCL_EXTERNAL float getRadius() const;
     SYCL_EXTERNAL bool getAtDestination() const;
     SYCL_EXTERNAL std::array<int, 3> getColor() const;
-    SYCL_EXTERNAL bool getHeatmapEnabled() const;
     SYCL_EXTERNAL std::array<int, 2> getBBox() const;
     SYCL_EXTERNAL uint getSeed() const;
     SYCL_EXTERNAL float getForce() const;
 
-    SYCL_EXTERNAL void setPos(vecType newPos);
-    SYCL_EXTERNAL void setVelocity(vecType newVelocity);
+    SYCL_EXTERNAL void setPos(sycl::float2 newPos);
+    SYCL_EXTERNAL void setVelocity(sycl::float2 newVelocity);
     SYCL_EXTERNAL void setDesiredSpeed(float newDesiredSpeed);
     SYCL_EXTERNAL void setAtDestination(bool param);
     SYCL_EXTERNAL void setColor(std::array<int, 3> newColor);
     SYCL_EXTERNAL void setBBox(std::array<int, 2> newBBox);
     SYCL_EXTERNAL void setSeed(uint newSeed);
     SYCL_EXTERNAL void setForce(float newForce);
 
-    SYCL_EXTERNAL void checkAtDestination(std::array<vecType, 2> destination,
-                                          int pathSize);
+    SYCL_EXTERNAL void
+    checkAtDestination(std::array<sycl::float2, 2> destination, int pathSize);
 };
 
 #endif

external/CMakeLists.txt

@@ -5,7 +5,6 @@ add_library(external Actor.cpp
                      Path.cpp 
                      MathHelper.cpp 
                      DifferentialEq.cpp 
-                     VectorMaths.cpp 
                      Heatmap.cpp 
                      ParseInputFile.cpp 
                      RandomNumber.cpp 

external/DifferentialEq.cpp

@@ -20,30 +20,32 @@
  *
  *  Description:
  *    Kernel for calculating social forces
- * 
+ *
  **************************************************************************/
 
 #include "DifferentialEq.hpp"
 
 SYCL_EXTERNAL void differentialEq(
     int actorIndex,
     sycl::accessor<Actor, 1, sycl::access::mode::read_write> actors,
-    sycl::accessor<std::array<vecType, 2>, 1, sycl::access::mode::read> walls,
-    sycl::accessor<Path, 1, sycl::access::mode::read> paths) {
+    sycl::accessor<std::array<sycl::float2, 2>, 1, sycl::access::mode::read>
+        walls,
+    sycl::accessor<Path, 1, sycl::access::mode::read> paths,
+    sycl::accessor<bool, 1, sycl::access::mode::read> heatmapEnabled) {
     Actor *currentActor = &actors[actorIndex];
 
-    vecType pos = currentActor->getPos();
+    sycl::float2 pos = currentActor->getPos();
 
     // Calculate personal impulse
     float mi = currentActor->getMass();
     float v0i = currentActor->getDesiredSpeed();
-    std::array<vecType, 2> destination =
+    std::array<sycl::float2, 2> destination =
         paths[currentActor->getPathId()]
             .getCheckpoints()[currentActor->getDestinationIndex()];
 
     // Find direction vector to nearest point in destination region
-    std::pair<float, vecType> minRegionDistance;
-    std::array<vecType, 4> destinationRect = {
+    std::pair<float, sycl::float2> minRegionDistance;
+    std::array<sycl::float2, 4> destinationRect = {
         destination[0],
         {destination[1][0], destination[0][1]},
         destination[1],
@@ -59,11 +61,12 @@ SYCL_EXTERNAL void differentialEq(
         }
     }
     minRegionDistance.second = normalize(minRegionDistance.second);
-    vecType e0i = {-minRegionDistance.second[0], -minRegionDistance.second[1]};
+    sycl::float2 e0i = {-minRegionDistance.second[0],
+                        -minRegionDistance.second[1]};
 
-    vecType vi = currentActor->getVelocity();
+    sycl::float2 vi = currentActor->getVelocity();
 
-    vecType personalImpulse = mi * (((v0i * e0i) - vi) / Ti);
+    sycl::float2 personalImpulse = mi * (((v0i * e0i) - vi) / Ti);
 
     // Collect neighbouring bounding boxes
     std::array<int, 2> currentBBox = currentActor->getBBox();
@@ -80,7 +83,7 @@ SYCL_EXTERNAL void differentialEq(
     }};
 
     // Calculate forces applied by neighbouring actors (in valid bounding boxes)
-    vecType peopleForces = {0, 0};
+    sycl::float2 peopleForces = {0, 0};
     for (int x = 0; x < actors.size(); x++) {
         Actor neighbour = actors[x];
 
@@ -92,11 +95,11 @@ SYCL_EXTERNAL void differentialEq(
                         });
 
         if (actorIndex != x && !neighbour.getAtDestination() && bBoxFlag) {
-            vecType currentToNeighbour = pos - neighbour.getPos();
+            sycl::float2 currentToNeighbour = pos - neighbour.getPos();
             float dij = magnitude(currentToNeighbour);
             float rij = neighbour.getRadius() + currentActor->getRadius();
-            vecType nij = (currentToNeighbour) / dij;
-            vecType tij = getTangentialVector(nij);
+            sycl::float2 nij = currentToNeighbour / dij;
+            sycl::float2 tij = getTangentialVector(nij);
             float g = dij > rij ? 0 : rij - dij;
             float deltavtij = dotProduct(
                 (neighbour.getVelocity() - currentActor->getVelocity()), tij);
@@ -108,21 +111,22 @@ SYCL_EXTERNAL void differentialEq(
     }
 
     // Calculate forces applied by walls
-    vecType wallForces = {0, 0};
+    sycl::float2 wallForces = {0, 0};
     for (int x = 0; x < walls.size(); x++) {
-        std::array<vecType, 2> currentWall = walls[x];
+        std::array<sycl::float2, 2> currentWall = walls[x];
         float ri = currentActor->getRadius();
-        std::pair<float, vecType> dAndn = getDistanceAndNiw(pos, currentWall);
+        std::pair<float, sycl::float2> dAndn =
+            getDistanceAndNiw(pos, currentWall);
         float diw = dAndn.first;
         float g = diw > ri ? 0 : ri - diw;
-        vecType niw = normalize(dAndn.second);
-        vecType tiw = getTangentialVector(niw);
+        sycl::float2 niw = normalize(dAndn.second);
+        sycl::float2 tiw = getTangentialVector(niw);
 
         wallForces += (WALLAi * sycl::exp((ri - diw) / Bi) + K1 * g) * niw -
                       (K2 * g * dotProduct(vi, tiw) * tiw);
     }
 
-    vecType forceSum = personalImpulse + peopleForces + wallForces;
+    sycl::float2 forceSum = personalImpulse + peopleForces + wallForces;
 
 #ifdef STATS
     if (!currentActor->getAtDestination()) {
@@ -138,7 +142,7 @@ SYCL_EXTERNAL void differentialEq(
     currentActor->setSeed(randXorShift(seed));
 
     // Color actor according to heatmap
-    if (currentActor->getHeatmapEnabled()) {
+    if (heatmapEnabled[0]) {
         // theoreticalMax was decided based on observed max forces for a set of
         // configurations It may need to be altered based on the max forces of
         // your config to create a satisfying heatmap
@@ -153,7 +157,7 @@ SYCL_EXTERNAL void differentialEq(
     }
 
     // Perform integration
-    vecType acceleration = forceSum / mi;
+    sycl::float2 acceleration = forceSum / mi;
     currentActor->setVelocity(vi + acceleration * TIMESTEP);
     currentActor->setPos(pos + currentActor->getVelocity() * TIMESTEP);
 

external/DifferentialEq.hpp

@@ -20,7 +20,7 @@
  *
  *  Description:
  *    Kernel for calculating social forces
- * 
+ *
  **************************************************************************/
 
 #ifndef DifferentialEqu_hpp
@@ -30,7 +30,6 @@
 #include "Heatmap.hpp"
 #include "MathHelper.hpp"
 #include "Path.hpp"
-#include "VectorMaths.hpp"
 #include <algorithm>
 #include <array>
 #include <iostream>
@@ -55,7 +54,9 @@ constexpr float TIMESTEP = 0.001;
 SYCL_EXTERNAL void differentialEq(
     int actorIndex,
     sycl::accessor<Actor, 1, sycl::access::mode::read_write> actors,
-    sycl::accessor<std::array<vecType, 2>, 1, sycl::access::mode::read> walls,
-    sycl::accessor<Path, 1, sycl::access::mode::read> paths);
+    sycl::accessor<std::array<sycl::float2, 2>, 1, sycl::access::mode::read>
+        walls,
+    sycl::accessor<Path, 1, sycl::access::mode::read> paths,
+    sycl::accessor<bool, 1, sycl::access::mode::read> heatmapEnabled);
 
 #endif

external/Heatmap.cpp

@@ -21,7 +21,7 @@
  *  Description:
  *    Applying heatmap across actors reflecting how much force they are
  *    experiencing
- * 
+ *
  **************************************************************************/
 
 #include "Heatmap.hpp"

external/Heatmap.hpp

@@ -21,7 +21,7 @@
  *  Description:
  *    Applying heatmap across actors reflecting how much force they are
  *    experiencing
- * 
+ *
  **************************************************************************/
 
 #ifndef Heatmap_hpp