src/cats/actions/process_inter_period_survival.c

@@ -57,22 +57,18 @@ void write_stats(struct cats_grid *grid, const struct cats_configuration *conf,
                 j_sum_weighted,
                 get_seed_sum(g, 0, 0));
 
-        fprintf(f, ",%f", g->dispersed_seeds[0][0]);
+        fprintf(f, ",%f", get_dispersed_seeds(grid, 0, 0));
         for (int32_t i = 0; i < seed_persistence; i++) {
-                if (g->seed_bank[0][0]) {
-                        fprintf(f, ",%f", g->seed_bank[0][0][i]);
+                if (seed_bank_exists(g, 0, 0)) {
+                        fprintf(f, ",%f", get_seed_bank_seeds(g, 0, 0, i));
                 } else {
                         fprintf(f, ",%f", 0.0);
 
                 }
         }
-        for (int32_t i = 0; i < max_age_of_maturity + 1; i++) {
-                if (g->juveniles[0][0]) {
-                        fprintf(f, ",%d", g->juveniles[0][0][i]);
-                } else {
 
-                        fprintf(f, ",%d", 0);
-                }
+        for (int32_t i = 0; i < max_age_of_maturity + 1; i++) {
+                fprintf(f, ",%d", get_juveniles(g, 0, 0, i));
         }
         fprintf(f, "\n");
 

src/cats/actions/process_seed_dispersal.c

@@ -43,6 +43,7 @@
 #include "inline_overlays.h"
 #include "actions/cats_actions.h"
 #include "temporal/years.h"
+#include "inline.h"
 
 void area_post_process_seeds(struct cats_grid *grid, struct cats_thread_info *ts);
 
@@ -106,7 +107,7 @@ enum action_status process_disperse_seeds(struct cats_grid *grid, struct cats_co
 
         if (conf->command_line_options.lambda_test) {
                 disperse_seeds(grid, 0, 0, grid->single_thread);
-                grid->seeds_produced[0][0] = 0.0f;
+                set_produced_seeds(grid, 0, 0, 0.0f);
                 cell_post_process_seeds(grid, conf, 0, 0, grid->single_thread);
                 return ACTION_RUN;
         }
@@ -172,7 +173,7 @@ void area_post_process_seeds(struct cats_grid *grid, struct cats_thread_info *ts
                         mark_cell_done(&debug, row, col);
 #endif
                         if (cell_excluded_by_overlay(conf, row, col)) {
-                                grid->dispersed_seeds[row][col] = 0;
+                                set_dispersed_seeds(grid, row, col, 0.0f);
                         } else {
                                 cell_post_process_seeds(grid, conf, row, col, ts);
                         }
@@ -194,8 +195,8 @@ void dispersal_wrapper(struct cats_grid *grid, struct cats_thread_info *ts)
                         mark_cell_done(&debug, row, col);
 #endif
                         if (cell_excluded_by_overlay(conf, row, col)) { continue; }
-                        if (grid->seeds_produced[row][col] > 0.0) disperse_seeds(grid, row, col, ts);
-                        grid->seeds_produced[row][col] = 0.0f;
+                        if (get_produced_seeds(grid, row, col) > 0.0) disperse_seeds(grid, row, col, ts);
+                        set_produced_seeds(grid, row, col, 0.0f);
                 }
         }
 }

src/cats/dispersal/dispersal.c

@@ -51,6 +51,7 @@
 
 #include "memory/cats_memory.h"
 #include "inline_overlays.h"
+#include "inline.h"
 
 // ANSATZPUNKTE
 // 3 verschiedene dispersals:
@@ -153,7 +154,7 @@ void disperse_seeds(const struct cats_grid *restrict grid, cats_dt_coord s_row,
         assert(s_col < grid->dimension.cols);
 
 
-        float seeds = grid->seeds_produced[s_row][s_col];
+        float seeds = get_produced_seeds(grid, s_row, s_col);
         assert(seeds >= 0.0);
         if (seeds < 1.0) return;
 

src/cats/dispersal/local_dispersal.c

@@ -29,6 +29,7 @@
 #include "configuration/configuration.h"
 #include "data/cats_grid.h"
 #include "local_dispersal.h"
+#include "inline.h"
 
 
 void cell_local_dispersal(struct cats_configuration *conf, struct cats_grid *grid, cats_dt_coord row,
@@ -37,11 +38,12 @@ void cell_local_dispersal(struct cats_configuration *conf, struct cats_grid *gri
         const struct cats_dispersal *const dispersal = grid->dispersal;
         if (dispersal->local_dispersal <= 0.0) return;
 
-        float seeds = grid->seeds_produced[row][col];
+        float seeds = get_produced_seeds(grid, row, col);
 
         cats_dt_seeds self = (float) (seeds * dispersal->local_dispersal);
         self = min_float(seeds, self);
 
-        grid->dispersed_seeds[row][col] += self;
-        grid->seeds_produced[row][col] -= self;
+        increase_dispersed_seeds(grid, row, col, self);
+        decrease_produced_seeds(grid, row, col, self);
+
 }
\ No newline at end of file

src/cats/environment/environment.c

@@ -70,8 +70,9 @@ void interpolate_environment(const struct cats_configuration *conf,
         const cats_dt_coord rows = environment->current.dimension.rows;
         const cats_dt_coord cols = environment->current.dimension.cols;
 
-        bool matching_dimensions = dimensions_match(&environment->start.dimension, &environment->end.dimension)
-                                   && dimensions_match(&environment->start.dimension, &environment->current.dimension);
+        bool matching_dimensions = cats_dimensions_match(&environment->start.dimension, &environment->end.dimension)
+                                   &&
+                                   cats_dimensions_match(&environment->start.dimension, &environment->current.dimension);
 
         if (!matching_dimensions) {
                 log_message(LOG_ERROR, "%s: dimension mismatch", __func__);
@@ -151,7 +152,7 @@ load_environment_raster(struct cats_configuration *conf, struct cats_environment
 
         unload_environment_raster(raster);
 
-        copy_dimensions_from_to(&conf->geometry.dimension, &raster->dimension);
+        copy_cats_dimensions(&conf->geometry.dimension, &raster->dimension);
 
         raster->interpolation_type = type;
         raster->environment_type = environment_type;

src/cats/environment/environment_rasters.c

@@ -55,7 +55,7 @@ void create_raster_if_needed(struct cats_configuration *conf, struct cats_enviro
         log_message(LOG_DEBUG, "%s: ALLOCATING NEW GRID NOW", __func__);
         raster->values = new_raw_2d_array_from_dimension(conf->geometry.dimension, sizeof(cats_dt_environment));
 
-        copy_dimensions_from_to(&conf->geometry.dimension, &raster->dimension);
+        copy_cats_dimensions(&conf->geometry.dimension, &raster->dimension);
 }
 
 

src/cats/grids/cats_grid.c

@@ -255,7 +255,7 @@ void cleanup_grid_seeds_and_juveniles(struct cats_grid *grid)
                         for (cats_dt_coord col = 0; col < grid->dimension.cols; col++) {
                                 destroy_seed_structure(grid, row, col);
                         }
-                        free(grid->seed_bank[row]);
+                        free(grid->seed_bank[row]);     // clean-up [cleanup_grid_seeds_and_juveniles]
                 }
         }
 
@@ -266,7 +266,7 @@ void cleanup_grid_seeds_and_juveniles(struct cats_grid *grid)
                                 destroy_juveniles(grid, row, col);
                         }
 
-                        free(grid->juveniles[row]);
+                        free(grid->juveniles[row]); // clean-up [cleanup_grid_seeds_and_juveniles]
                 }
        }
 

src/cats/grids/dimensions.c

 #include "dimensions.h"
 
 
-void copy_dimensions_from_to(const struct cats_dimension *from, struct cats_dimension *to)
+void copy_cats_dimensions(const struct cats_dimension *source, struct cats_dimension *destination)
 {
-        to->rows = from->rows;
-        to->cols = from->cols;
+        assert(source != NULL);
+        assert(destination != NULL);
+        destination->rows = source->rows;
+        destination->cols = source->cols;
 }
 
 
-bool dimensions_match(const struct cats_dimension *dim1, const struct cats_dimension *dim2)
+bool cats_dimensions_match(const struct cats_dimension *dim1, const struct cats_dimension *dim2)
 {
-        if (dim1->rows == dim2->rows && dim1->cols == dim2->cols) {
-                return true;
-        }
+        if (dim1->rows == dim2->rows && dim1->cols == dim2->cols) return true;
         return false;
 }
\ No newline at end of file

src/cats/grids/dimensions.h

@@ -8,17 +8,15 @@
 static inline bool valid_coordinates(const struct cats_dimension *dim, cats_dt_coord row, cats_dt_coord col)
 {
         assert(dim != NULL);
-        assert(row >= 0 && row < dim->rows);
-        assert(col >= 0 && col < dim->cols);
         if (row < 0 || col < 0) return false;
         if (row >= dim->rows || col >= dim->cols) return false;
         return true;
 }
 
 
-void copy_dimensions_from_to(const struct cats_dimension *from, struct cats_dimension *to);
+void copy_cats_dimensions(const struct cats_dimension *source, struct cats_dimension *destination);
 
-bool dimensions_match(const struct cats_dimension *dim1, const struct cats_dimension *dim2);
+bool cats_dimensions_match(const struct cats_dimension *dim1, const struct cats_dimension *dim2);
 
 bool valid_coordinates(const struct cats_dimension *dim, cats_dt_coord row, cats_dt_coord col);
 

src/cats/grids/gdal_save.c

@@ -173,13 +173,13 @@ void *save_seeds_to_gdal(struct cats_grid *grid, struct cats_configuration *conf
                         for (cats_dt_coord col = 0; col < cols; col++) {
                                 if (i > 0) {
                                         int year = i - 1;
-                                        if (grid->seed_bank[row][col]) {
-                                                seeds[row][col] = (int32_t) grid->seed_bank[row][col][year];
+                                        if (seed_bank_exists(grid, row, col)) {
+                                                seeds[row][col] = (int32_t) get_seed_bank_seeds(grid, row, col, year);
                                         } else {
                                                 seeds[row][col] = 0;
                                         }
                                 } else {
-                                        seeds[row][col] = (int32_t) grid->dispersed_seeds[row][col];
+                                        seeds[row][col] = (int32_t) get_dispersed_seeds(grid, row, col);
                                 }
                         }
                 }
@@ -221,11 +221,7 @@ void *save_juveniles_to_gdal(struct cats_grid *grid, struct cats_configuration *
                                                   sizeof(int32_t));//new_int32t_grid(grid->rows, grid->cols);
                 for (cats_dt_coord row = 0; row < rows; row++) {
                         for (cats_dt_coord col = 0; col < cols; col++) {
-                                if (grid->juveniles[row][col]) {
-                                        juvs[row][col] = grid->juveniles[row][col][i];
-                                } else {
-                                        juvs[row][col] = 0;
-                                }
+                                juvs[row][col] = get_juveniles(grid, row, col, i);
                         }
                 }
                 struct cats_dimension dim = {.rows = rows, .cols = cols};

src/cats/grids/grid_setup.c

@@ -53,7 +53,7 @@ void setup_grid_seed_structures(const struct cats_configuration *conf, struct ca
         grid->seed_bank = calloc_or_die(rows, sizeof(cats_dt_seeds **));
 
         for (cats_dt_coord row = 0; row < rows; row++) {
-                grid->seed_bank[row] = calloc_or_die(cols, sizeof(cats_dt_seeds *));
+                grid->seed_bank[row] = calloc_or_die(cols, sizeof(cats_dt_seeds *));  // initialisation [setup_grid_seed_structure]
 
                 for (cats_dt_coord col = 0; col < cols; col++) {
                         grid->seed_bank[row][col] = NULL;  // initialisation [setup_grid_seed_structure]
@@ -98,10 +98,10 @@ void setup_grid_juvenile_structures_opt(struct cats_configuration *conf, struct
         grid->juveniles = calloc_or_die(grid->dimension.rows, sizeof(cats_dt_population **));
 
         for (cats_dt_coord row = 0; row < grid->dimension.rows; row++) {
-                grid->juveniles[row] = calloc_or_die(grid->dimension.cols, sizeof(cats_dt_population *));
+                grid->juveniles[row] = calloc_or_die(grid->dimension.cols, sizeof(cats_dt_population *)); // initialisation [setup_grid_juvenile_structures_opt]
 
                 for (cats_dt_coord col = 0; col < grid->dimension.cols; col++) {
-                        grid->juveniles[row][col] = NULL;
+                        grid->juveniles[row][col] = NULL;  // initialisation [setup_grid_juvenile_structures_opt]
                 }
         }
 }

src/cats/inline.h

@@ -44,14 +44,15 @@
 #include "inline_vital_ages.h"
 #include "grids/dimensions.h"
 
-static inline bool valid_dispersed_seed_grid(const struct cats_grid *grid, cats_dt_coord row)
+static inline bool valid_dispersed_seeds_grid(const struct cats_grid *grid, cats_dt_coord row)
 {
         if (grid == NULL) return false;
         if (grid->dispersed_seeds == NULL) return false;
-        if (grid->dispersed_seeds[row] == NULL) return false;       // validator [valid_population_grid]
+        if (grid->dispersed_seeds[row] == NULL) return false;       // validator [valid_dispersed_seeds_grid]
         return true;
 }
 
+
 static inline bool valid_produced_seed_grid(const struct cats_grid *grid, cats_dt_coord row)
 {
         if (grid == NULL) return false;
@@ -75,19 +76,110 @@ static inline cats_dt_seeds
 get_dispersed_seeds(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col)
 {
         assert(valid_coordinates(&grid->dimension, row, col));
-        assert(valid_dispersed_seed_grid(grid, row));
-        return grid->dispersed_seeds[row][col];  // get [get_dispersed_seeds]
+        assert(valid_dispersed_seeds_grid(grid, row));
+        return grid->dispersed_seeds[row][col];  // getter [get_dispersed_seeds]
+}
+
+static inline void
+set_dispersed_seeds(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col, cats_dt_seeds seeds)
+{
+        assert(valid_coordinates(&grid->dimension, row, col));
+        assert(valid_dispersed_seeds_grid(grid, row));
+        assert(seeds >= 0);
+        grid->dispersed_seeds[row][col] = seeds;  // setter [set_dispersed_seeds]
 }
 
+static inline void
+increase_dispersed_seeds(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col, cats_dt_seeds by)
+{
+        assert(valid_coordinates(&grid->dimension, row, col));
+        assert(valid_dispersed_seeds_grid(grid, row));
+        assert(by >= 0);
+        grid->dispersed_seeds[row][col] += by;  // setter [increase_dispersed_seeds]
+}
+
+static inline void
+decrease_dispersed_seeds(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col, cats_dt_seeds by)
+{
+        assert(valid_coordinates(&grid->dimension, row, col));
+        assert(valid_dispersed_seeds_grid(grid, row));
+        assert(by >= 0);
+        grid->dispersed_seeds[row][col] -= by;  // setter [decrease_dispersed_seeds]
+        assert(grid->dispersed_seeds[row][col] >= 0); // setter [decrease_dispersed_seeds]
+}
+
+
+
 static inline cats_dt_seeds
 get_produced_seeds(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col)
 {
         assert(valid_coordinates(&grid->dimension, row, col));
         assert(valid_produced_seed_grid(grid, row));
-        return grid->seeds_produced[row][col];  // get [get_produced_seeds]
+        return grid->seeds_produced[row][col];  // getter [get_produced_seeds]
+}
+
+static inline bool valid_seed_bank_grid(const struct cats_grid *grid, cats_dt_coord row)
+{
+        if (grid == NULL || grid->seed_bank == NULL || grid->seed_bank[row] == NULL) return false;  // validator [valid_seed_bank_grid]
+        return true;
+}
+
+static inline bool seed_bank_exists(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col)
+{
+        assert(valid_coordinates(&grid->dimension, row, col));
+        assert(valid_seed_bank_grid(grid, row));
+        return grid->seed_bank[row][col] != NULL; // validator [seed_bank_exists]
+}
+
+static inline cats_dt_seeds get_seed_bank_seeds(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col, int32_t year)
+{
+        assert(seed_bank_exists(grid, row, col));
+        assert(year < get_vital_age(grid, VA_SEED_PERSISTENCE));
+        assert(year >= 0);
+        return grid->seed_bank[row][col][year]; // getter [get_seed_bank_seeds]
+}
+
+static inline void set_seed_bank_seeds(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col, int32_t year, cats_dt_seeds seeds)
+{
+        assert(seed_bank_exists(grid, row, col));
+        assert(year < get_vital_age(grid, VA_SEED_PERSISTENCE));
+        assert(seeds >= 0.0f);
+        grid->seed_bank[row][col][year] = seeds; // setter [set_seed_bank_seeds]
+}
+
+
+
+static inline void
+set_produced_seeds(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col, cats_dt_seeds seeds)
+{
+        assert(valid_coordinates(&grid->dimension, row, col));
+        assert(valid_produced_seed_grid(grid, row));
+        assert(seeds >= 0);
+        grid->seeds_produced[row][col] = seeds;  // setter [set_produced_seeds]
+}
+
+static inline void
+increase_produced_seeds(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col, cats_dt_seeds by)
+{
+        assert(valid_coordinates(&grid->dimension, row, col));
+        assert(valid_produced_seed_grid(grid, row));
+        assert(by > 0);
+        grid->seeds_produced[row][col] += by;  // setter [increase_produced_seeds]
+}
+
+
+static inline void
+decrease_produced_seeds(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col, cats_dt_seeds by)
+{
+        assert(valid_coordinates(&grid->dimension, row, col));
+        assert(valid_produced_seed_grid(grid, row));
+        assert(by > 0);
+        grid->seeds_produced[row][col] -= by;  // setter [decrease_produced_seeds]
+        assert(grid->seeds_produced[row][col] >= 0); // setter [decrease_produced_seeds]
 }
 
 
+
 static inline void
 set_suitability(struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col, cats_dt_environment value)
 {
@@ -213,10 +305,11 @@ static inline double get_seed_sum(const struct cats_grid *grid, cats_dt_coord ro
         assert(grid != NULL && grid->juveniles != NULL);
         assert(valid_coordinates(&grid->dimension, row, col));
         const int32_t max_sp = get_vital_age(grid, VA_SEED_PERSISTENCE); //grid->param.seed_persistence;
-        double sum = grid->dispersed_seeds[row][col];
-        if (grid->seed_bank[row][col] == NULL) return sum;
+        double sum = get_dispersed_seeds(grid, row, col);
+
+        if (!seed_bank_exists(grid, row, col)) return sum;
         for (int32_t i = 0; i < max_sp; i++) {
-                sum += grid->seed_bank[row][col][i];
+                sum += get_seed_bank_seeds(grid, row, col, i);
         }
         return sum;
 }
@@ -226,19 +319,16 @@ static inline cats_dt_population_sum
 get_juvenile_sum(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col)
 {
         assert(grid != NULL && grid->juveniles != NULL);
-        assert(valid_coordinates(&grid->dimension, row, col));
-        assert(grid->juveniles[row] != NULL);
+        if (!juveniles_exist(grid, row, col)) return 0;
 
-        const cats_dt_population *juveniles = grid->juveniles[row][col];
-        if (juveniles == NULL) return 0;
+        const cats_dt_population *juveniles = grid->juveniles[row][col];        // getter [get_juvenile_sum]
 
         cats_dt_population_sum juvenile_sum = 0;
-        const int32_t max_stage =
-                get_vital_age(grid, VA_AGE_OF_MATURITY_MAX) + 1; //grid->param.max_age_of_maturity + 1;
+        const int32_t max_stage = get_vital_age(grid, VA_AGE_OF_MATURITY_MAX) + 1;
+
         for (int32_t i = 0; i < max_stage; i++) {
-                juvenile_sum += juveniles[i];
+                juvenile_sum += juveniles[i]; // getter [get_juvenile_sum]
         }
-
         return juvenile_sum;
 }
 

src/cats/inline_overlays.h

@@ -39,7 +39,6 @@ cell_excluded_by_habitat(const struct cats_configuration *config, cats_dt_coord
         return (load_input_2d_array_double(config->overlays.habitat_cc, row, col) == 0.0);
 }
 
-
 static inline bool
 cell_excluded_by_overlay(const struct cats_configuration *config, cats_dt_coord row, cats_dt_coord col)
 {

src/cats/inline_population.h

@@ -35,13 +35,13 @@
 #include "populations/carrying_capacity.h"
 #include "populations/plant_juveniles.h"
 #include "grids/dimensions.h"
+#include "inline_vital_ages.h"
+
 
 static inline bool valid_population_grid(const struct cats_grid *grid, cats_dt_coord row)
 {
-        if (grid == NULL) return false;
-        if (grid->population == NULL) return false;
-        if (grid->population[row] == NULL) return false;       // validator [valid_population_grid]
-        return true;
+        if (grid && grid->population && grid->population[row]) return true; // validator [valid_population_grid]
+        return false;
 }
 
 static inline bool valid_juvenile_grid(const struct cats_grid *grid, cats_dt_coord row)
@@ -53,12 +53,27 @@ static inline bool valid_juvenile_grid(const struct cats_grid *grid, cats_dt_coo
 }
 
 
-static inline cats_dt_population get_juveniles(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col, int year)
+static inline bool juveniles_exist(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col)
 {
-        assert(valid_juvenile_grid(grid, row));
         assert(valid_coordinates(&grid->dimension, row, col));
-        if (grid->juveniles[row][col] == NULL) return 0;
-        return grid->juveniles[row][col][year];
+        assert(valid_juvenile_grid(grid, row));
+        return grid->juveniles[row][col] != NULL; // validator [juveniles_exist]
+}
+
+static inline cats_dt_population get_juveniles(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col, int year)
+{
+        if (juveniles_exist(grid, row, col) == false) return 0;
+        assert(year <  get_vital_age(grid, VA_AGE_OF_MATURITY_MAX) + 1);
+        // FIXME check year
+        return grid->juveniles[row][col][year]; // getter [get_juveniles]
+}
+
+static inline void set_juveniles(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col, int year, cats_dt_population juv)
+{
+        assert(juveniles_exist(grid, row, col));
+        assert(year <  get_vital_age(grid, VA_AGE_OF_MATURITY_MAX) + 1);
+        assert(juv >= 0);
+        grid->juveniles[row][col][year] = juv; // setter [set_juveniles]
 }
 
 

src/cats/misc/debug.c

@@ -30,8 +30,8 @@
 
 static inline cats_dt_population debug_get_juveniles(const struct cats_grid *grid, cats_dt_coord row, cats_dt_coord col, int year)
 {
-        if (grid->juveniles[row][col] == NULL) return 0;
-        return grid->juveniles[row][col][year];
+        if (grid->juveniles[row][col] == NULL) return 0; // debug [debug_get_juveniles]
+        return grid->juveniles[row][col][year]; // debug [debug_get_juveniles]
 }
 
 void
@@ -57,11 +57,11 @@ void debug_seeds(struct cats_grid *grid, const struct cats_configuration *conf,
 {
         if (row == cats_debug.misc_debug_coords.row && col == cats_debug.misc_debug_coords.col) {
                 fprintf(cats_debug.misc_debug_file, "%d,%d,%s,seeds,%f", grid->id, conf->time.year_current, action,
-                        grid->dispersed_seeds[row][col]);  // debug [debug_seeds]
+                        get_dispersed_seeds(grid, row, col));
                 const int32_t seed_persistence = get_vital_age(grid, VA_SEED_PERSISTENCE);
                 for (int32_t i = 0; i < seed_persistence; i++) {
-                        if (grid->seed_bank[row][col]) {  // debug [debug_seeds]
-                                fprintf(cats_debug.misc_debug_file, ",%f", grid->seed_bank[row][col][i]); // debug [debug_seeds]
+                        if (seed_bank_exists(grid, row, col)) {
+                                fprintf(cats_debug.misc_debug_file, ",%f", get_seed_bank_seeds(grid, row, col, i));
                         } else {
                                 fprintf(cats_debug.misc_debug_file, ",%d", 0);
                         }

src/cats/mpi/mpi_save.c

@@ -35,6 +35,7 @@
 #include "memory/cats_memory.h"
 #include "mpi/mpi_grid_helpers.h"
 #include "paths/output_paths.h"
+#include "inline.h"
 
 
 /*
@@ -80,7 +81,7 @@ void *save_seeds0_to_gdal_mpi(struct cats_grid *grid, struct cats_configuration
 
         for (int r = 0; r < grid->dimension.rows; r++) {
                 for (int c = 0; c < grid->dimension.cols; c++) {
-                        seeds0[r * grid->dimension.cols + c] = grid->dispersed_seeds[r][c];
+                        seeds0[r * grid->dimension.cols + c] = get_dispersed_seeds(grid, r, c);
                 }
         }
 

src/cats/mpi/mpi_seeds.c

@@ -29,6 +29,7 @@
 #include "mpi_grid_helpers.h"
 #include "memory/raw_arrays.h"
 #include "mpi_seeds.h"
+#include "inline.h"
 
 
 void send_and_receive_dispersed_seeds_mpi(struct cats_grid *grid, struct cats_configuration *conf)
@@ -143,7 +144,7 @@ void add_seeds0_from_below(const struct cats_configuration *conf, struct cats_gr
 
         for (int r = 0; r < radius; r++) {
                 for (int c = 0; c < cols; c++) {
-                        grid->dispersed_seeds[start_row + r][c] += from_below[r * cols + c];
+                        increase_dispersed_seeds(grid, start_row + r, c, (cats_dt_seeds) from_below[r * cols + c]);
                 }
         }
 }
@@ -159,7 +160,7 @@ void add_seeds0_from_above(const struct cats_configuration *conf, struct cats_gr
 
         for (int r = 0; r < radius; r++) {
                 for (int c = 0; c < cols; c++) {
-                        grid->dispersed_seeds[r][c] += from_above[r * cols + c];
+                        increase_dispersed_seeds(grid, r, c, (cats_dt_seeds) from_above[r * cols + c]);
                 }
         }
 }
\ No newline at end of file

src/cats/plants/inter_period.c

@@ -35,53 +35,63 @@ void inter_period_survival_seeds(struct cats_grid *grid, struct cats_configurati
                                  cats_dt_coord col, struct cats_thread_info *ts)
 {
         // if we have no seeds, we are done
-        if (grid->dispersed_seeds[row][col] == 0.0 && grid->seed_bank[row][col] == NULL) return;
+        cats_dt_seeds disp_seeds = get_dispersed_seeds(grid, row, col);
+        if (disp_seeds == 0.0 && seed_bank_exists(grid, row, col) == false) return;
 
         cats_dt_rates seed_survival_rate;
 
+        bool have_seed_bank = seed_bank_exists(grid, row, col);
 
         const struct cats_vital_rate *rate_link_surv = get_default_vital_rate(grid, VR_SEED_SURVIVAL);
         seed_survival_rate = calculate_rate(rate_link_surv, NAN, &grid->param, grid, row, col, NULL);
 
-        if (grid->dispersed_seeds[row][col] > 0) {
-                cats_dt_seeds dying_0 = poisson_seeds_capped(ts->rng, grid->dispersed_seeds[row][col] *
+        if (disp_seeds > 0) {
+                cats_dt_seeds dying_0 = poisson_seeds_capped(ts->rng, disp_seeds *
                                                                       (1.0 - seed_survival_rate),
-                                                             grid->dispersed_seeds[row][col]);
+                                                             disp_seeds);
 
-                grid->dispersed_seeds[row][col] = grid->dispersed_seeds[row][col] - dying_0;
+                disp_seeds = disp_seeds - dying_0;
+                set_dispersed_seeds(grid, row, col, disp_seeds);
 
-                if (grid->dispersed_seeds[row][col] > 0.0 && grid->seed_bank[row][col] == NULL) {
+
+                if (disp_seeds > 0.0 && have_seed_bank == false) {
                         create_seed_structure(grid, row, col);
                 }
         }
 
-        if (grid->dispersed_seeds[row][col] == 0.0 && grid->seed_bank[row][col] == NULL) return;
+
+        if (disp_seeds == 0.0 && have_seed_bank == false) return;
+
+        if (have_seed_bank == false) create_seed_structure(grid, row, col);
 
         const int32_t seed_persistence = get_vital_age(grid, VA_SEED_PERSISTENCE);
-        for (int32_t stage = 0; stage < seed_persistence - 0; stage++) { // -1
+        for (int32_t stage = 0; stage < seed_persistence; stage++) {
+                cats_dt_seeds seeds_i = get_seed_bank_seeds(grid, row, col, stage);
                 cats_dt_seeds dying = poisson_seeds_capped(ts->rng,
-                                                           grid->seed_bank[row][col][stage] *
+                                                           seeds_i *
                                                            (1.0 - seed_survival_rate),
-                                                           grid->seed_bank[row][col][stage]);
-                grid->seed_bank[row][col][stage] = grid->seed_bank[row][col][stage] - dying;
+                                                           seeds_i);
 
+                set_seed_bank_seeds(grid, row, col, stage, seeds_i - dying);
         }
 
-        for (int32_t k = seed_persistence - 1; k >= 1; k--) { // -2
-                grid->seed_bank[row][col][k] = grid->seed_bank[row][col][k - 1];
+        for (int32_t k = seed_persistence - 1; k >= 1; k--) {
+                cats_dt_seeds s = get_seed_bank_seeds(grid, row, col, k - 1);
+                set_seed_bank_seeds(grid, row, col, k, s);
         }
 
-        grid->seed_bank[row][col][0] = grid->dispersed_seeds[row][col];
-        assert(grid->seed_bank[row][col][0] >= 0.0);
-        grid->dispersed_seeds[row][col] = 0.0f;
+        set_seed_bank_seeds(grid, row, col, 0, get_dispersed_seeds(grid, row, col));
 
+        assert(get_seed_bank_seeds(grid, row, col, 0) >= 0);
+        set_dispersed_seeds(grid, row, col, 0.0f);
 }
 
 
 void inter_period_survival_juveniles(struct cats_grid *grid, struct cats_configuration *conf, cats_dt_coord row,
                                      cats_dt_coord col, struct cats_thread_info *ts)
 {
-        if (grid->juveniles[row][col] == NULL) return;
+        if (juveniles_exist(grid, row, col) == false) return;
+
         const int32_t mat_max = get_vital_age(grid, VA_AGE_OF_MATURITY_MAX);
         const int32_t mat_min = get_vital_age(grid, VA_AGE_OF_MATURITY_MIN);
 
@@ -94,30 +104,34 @@ void inter_period_survival_juveniles(struct cats_grid *grid, struct cats_configu
                 germination_to_adult_survival, &grid->param);
 
         for (int32_t i = 0; i <= mat_max; i++) {
+
                 cats_dt_rates modified_juvenile_transition_rate = age_modified_juvenile_survival_rate(
                         juvenile_transition_rate, i, mat_min, mat_max);
+
                 cats_dt_rates juvenile_mortality = (1.0 - modified_juvenile_transition_rate);
 
                 assert(juvenile_mortality >= 0 && juvenile_mortality <= 1.0);
-                assert(grid->juveniles[row][col][i] >= 0);
+                cats_dt_population juveniles_i = get_juveniles(grid, row, col, i);
+                assert(juveniles_i >= 0);
+
 
                 cats_dt_population dying = poisson_population_capped(ts->rng,
-                                                                     (cats_dt_rates) grid->juveniles[row][col][i] *
+                                                                     (cats_dt_rates) juveniles_i *
                                                                      juvenile_mortality,
-                                                                     grid->juveniles[row][col][i]);
+                                                                     juveniles_i);
+                set_juveniles(grid, row, col, i, juveniles_i - dying);
 
-                grid->juveniles[row][col][i] = grid->juveniles[row][col][i] - dying;
-                assert(grid->juveniles[row][col][i] >= 0);
+                assert(get_juveniles(grid, row, col, i) >= 0);
 
         }
         // advance juvenile stage (after transition rates have been applied)
         for (int32_t stage = mat_max; stage > 0; stage--) {
-                grid->juveniles[row][col][stage] = grid->juveniles[row][col][stage - 1];
+                cats_dt_population juveniles_younger = get_juveniles(grid, row, col, stage - 1);
+                set_juveniles(grid, row, col, stage, juveniles_younger);
         }
 
         // youngest stage now empty
-        grid->juveniles[row][col][0] = 0;
-
+        set_juveniles(grid, row, col, 0, 0);
 }
 
 

src/cats/plants/juveniles.c

@@ -54,21 +54,23 @@ juvenile_adult_transition(struct cats_grid *g, cats_dt_coord row, cats_dt_coord
         // once the cell is full, we stop and juveniles have to wait at least until
         // the next year to have a chance to mature
 
+        // FIXME check max age!
         for (int32_t age = mat_max; age >= mat_min; age--) {
-                cats_dt_population juveniles = g->juveniles[row][col][age];
+                cats_dt_population juveniles = get_juveniles(g, row, col, age);
 
                 if (juveniles == 0) continue;
                 // the cell_maturation rate depends on the age -- the older the juvenile, the higher the probability to mature
                 cats_dt_rates maturation_rate = age_specific_maturation_rate(age, juvenile_survival_rate, mat_min,
                                                                              mat_max);
+
                 cats_dt_population newly_matured = poisson_population_capped(ts->rng, (cats_dt_rates) juveniles *
                                                                                       maturation_rate,
                                                                              juveniles);
 
                 newly_matured = min_population_t(newly_matured, space_left);
+                set_juveniles(g, row, col, age, juveniles - newly_matured);
 
-                g->juveniles[row][col][age] = juveniles - newly_matured;
-                assert(g->juveniles[row][col][age] >= 0);
+                assert(get_juveniles(g, row, col, age) >= 0);
                 newly_matured_sum += newly_matured;
                 space_left -= newly_matured;
 
@@ -100,8 +102,7 @@ cell_maturation(struct cats_grid *grid, struct cats_thread_info *ts, cats_dt_coo
 #else
         if (__builtin_expect(cell_excluded_by_overlay(conf, row, col), false)) { return 0; }
 #endif
-
-        if (grid->juveniles[row][col] == NULL) return 0;
+        if (juveniles_exist(grid, row, col) == false) return 0;
 
         const int32_t mat_max = get_vital_age(grid, VA_AGE_OF_MATURITY_MAX);
         const int32_t mat_min = get_vital_age(grid, VA_AGE_OF_MATURITY_MIN);

src/cats/plants/long_range_dispersal.c

@@ -87,7 +87,7 @@ void disperse_long_range(struct cats_grid *grid)
                                 }
 
                                 // disperse seeds and reduce number of local seeds
-                                grid->dispersed_seeds[trow][tcol] += (cats_dt_seeds) package;
+                                increase_dispersed_seeds(grid, trow, tcol, (cats_dt_seeds) package);
                                 grid->seeds_produced[row][col] -= (cats_dt_seeds) package;
 
                                 // stop if no more seeds are left to distribute