mhd.c

Go to the documentation of this file.

 
#include <stdlib.h>
#include "ascot5.h"
#include "error.h"
#include "print.h"
#include "mhd.h"
#include "B_field.h"
#include "boozer.h"
#include "mhd/mhd_stat.h"
#include "mhd/mhd_nonstat.h"
 
int mhd_init_offload(mhd_offload_data* offload_data,
                     real** offload_array) {
    int err = 0;
 
    switch(offload_data->type) {
 
        case mhd_type_stat:
            err = mhd_stat_init_offload(&(offload_data->stat), offload_array);
            offload_data->offload_array_length =
                offload_data->stat.offload_array_length;
            break;
 
        case mhd_type_nonstat:
            err = mhd_nonstat_init_offload(&(offload_data->nonstat),
                                           offload_array);
            offload_data->offload_array_length =
                offload_data->nonstat.offload_array_length;
            break;
 
        default:
            /* Unregonized input. Produce error. */
            print_err("Error: Unregonized MHD 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 mhd_free_offload(mhd_offload_data* offload_data,
                      real** offload_array) {
    switch(offload_data->type) {
 
        case mhd_type_stat:
            mhd_stat_free_offload(&(offload_data->stat), offload_array);
            break;
 
        case mhd_type_nonstat:
            mhd_nonstat_free_offload(&(offload_data->nonstat), offload_array);
            break;
    }
}
 
int mhd_init(mhd_data* mhddata, mhd_offload_data* offload_data,
             real* offload_array) {
    int err = 0;
 
    switch(offload_data->type) {
 
        case mhd_type_stat:
            mhd_stat_init(&(mhddata->stat), &(offload_data->stat),
                          offload_array);
            break;
 
        case mhd_type_nonstat:
            mhd_nonstat_init(&(mhddata->nonstat), &(offload_data->nonstat),
                             offload_array);
            break;
 
        default:
            /* Unregonized input. Produce error. */
            print_err("Error: Unregonized electric field type.\n");
            err = 1;
            break;
    }
    mhddata->type = offload_data->type;
 
    return err;
}
 
a5err mhd_eval(real mhd_dmhd[10], real r, real phi, real z, real t,
               int includemode, boozer_data* boozerdata, mhd_data* mhddata,
               B_field_data* Bdata) {
    a5err err = 0;
 
    switch(mhddata->type) {
 
        case mhd_type_stat:
            err = mhd_stat_eval(mhd_dmhd, r, phi, z, t, includemode,
                                boozerdata, &(mhddata->stat), Bdata);
            break;
 
        case mhd_type_nonstat:
            err = mhd_nonstat_eval(mhd_dmhd, r, phi, z, t, includemode,
                                   boozerdata, &(mhddata->nonstat), Bdata);
            break;
 
        default:
            /* Unregonized input. Produce error. */
            err = error_raise( ERR_UNKNOWN_INPUT, __LINE__, EF_MHD );
            break;
    }
 
    return err;
}
 
a5err mhd_perturbations(real pert_field[7], real r, real phi, real z,
                        real t, int pertonly, int includemode,
                        boozer_data* boozerdata, mhd_data* mhddata,
                        B_field_data* Bdata) {
    a5err err = 0;
 
    switch(mhddata->type) {
 
        case mhd_type_stat:
            err =  mhd_stat_perturbations(pert_field, r, phi, z, t, pertonly,
                                          includemode, boozerdata,
                                          &(mhddata->stat), Bdata);
            break;
 
        case mhd_type_nonstat:
            err =  mhd_nonstat_perturbations(pert_field, r, phi, z, t, pertonly,
                                             includemode, boozerdata,
                                             &(mhddata->nonstat), Bdata);
            break;
 
        default:
            /* Unregonized input. Produce error. */
            err = error_raise( ERR_UNKNOWN_INPUT, __LINE__, EF_MHD );
            break;
    }
 
    return err;
}
 
int mhd_get_n_modes(mhd_data* mhddata) {
    int val = 0;
    switch(mhddata->type) {
        case mhd_type_stat:
            val = mhddata->stat.n_modes;
            break;
        case mhd_type_nonstat:
            val = mhddata->nonstat.n_modes;
            break;
    }
    return val;
}
 
const int* mhd_get_nmode(mhd_data* mhddata) {
    const int* val = NULL;
    switch(mhddata->type) {
        case mhd_type_stat:
            val = mhddata->stat.nmode;
            break;
        case mhd_type_nonstat:
            val = mhddata->nonstat.nmode;
            break;
    }
    return val;
}
 
const int* mhd_get_mmode(mhd_data* mhddata) {
    const int* val = NULL;
    switch(mhddata->type) {
        case mhd_type_stat:
            val = mhddata->stat.mmode;
            break;
        case mhd_type_nonstat:
            val = mhddata->nonstat.mmode;
            break;
    }
    return val;
}
 
const real* mhd_get_amplitude(mhd_data* mhddata) {
    const real* val = NULL;
    switch(mhddata->type) {
        case mhd_type_stat:
            val = mhddata->stat.amplitude_nm;
            break;
        case mhd_type_nonstat:
            val = mhddata->nonstat.amplitude_nm;
            break;
    }
    return val;
}
 
const real* mhd_get_frequency(mhd_data* mhddata) {
    const real* val = NULL;
    switch(mhddata->type) {
        case mhd_type_stat:
            val = mhddata->stat.omega_nm;
            break;
        case mhd_type_nonstat:
            val = mhddata->nonstat.omega_nm;
            break;
    }
    return val;
}
 
const real* mhd_get_phase(mhd_data* mhddata) {
    const real* val = NULL;
    switch(mhddata->type) {
        case mhd_type_stat:
            val = mhddata->stat.phase_nm;
            break;
        case mhd_type_nonstat:
            val = mhddata->nonstat.phase_nm;
            break;
    }
    return val;
}