amns_interface.h

Go to the documentation of this file.

#include <ctype.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include "itm_constants.h"

#ifndef AMNS_INTERFACE_H
#define AMNS_INTERFACE_H


// TODO: these should be uppercase...
#define version_length 32
#define set_length 32
#define reaction_length 16
#define query_length 16
#define answer_length 128
#define amns_max_length 128

char *strcpy_f2c(char *fsrc, int flen, char **cdest);
char *strcpy_c2f(char *csrc, char *fdest, int flen);

typedef struct {
    char string[version_length];     
    int number;                      
    char backend[version_length];    
    char user[version_length];       
} amns_version_type;

typedef struct {
    char *string;                    
    int number;                      
    char *backend;                   
    char *user;                      
} amns_c_version_type;

const amns_version_type DEFAULT_AMNS_VERSION_TYPE = { "", 0, "", "" };
const amns_c_version_type DEFAULT_AMNS_C_VERSION_TYPE = { "", 0, "", "" };

amns_c_version_type get_default_amns_c_version_type(void); 
amns_c_version_type get_default_amns_c_version_type() {
  return DEFAULT_AMNS_C_VERSION_TYPE;
}

void amns_version_type_f2c(amns_version_type ftype, amns_c_version_type *ctype) {
    strcpy_f2c(ftype.string, version_length, &((*ctype).string));
    ctype->number = ftype.number;
    strcpy_f2c(ftype.backend, version_length, &(ctype->backend));
    strcpy_f2c(ftype.user, version_length, &(ctype->user));
}

void amns_version_type_c2f(amns_c_version_type ctype, amns_version_type *ftype) {    
    strcpy_c2f(ctype.string, ftype->string, version_length);
    ftype->number = ctype.number;
    strcpy_c2f(ctype.backend, ftype->backend, version_length);
    strcpy_c2f(ctype.user, ftype->user, version_length);
}

typedef struct {
  double ZN;               
  double ZA;               
  double MI;               
  int LR;                  
  double real_specifier;   
  int int_specifier;       
} amns_reactant_type;

typedef amns_reactant_type amns_c_reactant_type;

const amns_reactant_type DEFAULT_AMNS_REACTANT_TYPE = { 0.0, 0.0, 0.0, 0, ITM_INVALID_FLOAT, ITM_INVALID_INT };
const amns_c_reactant_type DEFAULT_AMNS_C_REACTANT_TYPE = { 0.0, 0.0, 0.0, 0, ITM_INVALID_FLOAT, ITM_INVALID_INT };

amns_c_reactant_type get_default_amns_c_reactant_type(void); 
amns_c_reactant_type get_default_amns_c_reactant_type() {
  return DEFAULT_AMNS_C_REACTANT_TYPE;
}

typedef struct {
    bool flag;                    
    char string[answer_length];   
} amns_error_type;

typedef struct {
    bool flag;                    
    char *string;                 
} amns_c_error_type;

const amns_error_type DEFAULT_AMNS_ERROR_TYPE = { false, "" };
const amns_c_error_type DEFAULT_AMNS_C_ERROR_TYPE = { false, "" };

amns_c_error_type get_default_amns_c_error_type(void); 
amns_c_error_type get_default_amns_c_error_type() {
    return DEFAULT_AMNS_C_ERROR_TYPE;
}

void amns_error_type_f2c(amns_error_type ftype, amns_c_error_type *ctype) {
    strcpy_f2c(ftype.string, answer_length, &(ctype->string));
    ctype->flag = ftype.flag;
}

void amns_error_type_c2f(amns_c_error_type ctype, amns_error_type *ftype) {    
    strcpy_c2f(ctype.string, ftype->string, answer_length);
    ftype->flag = ctype.flag;
}

typedef struct {
    char string[reaction_length];   
    int isotope_resolved;           
} amns_reaction_type;

typedef struct {
    char *string;                   
    int isotope_resolved;           
} amns_c_reaction_type;

const amns_reaction_type DEFAULT_AMNS_REACTION_TYPE = { "", 0 };
const amns_c_reaction_type DEFAULT_AMNS_C_REACTION_TYPE = { "", 0 };

amns_c_reaction_type get_default_amns_c_reaction_type(void);  
amns_c_reaction_type get_default_amns_c_reaction_type() {
    return DEFAULT_AMNS_C_REACTION_TYPE;
}

void amns_reaction_type_f2c(amns_reaction_type ftype, amns_c_reaction_type *ctype) {
    strcpy_f2c(ftype.string, reaction_length, &(ctype->string));
    ctype->isotope_resolved = ftype.isotope_resolved;
}

void amns_reaction_type_c2f(amns_c_reaction_type ctype, amns_reaction_type *ftype) {    
    strcpy_c2f(ctype.string, ftype->string, reaction_length);
    ftype->isotope_resolved = ctype.isotope_resolved;
}

typedef struct {
    char string[set_length];   
} amns_set_type;

typedef struct {
    char *string;              
} amns_c_set_type;

const amns_set_type DEFAULT_AMNS_SET_TYPE = { "" };
const amns_c_set_type DEFAULT_AMNS_C_SET_TYPE = { "" };

void amns_set_type_f2c(amns_set_type ftype, amns_c_set_type *ctype) {
    strcpy_f2c(ftype.string, set_length, &(ctype->string));
}

void amns_set_type_c2f(amns_c_set_type ctype, amns_set_type *ftype) {    
    strcpy_c2f(ctype.string, ftype->string, set_length);
}

typedef struct {
    char string[query_length];   
} amns_query_type;

typedef struct {
    char *string;                
} amns_c_query_type;

const amns_query_type DEFAULT_AMNS_QUERY_TYPE = { "" };
const amns_c_query_type DEFAULT_AMNS_C_QUERY_TYPE = { "" };

void amns_query_type_f2c(amns_query_type ftype, amns_c_query_type *ctype) {
    strcpy_f2c(ftype.string, query_length, &(ctype->string));
}

void amns_query_type_c2f(amns_c_query_type ctype, amns_query_type *ftype) {    
    strcpy_c2f(ctype.string, ftype->string, query_length);
}

typedef struct {
    char string[answer_length];   
    int number;                   
} amns_answer_type;

typedef struct {
    char *string;                 
    int number;                   
} amns_c_answer_type;

const amns_answer_type DEFAULT_AMNS_ANSWER_TYPE = { "", 0 };
const amns_c_answer_type DEFAULT_AMNS_C_ANSWER_TYPE = { "", 0 };

void amns_answer_type_f2c(amns_answer_type ftype, amns_c_answer_type *ctype) {
    strcpy_f2c(ftype.string, answer_length, &(ctype->string));
    ctype->number = ftype.number;
}

void amns_answer_type_c2f(amns_c_answer_type ctype, amns_answer_type *ftype) {    
    strcpy_c2f(ctype.string, ftype->string, answer_length);
    ftype->number = ctype.number;
}

// Function prototypes for the Fortran functions

#ifdef __cplusplus
extern "C" {
#endif
void ITM_AMNS_C_SETUP(void **handle_out, amns_error_type *error_status);
void ITM_AMNS_C_SETUP_VERSION(void **handle_in, amns_version_type *version, amns_error_type *error_status);
void ITM_AMNS_C_FINISH(void **handle_inout, amns_error_type *error_status);
void ITM_AMNS_C_FINISH_TABLE(void **handle_rx_inout, amns_error_type *error_status);
void ITM_AMNS_C_SET(void *handle_in, amns_set_type *set, amns_error_type *error_status);
void ITM_AMNS_C_QUERY(void *handle_in, amns_query_type *query, amns_answer_type *answer, amns_error_type *error_status);

void ITM_AMNS_C_SETUP_TABLE(void *handle_in, amns_reaction_type *reaction_type, void *reactant_handle_in, void **handle_rx_out, amns_error_type *error_status);
void ITM_AMNS_C_QUERY_TABLE(void *handle_rx_in, amns_query_type *query, amns_answer_type *answer, amns_error_type *error_status);
void ITM_AMNS_C_SET_TABLE(void *handle_rx_in, amns_set_type *set, amns_error_type *error_status);

void ITM_AMNS_C_RX_0_A(void *handle_rx_in, double *out, double arg1, amns_error_type *error_status);
void ITM_AMNS_C_RX_0_B(void *handle_rx_in, double *out, double arg1, double arg2, amns_error_type *error_status);
void ITM_AMNS_C_RX_0_C(void *handle_rx_in, double *out, double arg1, double arg2, double arg3, amns_error_type *error_status);    

void ITM_AMNS_C_RX_1_A(void *handle_rx_in, int nx, double *out, double *arg1, amns_error_type *error_status);
void ITM_AMNS_C_RX_1_B(void *handle_rx_in, int nx, double *out, double *arg1, double *arg2, amns_error_type *error_status);
void ITM_AMNS_C_RX_1_C(void *handle_rx_in, int nx, double *out, double *arg1, double *arg2, double *arg3, amns_error_type *error_status);    

void ITM_AMNS_C_RX_2_A(void *handle_rx_in, int nx, int ny, double *out, double *arg1, amns_error_type *error_status);
void ITM_AMNS_C_RX_2_B(void *handle_rx_in, int nx, int ny, double *out, double *arg1, double *arg2, amns_error_type *error_status);
void ITM_AMNS_C_RX_2_C(void *handle_rx_in, int nx, int ny, double *out, double *arg1, double *arg2, double *arg3, amns_error_type *error_status);    

void ITM_AMNS_C_RX_3_A(void *handle_rx_in, int nx, int ny, int nz, double *out, double *arg1, amns_error_type *error_status);
void ITM_AMNS_C_RX_3_B(void *handle_rx_in, int nx, int ny, int nz, double *out, double *arg1, double *arg2, amns_error_type *error_status);
void ITM_AMNS_C_RX_3_C(void *handle_rx_in, int nx, int ny, int nz, double *out, double *arg1, double *arg2, double *arg3, amns_error_type *error_status);    

void ITM_AMNS_C_SETUP_REACTANTS(void **reactants_handle_out, char string_in[reaction_length], int index_in, int n_reactants);
void ITM_AMNS_C_SET_REACTANT(void *reactants_handle_in, int reactant_index, amns_reactant_type *reactant_in);
void ITM_AMNS_C_GET_REACTANT(void *reactants_handle_in, int reactant_index, amns_reactant_type *reactant_out);
void ITM_AMNS_C_FINISH_REACTANTS(void **reactants_handle_inout);

#ifdef __cplusplus
}
#endif


// Routines for C / Fortran string conversion

/* Return the length of a Fortran string, not counting trailing whitespace */
int fstrlen(char *fstr, int flen) {
    char *end;
    end = fstr + flen - 1;
    while(end >= fstr && isspace(*end)) end--;
    return end - fstr + 1;
}

/* Copy fixed-length Fortran string to C, omitting trailing whitespace
   and allocating memory as needed. If the Fortran string contains only
   whitespace (i.e., is empty), the C string is allocated but of zero length
   (i.e. only contains the \0 termination character).*/
char *strcpy_f2c(char *fsrc, int flen, char **cdest) {
    int trimlen = fstrlen(fsrc, flen);
    if (((*cdest) = malloc(trimlen+1)) != NULL) {
        memcpy(*cdest, fsrc, trimlen);
        *(*cdest + trimlen) = 0;
    }
    return *cdest;
}

/* Copy zero-terminated C string into fixed-length Fortran string, ensuring
   that the allowed string length is not exceeded. The Fortran string 
   fdest is assumed to be allocated to the length flen. If the C string
   is unassociated (NULL), the Fortran string is returned empty (i.e., filled with 
   whitespace/spaces) */
char *strcpy_c2f(char *csrc, char *fdest, int flen) {
    memset(fdest, ' ', flen);
    if (csrc != NULL) {
        int clen = strlen(csrc);
        if (clen > flen) {
            printf("strcpy_c2f: WARNING: C string exceeds size of target Fortran string. Truncating.");
            clen = flen;
        }
        memcpy(fdest, csrc, clen);
    }
    return fdest;       
}


// Convenience versions of the ITM_AMNS_C_* routines using the amns_c_* variants
// of the AMNS structures. These routines transparently handle conversion between
// zero-terminated C strings and fixed length Fortran strings
//
// Notation: CC = "C Convenience"
//
// Note: the routines below contain calls to copy routines in both directions
//       for all arguments of C convenience type. In the Fortran code, the
//       arguments are specified to be intent in, out or inout. Thus some
//       copy calls are unnecessary, and commented out in the below code.
//
// TODO: for some routines, the convenience routines are missing (commented below)


void ITM_AMNS_CC_SETUP(void **handle_out, amns_c_error_type *error_status) {       
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_SETUP(handle_out, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_SETUP_VERSION(void **handle_in, amns_c_version_type *version, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    amns_version_type f_version;
    //amns_error_type_c2f(*error_status, &f_error_status);
    amns_version_type_c2f(*version, &f_version);
    ITM_AMNS_C_SETUP_VERSION(handle_in, &f_version, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
    //amns_version_type_f2c(f_version, version);
}

void ITM_AMNS_CC_FINISH(void **handle_inout, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_FINISH(handle_inout, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_FINISH_TABLE(void **handle_rx_inout, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_FINISH_TABLE(handle_rx_inout, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_SET(void *handle_in, amns_c_set_type *set, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    amns_set_type f_set;
    //amns_error_type_c2f(*error_status, &f_error_status);
    amns_set_type_c2f(*set, &f_set);
    ITM_AMNS_C_SET(handle_in, &f_set, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
    //amns_set_type_f2c(f_set, set);
}

void ITM_AMNS_CC_QUERY(void *handle_in, amns_c_query_type *query, amns_c_answer_type *answer, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    amns_answer_type f_answer;
    amns_query_type f_query;
    //amns_error_type_c2f(*error_status, &f_error_status);
    //amns_answer_type_c2f(*answer, &f_answer);
    amns_query_type_c2f(*query, &f_query);
    ITM_AMNS_C_QUERY(handle_in, &f_query, &f_answer, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
    amns_answer_type_f2c(f_answer, answer);
    //amns_query_type_f2c(f_query, query);
}

void ITM_AMNS_CC_SETUP_TABLE(void *handle_in, amns_c_reaction_type *reaction_type, void *reactant_handle_in, void **handle_rx_out, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    amns_reaction_type f_reaction;
    //amns_error_type_c2f(*error_status, &f_error_status);
    amns_reaction_type_c2f(*reaction_type, &f_reaction);
    ITM_AMNS_C_SETUP_TABLE(handle_in, &f_reaction, reactant_handle_in, handle_rx_out, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
    //amns_reaction_type_f2c(f_reaction, reaction_type);
}

void ITM_AMNS_CC_QUERY_TABLE(void *handle_rx_in, amns_c_query_type *query, amns_c_answer_type *answer, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    amns_query_type f_query;
    amns_answer_type f_answer;
    //amns_error_type_c2f(*error_status, &f_error_status);
    amns_query_type_c2f(*query, &f_query);
    //amns_answer_type_c2f(*answer, &f_answer);
    ITM_AMNS_C_QUERY_TABLE(handle_rx_in, &f_query, &f_answer, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
    //amns_query_type_f2c(f_query, query);
    amns_answer_type_f2c(f_answer, answer);
}

void ITM_AMNS_CC_SET_TABLE(void *handle_rx_in, amns_c_set_type *set, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    amns_set_type f_set;
    //amns_error_type_c2f(*error_status, &f_error_status);
    amns_set_type_c2f(*set, &f_set);
    ITM_AMNS_C_SET_TABLE(handle_rx_in, &f_set, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
    //amns_set_type_f2c(f_set, set);
}

void ITM_AMNS_CC_RX_0_A(void *handle_rx_in, double *out, double arg1, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_RX_0_A(handle_rx_in, out, arg1, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_RX_0_B(void *handle_rx_in, double *out, double arg1, double arg2, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_RX_0_B(handle_rx_in, out, arg1, arg2, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_RX_0_C(void *handle_rx_in, double *out, double arg1, double arg2, double arg3, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_RX_0_C(handle_rx_in, out, arg1, arg2, arg3, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_RX_1_A(void *handle_rx_in, int nx, double *out, double *arg1, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_RX_1_A(handle_rx_in, nx, out, arg1, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_RX_1_B(void *handle_rx_in, int nx, double *out, double *arg1, double *arg2, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_RX_1_B(handle_rx_in, nx, out, arg1, arg2, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_RX_1_C(void *handle_rx_in, int nx, double *out, double *arg1, double *arg2, double *arg3, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_RX_1_C(handle_rx_in, nx, out, arg1, arg2, arg3, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_RX_2_A(void *handle_rx_in, int nx, int ny, double *out, double *arg1, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_RX_2_A(handle_rx_in, nx, ny, out, arg1, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_RX_2_B(void *handle_rx_in, int nx, int ny, double *out, double *arg1, double *arg2, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_RX_2_B(handle_rx_in, nx, ny, out, arg1, arg2, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_RX_2_C(void *handle_rx_in, int nx, int ny, double *out, double *arg1, double *arg2, double *arg3, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_RX_2_C(handle_rx_in, nx, ny, out, arg1, arg2, arg3, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_RX_3_A(void *handle_rx_in, int nx, int ny, int nz, double *out, double *arg1, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_RX_3_A(handle_rx_in, nx, ny, nz, out, arg1, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_RX_3_B(void *handle_rx_in, int nx, int ny, int nz, double *out, double *arg1, double *arg2, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_RX_3_B(handle_rx_in, nx, ny, nz, out, arg1, arg2, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_RX_3_C(void *handle_rx_in, int nx, int ny, int nz, double *out, double *arg1, double *arg2, double *arg3, amns_c_error_type *error_status) {
    amns_error_type f_error_status;
    //amns_error_type_c2f(*error_status, &f_error_status);
    ITM_AMNS_C_RX_3_C(handle_rx_in, nx, ny, nz, out, arg1, arg2, arg3, &f_error_status);
    amns_error_type_f2c(f_error_status, error_status);
}

void ITM_AMNS_CC_SETUP_REACTANTS(void **reactants_handle_out, char *string_in, int index_in, int n_reactants) {
    char f_string_in[reaction_length];    
    strcpy_c2f(string_in, f_string_in, reaction_length);
    ITM_AMNS_C_SETUP_REACTANTS(reactants_handle_out, f_string_in, index_in, n_reactants);
    //strcpy_f2c(f_string_inchar, reaction_length, string_in) {
}

void ITM_AMNS_CC_SET_REACTANT(void *reactants_handle_in, int reactant_index, amns_c_reactant_type *reactant_in) {
    // amns_c_reactant_type and amns_reactant_type are the same
    ITM_AMNS_C_SET_REACTANT(reactants_handle_in, reactant_index, (amns_reactant_type*)reactant_in);
}

void ITM_AMNS_CC_GET_REACTANT(void *reactants_handle_in, int reactant_index, amns_c_reactant_type *reactant_out) {
    ITM_AMNS_C_GET_REACTANT(reactants_handle_in, reactant_index, (amns_reactant_type*)reactant_out);
}

void ITM_AMNS_CC_FINISH_REACTANTS(void **reactants_handle_inout) {
    ITM_AMNS_C_FINISH_REACTANTS(reactants_handle_inout);
}

#endif