wall.c

Go to the documentation of this file.

 
#include <stdio.h>
#include <math.h>
#include "ascot5.h"
#include "print.h"
#include "wall.h"
#include "wall/wall_2d.h"
#include "wall/wall_3d.h"
 
int wall_init_offload(wall_offload_data* offload_data, real** offload_array,
                      int** int_offload_array) {
 
    int err = 0;
 
    switch(offload_data->type) {
 
        case wall_type_2D:
            err = wall_2d_init_offload(&(offload_data->w2d), offload_array);
            offload_data->offload_array_length =
                offload_data->w2d.offload_array_length;
            offload_data->int_offload_array_length = 0;
            break;
 
        case wall_type_3D:
            err = wall_3d_init_offload(&(offload_data->w3d), offload_array,
                                       int_offload_array);
            offload_data->offload_array_length =
                offload_data->w3d.offload_array_length;
            offload_data->int_offload_array_length =
                offload_data->w3d.int_offload_array_length;
            break;
 
        default:
            /* Unregonized input. Produce error. */
            print_err("Error: Unregonized electric field type.");
            err = 1;
            break;
    }
    if(!err) {
        print_out(VERBOSE_IO, "Estimated memory usage %.1f MB\n",
                  offload_data->offload_array_length
                  * sizeof(real) / (1024.0*1024.0) );
    }
 
    return err;
}
 
void wall_free_offload(wall_offload_data* offload_data, real** offload_array,
                       int** int_offload_array) {
    switch(offload_data->type) {
        case wall_type_2D:
            wall_2d_free_offload(&(offload_data->w2d), offload_array);
            break;
 
        case wall_type_3D:
            wall_3d_free_offload(&(offload_data->w3d), offload_array,
                                 int_offload_array);
            break;
    }
}
 
int wall_init(wall_data* w, wall_offload_data* offload_data,
              real* offload_array, int* int_offload_array) {
    int err = 0;
    switch(offload_data->type) {
        case wall_type_2D:
            wall_2d_init(&(w->w2d), &(offload_data->w2d), offload_array);
            break;
 
        case wall_type_3D:
            wall_3d_init(&(w->w3d), &(offload_data->w3d), offload_array,
                         int_offload_array);
            break;
        default:
            /* Unregonized input. Produce error. */
            err = 1;
            break;
    }
    w->type = offload_data->type;
 
    return err;
}
 
int wall_hit_wall(real r1, real phi1, real z1, real r2, real phi2, real z2,
                  wall_data* w, real* w_coll) {
    int ret = 0;
    switch(w->type) {
        case wall_type_2D:
            ret = wall_2d_hit_wall(r1, phi1, z1, r2, phi2, z2, &(w->w2d),
                                   w_coll);
            break;
 
        case wall_type_3D:
            ret = wall_3d_hit_wall(r1, phi1, z1, r2, phi2, z2, &(w->w3d),
                                   w_coll);
            break;
    }
    return ret;
}
 
int wall_get_n_elements(wall_data* w) {
    int ret = 0;
    switch(w->type) {
        case wall_type_2D:
            ret = w->w2d.n;
            break;
 
        case wall_type_3D:
            ret = w->w3d.n;
            break;
    }
    return ret;
}