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"

void plasma_free(plasma_data* data) {
    switch(data->type) {
        case plasma_type_1D:
            plasma_1D_free(&data->plasma_1D);
            break;
        case plasma_type_1Dt:
            plasma_1Dt_free(&data->plasma_1Dt);
            break;
        case plasma_type_1DS:
            plasma_1DS_free(&data->plasma_1DS);
            break;
    }
}

void plasma_offload(plasma_data* data) {
    switch(data->type) {
        case plasma_type_1D:
            plasma_1D_offload(&data->plasma_1D);
            break;
        case plasma_type_1Dt:
            plasma_1Dt_offload(&data->plasma_1Dt);
            break;
        case plasma_type_1DS:
            plasma_1DS_offload(&data->plasma_1DS);
            break;
    }
}

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;
}

a5err plasma_eval_flow(
    real* vflow, 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_flow(
                vflow, rho, r, &(pls_data->plasma_1D));
            break;
 
        case plasma_type_1DS:
            err = plasma_1DS_eval_flow(
                vflow, rho, r, &(pls_data->plasma_1DS));
            break;
 
        case plasma_type_1Dt:
            err = plasma_1Dt_eval_flow(
                vflow, rho, t, r, &(pls_data->plasma_1Dt));
            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 */
        *vflow = 0;
    }
 
    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;
}