plasma.c

Go to the documentation of this file.

 
#include <stdio.h>
#include <stdlib.h>
#include "ascot5.h"
#include "error.h"
#include "print.h"
#include "plasma.h"
#include "plasma/plasma_1D.h"
#include "plasma/plasma_1DS.h"
#include "consts.h"
 
int plasma_init_offload(plasma_offload_data* offload_data,
                        real** offload_array) {
    int err = 0;
 
    switch(offload_data->type) {
 
        case plasma_type_1D:
            err = plasma_1D_init_offload(&(offload_data->plasma_1D),
                                         offload_array);
            offload_data->offload_array_length =
                offload_data->plasma_1D.offload_array_length;
            break;
 
        case plasma_type_1Dt:
            err = plasma_1Dt_init_offload(&(offload_data->plasma_1Dt),
                                          offload_array);
            offload_data->offload_array_length =
                offload_data->plasma_1Dt.offload_array_length;
            break;
 
        case plasma_type_1DS:
            err = plasma_1DS_init_offload(&(offload_data->plasma_1DS),
                                          offload_array);
            offload_data->offload_array_length =
                offload_data->plasma_1DS.offload_array_length;
            break;
 
        default:
            /* Unregonized input. Produce error. */
            print_err("Error: Unregonized plasma data 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 plasma_free_offload(plasma_offload_data* offload_data,
                            real** offload_array) {
    switch(offload_data->type) {
        case plasma_type_1D:
            plasma_1D_free_offload(
                &(offload_data->plasma_1D), offload_array);
            break;
 
        case plasma_type_1Dt:
            plasma_1Dt_free_offload(
                &(offload_data->plasma_1Dt), offload_array);
            break;
 
        case plasma_type_1DS:
            plasma_1DS_free_offload(
                &(offload_data->plasma_1DS), offload_array);
            break;
    }
}
 
int plasma_init(plasma_data* pls_data, plasma_offload_data* offload_data,
                real* offload_array) {
    int err = 0;
    switch(offload_data->type) {
        case plasma_type_1D:
            plasma_1D_init(&(pls_data->plasma_1D),
                           &(offload_data->plasma_1D), offload_array);
            break;
 
        case plasma_type_1Dt:
            plasma_1Dt_init(&(pls_data->plasma_1Dt),
                            &(offload_data->plasma_1Dt), offload_array);
            break;
 
        case plasma_type_1DS:
            plasma_1DS_init(&(pls_data->plasma_1DS),
                            &(offload_data->plasma_1DS), offload_array);
            break;
 
        default:
            /* Unregonized input. Produce error. */
            print_err("Error: Unregonized plasma data type.");
            err = 1;
            break;
    }
    pls_data->type = offload_data->type;
 
    return err;
}
 
a5err plasma_eval_temp(real* temp, real rho, real r, real phi, real z, real t,
                       int species, plasma_data* pls_data) {
    a5err err = 0;
 
    switch(pls_data->type) {
        case plasma_type_1D:
            err = plasma_1D_eval_temp(temp, rho, species,
                                      &(pls_data->plasma_1D));
            break;
 
        case plasma_type_1Dt:
            err = plasma_1Dt_eval_temp(temp, rho, t, species,
                                       &(pls_data->plasma_1Dt));
            break;
 
        case plasma_type_1DS:
            err = plasma_1DS_eval_temp(temp, rho, species,
                                       &(pls_data->plasma_1DS));
            break;
    }
    if(err) {
        /* In case of error, return some reasonable value to avoid further
           complications */
        temp[0] = 1e20;
    }
 
    return err;
}
 
a5err plasma_eval_dens(real* dens, real rho, real r, real phi, real z, real t,
                       int species, plasma_data* pls_data) {
    a5err err = 0;
 
    switch(pls_data->type) {
        case plasma_type_1D:
            err = plasma_1D_eval_dens(dens, rho, species,
                                      &(pls_data->plasma_1D));
            break;
 
        case plasma_type_1Dt:
            err = plasma_1Dt_eval_dens(dens, rho, t, species,
                                       &(pls_data->plasma_1Dt));
            break;
 
        case plasma_type_1DS:
            err = plasma_1DS_eval_dens(dens, rho, species,
                                       &(pls_data->plasma_1DS));
            break;
    }
 
    if(err) {
        /* In case of error, return some reasonable value to avoid further
           complications */
        dens[0] = 1e20;
    }
    return err;
}
 
a5err plasma_eval_densandtemp(real* dens, real* temp, real rho,
                              real r, real phi, real z, real t,
                              plasma_data* pls_data) {
    a5err err = 0;
 
    switch(pls_data->type) {
        case plasma_type_1D:
            err = plasma_1D_eval_densandtemp(dens, temp,
                                             rho, &(pls_data->plasma_1D));
            break;
 
        case plasma_type_1Dt:
            err = plasma_1Dt_eval_densandtemp(dens, temp,
                                              rho, t, &(pls_data->plasma_1Dt));
            break;
 
        case plasma_type_1DS:
            err = plasma_1DS_eval_densandtemp(dens, temp,
                                              rho, &(pls_data->plasma_1DS));
            break;
 
        default:
            /* Unregonized input. Produce error. */
            err = error_raise( ERR_UNKNOWN_INPUT, __LINE__, EF_PLASMA );
            break;
    }
 
    if(err) {
        /* In case of error, return some reasonable values to avoid further
           complications */
        for(int i=0; i<MAX_SPECIES; i++) {
            dens[i] = 1e20;
            temp[i] = 1e3;
        }
    }
 
    return err;
}
 
int plasma_get_n_species(plasma_data* pls_data) {
    int n = 0;
    switch(pls_data->type) {
        case plasma_type_1D:
            n = pls_data->plasma_1D.n_species;
            break;
 
        case plasma_type_1Dt:
            n = pls_data->plasma_1Dt.n_species;
            break;
 
        case plasma_type_1DS:
            n = pls_data->plasma_1DS.n_species;
            break;
    }
 
    return n;
}
 
const real* plasma_get_species_mass(plasma_data* pls_data) {
    const real* mass = NULL;
    switch(pls_data->type) {
        case plasma_type_1D:
            mass = pls_data->plasma_1D.mass;
            break;
 
        case plasma_type_1Dt:
            mass = pls_data->plasma_1Dt.mass;
            break;
 
        case plasma_type_1DS:
            mass = pls_data->plasma_1DS.mass;
            break;
    }
 
    return mass;
}
 
const real* plasma_get_species_charge(plasma_data* pls_data) {
    const real* charge = NULL;
    switch(pls_data->type) {
        case plasma_type_1D:
            charge = pls_data->plasma_1D.charge;
            break;
 
        case plasma_type_1Dt:
            charge = pls_data->plasma_1Dt.charge;
            break;
 
        case plasma_type_1DS:
            charge = pls_data->plasma_1DS.charge;
            break;
    }
 
    return charge;
}
 
const int* plasma_get_species_znum(plasma_data* pls_data) {
    const int* znum = NULL;
    switch(pls_data->type) {
        case plasma_type_1D:
            znum = pls_data->plasma_1D.znum;
            break;
 
        case plasma_type_1Dt:
            znum = pls_data->plasma_1Dt.znum;
            break;
 
        case plasma_type_1DS:
            znum = pls_data->plasma_1DS.znum;
            break;
    }
 
    return znum;
}
 
const int* plasma_get_species_anum(plasma_data* pls_data) {
    const int* anum = NULL;
    switch(pls_data->type) {
        case plasma_type_1D:
            anum = pls_data->plasma_1D.anum;
            break;
 
        case plasma_type_1Dt:
            anum = pls_data->plasma_1Dt.anum;
            break;
 
        case plasma_type_1DS:
            anum = pls_data->plasma_1DS.anum;
            break;
    }
 
    return anum;
}