CMakeLists.txt

@@ -11,7 +11,6 @@ if ("${CMAKE_C_COMPILER_ID}" MATCHES "Clang" OR "${CMAKE_C_COMPILER_ID}" STREQUA
             -Wall
             -Werror
             -O3
-            -g
             -D_GNU_SOURCE
             -DHAVE_INLINE
             -DGSL_C99_INLINE

src/cats/CMakeLists.txt

@@ -39,7 +39,7 @@ include_directories(${GDAL_INCLUDE_DIR})
 include_directories(${GSL_INCLUDE_DIR})
 include_directories(${MPI_C_INCLUDE_PATH})
 
-add_library(libcats STATIC "" stats/statistics.c stats/statistics.h data/cats_global.c ../cats_windows.h test/test_ini.c test/test_ini.h debug/debug_vital_rates.c debug/debug_vital_rates.h overlays/overlay_resources.c overlays/overlay_resources.h paths/path_patterns.c paths/path_patterns.h)
+add_library(libcats STATIC "" stats/statistics.c stats/statistics.h data/cats_global.c ../cats_windows.h test/test_ini.c test/test_ini.h debug/debug_vital_rates.c debug/debug_vital_rates.h overlays/overlay_resources.c overlays/overlay_resources.h paths/path_patterns.c paths/path_patterns.h grids/dimensions.c grids/dimensions.h grids/direct_access.c grids/direct_access.h)
 target_include_directories(libcats PUBLIC ".")
 
 target_sources(libcats PRIVATE

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/actions/setup.c

@@ -37,6 +37,7 @@
 #include "temporal/simulation_time.h"
 #include "populations/population.h"
 #include "dispersal/dispersal.h"
+#include "inline.h"
 
 
 void setup_lambda_test_simulation(struct cats_configuration *conf, struct cats_grid *grid) // FIXME MAYBE MOVE
@@ -55,7 +56,7 @@ void setup_lambda_test_simulation(struct cats_configuration *conf, struct cats_g
         cats_dt_coord row = 0;
         cats_dt_coord col = 0;
 
-        grid->suitability->environments[0]->current.values[row][col] = (cats_dt_environment) grid->param.OT; // FIXME -> set suitability
+        set_suitability(grid, row, col,  (cats_dt_environment) grid->param.OT);
 
         cats_dt_population target_pop = get_adult_carrying_capacity(grid, row, col) / 5;
         set_population_ignore_cc(grid, row, col, target_pop);
@@ -94,7 +95,8 @@ void setup_lambda_gradient_simulation(struct cats_configuration *conf, struct ca
         cats_dt_environment diff = 1.0f / ((cats_dt_environment) conf->geometry.dimension.cols - 1.0f);
         for (cats_dt_coord row = 0; row < rows; row++) {
                 for (cats_dt_coord col = 0; col < cols; col++) {
-                        grid->suitability->environments[0]->current.values[row][col] = (cats_dt_environment) col * diff;
+                        cats_dt_environment  value = (cats_dt_environment) col * diff;
+                        set_suitability(grid, row, col, value);
                 }
         }
 

src/cats/configuration/check_configuration.c

@@ -32,6 +32,7 @@
 #include "inline_vital_rates.h"
 #include "dispersal/dispersal.h"
 #include "data/simulation_geometry.h"
+#include "inline_vital_ages.h"
 
 
 int check_string(char *value, char *name)

src/cats/configuration/configuration.c

@@ -48,6 +48,7 @@
 #include "inline_vital_rates.h"
 #include "dispersal/dispersal.h"
 #include "stats/grid_stats.h"
+#include "inline_vital_ages.h"
 
 #ifdef CATS_ON_WINDOWS
 #include <windows.h>

src/cats/configuration/preset.c

@@ -21,11 +21,14 @@
  *
  */
 
+#include <string.h>
 #include "cats_global.h"
 #include "preset.h"
 #include "vital_ages/default_vital_ages.h"
 #include "vital_rates/default_vital_rates.h"
 #include "inline_vital_rates.h"
+#include "inline_vital_ages.h"
+#include "misc/cats_maths_inline.h"
 
 
 enum cats_species_preset get_species_preset_from_from_string(const char *string)

src/cats/configuration/print_configuration.c

@@ -33,6 +33,7 @@
 #include "inline_vital_rates.h"
 #include "dispersal/dispersal.h"
 #include "modules/load_module.h"
+#include "inline_vital_ages.h"
 
 const char *get_dispersal_name(enum dispersal_type type);
 

src/cats/debug/debug_vital_rates.c

@@ -90,7 +90,7 @@ struct cats_grid *minimal_grid(struct cats_configuration *conf, struct cats_envi
 }
 
 
-void set_suitability(struct cats_environment *env, cats_dt_environment suit)
+void debug_set_suitability(struct cats_environment *env, cats_dt_environment suit)
 {
         env->environments[0]->current.values[0][0] = suit;
 }
@@ -138,7 +138,7 @@ static inline cats_dt_rates attempt_rate_calculation(cats_dt_environment suit, c
         }
 
 
-        set_suitability(grid->suitability, suit);
+        debug_set_suitability(grid->suitability, suit);
         *K_suit = get_adult_carrying_capacity(grid, 0, 0);
         if (N > *K_suit) return NAN;
 
@@ -209,7 +209,7 @@ void debug_vital_rate(struct cats_vital_rate *vr, struct cats_vital_rate *cc, st
 void debug_vital_rates(struct cats_configuration *conf, const struct program_options *command_line_options)
 {
         struct cats_environment *env = minimal_suitability_environment();
-        set_suitability(env, 0.5f);
+        debug_set_suitability(env, 0.5f);
         struct cats_grid *grid = minimal_grid(conf, env);
         struct cats_species_param *param = &grid->param;
         set_param_values(param, 0.5, 0.25, 0.5);

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

@@ -38,6 +38,7 @@
 #include "environment.h"
 #include "grids/gdal_load.h"
 #include "environment/environment_rasters.h"
+#include "grids/dimensions.h"
 
 #ifdef USEMPI
 #include "mpi/mpi_save.h"
@@ -69,10 +70,11 @@ 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;
 
-        if (environment->start.dimension.rows != environment->end.dimension.rows
-            || environment->start.dimension.cols != environment->end.dimension.cols
-            || environment->start.dimension.rows != environment->current.dimension.rows
-            || environment->start.dimension.cols != environment->current.dimension.cols) {
+        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__);
                 log_message(LOG_ERROR, "environment (start):   %d x %d", environment->start.dimension.rows,
                             environment->start.dimension.cols);
@@ -149,8 +151,9 @@ load_environment_raster(struct cats_configuration *conf, struct cats_environment
         }
 
         unload_environment_raster(raster);
-        raster->dimension.rows = conf->geometry.dimension.rows;
-        raster->dimension.cols = conf->geometry.dimension.cols;
+
+        copy_cats_dimensions(&conf->geometry.dimension, &raster->dimension);
+
         raster->interpolation_type = type;
         raster->environment_type = environment_type;
         if (raster->values == NULL) {

src/cats/environment/environment_rasters.c

@@ -27,6 +27,7 @@
 #include "logging.h"
 #include "environment_rasters.h"
 #include "environment.h"
+#include "grids/dimensions.h"
 
 
 void print_raster_quick_info(struct cats_environment_raster *gr)
@@ -53,9 +54,8 @@ void create_raster_if_needed(struct cats_configuration *conf, struct cats_enviro
         log_message(LOG_INFO, "\tinitializing empty grid for <%s>", get_raster_type_name_specific(raster));
         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));
-        raster->dimension.rows = conf->geometry.dimension.rows;
-        raster->dimension.cols = conf->geometry.dimension.cols;
 
+        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_cats_dimensions(const struct cats_dimension *source, struct cats_dimension *destination)
+{
+        assert(source != NULL);
+        assert(destination != NULL);
+        destination->rows = source->rows;
+        destination->cols = source->cols;
+}
+
+
+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;
+        return false;
+}
\ No newline at end of file

src/cats/grids/dimensions.h

+#ifndef CATS_DIMENSIONS_H
+#define CATS_DIMENSIONS_H
+
+#include "memory/arrays.h"
+#include "assert.h"
+
+
+static inline bool valid_coordinates(const struct cats_dimension *dim, cats_dt_coord row, cats_dt_coord col)
+{
+        assert(dim != NULL);
+        if (row < 0 || col < 0) return false;
+        if (row >= dim->rows || col >= dim->cols) return false;
+        return true;
+}
+
+
+void copy_cats_dimensions(const struct cats_dimension *source, struct cats_dimension *destination);
+
+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);
+
+#endif //CATS_DIMENSIONS_H

src/cats/grids/direct_access.c

+#include <assert.h>
+#include "direct_access.h"
+#include "dimensions.h"
+
+
+double load_input_2d_array_double(const struct cats_2d_array_double *raster, cats_dt_coord row, cats_dt_coord col)
+{
+        valid_coordinates(&raster->dimension, row, col);
+        return raster->data[row][col];  // getter [load_input2d_array_double]
+}
+
+char load_input_2d_array_char(const struct cats_2d_array_char *raster, cats_dt_coord row, cats_dt_coord col)
+{
+        valid_coordinates(&raster->dimension, row, col);
+        return raster->data[row][col];  // getter [load_input_2d_array_char]
+}
+
+cats_dt_environment load_input_environment_raster(struct cats_environment_raster *raster, cats_dt_coord row, cats_dt_coord col)
+{
+        valid_coordinates(&raster->dimension, row, col);
+        return raster->values[row][col];  // getter [load_input_environment_raster]
+}
+
+void set_input_environment_raster(struct cats_environment_raster *raster, cats_dt_coord row, cats_dt_coord col, cats_dt_environment value)
+{
+        valid_coordinates(&raster->dimension, row, col);
+        raster->values[row][col] = value;  // getter [set_input_environment_raster]
+}
\ No newline at end of file

src/cats/grids/direct_access.h

+#ifndef CATS_DIRECT_ACCESS_H
+#define CATS_DIRECT_ACCESS_H
+#include "memory/arrays.h"
+#include "environment/environment.h"
+
+double load_input_2d_array_double(const struct cats_2d_array_double *raster, cats_dt_coord row, cats_dt_coord col);
+cats_dt_environment load_input_environment_raster(struct cats_environment_raster *raster, cats_dt_coord row, cats_dt_coord col);
+void set_input_environment_raster(struct cats_environment_raster *raster, cats_dt_coord row, cats_dt_coord col, cats_dt_environment value);
+char load_input_2d_array_char(const struct cats_2d_array_char *raster, cats_dt_coord row, cats_dt_coord col);
+#endif //CATS_DIRECT_ACCESS_H

src/cats/grids/gdal_save.c

@@ -132,7 +132,7 @@ void *save_dispersed_seeds_to_gdal(struct cats_grid *grid, struct cats_configura
         const int32_t cols = grid->dimension.cols;
         for (cats_dt_coord row = 0; row < rows; row++) {
                 for (cats_dt_coord col = 0; col < cols; col++) {
-                        seeds[row][col] = grid->dispersed_seeds[row][col];
+                        seeds[row][col] = get_dispersed_seeds(grid, row, col);
                 }
         }
 
@@ -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};