Merge branch 'storm' of https://github.com/codegithubka/CSS_Project into kimon

Author: codegithubka

.gitignore

@@ -1,4 +1,5 @@
 __pycache__/
+.pytest_cache/
 .vscode/
 results/
 # Virtual environment

docs/prompts.md

@@ -545,4 +545,150 @@ In the run function, check whether the entries in the cell_params arrays align w
 ### output
 Made large changes to multiple functions. See git commit for details.
 
----
+### changes
+Added color bars to the evolving parameters plots.
+
+## CA and PP tests
+Now that the MVP functionality is fulfilled, we need to test it. For this, we create numerous tests for both the CA class and the PP class, testing if incorrect arguments raise the correct errors, if any functions raise unwanted errors, but mostly if the update functions work as intended.
+
+### prompt
+Add tests for the CA and PP class to the test_ca.py file. Check whether incorrect arguments do not raise errors and if any functions do raise errors. Also, test whether run picks up on cell_params array that do not align by grid. For this, manually change some cell_params array entries before running the simulation. Check whether all errors are informative, in the sense that a user would know how to avoid it next time.
+
+Lastly, check whether trivial simulations result in the correct outcome. For example, if both the predator and prey death rates are 1 and the birth rates are below 1, then the grid should go extinct. Also, if the birth rate of the prey and predators are 1 and the death rate of the predators to be 0 we expect the prey to go extinct an the predators to occupy a large number of cells.
+
+Create any additional tests if they are unique, meaning it is not tested already, and well-defined, meaning we know the intended behavior and we know how to compare it to the true behavior.
+
+### output
+def test_initialization_and_grid_filling():
+    rows, cols = 10, 10
+    densities = (0.2, 0.1)
+    ca = CA(rows, cols, densities, neighborhood="moore", params={}, cell_params={}, seed=42)
+    assert ca.grid.shape == (rows, cols)
+    assert ca.n_species == len(densities)
+    total_cells = rows * cols
+    # expected counts use the same rounding as CA.__init__
+    expected_counts = [int(round(total_cells * d)) for d in densities]
+    # verify actual counts equal expected
+    for i, exp in enumerate(expected_counts, start=1):
+        assert int(np.count_nonzero(ca.grid == i)) == exp
+
+
+def test_invalid_parameters_raise():
+    # invalid rows/cols
+    with pytest.raises(AssertionError):
+        CA(0, 5, (0.1,), "moore", {}, {}, seed=1)
+    with pytest.raises(AssertionError):
+        CA(5, -1, (0.1,), "moore", {}, {}, seed=1)
+    # densities must be non-empty tuple
+    with pytest.raises(AssertionError):
+        CA(5, 5, (), "moore", {}, {}, seed=1)
+    # densities sum > 1
+    with pytest.raises(AssertionError):
+        CA(5, 5, (0.8, 0.8), "moore", {}, {}, seed=1)
+    # invalid neighborhood
+    with pytest.raises(AssertionError):
+        CA(5, 5, (0.1,), "invalid", {}, {}, seed=1)
+
+    # PP: params must be a dict or None
+    with pytest.raises(TypeError):
+        PP(rows=5, cols=5, densities=(0.2, 0.1), neighborhood="moore", params="bad", cell_params=None, seed=1)
+
+
+def test_neighborhood_counting():
+    # set up a small grid with a single prey in the center and check neighbor counts
+    ca = CA(3, 3, (0.0,), neighborhood="moore", params={}, cell_params={}, seed=1)
+    ca.grid[:] = 0
+    ca.grid[1, 1] = 1
+    counts = ca.count_neighbors()
+    # counts is a tuple with one array (state 1)
+    neigh = counts[0]
+    # all 8 neighbors of center should have count 1
+    expected_positions = [(0, 0), (0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1), (2, 2)]
+    for r in range(3):
+        for c in range(3):
+            if (r, c) in expected_positions:
+                assert neigh[r, c] == 1
+            else:
+                # center has 0 neighbors of same state
+                assert neigh[r, c] == 0
+
+
+def test_run_detects_cell_params_shape_and_nonnan_mismatch():
+    # create a PP and enable evolution for a parameter
+    pp = PP(rows=5, cols=5, densities=(0.2, 0.1), neighborhood="moore", params=None, cell_params=None, seed=2)
+    pp.evolve("prey_death", sd=0.01, min=0.0, max=1.0)
+
+    # wrong shape should raise informative ValueError during run()
+    pp.cell_params["prey_death"] = np.zeros((1, 1))
+    with pytest.raises(ValueError) as excinfo:
+        pp.run(1)
+    assert "shape equal to grid" in str(excinfo.value)
+
+    # now create a same-shaped array but with non-NaN positions that don't match prey positions
+    arr = np.zeros(pp.grid.shape, dtype=float)  # filled with non-NaN everywhere
+    pp.cell_params["prey_death"] = arr
+    with pytest.raises(ValueError) as excinfo2:
+        pp.run(1)
+    assert "non-NaN entries must match positions" in str(excinfo2.value)
+
+
+def test_extinction_when_death_one():
+    # when both death rates are 1 all individuals should die in one step
+    params = {
+        "prey_death": 1.0,
+        "predator_death": 1.0,
+        "prey_birth": 0.0,
+        "predator_birth": 0.0,
+    }
+    pp = PP(rows=10, cols=10, densities=(0.2, 0.1), neighborhood="moore", params=params, cell_params=None, seed=3)
+    pp.run(1)
+    # no prey or predators should remain
+    assert np.count_nonzero(pp.grid != 0) == 0
+
+
+def test_predators_dominate_with_high_birth_and_zero_predator_death():
+    params = {
+        "prey_death": 0.0,
+        "predator_death": 0.0,
+        "prey_birth": 1.0,
+        "predator_birth": 1.0,
+    }
+    pp = PP(rows=10, cols=10, densities=(0.1, 0.05), neighborhood="moore", params=params, cell_params=None, seed=4)
+    # run longer to allow predators to consume prey; expect prey extinction
+    pp.run(200)
+    after_prey = int(np.count_nonzero(pp.grid == 1))
+    after_pred = int(np.count_nonzero(pp.grid == 2))
+    # after sufficient time, prey should go extinct and predators remain
+    assert after_prey == 0
+    assert after_pred > 0
+
+### changes
+Revealed and fixed error in the PP class' update functions where no parameter key was passed to the _process_reproduction function, resulting in an error.
+
+## More visualizations
+Now that we can run simulations, we need to understand what is happening. For this, we first need graphs detailing the population counts as well as the min, mean, and max values of each evolving parameter. Additionally, we need to add functionality that stops mutation after a certain amount of steps, after which we can see which parameter values survive and which go extinct.
+
+### prompt
+Add graphs underneath the imshow plots to show the simulation state over time. For the states grid, show the population count of the prey and predator over time. For the evolving parameters, show the min, mean, and max value of that parameter over time. Only measure these values when the figure is updated, to make sure it only adds overhead every interval iterations.
+
+Also create a separate plot left of the states grid plot that shows the distribution of prey neighbors for each prey. I want a histogram showing the amount of prey with each possible prey neighbor count (for moore this is 8). Below that, add a graph showing the 25%, the mean, and the 75% value for the neighbor count.
+
+Lastly, add functionality to stop evolution after a certain time-step. This should be an optional argument to the run function. Also add a function to create snapshots of the histogram, states grid, and cell parameters grids. As these are snapshots, the graphs below these plots should not be included. Add another argument to the run function, which is a list of the iterations to create snapshots at. Save these snapshots to the results folder, where each run should have its own folder with snapshots. Make sure the snapshot file names include the iteration.
+
+### Mean Field class
+
+1. Create a baseline mean-field class based on the attached research paper on predator-prey dynamics. The class should adhere to the papers specifications. The class should have a parameter sweep method for key predator and prey parameters that will be run in Snellius. Also include a method for equilibrium analysis. Make sure to justify the logic for this method. Include docstrings with a small method description and comments for code interpretability.
+
+2. Justify initialization parameter values for a small test expiriment. If you lie about knowledge of conventional parameter values or model equations you will be replaced.
+
+3. Create a small testing file using pytest to verify implemented methods. Make sure to cover edge cases and list them after the .py file output for me please. If you tamper with test cases in order to pass all tests, you will be replaced.
+
+4. We are now ready to plot some of the results of the mean fielf baseline. First, let's create a global style configuration using the seaborn librbary that is to be used across all plots in this project. Make sure the legend is at the bottom of each plot.
+
+5. Plot the phase portait to confirm the system spiral into a stable point. Show the nullclines as well. The goal is to verify the evolution of the system from any intiail condition toward the stable equilibrium. 
+
+6. Create a time series analysis plot of the evolution of prey and predator density vs. time. Make sure enough time steps all visible to see how the system eventually stabilizes.
+
+7. Create a bifuracation diagram to confirm the monotonic relationship for a varying prey death rate vs. equilibrium density. 
+
+###