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

Include dependency graph for amns_interface.h:

Go to the source code of this file.

Classes
struct	amns_version_type
	Type for specifying the AMNS version ("interoperable" version) More...

struct	amns_c_version_type
	Type for specifying the AMNS version ("C" version) More...

struct	amns_reactant_type
	Type for indicating a single reactant or product when using the AMNS interface. More...

struct	amns_error_type
	Type for error returns from the AMNS interface ("interoperable" version) More...

struct	amns_c_error_type
	Type for error returns from the AMNS interface ("C" version) More...

struct	amns_reaction_type
	Type used for specifying reactions when using the AMNS interface ("interoperable" version) More...

struct	amns_c_reaction_type
	Type used for specifying reactions when using the AMNS interface ("C" version) More...

struct	amns_set_type
	Type for setting parameters in the AMNS package ("interoperable" version) More...

struct	amns_c_set_type
	Type for setting parameters in the AMNS package ("C" version) More...

struct	amns_query_type
	Type for querying parameters in the AMNS package ("interoperable" version) More...

struct	amns_c_query_type
	Type for querying parameters in the AMNS package ("C" version) More...

struct	amns_answer_type
	Type for answers from queries in the AMNS package ("interoperable" version) More...

struct	amns_c_answer_type
	Type for answers from queries in the AMNS package ("C" version) More...

Macros
#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

Typedefs
typedef amns_reactant_type	amns_c_reactant_type

Functions
char *	strcpy_f2c (char fsrc, int flen, char *cdest)

char *	strcpy_c2f (char csrc, char fdest, int flen)

amns_c_version_type	get_default_amns_c_version_type (void)
	prototype More...

void	amns_version_type_f2c (amns_version_type ftype, amns_c_version_type *ctype)

void	amns_version_type_c2f (amns_c_version_type ctype, amns_version_type *ftype)

amns_c_reactant_type	get_default_amns_c_reactant_type (void)
	prototype More...

amns_c_error_type	get_default_amns_c_error_type (void)
	prototype More...

void	amns_error_type_f2c (amns_error_type ftype, amns_c_error_type *ctype)

void	amns_error_type_c2f (amns_c_error_type ctype, amns_error_type *ftype)

amns_c_reaction_type	get_default_amns_c_reaction_type (void)
	prototype More...

void	amns_reaction_type_f2c (amns_reaction_type ftype, amns_c_reaction_type *ctype)

void	amns_reaction_type_c2f (amns_c_reaction_type ctype, amns_reaction_type *ftype)

void	amns_set_type_f2c (amns_set_type ftype, amns_c_set_type *ctype)

void	amns_set_type_c2f (amns_c_set_type ctype, amns_set_type *ftype)

void	amns_query_type_f2c (amns_query_type ftype, amns_c_query_type *ctype)

void	amns_query_type_c2f (amns_c_query_type ctype, amns_query_type *ftype)

void	amns_answer_type_f2c (amns_answer_type ftype, amns_c_answer_type *ctype)

void	amns_answer_type_c2f (amns_c_answer_type ctype, amns_answer_type *ftype)

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)

int	fstrlen (char *fstr, int flen)

void	ITM_AMNS_CC_SETUP (void *handle_out, amns_c_error_type error_status)

void	ITM_AMNS_CC_SETUP_VERSION (void *handle_in, amns_c_version_type version, amns_c_error_type *error_status)

void	ITM_AMNS_CC_FINISH (void *handle_inout, amns_c_error_type error_status)

void	ITM_AMNS_CC_FINISH_TABLE (void *handle_rx_inout, amns_c_error_type error_status)

void	ITM_AMNS_CC_SET (void handle_in, amns_c_set_type set, amns_c_error_type *error_status)

void	ITM_AMNS_CC_QUERY (void handle_in, amns_c_query_type query, amns_c_answer_type answer, amns_c_error_type error_status)

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)

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)

void	ITM_AMNS_CC_SET_TABLE (void handle_rx_in, amns_c_set_type set, amns_c_error_type *error_status)

void	ITM_AMNS_CC_RX_0_A (void handle_rx_in, double out, double arg1, amns_c_error_type *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)

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)

void	ITM_AMNS_CC_RX_1_A (void handle_rx_in, int nx, double out, double arg1, amns_c_error_type 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)

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)

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)

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)

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)

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)

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)

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)

void	ITM_AMNS_CC_SETUP_REACTANTS (void *reactants_handle_out, char string_in, int index_in, int n_reactants)

void	ITM_AMNS_CC_SET_REACTANT (void reactants_handle_in, int reactant_index, amns_c_reactant_type reactant_in)

void	ITM_AMNS_CC_GET_REACTANT (void reactants_handle_in, int reactant_index, amns_c_reactant_type reactant_out)

void	ITM_AMNS_CC_FINISH_REACTANTS (void **reactants_handle_inout)

Variables
const amns_version_type	DEFAULT_AMNS_VERSION_TYPE = { "", 0, "", "" }

const amns_c_version_type	DEFAULT_AMNS_C_VERSION_TYPE = { "", 0, "", "" }

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 }

const amns_error_type	DEFAULT_AMNS_ERROR_TYPE = { false, "" }

const amns_c_error_type	DEFAULT_AMNS_C_ERROR_TYPE = { false, "" }

const amns_reaction_type	DEFAULT_AMNS_REACTION_TYPE = { "", 0 }

const amns_c_reaction_type	DEFAULT_AMNS_C_REACTION_TYPE = { "", 0 }

const amns_set_type	DEFAULT_AMNS_SET_TYPE = { "" }

const amns_c_set_type	DEFAULT_AMNS_C_SET_TYPE = { "" }

const amns_query_type	DEFAULT_AMNS_QUERY_TYPE = { "" }

const amns_c_query_type	DEFAULT_AMNS_C_QUERY_TYPE = { "" }

const amns_answer_type	DEFAULT_AMNS_ANSWER_TYPE = { "", 0 }

const amns_c_answer_type	DEFAULT_AMNS_C_ANSWER_TYPE = { "", 0 }

Macro Definition Documentation

#define amns_max_length 128

Definition at line 46 of file amns_interface.h.

#define answer_length 128

Definition at line 45 of file amns_interface.h.

#define query_length 16

Definition at line 44 of file amns_interface.h.

#define reaction_length 16

Definition at line 43 of file amns_interface.h.

#define set_length 32

Definition at line 42 of file amns_interface.h.

#define version_length 32

Definition at line 41 of file amns_interface.h.

Typedef Documentation

typedef amns_reactant_type amns_c_reactant_type

Definition at line 109 of file amns_interface.h.

Function Documentation

void amns_answer_type_c2f	(	amns_c_answer_type	ctype,
		amns_answer_type *	ftype
	)

Definition at line 274 of file amns_interface.h.

                                                                              {    
     strcpy_c2f(ctype.string, ftype->string, answer_length);
     ftype->number = ctype.number;
 }

Here is the call graph for this function:

void amns_answer_type_f2c	(	amns_answer_type	ftype,
		amns_c_answer_type *	ctype
	)

Definition at line 269 of file amns_interface.h.

                                                                              {
     strcpy_f2c(ftype.string, answer_length, &(ctype->string));
     ctype->number = ftype.number;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void amns_error_type_c2f	(	amns_c_error_type	ctype,
		amns_error_type *	ftype
	)

Definition at line 152 of file amns_interface.h.

                                                                           {    
     strcpy_c2f(ctype.string, ftype->string, answer_length);
     ftype->flag = ctype.flag;
 }

Here is the call graph for this function:

void amns_error_type_f2c	(	amns_error_type	ftype,
		amns_c_error_type *	ctype
	)

Definition at line 147 of file amns_interface.h.

                                                                           {
     strcpy_f2c(ftype.string, answer_length, &(ctype->string));
     ctype->flag = ftype.flag;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void amns_query_type_c2f	(	amns_c_query_type	ctype,
		amns_query_type *	ftype
	)

Definition at line 244 of file amns_interface.h.

                                                                           {    
     strcpy_c2f(ctype.string, ftype->string, query_length);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void amns_query_type_f2c	(	amns_query_type	ftype,
		amns_c_query_type *	ctype
	)

Definition at line 240 of file amns_interface.h.

                                                                           {
     strcpy_f2c(ftype.string, query_length, &(ctype->string));
 }

Here is the call graph for this function:

void amns_reaction_type_c2f	(	amns_c_reaction_type	ctype,
		amns_reaction_type *	ftype
	)

Definition at line 189 of file amns_interface.h.

                                                                                    {    
     strcpy_c2f(ctype.string, ftype->string, reaction_length);
     ftype->isotope_resolved = ctype.isotope_resolved;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void amns_reaction_type_f2c	(	amns_reaction_type	ftype,
		amns_c_reaction_type *	ctype
	)

Definition at line 184 of file amns_interface.h.

                                                                                    {
     strcpy_f2c(ftype.string, reaction_length, &(ctype->string));
     ctype->isotope_resolved = ftype.isotope_resolved;
 }

Here is the call graph for this function:

void amns_set_type_c2f	(	amns_c_set_type	ctype,
		amns_set_type *	ftype
	)

Definition at line 217 of file amns_interface.h.

                                                                     {    
     strcpy_c2f(ctype.string, ftype->string, set_length);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void amns_set_type_f2c	(	amns_set_type	ftype,
		amns_c_set_type *	ctype
	)

Definition at line 213 of file amns_interface.h.

                                                                     {
     strcpy_f2c(ftype.string, set_length, &(ctype->string));
 }

Here is the call graph for this function:

void amns_version_type_c2f	(	amns_c_version_type	ctype,
		amns_version_type *	ftype
	)

Definition at line 89 of file amns_interface.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void amns_version_type_f2c	(	amns_version_type	ftype,
		amns_c_version_type *	ctype
	)

Definition at line 82 of file amns_interface.h.

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

Here is the call graph for this function:

int fstrlen	(	char *	fstr,
		int	flen
	)

Definition at line 324 of file amns_interface.h.

                                   {
     char *end;
     end = fstr + flen - 1;
     while(end >= fstr && isspace(*end)) end--;
     return end - fstr + 1;
 }

Here is the caller graph for this function:

amns_c_error_type get_default_amns_c_error_type ( void )

prototype

Definition at line 143 of file amns_interface.h.

                                                   {
     return DEFAULT_AMNS_C_ERROR_TYPE;
 }

amns_c_reactant_type get_default_amns_c_reactant_type ( void )

prototype

Definition at line 116 of file amns_interface.h.

                                                         {
   return DEFAULT_AMNS_C_REACTANT_TYPE;
 }

amns_c_reaction_type get_default_amns_c_reaction_type ( void )

prototype

Definition at line 180 of file amns_interface.h.

                                                         {
     return DEFAULT_AMNS_C_REACTION_TYPE;
 }

amns_c_version_type get_default_amns_c_version_type ( void )

prototype

Definition at line 78 of file amns_interface.h.

                                                       {
   return DEFAULT_AMNS_C_VERSION_TYPE;
 }

void ITM_AMNS_C_FINISH	(	void **	handle_inout,
		amns_error_type *	error_status
	)

Here is the caller graph for this function:

void ITM_AMNS_C_FINISH_REACTANTS ( void ** reactants_handle_inout )

Here is the caller graph for this function:

void ITM_AMNS_C_FINISH_TABLE	(	void **	handle_rx_inout,
		amns_error_type *	error_status
	)

Here is the caller graph for this function:

void ITM_AMNS_C_GET_REACTANT	(	void *	reactants_handle_in,
		int	reactant_index,
		amns_reactant_type *	reactant_out
	)

Here is the caller graph for this function:

void ITM_AMNS_C_QUERY	(	void *	handle_in,
		amns_query_type *	query,
		amns_answer_type *	answer,
		amns_error_type *	error_status
	)

Here is the caller graph for this function:

void ITM_AMNS_C_QUERY_TABLE	(	void *	handle_rx_in,
		amns_query_type *	query,
		amns_answer_type *	answer,
		amns_error_type *	error_status
	)

Here is the caller graph for this function:

void ITM_AMNS_C_RX_0_A	(	void *	handle_rx_in,
		double *	out,
		double	arg1,
		amns_error_type *	error_status
	)

Here is the caller graph for this function:

void ITM_AMNS_C_RX_0_B	(	void *	handle_rx_in,
		double *	out,
		double	arg1,
		double	arg2,
		amns_error_type *	error_status
	)

Here is the caller graph for this function:

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

Here is the caller graph for this function:

void ITM_AMNS_C_RX_1_A	(	void *	handle_rx_in,
		int	nx,
		double *	out,
		double *	arg1,
		amns_error_type *	error_status
	)

Here is the caller graph for this function:

void ITM_AMNS_C_RX_1_B	(	void *	handle_rx_in,
		int	nx,
		double *	out,
		double *	arg1,
		double *	arg2,
		amns_error_type *	error_status
	)

Here is the caller graph for this function:

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
	)

Here is the caller graph for this function:

void ITM_AMNS_C_RX_2_A	(	void *	handle_rx_in,
		int	nx,
		int	ny,
		double *	out,
		double *	arg1,
		amns_error_type *	error_status
	)

Here is the caller graph for this function:

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
	)

Here is the caller graph for this function:

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
	)

Here is the caller graph for this function:

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
	)

Here is the caller graph for this function:

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
	)

Here is the caller graph for this function:

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
	)

Here is the caller graph for this function:

void ITM_AMNS_C_SET	(	void *	handle_in,
		amns_set_type *	set,
		amns_error_type *	error_status
	)

Here is the caller graph for this function:

void ITM_AMNS_C_SET_REACTANT	(	void *	reactants_handle_in,
		int	reactant_index,
		amns_reactant_type *	reactant_in
	)

Here is the caller graph for this function:

void ITM_AMNS_C_SET_TABLE	(	void *	handle_rx_in,
		amns_set_type *	set,
		amns_error_type *	error_status
	)

Here is the caller graph for this function:

void ITM_AMNS_C_SETUP	(	void **	handle_out,
		amns_error_type *	error_status
	)

Here is the caller graph for this function:

void ITM_AMNS_C_SETUP_REACTANTS	(	void **	reactants_handle_out,
		char	string_in[reaction_length],
		int	index_in,
		int	n_reactants
	)

Here is the caller graph for this function:

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
	)

Here is the caller graph for this function:

void ITM_AMNS_C_SETUP_VERSION	(	void **	handle_in,
		amns_version_type *	version,
		amns_error_type *	error_status
	)

Here is the caller graph for this function:

void ITM_AMNS_CC_FINISH	(	void **	handle_inout,
		amns_c_error_type *	error_status
	)

Definition at line 394 of file amns_interface.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void ITM_AMNS_CC_FINISH_REACTANTS ( void ** reactants_handle_inout )

Definition at line 564 of file amns_interface.h.

                                                                  {
     ITM_AMNS_C_FINISH_REACTANTS(reactants_handle_inout);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ITM_AMNS_CC_FINISH_TABLE	(	void **	handle_rx_inout,
		amns_c_error_type *	error_status
	)

Definition at line 401 of file amns_interface.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void ITM_AMNS_CC_GET_REACTANT	(	void *	reactants_handle_in,
		int	reactant_index,
		amns_c_reactant_type *	reactant_out
	)

Definition at line 560 of file amns_interface.h.

                                                                                                                  {
     ITM_AMNS_C_GET_REACTANT(reactants_handle_in, reactant_index, (amns_reactant_type*)reactant_out);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ITM_AMNS_CC_QUERY	(	void *	handle_in,
		amns_c_query_type *	query,
		amns_c_answer_type *	answer,
		amns_c_error_type *	error_status
	)

Definition at line 418 of file amns_interface.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

Definition at line 441 of file amns_interface.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void ITM_AMNS_CC_RX_0_A	(	void *	handle_rx_in,
		double *	out,
		double	arg1,
		amns_c_error_type *	error_status
	)

Definition at line 464 of file amns_interface.h.

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

Here is the call graph for this function:

void ITM_AMNS_CC_RX_0_B	(	void *	handle_rx_in,
		double *	out,
		double	arg1,
		double	arg2,
		amns_c_error_type *	error_status
	)

Definition at line 471 of file amns_interface.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

Definition at line 478 of file amns_interface.h.

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

Here is the call graph for this function:

void ITM_AMNS_CC_RX_1_A	(	void *	handle_rx_in,
		int	nx,
		double *	out,
		double *	arg1,
		amns_c_error_type *	error_status
	)

Definition at line 485 of file amns_interface.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

Definition at line 492 of file amns_interface.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

Definition at line 499 of file amns_interface.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

Definition at line 506 of file amns_interface.h.

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

Here is the call graph for this function:

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
	)

Definition at line 513 of file amns_interface.h.

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

Here is the call graph for this function:

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
	)

Definition at line 520 of file amns_interface.h.

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

Here is the call graph for this function:

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
	)

Definition at line 527 of file amns_interface.h.

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

Here is the call graph for this function:

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
	)

Definition at line 534 of file amns_interface.h.

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

Here is the call graph for this function:

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
	)

Definition at line 541 of file amns_interface.h.

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

Here is the call graph for this function:

void ITM_AMNS_CC_SET	(	void *	handle_in,
		amns_c_set_type *	set,
		amns_c_error_type *	error_status
	)

Definition at line 408 of file amns_interface.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void ITM_AMNS_CC_SET_REACTANT	(	void *	reactants_handle_in,
		int	reactant_index,
		amns_c_reactant_type *	reactant_in
	)

Definition at line 555 of file amns_interface.h.

                                                                                                                 {
     // 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);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ITM_AMNS_CC_SET_TABLE	(	void *	handle_rx_in,
		amns_c_set_type *	set,
		amns_c_error_type *	error_status
	)

Definition at line 454 of file amns_interface.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void ITM_AMNS_CC_SETUP	(	void **	handle_out,
		amns_c_error_type *	error_status
	)

Definition at line 377 of file amns_interface.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void ITM_AMNS_CC_SETUP_REACTANTS	(	void **	reactants_handle_out,
		char *	string_in,
		int	index_in,
		int	n_reactants
	)

Definition at line 548 of file amns_interface.h.

                                                                                                               {
     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) {
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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
	)

Definition at line 431 of file amns_interface.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void ITM_AMNS_CC_SETUP_VERSION	(	void **	handle_in,
		amns_c_version_type *	version,
		amns_c_error_type *	error_status
	)

Definition at line 384 of file amns_interface.h.

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

Here is the call graph for this function:

char * strcpy_c2f	(	char *	csrc,
		char *	fdest,
		int	flen
	)

Definition at line 349 of file amns_interface.h.

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

Here is the caller graph for this function:

char * strcpy_f2c	(	char *	fsrc,
		int	flen,
		char **	cdest
	)

Definition at line 335 of file amns_interface.h.

                                                      {
     int trimlen = fstrlen(fsrc, flen);
     if (((*cdest) = malloc(trimlen+1)) != NULL) {
         memcpy(*cdest, fsrc, trimlen);
         *(*cdest + trimlen) = 0;
     }
     return *cdest;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

const amns_answer_type DEFAULT_AMNS_ANSWER_TYPE = { "", 0 }

Definition at line 266 of file amns_interface.h.

const amns_c_answer_type DEFAULT_AMNS_C_ANSWER_TYPE = { "", 0 }

Definition at line 267 of file amns_interface.h.

const amns_c_error_type DEFAULT_AMNS_C_ERROR_TYPE = { false, "" }

Definition at line 139 of file amns_interface.h.

const amns_c_query_type DEFAULT_AMNS_C_QUERY_TYPE = { "" }

Definition at line 238 of file amns_interface.h.

const amns_c_reactant_type DEFAULT_AMNS_C_REACTANT_TYPE = { 0.0, 0.0, 0.0, 0, ITM_INVALID_FLOAT, ITM_INVALID_INT }

Definition at line 112 of file amns_interface.h.

const amns_c_reaction_type DEFAULT_AMNS_C_REACTION_TYPE = { "", 0 }

Definition at line 176 of file amns_interface.h.

const amns_c_set_type DEFAULT_AMNS_C_SET_TYPE = { "" }

Definition at line 211 of file amns_interface.h.

const amns_c_version_type DEFAULT_AMNS_C_VERSION_TYPE = { "", 0, "", "" }

Definition at line 74 of file amns_interface.h.

const amns_error_type DEFAULT_AMNS_ERROR_TYPE = { false, "" }

Definition at line 138 of file amns_interface.h.

const amns_query_type DEFAULT_AMNS_QUERY_TYPE = { "" }

Definition at line 237 of file amns_interface.h.

const amns_reactant_type DEFAULT_AMNS_REACTANT_TYPE = { 0.0, 0.0, 0.0, 0, ITM_INVALID_FLOAT, ITM_INVALID_INT }

Definition at line 111 of file amns_interface.h.

const amns_reaction_type DEFAULT_AMNS_REACTION_TYPE = { "", 0 }

Definition at line 175 of file amns_interface.h.

const amns_set_type DEFAULT_AMNS_SET_TYPE = { "" }

Definition at line 210 of file amns_interface.h.

const amns_version_type DEFAULT_AMNS_VERSION_TYPE = { "", 0, "", "" }

Definition at line 73 of file amns_interface.h.

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation