asigma.c

Go to the documentation of this file.

 
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "ascot5.h"
#include "print.h"
#include "error.h"
#include "math.h"
#include "asigma.h"
#include "asigma/asigma_loc.h"
#include "consts.h"
 
#pragma omp declare target
static int ASIGMA_EXTRAPOLATE = 0;
#pragma omp end declare target
 
void asigma_extrapolate(int extrapolate) {
    ASIGMA_EXTRAPOLATE = extrapolate;
}
 
int asigma_init_offload(asigma_offload_data* offload_data,
                        real** offload_array) {
    int err = 0;
 
    switch(offload_data->type) {
 
        case asigma_type_loc:
            err = asigma_loc_init_offload(&(offload_data->asigma_loc),
                                          offload_array);
            offload_data->offload_array_length =
                offload_data->asigma_loc.offload_array_length;
            break;
 
        default:
            /* Unrecognized input. Produce error. */
            print_err("Error: Unrecognized atomic reaction 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 asigma_free_offload(asigma_offload_data* offload_data,
                         real** offload_array) {
    switch(offload_data->type) {
        case asigma_type_loc:
            asigma_loc_free_offload(&(offload_data->asigma_loc), offload_array);
            break;
    }
}
 
int asigma_init(asigma_data* asigma_data, asigma_offload_data* offload_data,
                real* offload_array) {
    int err = 0;
    switch(offload_data->type) {
        case asigma_type_loc:
            asigma_loc_init(&(asigma_data->asigma_loc),
                            &(offload_data->asigma_loc), offload_array);
            break;
 
        default:
            /* Unrecognized input. Produce error. */
            print_err("Error: Unrecognized atomic reaction data type.");
            err = 1;
            break;
    }
    asigma_data->type = offload_data->type;
 
    return err;
}
 
a5err asigma_eval_sigma(
    real* sigma, int z_1, int a_1, int z_2, int a_2, real E_coll_per_amu,
    asigma_reac_type reac_type, asigma_data* asigma_data) {
    a5err err = 0;
 
    switch(asigma_data->type) {
        case asigma_type_loc:
            err = asigma_loc_eval_sigma(
                sigma, z_1, a_1, z_2, a_2, E_coll_per_amu, reac_type,
                ASIGMA_EXTRAPOLATE, &(asigma_data->asigma_loc));
            break;
 
        default:
            /* Unrecognized input. Produce error. */
            err = error_raise( ERR_UNKNOWN_INPUT, __LINE__, EF_ASIGMA );
            break;
    }
    if(err || sigma[0] < 0.0) {
        /* In case of error or unphysical negative value, return zero value
           to avoid further complications */
        sigma[0] = 0.0;
    }
 
    return err;
}
 
a5err asigma_eval_sigmav(
    real* sigmav, int z_1, int a_1, real m_1, int z_2, int a_2,
    real E, real T_e, real T_0, real n_i, asigma_reac_type reac_type,
    asigma_data* asigma_data) {
    a5err err = 0;
 
    switch(asigma_data->type) {
        case asigma_type_loc:
            err = asigma_loc_eval_sigmav(
                sigmav, z_1, a_1, m_1, z_2, a_2, E, T_e, T_0, n_i,
                reac_type, ASIGMA_EXTRAPOLATE, &(asigma_data->asigma_loc));
            break;
 
        default:
            /* Unrecognized input. Produce error. */
            err = error_raise( ERR_UNKNOWN_INPUT, __LINE__, EF_ASIGMA );
            break;
    }
    if(err || sigmav[0] < 0.0) {
        /* In case of error or unphysical negative value, return zero value
           to avoid further complications */
        sigmav[0] = 0.0;
    }
 
    return err;
}
 
a5err asigma_eval_cx(
    real* ratecoeff, int z_1, int a_1, real E, real mass, int nspec,
    const int* znum, const int* anum, real T_0, real* n_0,
    asigma_data* asigma_data) {
    a5err err = 0;
 
    switch(asigma_data->type) {
        case asigma_type_loc:
            err = asigma_loc_eval_cx(
                    ratecoeff, z_1, a_1, E, mass, nspec, znum, anum, T_0, n_0,
                    ASIGMA_EXTRAPOLATE, &(asigma_data->asigma_loc));
            break;
 
        default:
            /* Unrecognized input. Produce error. */
            err = error_raise( ERR_UNKNOWN_INPUT, __LINE__, EF_ASIGMA );
            break;
    }
    if(err || ratecoeff[0] < 0.0) {
        /* In case of error or unphysical negative value, return zero value
           to avoid further complications */
        ratecoeff[0] = 0.0;
    }
 
    return err;
}
 
a5err asigma_eval_bms(
    real* ratecoeff, int z_1, int a_1, real E, real mass, int nion,
    const int* znum, const int* anum, real T_e, real* n_i,
    asigma_data* asigma_data) {
    a5err err = 0;
 
    switch(asigma_data->type) {
        case asigma_type_loc:
            err = asigma_loc_eval_bms(
                    ratecoeff, z_1, a_1, E, mass, nion, znum, anum, T_e, n_i,
                    ASIGMA_EXTRAPOLATE, &(asigma_data->asigma_loc));
            break;
 
        default:
            /* Unrecognized input. Produce error. */
            err = error_raise( ERR_UNKNOWN_INPUT, __LINE__, EF_ASIGMA );
            break;
    }
    if(err || ratecoeff[0] < 0.0) {
        /* In case of error or unphysical negative value, return zero value
           to avoid further complications */
        ratecoeff[0] = 0.0;
    }
 
    return err;
}