butterfly_actions.c

#include "actions/cats_actions.h"
#include "actions/setup_actions.h"
#include "modules/module_header.h"
#include "butterfly_actions.h"
#include "module.h"
#include "butterflies_main.h"
#include "inline_overlays.h"
#include "butterflies_populations.h"
#include "inline_population.h"
#include "random_walk.h"
#include "butterflies_inline.h"


enum action_status action_butterfly_stats_reset(struct cats_grid *grid, struct cats_configuration *conf)
{
        return ACTION_RUN;
}


void grid_butterflies_maturation(struct cats_grid *grid, struct cats_thread_info *ts)
{
        struct cats_configuration *conf = ts->conf;
        const cats_dt_coord start_row = ts->area.start_row;
        const cats_dt_coord end_row = ts->area.end_row;

        const cats_dt_coord start_col = ts->area.start_col;
        const cats_dt_coord end_col = ts->area.end_col;



        for (cats_dt_coord row = start_row; row < end_row; row++) {
                for (cats_dt_coord col = start_col; col < end_col; col++) {

                        if (cell_excluded_by_overlay(conf, row, col)
                            || cell_excluded_by_generation(grid, row, col)) {
                                continue;
                        }

                        butterflies_cell_maturation(grid, ts, row, col, false);
                }
        }
}


void grid_butterflies_dispersal(struct cats_grid *grid, struct cats_thread_info *ts)
{
        struct cats_configuration *conf = ts->conf;
        const cats_dt_coord start_row = ts->area.start_row;
        const cats_dt_coord end_row = ts->area.end_row;

        const cats_dt_coord start_col = ts->area.start_col;
        const cats_dt_coord end_col = ts->area.end_col;

        struct conf_data_butterflies *module_conf = CATS_MODULE_DATA;
        const int module_id = CATS_MODULE_ID;
        struct grid_data_butterflies *data = grid->grid_modules[module_id].module_data;


        for (cats_dt_coord row = start_row; row < end_row; row++) {
                for (cats_dt_coord col = start_col; col < end_col; col++) {

                        if (cell_excluded_by_overlay(conf, row, col)
                            || data->generation_current > (int32_t) ceilf(data->generations[row][col])) {
                                continue;
                        }

                        butterflies_random_walk()
                }
        }
}


void grid_butterflies_kill_adults(struct cats_grid *grid, struct cats_thread_info *ts)
{
        const cats_dt_coord start_row = ts->area.start_row;
        const cats_dt_coord end_row = ts->area.end_row;

        const cats_dt_coord start_col = ts->area.start_col;
        const cats_dt_coord end_col = ts->area.end_col;

        for (cats_dt_coord row = start_row; row < end_row; row++) {
                for (cats_dt_coord col = start_col; col < end_col; col++) {
                        set_population_ignore_cc(grid, row, col, 0);
                }
        }
}


enum action_status action_butterflies_maturation(struct cats_grid *grid, struct cats_configuration *conf)
{
        threaded_action(&grid_butterflies_maturation, grid, conf, TS_DEFAULT);

        return ACTION_RUN;
}


enum action_status action_butterflies_kill_adults(struct cats_grid *grid, struct cats_configuration *conf)
{
        threaded_action(&grid_butterflies_kill_adults, grid, conf, TS_DEFAULT);

        return ACTION_RUN;
}


enum action_status action_butterflies_dispersal(struct cats_grid *grid, struct cats_configuration *conf)
{
        return ACTION_RUN;
}


enum action_status action_butterflies_output(struct cats_grid *grid, struct cats_configuration *conf)
{
        return ACTION_RUN;
}


enum action_status action_butterfly_stats_gather(struct cats_grid *grid, struct cats_configuration *conf)
{
        return ACTION_RUN;
}


enum action_status action_butterfly_stats_write(struct cats_grid *grid, struct cats_configuration *conf)
{
        return ACTION_RUN;
}


void grid_update_generations(struct cats_grid *grid, struct cats_thread_info *ts)
{
        struct cats_configuration *conf = ts->conf;


        struct conf_data_butterflies *module_conf = CATS_MODULE_DATA;
        int module_id = CATS_MODULE_ID;
        struct grid_data_butterflies *data = grid->grid_modules[module_id].module_data;
        struct cats_vital_rate *rate = &module_conf->butterfly_generations;

        const cats_dt_coord start_row = ts->area.start_row;
        const cats_dt_coord end_row = ts->area.end_row;

        const cats_dt_coord start_col = ts->area.start_col;
        const cats_dt_coord end_col = ts->area.end_col;
        for (cats_dt_coord row = start_row; row < end_row; row++) {
                for (cats_dt_coord col = start_col; col < end_col; col++) {

                        if (cell_excluded_by_overlay(conf, row, col)) {
                                data->generations[row][col] = 0.0f;
                                continue;
                        }
                        cats_dt_rates gen = calculate_rate(rate, 0, conf->param, grid, row, col, NULL);
                        data->generations[row][col] = (float) gen;
                        //printf("GENERATIONS::thread %03d:: %d %d %f\n", ts->id ,row, col, (float) gen);
                }
        }
}


enum action_status action_butterfly_update_generations(struct cats_grid *grid, struct cats_configuration *conf)
{
        struct conf_data_butterflies *data = CATS_MODULE_DATA;
        threaded_action(&grid_update_generations, grid, conf, TS_DEFAULT);
        return ACTION_RUN;
}


enum action_status action_update_generation(struct cats_grid *grid, struct cats_configuration *conf)
{
        struct conf_data_butterflies *data = CATS_MODULE_DATA;
        return ACTION_RUN;
}


void add_butterfly_generation_action(struct cats_configuration *conf, action_function function, const char *name,
                                     int generation)
{
        char *result = NULL;
        int rc = asprintf(&result, "%s (generation %d)", name, generation);
        asprintf_check(rc);
        append_action(conf, function, ALL_STAGES, result, module_name);
        free(result);
}


void add_actions(struct cats_configuration *conf)
{
        struct conf_data_butterflies *data = CATS_MODULE_DATA;
        printf("MAXIMUM GENERATIONS %d\n", data->generations_max);

        register_action_function(conf, action_butterfly_stats_reset, "butterfly_action_reset_stats",
                                 "resetting butterfly statistics");
        register_action_function(conf, action_butterfly_update_generations, "butterfly_action_update_generations",
                                 "update generations");
        register_action_function(conf, action_butterflies_maturation, "butterfly_action_egg_to_adult",
                                 "transition eggs to adults");

        register_action_function(conf, action_butterflies_dispersal, "butterfly_action_dispersal", "egg dispersal");
        register_action_function(conf, action_butterflies_kill_adults, "butterfly_kill_adults", "kill adults");
        list_actions_full(conf);


        append_action(conf, action_butterfly_stats_reset, ALL_STAGES, "resetting butterfly statistics", module_name);
        append_action_by_name(conf, "action_load_environments", ALL_STAGES, "environment update", module_name);
        append_action_by_name(conf, "action_overlay_update", ALL_STAGES, "overlay update", module_name);
        append_action(conf, action_butterfly_update_generations, ALL_STAGES, "update generations", module_name);
        for (int32_t generation = data->generations_max; generation > 0; generation--) {
                add_butterfly_generation_action(conf, action_update_generation, "update generation", generation);
                add_butterfly_generation_action(conf, action_butterflies_maturation, "transition eggs to adults",
                                                generation);
                add_butterfly_generation_action(conf, action_butterflies_dispersal, "dispersal", generation);
                add_butterfly_generation_action(conf, action_butterflies_kill_adults, "kill adults", generation);
        }

}