diff --git a/src/main/java/RunExperiment.java b/src/main/java/RunExperiment.java deleted file mode 100644 index 2084dc0588e48bbcb60a8eb77d65a2f80b495613..0000000000000000000000000000000000000000 --- a/src/main/java/RunExperiment.java +++ /dev/null @@ -1,54 +0,0 @@ -import agents.RandomWalkingAgent; -import agents.SEIRSAgent; -import agents.states.InfectedSEIRSState; -import environment.SEIRSEnvironment; -import models.Parameters; -import scheduler.FairAsynchronousScheduler; -import scheduler.FairSynchronousScheduler; -import scheduler.Scheduler; -import sma.SEIRS_SMA; -import sma.SMA; -import utils.YamlReader; - -import java.awt.*; -import java.util.Random; - -public class RunExperiment { - - public static void main(String[] args) { - SMA sma = new SEIRS_SMA(); - Parameters parameters = YamlReader.getParams(); - Random r = new Random(parameters.getSeed()); - - SEIRSAgent[] agents = new RandomWalkingAgent[parameters.getPopulation()]; - Scheduler scheduler; - SEIRSEnvironment environment = new SEIRSEnvironment(parameters.getSize(),agents); - - //Populate agents - for (int i = 0; i<parameters.getPopulation();i++) { - Point position = new Point(r.nextInt(parameters.getSize()),r.nextInt(parameters.getSize())); - RandomWalkingAgent agent = new RandomWalkingAgent(position,parameters.getSeed()+i,environment); - agents[i] = agent; - } - - //Infect agents - for (int i=0 ; i< parameters.getNbOfPatientZero(); i++) { - SEIRSAgent agent = agents[(r.nextInt(parameters.getPopulation()))]; - while (agent.getState() instanceof InfectedSEIRSState) { - agent = agents[(r.nextInt(parameters.getPopulation()))]; - } - agent.changeState(new InfectedSEIRSState(agent)); - } - - //create scheduler - if (parameters.isSynchronousMode()) { - scheduler = new FairSynchronousScheduler(parameters.getSeed()); - } else { - scheduler = new FairAsynchronousScheduler(); - } - - sma.init(environment,scheduler,agents); - sma.run(); - } - -} diff --git a/src/main/java/agents/RandomWalkingAgent.java b/src/main/java/agents/RandomWalkingAgent.java index 09f3c0b0d5c9c48bb45366c9898f9804d9fe35e3..6f8b635e4aad36d90114b307e4654bee35300f08 100644 --- a/src/main/java/agents/RandomWalkingAgent.java +++ b/src/main/java/agents/RandomWalkingAgent.java @@ -1,9 +1,8 @@ package agents; -import agents.states.InfectedSEIRSState; import agents.states.SEIRSState; import agents.states.SuceptibleSEIRSState; -import environment.SquareEnvironment2D; +import environment.ChunkedSEIRSEnvironment; import environment.SEIRSEnvironment; import utils.YamlReader; @@ -15,23 +14,23 @@ public class RandomWalkingAgent implements SEIRSAgent { private Point position; private final Random r; private final SEIRSEnvironment environment; - private SEIRSState SEIRSState; + private SEIRSState state; public RandomWalkingAgent(Point position, int seed, SEIRSEnvironment environment) { this.position = position; - this.SEIRSState = new SuceptibleSEIRSState(this); + this.state = new SuceptibleSEIRSState(this); this.environment = environment; this.r = new Random(seed); } private void move() { - SEIRSState.onMovement(); + state.onMovement(); int move = r.nextInt(4); Point newPosition = switch (move) { - case SquareEnvironment2D.LEFT -> new Point(position.x- SEIRSEnvironment.RADIUS,position.y); - case SquareEnvironment2D.RIGHT -> new Point(position.x+ SEIRSEnvironment.RADIUS,position.y); - case SquareEnvironment2D.UP -> new Point(position.x,position.y- SEIRSEnvironment.RADIUS); - case SquareEnvironment2D.DOWN -> new Point(position.x,position.y+ SEIRSEnvironment.RADIUS); + case SEIRSEnvironment.LEFT -> new Point(position.x- ChunkedSEIRSEnvironment.RADIUS,position.y); + case SEIRSEnvironment.RIGHT -> new Point(position.x+ ChunkedSEIRSEnvironment.RADIUS,position.y); + case SEIRSEnvironment.UP -> new Point(position.x,position.y- ChunkedSEIRSEnvironment.RADIUS); + case SEIRSEnvironment.DOWN -> new Point(position.x,position.y+ ChunkedSEIRSEnvironment.RADIUS); default -> throw new IllegalStateException("Unexpected value: " + move); }; if (newPosition.x <= environment.getSize()-1 && newPosition.x >= 0 && newPosition.y <= environment.getSize()-1 && newPosition.y >=0 ) { @@ -47,17 +46,15 @@ public class RandomWalkingAgent implements SEIRSAgent { @Override - public void changeState(SEIRSState SEIRSState) { this.SEIRSState = SEIRSState; } + public void changeState(SEIRSState SEIRSState) { this.state = SEIRSState; } @Override public boolean isExposed() { boolean isExposed = false; - for (SEIRSAgent neighbor: environment.getNeighbors(position)) { - if ((neighbor).getState() instanceof InfectedSEIRSState) { - int roll = r.nextInt(10000)+1; - if (roll <= YamlReader.getParams().getInfectionRate()*10000) { - isExposed = true; - } + for (int i = 0 ; i<environment.getInfectedNeighbors(position).size() ; i++) { + int roll = r.nextInt(10000)+1; + if (roll <= YamlReader.getParams().getInfectionRate()*10000) { + isExposed = true; } } return isExposed; @@ -94,7 +91,7 @@ public class RandomWalkingAgent implements SEIRSAgent { } @Override - public SEIRSState getState() { return this.SEIRSState; } + public SEIRSState getState() { return this.state; } @Override public Point getPosition() { return position; } diff --git a/src/main/java/agents/states/ExposedSEIRSState.java b/src/main/java/agents/states/ExposedSEIRSState.java index b4b39c32e64849bfecc876d0eb67edf5013c3651..c7dbbcccad4c9c9764732ab5a821a308d9469ea2 100644 --- a/src/main/java/agents/states/ExposedSEIRSState.java +++ b/src/main/java/agents/states/ExposedSEIRSState.java @@ -1,9 +1,11 @@ package agents.states; +import agents.SEIRSAgent; + public class ExposedSEIRSState extends SEIRSState { - public ExposedSEIRSState(agents.SEIRSAgent SEIRSAgent) { - super(SEIRSAgent); + public ExposedSEIRSState(SEIRSAgent agent) { + super(agent); } @Override diff --git a/src/main/java/agents/states/InfectedSEIRSState.java b/src/main/java/agents/states/InfectedSEIRSState.java index db3bfc874d4cd6d6971a8e066bfe891839e8e435..012d0cb8dfd7cba0cd3a5f337cfa24f80f56563c 100644 --- a/src/main/java/agents/states/InfectedSEIRSState.java +++ b/src/main/java/agents/states/InfectedSEIRSState.java @@ -1,9 +1,11 @@ package agents.states; +import agents.SEIRSAgent; + public class InfectedSEIRSState extends SEIRSState { - public InfectedSEIRSState(agents.SEIRSAgent SEIRSAgent) { - super(SEIRSAgent); + public InfectedSEIRSState(SEIRSAgent agent) { + super(agent); } @Override diff --git a/src/main/java/agents/states/RecoveredSEIRSState.java b/src/main/java/agents/states/RecoveredSEIRSState.java index f9643243f0f0ebf4ead02fe3e166afa9b32c1620..11df581e4c827d540adfef5f1e915318101a281a 100644 --- a/src/main/java/agents/states/RecoveredSEIRSState.java +++ b/src/main/java/agents/states/RecoveredSEIRSState.java @@ -4,8 +4,8 @@ import agents.SEIRSAgent; public class RecoveredSEIRSState extends SEIRSState { - public RecoveredSEIRSState(SEIRSAgent SEIRSAgent) { - super(SEIRSAgent); + public RecoveredSEIRSState(SEIRSAgent agent) { + super(agent); } @Override diff --git a/src/main/java/agents/states/SuceptibleSEIRSState.java b/src/main/java/agents/states/SuceptibleSEIRSState.java index f333f05c9fae315547311f1989729fddbc7bde98..28a2511c078bfc66dda80ecdeca91da72e036178 100644 --- a/src/main/java/agents/states/SuceptibleSEIRSState.java +++ b/src/main/java/agents/states/SuceptibleSEIRSState.java @@ -1,9 +1,11 @@ package agents.states; +import agents.SEIRSAgent; + public class SuceptibleSEIRSState extends SEIRSState { - public SuceptibleSEIRSState(agents.SEIRSAgent SEIRSAgent) { - super(SEIRSAgent); + public SuceptibleSEIRSState(SEIRSAgent agent) { + super(agent); } @Override diff --git a/src/main/java/environment/ChunkedSEIRSEnvironment.java b/src/main/java/environment/ChunkedSEIRSEnvironment.java new file mode 100644 index 0000000000000000000000000000000000000000..cf7e601697698f0169061d3639cd8632a5e71613 --- /dev/null +++ b/src/main/java/environment/ChunkedSEIRSEnvironment.java @@ -0,0 +1,127 @@ +package environment; + +import agents.Agent2D; +import agents.SEIRSAgent; +import agents.states.InfectedSEIRSState; +import agents.states.SEIRSState; + +import java.awt.*; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +@SuppressWarnings("unchecked") +public class ChunkedSEIRSEnvironment implements SEIRSEnvironment { + + public final static int RADIUS = 10; + public final static int CHUNK_SIZE = 2*RADIUS; + + public final int size; + private final SEIRSAgent[] agents; + private List<SEIRSAgent>[][] chunks; + + public ChunkedSEIRSEnvironment(int size, SEIRSAgent[] agents) { + this.agents = agents; + this.size = size; + } + + private void initiateChunks() { + chunks = new ArrayList[(size/CHUNK_SIZE)][(size/CHUNK_SIZE)]; + for (int i = 0; i < chunks.length; i++) { + for (int j = 0; j < chunks[i].length; j++) { + chunks[i][j] = new ArrayList<>(); + } + } + for (SEIRSAgent agent : agents) { + int x = agent.getPosition().x/CHUNK_SIZE; + int y = agent.getPosition().y/CHUNK_SIZE; + chunks[x][y].add(agent); + } + } + private Boolean detectCollision(Point pos1, Point pos2) { + double xDif = pos1.x - pos2.x; + double yDif = pos1.y - pos2.y; + double distanceSquared = xDif * xDif + yDif * yDif; + return distanceSquared < (2*RADIUS) * (2*RADIUS); + } + + private Point getRelativePoint(int relativeTo, Point p) { + return switch (relativeTo) { + case LEFT -> new Point(p.x-1,p.y); + case RIGHT -> new Point(p.x+1,p.y); + case UP -> new Point(p.x,p.y-1); + case DOWN -> new Point(p.x,p.y+1); + case CENTER -> p; + case UP_LEFT -> new Point(p.x-1,p.y-1); + case UP_RIGHT -> new Point(p.x+1,p.y-1); + case DOWN_LEFT -> new Point(p.x-1,p.y+1); + case DOWN_RIGHT -> new Point(p.x+1,p.y+1); + default -> throw new IllegalStateException("Unexpected value: " + relativeTo); + }; + } + + private List<SEIRSAgent> getInfectedChunkNeighbors(int relativeTo, Point p) { + Point newPosition = getRelativePoint(relativeTo,p); + Point chunk = new Point(newPosition.x/CHUNK_SIZE,newPosition.y/CHUNK_SIZE); + List<SEIRSAgent> neighbors = new ArrayList<>(); + try{ + for (SEIRSAgent agent : chunks[chunk.x][chunk.y]) { + if (detectCollision(p, agent.getPosition())) { + if (agent.getState() instanceof InfectedSEIRSState) { + neighbors.add(agent); + } + } + } + }catch (Exception e) { + return neighbors; + } + return neighbors; + } + + @Override + public void notifyNewPosition(Point oldPosition, Point newPosition, Agent2D agent) { + if (chunks == null) { + initiateChunks(); + } + if (oldPosition.x/CHUNK_SIZE != newPosition.x/CHUNK_SIZE || oldPosition.y/CHUNK_SIZE != newPosition.y/CHUNK_SIZE) { + chunks[oldPosition.x/CHUNK_SIZE][oldPosition.y/CHUNK_SIZE].remove((SEIRSAgent) agent); + chunks[newPosition.x/CHUNK_SIZE][newPosition.y/CHUNK_SIZE].add((SEIRSAgent) agent); + } + } + + @Override + public List<SEIRSAgent> getInfectedNeighbors(Point p) { + if (chunks == null) { + initiateChunks(); + } + var neighbors = new ArrayList<SEIRSAgent>(); + + for (int i = 0; i < MAX_CHUNK; i++) { + neighbors.addAll(getInfectedChunkNeighbors(i,p)); + } + return neighbors; + } + + @Override + public HashMap<String,Integer> getAgentsStatus() { + if (chunks == null) { + initiateChunks(); + } + var map = new HashMap<String,Integer>(); + map.put(SEIRSState.EXPOSED,0); + map.put(SEIRSState.INFECTED,0); + map.put(SEIRSState.RECOVERED,0); + map.put(SEIRSState.SUCEPTIBLE,0); + + for (SEIRSAgent SEIRSAgent : agents) { + String state = SEIRSAgent.getState().toString(); + map.put(state,map.get(state)+1); + } + return map; + } + + @Override + public int getSize() { + return size; + } +} diff --git a/src/main/java/environment/Environment2D.java b/src/main/java/environment/Environment2D.java index 59a1643cdf6e8e121a319d8b0c3663cb6d83c66d..d951d4f2b99f615d20e7a82a4330c35d039eb11b 100644 --- a/src/main/java/environment/Environment2D.java +++ b/src/main/java/environment/Environment2D.java @@ -1,10 +1,22 @@ package environment; -import agents.Agent; +import agents.Agent2D; import java.awt.*; public interface Environment2D extends Environment { - void notifyNewPosition(Point oldPosition, Point newPosition, Agent agent); + int LEFT = 0; + int RIGHT = 1; + int UP = 2; + int DOWN = 3; + int CENTER = 4; + int UP_LEFT = 5; + int UP_RIGHT = 6; + int DOWN_LEFT = 7; + int DOWN_RIGHT = 8; + int MAX_CHUNK = 9; + + void notifyNewPosition(Point oldPosition, Point newPosition, Agent2D agent); + int getSize(); } diff --git a/src/main/java/environment/SEIRSEnvironment.java b/src/main/java/environment/SEIRSEnvironment.java index c4ab08ab5ed2a18dbbdc92550d047c49ee701dca..ddd65494ce7a40a8f0d40de8f5b3a17b3cf999ff 100644 --- a/src/main/java/environment/SEIRSEnvironment.java +++ b/src/main/java/environment/SEIRSEnvironment.java @@ -1,119 +1,13 @@ package environment; -import agents.Agent; import agents.SEIRSAgent; -import agents.states.SEIRSState; import java.awt.*; -import java.util.ArrayList; import java.util.HashMap; import java.util.List; -@SuppressWarnings("unchecked") -public class SEIRSEnvironment implements SquareEnvironment2D { +public interface SEIRSEnvironment extends Environment2D { + List<SEIRSAgent> getInfectedNeighbors(Point p); - public final static int RADIUS = 10; - public final static int CHUNK_SIZE = 2*RADIUS; - - public final int size; - private final SEIRSAgent[] agents; - private List<SEIRSAgent>[][] chunks; - - public SEIRSEnvironment(int size, SEIRSAgent[] agents) { - this.agents = agents; - this.size = size; - } - - public void initiateChunks() { - chunks = new ArrayList[(size/CHUNK_SIZE)][(size/CHUNK_SIZE)]; - for (int i = 0; i < chunks.length; i++) { - for (int j = 0; j < chunks[i].length; j++) { - chunks[i][j] = new ArrayList<>(); - } - } - for (SEIRSAgent agent : agents) { - int x = agent.getPosition().x/CHUNK_SIZE; - int y = agent.getPosition().y/CHUNK_SIZE; - chunks[x][y].add(agent); - } - } - private Boolean detectCollision(Point pos1, Point pos2) { - double xDif = pos1.x - pos2.x; - double yDif = pos1.y - pos2.y; - double distanceSquared = xDif * xDif + yDif * yDif; - return distanceSquared < (2*RADIUS) * (2*RADIUS); - } - - private Point getRelativePoint(int relativeTo, Point p) { - return switch (relativeTo) { - case LEFT -> new Point(p.x-1,p.y); - case RIGHT -> new Point(p.x+1,p.y); - case UP -> new Point(p.x,p.y-1); - case DOWN -> new Point(p.x,p.y+1); - case CENTER -> p; - case UP_LEFT -> new Point(p.x-1,p.y-1); - case UP_RIGHT -> new Point(p.x+1,p.y-1); - case DOWN_LEFT -> new Point(p.x-1,p.y+1); - case DOWN_RIGHT -> new Point(p.x+1,p.y+1); - default -> throw new IllegalStateException("Unexpected value: " + relativeTo); - }; - } - - private List<SEIRSAgent> getChunkNeighbors(int relativeTo, Point p) { - Point newPosition = getRelativePoint(relativeTo,p); - Point chunk = new Point(newPosition.x/CHUNK_SIZE,newPosition.y/CHUNK_SIZE); - List<SEIRSAgent> neighbors = new ArrayList<>(); - try{ - for (SEIRSAgent agent : chunks[chunk.x][chunk.y]) { - if (detectCollision(p, agent.getPosition())) { - neighbors.add(agent); - } - } - }catch (Exception e) { - return neighbors; - } - return neighbors; - } - - public List<SEIRSAgent> getNeighbors(Point position) { - if (chunks == null) { - throw new IllegalStateException("Chunks aren't initialized, you should use the initiateMethod() first."); - } - var neighbors = new ArrayList<SEIRSAgent>(); - - for (int i = 0; i < MAX_CHUNK; i++) { - neighbors.addAll(getChunkNeighbors(i,position)); - } - return neighbors; - } - - public void notifyNewPosition(Point oldPosition, Point newPosition, Agent agent) { - if (chunks == null) { - throw new IllegalStateException("Chunks aren't initialized, you should use the initiateMethod() first."); - } - if (oldPosition.x/CHUNK_SIZE != newPosition.x/CHUNK_SIZE || oldPosition.y/CHUNK_SIZE != newPosition.y/CHUNK_SIZE) { - chunks[oldPosition.x/CHUNK_SIZE][oldPosition.y/CHUNK_SIZE].remove((SEIRSAgent) agent); - chunks[newPosition.x/CHUNK_SIZE][newPosition.y/CHUNK_SIZE].add((SEIRSAgent) agent); - } - } - - public HashMap<String,Integer> getAgentStatus() { - - var map = new HashMap<String,Integer>(); - map.put(SEIRSState.EXPOSED,0); - map.put(SEIRSState.INFECTED,0); - map.put(SEIRSState.RECOVERED,0); - map.put(SEIRSState.SUCEPTIBLE,0); - - for (SEIRSAgent SEIRSAgent : agents) { - String state = SEIRSAgent.getState().toString(); - map.put(state,map.get(state)+1); - } - return map; - } - - @Override - public int getSize() { - return size; - } + HashMap<String, Integer> getAgentsStatus(); } diff --git a/src/main/java/environment/SquareEnvironment2D.java b/src/main/java/environment/SquareEnvironment2D.java deleted file mode 100644 index 308242fb34c10588c4ae7379ddd120d0ecd27d99..0000000000000000000000000000000000000000 --- a/src/main/java/environment/SquareEnvironment2D.java +++ /dev/null @@ -1,16 +0,0 @@ -package environment; - -public interface SquareEnvironment2D extends Environment2D { - int LEFT = 0; - int RIGHT = 1; - int UP = 2; - int DOWN = 3; - int CENTER = 4; - int UP_LEFT = 5; - int UP_RIGHT = 6; - int DOWN_LEFT = 7; - int DOWN_RIGHT = 8; - int MAX_CHUNK = 9; - - int getSize(); -} diff --git a/src/main/java/scheduler/AsynchronousScheduler.java b/src/main/java/scheduler/AsynchronousScheduler.java deleted file mode 100644 index 92f48a720f6e3a9805c0293e02eb42bfd6710889..0000000000000000000000000000000000000000 --- a/src/main/java/scheduler/AsynchronousScheduler.java +++ /dev/null @@ -1,4 +0,0 @@ -package scheduler; - -public abstract class AsynchronousScheduler implements Scheduler { -} diff --git a/src/main/java/scheduler/FairAsynchronousScheduler.java b/src/main/java/scheduler/FairAsynchronousScheduler.java index 4df02c25151ff6e6f3afef9e03664ee23e7a9308..4c5cf0decf777edeb47e258b1767b9fcb9ae9a6b 100644 --- a/src/main/java/scheduler/FairAsynchronousScheduler.java +++ b/src/main/java/scheduler/FairAsynchronousScheduler.java @@ -9,7 +9,7 @@ import java.util.concurrent.*; import java.util.function.Function; import java.util.stream.Collectors; -public class FairAsynchronousScheduler extends AsynchronousScheduler { +public class FairAsynchronousScheduler implements Scheduler { private final ExecutorService executor = Executors.newSingleThreadExecutor(); private Queue<Agent> queue; diff --git a/src/main/java/scheduler/FairSynchronousScheduler.java b/src/main/java/scheduler/FairSynchronousScheduler.java index 3c56381efe3b08d063a4c132c91bd194992bb13c..e385320c24a0dfbf6a7a6a22176b136117c6d16e 100644 --- a/src/main/java/scheduler/FairSynchronousScheduler.java +++ b/src/main/java/scheduler/FairSynchronousScheduler.java @@ -4,13 +4,14 @@ import agents.Agent; import java.util.*; -public class FairSynchronousScheduler extends SynchronousScheduler { +public class FairSynchronousScheduler implements Scheduler { private Agent[] agents; private Stack<Integer> executionOrder; + private final Random r; public FairSynchronousScheduler(int seed) { - super(seed); + r = new Random(seed); } private void generateExecutionOrder() { diff --git a/src/main/java/scheduler/SynchronousScheduler.java b/src/main/java/scheduler/SynchronousScheduler.java deleted file mode 100644 index e8fb3174f07900f152806e39bfee3474765550d1..0000000000000000000000000000000000000000 --- a/src/main/java/scheduler/SynchronousScheduler.java +++ /dev/null @@ -1,12 +0,0 @@ -package scheduler; - -import java.util.Random; - -public abstract class SynchronousScheduler implements Scheduler { - - protected final Random r; - - public SynchronousScheduler(int seed) { - r = new Random(seed); - } -} diff --git a/src/main/java/sma/SEIRS_SMA.java b/src/main/java/sma/SEIRS_SMA.java index 6125e9dd4777ba2aa0b6036d2546ebe3fe5068b4..7b9b7cce711d57a490d4ccf838596193f339b20b 100644 --- a/src/main/java/sma/SEIRS_SMA.java +++ b/src/main/java/sma/SEIRS_SMA.java @@ -1,10 +1,13 @@ package sma; -import agents.Agent; -import environment.Environment; +import agents.SEIRSAgent; +import agents.states.InfectedSEIRSState; +import environment.SEIRSEnvironment; import models.Parameters; import agents.RandomWalkingAgent; -import environment.SEIRSEnvironment; +import environment.ChunkedSEIRSEnvironment; +import scheduler.FairAsynchronousScheduler; +import scheduler.FairSynchronousScheduler; import scheduler.Scheduler; import utils.StatsRecorder; import utils.YamlReader; @@ -12,29 +15,27 @@ import view.DisplaySquaredEnvironment; import view.FrameBuilder; import view.StatisticsCanvas; +import java.awt.*; import java.io.IOException; import java.time.Duration; import java.time.Instant; import java.util.Date; import java.util.HashMap; +import java.util.Random; @SuppressWarnings("InfiniteLoopStatement") public class SEIRS_SMA implements SMA{ - private final Parameters parameters; + private Parameters parameters; private RandomWalkingAgent[] agents; private SEIRSEnvironment environment; private Scheduler scheduler; private StatisticsCanvas statisticsCanvas; private DisplaySquaredEnvironment display; + private Random r; private HashMap<String,Integer> stats; - public SEIRS_SMA() { - parameters = YamlReader.getParams(); - agents = new RandomWalkingAgent[parameters.getPopulation()]; - } - private void initGraphics() { statisticsCanvas = new StatisticsCanvas(500,500); display = new DisplaySquaredEnvironment(environment,agents); @@ -43,7 +44,7 @@ public class SEIRS_SMA implements SMA{ frameBuilder.addComponent(display,FrameBuilder.TOP); frameBuilder.addComponent(statisticsCanvas,FrameBuilder.RIGHT); frameBuilder.buildWindow(); - statisticsCanvas.updateValues(environment.getAgentStatus()); + statisticsCanvas.updateValues(environment.getAgentsStatus()); statisticsCanvas.repaint(); } @@ -55,7 +56,7 @@ public class SEIRS_SMA implements SMA{ private void doNextCycle(){ scheduler.doNextCycle(); - stats = environment.getAgentStatus(); + stats = environment.getAgentsStatus(); try{ StatsRecorder.writeToCSV(stats,"src/main/resources/output.csv"); } catch (IOException e) { @@ -74,13 +75,43 @@ public class SEIRS_SMA implements SMA{ } } - @Override - public void init(Environment environment, Scheduler scheduler, Agent[] agents) { - this.agents = (RandomWalkingAgent[]) agents; - this.scheduler = scheduler; + private void initPopulation() { + for (int i = 0; i<parameters.getPopulation();i++) { + Point position = new Point(r.nextInt(parameters.getSize()),r.nextInt(parameters.getSize())); + RandomWalkingAgent agent = new RandomWalkingAgent(position,parameters.getSeed()+i,environment); + agents[i] = agent; + } + } + + private void infectPatientZero() { + for (int i=0 ; i< parameters.getNbOfPatientZero(); i++) { + SEIRSAgent agent = agents[(r.nextInt(parameters.getPopulation()))]; + while (agent.getState() instanceof InfectedSEIRSState) { + agent = agents[(r.nextInt(parameters.getPopulation()))]; + } + agent.changeState(new InfectedSEIRSState(agent)); + } + } + + private void initScheduler() { + if (parameters.isSynchronousMode()) { + scheduler = new FairSynchronousScheduler(parameters.getSeed()); + } else { + scheduler = new FairAsynchronousScheduler(); + } scheduler.init(agents); - this.environment = (SEIRSEnvironment)environment; - this.environment.initiateChunks(); + } + + + @Override + public void init() { + parameters = YamlReader.getParams(); + r = new Random(parameters.getSeed()); + agents = new RandomWalkingAgent[parameters.getPopulation()]; + environment = new ChunkedSEIRSEnvironment(parameters.getSize(),agents); + initPopulation(); + infectPatientZero(); + initScheduler(); initGraphics(); } @@ -106,4 +137,10 @@ public class SEIRS_SMA implements SMA{ System.exit(0); } } + + public static void main(String[] args) { + SMA sma = new SEIRS_SMA(); + sma.init(); + sma.run(); + } } diff --git a/src/main/java/sma/SMA.java b/src/main/java/sma/SMA.java index 1d40aab645afd0d85a4a50a86a4ae85f9334e880..1d6ec46a27f130e81cffbe0b35f355d818aad4e0 100644 --- a/src/main/java/sma/SMA.java +++ b/src/main/java/sma/SMA.java @@ -1,11 +1,7 @@ package sma; -import agents.Agent; -import environment.Environment; -import scheduler.Scheduler; - public interface SMA{ - void init(Environment environment, Scheduler scheduler, Agent[] agents); + void init(); void run(); } diff --git a/src/main/java/view/DisplaySquaredEnvironment.java b/src/main/java/view/DisplaySquaredEnvironment.java index 45f0d12a2e7bd15fac73edd5fcd70cfae060b4fe..5d948df47534f0142e9b12647256f095fbd04d64 100644 --- a/src/main/java/view/DisplaySquaredEnvironment.java +++ b/src/main/java/view/DisplaySquaredEnvironment.java @@ -2,6 +2,7 @@ package view; import agents.SEIRSAgent; import agents.states.SEIRSState; +import environment.ChunkedSEIRSEnvironment; import environment.SEIRSEnvironment; import javax.swing.*; @@ -15,14 +16,14 @@ public class DisplaySquaredEnvironment extends JPanel { public DisplaySquaredEnvironment(SEIRSEnvironment environment, SEIRSAgent[] SEIRSAgents) { this.setDoubleBuffered(true); this.SEIRSAgents = SEIRSAgents; - setSize(environment.size,environment.size); + setSize(environment.getSize(),environment.getSize()); setVisible(true); } private void drawCenteredCircle(Graphics g, int x, int y) { - x = x-(SEIRSEnvironment.RADIUS /2); - y = y-(SEIRSEnvironment.RADIUS /2); - g.fillOval(x,y, SEIRSEnvironment.RADIUS, SEIRSEnvironment.RADIUS); + x = x-(ChunkedSEIRSEnvironment.RADIUS /2); + y = y-(ChunkedSEIRSEnvironment.RADIUS /2); + g.fillOval(x,y, ChunkedSEIRSEnvironment.RADIUS, ChunkedSEIRSEnvironment.RADIUS); } diff --git a/src/main/resources/parameters.yaml b/src/main/resources/parameters.yaml index 3ddf6aed6d973b2ca91423d04dcbd18c69932fb9..ac8b4ad128d1c18583e3db61416cd546ff66f78c 100644 --- a/src/main/resources/parameters.yaml +++ b/src/main/resources/parameters.yaml @@ -8,5 +8,5 @@ nbOfPatientZero: 10 population: 5000 seed: 120 size: 500 -synchronousMode: false -timeBetweenCycles: 0 +synchronousMode: true +timeBetweenCycles: 0 \ No newline at end of file