B_field.c

Go to the documentation of this file.

 
#include <stdio.h>
#include "ascot5.h"
#include "error.h"
#include "print.h"
#include "B_field.h"
#include "Bfield/B_GS.h"
#include "Bfield/B_2DS.h"
#include "Bfield/B_3DS.h"
#include "Bfield/B_STS.h"
#include "Bfield/B_TC.h"
 
void B_field_free(B_field_data* data) {
    switch(data->type) {
        case B_field_type_GS:
            B_GS_free(&(data->BGS));
            break;
 
        case B_field_type_2DS:
            B_2DS_free(&(data->B2DS));
            break;
 
        case B_field_type_3DS:
            B_3DS_free(&(data->B3DS));
            break;
 
        case B_field_type_STS:
            B_STS_free(&(data->BSTS));
            break;
 
        case B_field_type_TC:
            B_TC_free(&(data->BTC));
            break;
    }
}
 
void B_field_offload(B_field_data* data) {
    switch(data->type) {
        case B_field_type_GS:
            B_GS_offload(&(data->BGS));
            break;
 
        case B_field_type_2DS:
            B_2DS_offload(&(data->B2DS));
            break;
 
        case B_field_type_3DS:
            B_3DS_offload(&(data->B3DS));
            break;
 
        case B_field_type_STS:
            B_STS_offload(&(data->BSTS));
            break;
 
        case B_field_type_TC:
            B_TC_offload(&(data->BTC));
            break;
    }
}
 
a5err B_field_eval_psi(real* psi, real r, real phi, real z, real t,
                      B_field_data* Bdata) {
    a5err err = 0;
 
    switch(Bdata->type) {
        case B_field_type_GS:
            err = B_GS_eval_psi(psi, r, phi, z, &(Bdata->BGS));
            break;
 
        case B_field_type_2DS:
            err = B_2DS_eval_psi(psi, r, phi, z, &(Bdata->B2DS));
            break;
 
        case B_field_type_3DS:
            err = B_3DS_eval_psi(psi, r, phi, z, &(Bdata->B3DS));
            break;
 
        case B_field_type_STS:
            err = B_STS_eval_psi(psi, r, phi, z, &(Bdata->BSTS));
            break;
 
        case B_field_type_TC:
            err = B_TC_eval_psi(psi, r, phi, z, &(Bdata->BTC));
            break;
 
        default:
            /* Unregonized input. Produce error. */
            err = error_raise( ERR_UNKNOWN_INPUT, __LINE__, EF_B_FIELD );
            break;
    }
 
    if(err) {
        /* In case of error, return some reasonable value to avoid further
           complications */
        psi[0] = 1;
    }
 
    return err;
}
 
a5err B_field_eval_psi_dpsi(real psi_dpsi[4], real r, real phi, real z, real t,
                            B_field_data* Bdata) {
    a5err err = 0;
 
    switch(Bdata->type) {
        case B_field_type_GS:
            err = B_GS_eval_psi_dpsi(psi_dpsi, r, phi, z, &(Bdata->BGS));
            break;
 
        case B_field_type_2DS:
            err = B_2DS_eval_psi_dpsi(psi_dpsi, r, phi, z, &(Bdata->B2DS));
            break;
 
        case B_field_type_3DS:
            err = B_3DS_eval_psi_dpsi(psi_dpsi, r, phi, z, &(Bdata->B3DS));
            break;
 
        case B_field_type_STS:
            err = B_STS_eval_psi_dpsi(psi_dpsi, r, phi, z, &(Bdata->BSTS));
            break;
 
        case B_field_type_TC:
            err = B_TC_eval_psi_dpsi(psi_dpsi, r, phi, z, &(Bdata->BTC));
            break;
 
        default:
            /* Unregonized input. Produce error. */
            err = error_raise( ERR_UNKNOWN_INPUT, __LINE__, EF_B_FIELD );
            break;
    }
 
    if(err) {
        /* In case of error, return some reasonable values to avoid further
           complications */
        psi_dpsi[0] = 1;
        for(int k=1; k<4; k++) {psi_dpsi[k] = 0;}
    }
 
    return err;
}
 
a5err B_field_eval_rho(real rho[2], real psi, B_field_data* Bdata) {
    a5err err = 0;
 
    real psi0 = 0.0, psi1 = 1.0;
    switch(Bdata->type) {
        case B_field_type_GS:
            psi0 = Bdata->BGS.psi0;
            psi1 = Bdata->BGS.psi1;
            break;
 
        case B_field_type_2DS:
            psi0 = Bdata->B2DS.psi0;
            psi1 = Bdata->B2DS.psi1;
            break;
 
        case B_field_type_3DS:
            psi0 = Bdata->B3DS.psi0;
            psi1 = Bdata->B3DS.psi1;
            break;
 
        case B_field_type_STS:
            psi0 = Bdata->BSTS.psi0;
            psi1 = Bdata->BSTS.psi1;
            break;
 
        case B_field_type_TC:
            psi0 = Bdata->BTC.psival - Bdata->BTC.rhoval * Bdata->BTC.rhoval;
            psi1 = Bdata->BTC.psival - Bdata->BTC.rhoval * Bdata->BTC.rhoval
                   + 1.0;
            break;
 
        default:
            /* Unregonized input. Produce error. */
            err = error_raise( ERR_UNKNOWN_INPUT, __LINE__, EF_B_FIELD );
            break;
    }
 
    real delta = (psi1 - psi0);
    if( (psi - psi0) / delta < 0 ) {
         err = error_raise( ERR_INPUT_UNPHYSICAL, __LINE__, EF_B_FIELD );
    } else {
        rho[0] = sqrt( (psi - psi0) / delta );
        rho[1] = 1.0 / (2*delta*rho[0]);
    }
 
    if(err) {
        /* In case of error, return some reasonable value to avoid further
           complications */
        rho[0] = 1;
        rho[1] = 0;
    }
 
    return err;
}
 
a5err B_field_eval_rho_drho(real rho_drho[4], real r, real phi, real z,
                            B_field_data* Bdata) {
    a5err err = 0;
 
    switch(Bdata->type) {
        case B_field_type_GS:
            err = B_GS_eval_rho_drho(rho_drho, r, phi, z, &(Bdata->BGS));
            break;
 
        case B_field_type_2DS:
            err = B_2DS_eval_rho_drho(rho_drho, r, phi, z, &(Bdata->B2DS));
            break;
 
        case B_field_type_3DS:
            err = B_3DS_eval_rho_drho(rho_drho, r, phi, z, &(Bdata->B3DS));
            break;
 
        case B_field_type_STS:
            err = B_STS_eval_rho_drho(rho_drho, r, phi, z, &(Bdata->BSTS));
            break;
 
        case B_field_type_TC:
            err = B_TC_eval_rho_drho(rho_drho, r, phi, z, &(Bdata->BTC));
            break;
 
        default:
            /* Unregonized input. Produce error. */
            err = error_raise( ERR_UNKNOWN_INPUT, __LINE__, EF_B_FIELD );
            break;
    }
 
    if(err) {
        /* In case of error, return some reasonable values to avoid further
           complications */
        rho_drho[0] = 1;
        for(int k=1; k<4; k++) {rho_drho[k] = 0;}
    }
 
    return err;
}
 
a5err B_field_eval_B(real B[3], real r, real phi, real z, real t,
                     B_field_data* Bdata) {
    a5err err = 0;
 
    switch(Bdata->type) {
        case B_field_type_GS:
            err = B_GS_eval_B(B, r, phi, z, &(Bdata->BGS));
            break;
 
        case B_field_type_2DS:
            err = B_2DS_eval_B(B, r, phi, z, &(Bdata->B2DS));
            break;
 
        case B_field_type_3DS:
            err = B_3DS_eval_B(B, r, phi, z, &(Bdata->B3DS));
            break;
 
        case B_field_type_STS:
            err = B_STS_eval_B(B, r, phi, z, &(Bdata->BSTS));
            break;
 
        case B_field_type_TC:
            err = B_TC_eval_B(B, r, phi, z, &(Bdata->BTC));
            break;
 
        default:
            /* Unregonized input. Produce error. */
            err = error_raise( ERR_UNKNOWN_INPUT, __LINE__, EF_B_FIELD );
            break;
    }
 
    if(err) {
        /* In case of error, return some reasonable values to avoid further
           complications */
        B[0] = 1;
        for(int k=1; k<3; k++) {B[k] = 0;}
    }
 
    return err;
}
 
a5err B_field_eval_B_dB(real B_dB[15], real r, real phi, real z, real t,
                        B_field_data* Bdata) {
    a5err err = 0;
 
    switch(Bdata->type) {
        case B_field_type_GS:
            err = B_GS_eval_B_dB(B_dB, r, phi, z, &(Bdata->BGS));
            break;
 
        case B_field_type_2DS:
            err = B_2DS_eval_B_dB(B_dB, r, phi, z, &(Bdata->B2DS));
            break;
 
        case B_field_type_3DS:
            err = B_3DS_eval_B_dB(B_dB, r, phi, z, &(Bdata->B3DS));
            break;
 
        case B_field_type_STS:
            err = B_STS_eval_B_dB(B_dB, r, phi, z, &(Bdata->BSTS));
            break;
 
        case B_field_type_TC:
            err = B_TC_eval_B_dB(B_dB, r, phi, z, &(Bdata->BTC));
            break;
 
        default:
            /* Unregonized input. Produce error. */
            err = error_raise( ERR_UNKNOWN_INPUT, __LINE__, EF_B_FIELD );
            break;
    }
 
    if(err) {
        /* In case of error, return some reasonable values to avoid further
           complications */
        B_dB[0] = 1;
        for(int k=1; k<12; k++) {B_dB[k] = 0;}
    }
 
    return err;
}
 
a5err B_field_get_axis_rz(real rz[2], B_field_data* Bdata, real phi) {
    a5err err = 0;
 
    switch(Bdata->type) {
        case B_field_type_GS:
            err = B_GS_get_axis_rz(rz, &(Bdata->BGS));
            break;
 
        case B_field_type_2DS:
            err = B_2DS_get_axis_rz(rz, &(Bdata->B2DS));
            break;
 
        case B_field_type_3DS:
            err = B_3DS_get_axis_rz(rz, &(Bdata->B3DS));
            break;
 
        case B_field_type_STS:
            err = B_STS_get_axis_rz(rz, &(Bdata->BSTS), phi);
            break;
 
        case B_field_type_TC:
            err = B_TC_get_axis_rz(rz, &(Bdata->BTC));
            break;
 
        default:
            /* Unregonized input. Produce error. */
            err = error_raise( ERR_UNKNOWN_INPUT, __LINE__, EF_B_FIELD );
            break;
    }
 
    if(err) {
      /* In case of error, return some reasonable values to avoid further
         complications */
      rz[0] = 1.0;
      rz[1] = 0.0;
    }
 
    return err;
}