amns.pyx

Go to the documentation of this file.

cimport camns_interface
from camns_interface cimport *
import numpy as np
cimport numpy as np

# some SO for cython & numpy
# http://stackoverflow.com/questions/3046305/simple-wrapping-of-c-code-with-cython
# http://stackoverflow.com/questions/4495420/passing-numpy-arrays-to-c-code-wrapped-with-cython
# http://stackoverflow.com/questions/8366095/have-pointer-to-data-need-numpy-array-in-fortran-order-want-to-use-cython

cdef class Amns:
#    """Class for interfacing to the AMNS library"""

    cdef void* _handle
#        """AMNS handle (opaque)"""

    def __init__(self, version_string=None, version_number=None, version_backend=None, version_user=None):
        """Use to initialize the Amns class"""
        self._handle = NULL
        self._setup(version_string=version_string, version_number=version_number, version_backend=version_backend, version_user=version_user)

    cdef void* handle(self):
        return self._handle

    def _setup(self, version_string=None, version_number=None, version_backend=None, version_user=None):
        """Perform the actual call to the C interface to the original primary Fortran SETUP routine"""
        cdef camns_interface.amns_c_error_type error_status
        cdef camns_interface.amns_c_version_type version
        version = camns_interface.get_default_amns_c_version_type()
        if (version_string == None) & ( version_number == None) & (version_backend == None) & (version_user == None):
            camns_interface.ITM_AMNS_CC_SETUP(&self._handle, &error_status)
        else:
            print version
            if version_string  != None: version.string = version_string
            if version_number  != None: version.number = version_number
            if version_backend != None: version.backend = version_backend
            if version_user    != None: version.user = version_user
            print version
            camns_interface.ITM_AMNS_CC_SETUP_VERSION(&self._handle, &version, &error_status)
        if error_status.flag:
            raise AmnsException(error_status.string)

    cdef camns_interface.amns_c_answer_type lquery(self, queryString):
        cdef camns_interface.amns_c_query_type query
        cdef camns_interface.amns_c_answer_type answer
        cdef camns_interface.amns_c_error_type error_status
        query.string = queryString
        camns_interface.ITM_AMNS_CC_QUERY(self._handle, &query, &answer, &error_status);
        if error_status.flag:
            raise AmnsException(error_status.string)
        return answer

    def query(self, queryString):
        """Provide the interface to ITM_AMNS_QUERY"""
        cdef camns_interface.amns_c_query_type query
        cdef camns_interface.amns_c_answer_type answer
        cdef camns_interface.amns_c_error_type error_status
        query.string = queryString
        camns_interface.ITM_AMNS_CC_QUERY(self._handle, &query, &answer, &error_status);
        if error_status.flag:
            raise AmnsException(error_status.string)
        return answer.string, answer.number

    @property
    def version(self):
        """Query for version of the AMNS data"""
        cdef camns_interface.amns_c_answer_type answer
        answer = self.lquery("version")
        return answer.number, answer.string

    def set(self, setString):
        """Provide the interface to ITM_AMNS_SET"""
        cdef camns_interface.amns_c_set_type set
        cdef camns_interface.amns_c_error_type error_status
        set.string = setString
        camns_interface.ITM_AMNS_CC_SET(self._handle, &set, &error_status);
        if error_status.flag:
            raise AmnsException(error_status.string)

    def finalize(self):
        """Provide the interface to ITM_AMNS_FINISH"""
        cdef camns_interface.amns_c_error_type error_status
        camns_interface.ITM_AMNS_CC_FINISH(&self._handle, &error_status)
        if error_status.flag:
            raise AmnsException(error_status.string)

    def get_table(self, reactionString, Reactants reactants, isotope_resolved=None):
        """Provide the interface to the Table class used for tables"""
        return Table(reactionString, reactants, self, isotope_resolved)


cdef class Table:
#    """Class for interfacing to Tables in the the AMNS library"""

    cdef void* _handle
    cdef Amns _parentAmns

    def __init__(self, reactionString, Reactants reactants, Amns parentAmns, isotope_resolved=None):
        """Create a new table"""
        cdef camns_interface.amns_c_error_type error_status
        cdef camns_interface.amns_c_reaction_type reaction
        reaction = camns_interface.get_default_amns_c_reaction_type()
        self._parentAmns = parentAmns
        reaction.string = reactionString
        if isotope_resolved : reaction.isotope_resolved = isotope_resolved
        camns_interface.ITM_AMNS_CC_SETUP_TABLE(self._parentAmns.handle(),
                                                &reaction,
                                                reactants.handle(), &self._handle,
                                                &error_status)
        if error_status.flag:
            raise AmnsException(error_status.string)

        self.set("nowarn")


    cdef camns_interface.amns_c_answer_type lquery(self, queryString):
        cdef camns_interface.amns_c_query_type query
        cdef camns_interface.amns_c_answer_type answer
        cdef camns_interface.amns_c_error_type error_status
        query.string = queryString
        camns_interface.ITM_AMNS_CC_QUERY_TABLE(self._handle, &query, &answer, &error_status);
        if error_status.flag:
            raise AmnsException(error_status.string)
        return answer

    def query(self, queryString):
        """Provide the interface to ITM_AMNS_QUERY_TABLE"""
        cdef camns_interface.amns_c_query_type query
        cdef camns_interface.amns_c_answer_type answer
        cdef camns_interface.amns_c_error_type error_status
        query.string = queryString
        camns_interface.ITM_AMNS_CC_QUERY_TABLE(self._handle, &query, &answer, &error_status);
        if error_status.flag:
            raise AmnsException(error_status.string)
        return answer.string, answer.number

    def set(self, setString):
        """Provide the interface to ITM_AMNS_SET_TABLE"""
        cdef camns_interface.amns_c_set_type set
        cdef camns_interface.amns_c_error_type error_status
        set.string = setString
        camns_interface.ITM_AMNS_CC_SET_TABLE(self._handle, &set, &error_status);
        if error_status.flag:
            raise AmnsException(error_status.string)

    def finalize(self):
        """Provide the interface to ITM_AMNS_FINISH_TABLE"""
        cdef camns_interface.amns_c_error_type error_status
        camns_interface.ITM_AMNS_CC_FINISH_TABLE(&self._handle, &error_status)
        if error_status.flag:
            raise AmnsException(error_status.string)

    @property
    def no_of_reactants(self):
        """Query for no_of_reactants associated with the AMNS table"""
        cdef camns_interface.amns_c_answer_type answer
        answer = self.lquery("no_of_reactants")
        return answer.number

    @property
    def ndim(self):
        """Query for ndim associated with the AMNS table"""
        cdef camns_interface.amns_c_answer_type answer
        answer = self.lquery("ndim")
        return answer.number

    @property
    def source(self):
        """Query for source associated with the AMNS table"""
        cdef camns_interface.amns_c_answer_type answer
        answer = self.lquery("source")
        return answer.string

    @property
    def filled(self):
        """Query for filled status associated with the AMNS table"""
        cdef camns_interface.amns_c_answer_type answer
        answer = self.lquery("filled")
        return answer.string

    @property
    def reaction_type(self):
        """Query for reaction_type associated with the AMNS table"""
        cdef camns_interface.amns_c_answer_type answer
        answer = self.lquery("reaction_type")
        return answer.string

    @property
    def reactants(self):
        """Query for reactants associated with the AMNS table"""
        cdef camns_interface.amns_c_answer_type answer
        answer = self.lquery("reactants")
        return answer.string

    @property
    def version(self):
        """Query for version associated with the AMNS table"""
        cdef camns_interface.amns_c_answer_type answer
        answer = self.lquery("version")
        return answer.string, answer.number

    @property
    def state_label(self):
        """Query for state_label associated with the AMNS table"""
        cdef camns_interface.amns_c_answer_type answer
        answer = self.lquery("state_label")
        return answer.string

    @property
    def result_unit(self):
        """Query for result_unit associated with the AMNS table"""
        cdef camns_interface.amns_c_answer_type answer
        answer = self.lquery("result_unit")
        return answer.string

    @property
    def result_label(self):
        """Query for result_label associated with the AMNS table"""
        cdef camns_interface.amns_c_answer_type answer
        answer = self.lquery("result_label")
        return answer.string

    @property
    def interp_fun(self):
        """Query for interp_fun associated with the AMNS table"""
        cdef camns_interface.amns_c_answer_type answer
        answer = self.lquery("interp_fun")
        return answer.number

    def data(self, p1, p2 = None, p3 = None):
        """Return the AMNS data based on the arguments"""
        nargs = 1
        if p2 is not None: nargs += 1
        if p3 is not None: nargs += 1
        if nargs != self.ndim:
            raise AmnsException("Number of parameters does not match table dimensions (ndim="
                                + str(self.ndim) + ")")

        refShape = p1.shape
        if p2 is not None and p2.shape != refShape:
            raise AmnsException("Shape of parameter 2 inconsistent to shape of parameter 1")
        if p3 is not None and p3.shape != refShape:
            raise AmnsException("Shape of parameter 3 inconsistent to shape of parameter 1")

        if len(refShape) == 1:
            res = self._data_1d(p1,p2,p3)
        elif len(refShape) == 2:
            res = self._data_2d(p1,p2,p3)
        elif len(refShape) == 3:
            res = self._data_3d(p1,p2,p3)
        else:
            raise AmnsException("Unsupported rank of input arguments: %s" % (len(refShape),))

        return res

    def _data_1d(self, np.ndarray[np.double_t, ndim=1] p1,
                       np.ndarray[np.double_t, ndim=1] p2 = None,
                       np.ndarray[np.double_t, ndim=1] p3 = None):
        cdef camns_interface.amns_c_error_type error_status
        cdef np.ndarray[np.double_t, ndim=1] res

        nargs = 1
        if p2 is not None: nargs += 1
        if p3 is not None: nargs += 1

        res = np.empty_like(p1, order='F')

        if nargs == 1:
            camns_interface.ITM_AMNS_CC_RX_1_A(self._handle, p1.shape[0],
                                               <double*> res.data,
                                               <double*> p1.data, &error_status);
        elif nargs == 2:
            camns_interface.ITM_AMNS_CC_RX_1_B(self._handle, p1.shape[0],
                                               <double*> res.data,
                                               <double*> p1.data,
                                               <double*> p2.data, &error_status);
        elif nargs == 3:
            camns_interface.ITM_AMNS_CC_RX_1_C(self._handle, p1.shape[0],
                                               <double*> res.data,
                                               <double*> p1.data,
                                               <double*> p2.data,
                                               <double*> p3.data, &error_status);

        if error_status.flag:
            raise AmnsException(error_status.string)
        return res

    def _data_2d(self, np.ndarray[np.double_t, ndim=2] p1,
                       np.ndarray[np.double_t, ndim=2] p2 = None,
                       np.ndarray[np.double_t, ndim=2] p3 = None):

        cdef camns_interface.amns_c_error_type error_status
        cdef np.ndarray[np.double_t, ndim=2] res

        nargs = 1
        if p2 is not None: nargs += 1
        if p3 is not None: nargs += 1

        res = np.empty_like(p1, order='F')

        if nargs == 1:
            camns_interface.ITM_AMNS_CC_RX_2_A(self._handle, p1.shape[0], p1.shape[1],
                                               <double*> res.data,
                                               <double*> p1.data, &error_status);
        elif nargs == 2:
            camns_interface.ITM_AMNS_CC_RX_2_B(self._handle, p1.shape[0], p1.shape[1],
                                               <double*> res.data,
                                               <double*> p1.data,
                                               <double*> p2.data, &error_status);
        elif nargs == 3:
            camns_interface.ITM_AMNS_CC_RX_2_C(self._handle, p1.shape[0], p1.shape[1],
                                               <double*> res.data,
                                               <double*> p1.data,
                                               <double*> p2.data,
                                               <double*> p3.data, &error_status);

        if error_status.flag:
            raise AmnsException(error_status.string)
        return res

    def _data_3d(self, np.ndarray[np.double_t, ndim=3] p1,
                       np.ndarray[np.double_t, ndim=3] p2 = None,
                       np.ndarray[np.double_t, ndim=3] p3 = None):
        cdef camns_interface.amns_c_error_type error_status
        cdef np.ndarray[np.double_t, ndim=3] res

        nargs = 1
        if p2 is not None: nargs += 1
        if p3 is not None: nargs += 1

        res = np.empty_like(p1, order='F')

        if nargs == 1:
            camns_interface.ITM_AMNS_CC_RX_3_A(self._handle, p1.shape[0], p1.shape[1], p1.shape[2],
                                               <double*> res.data,
                                               <double*> p1.data, &error_status);
        elif nargs == 2:
            camns_interface.ITM_AMNS_CC_RX_3_B(self._handle, p1.shape[0], p1.shape[1], p1.shape[2],
                                               <double*> res.data,
                                               <double*> p1.data,
                                               <double*> p2.data, &error_status);
        elif nargs == 3:
            camns_interface.ITM_AMNS_CC_RX_3_C(self._handle, p1.shape[0], p1.shape[1], p1.shape[2],
                                               <double*> res.data,
                                               <double*> p1.data,
                                               <double*> p2.data,
                                               <double*> p3.data, &error_status);

        if error_status.flag:
            raise AmnsException(error_status.string)
        return res


cdef class Reactants:
#    """Class providing the machanism for indicating reactants and products"""
    cdef void* _handle
    cdef _reactants

    def __cinit__(self):
        pass

    def __init__(self):
        self._handle = NULL
        self._reactants= []
        pass

    cdef void* handle(self):
        cdef camns_interface.amns_c_reactant_type reactant
        if self._handle == NULL:
            camns_interface.ITM_AMNS_CC_SETUP_REACTANTS(&self._handle, "", 0, len(self._reactants));
            for i, reactant in enumerate(self._reactants):
                camns_interface.ITM_AMNS_CC_SET_REACTANT(self._handle, i+1, &reactant);
        return self._handle

    def _invalidate_handle(self):
        if self._handle != NULL:
            camns_interface.ITM_AMNS_CC_FINISH_REACTANTS(&self._handle)
            self._handle = NULL

    def add(self, zn, za, mi, lr=None, real_specifier=None, int_specifier=None):
        """Add to the list of reactants/products"""
        cdef camns_interface.amns_c_reactant_type r
        r = camns_interface.get_default_amns_c_reactant_type()
        self._invalidate_handle()
        r.ZN = zn
        r.ZA = za
        r.MI = mi
        if lr: r.LR = lr
        if real_specifier: r.real_specifier = real_specifier
        if int_specifier: r.int_specifier = int_specifier
        self._reactants.append(r)

    def __len__(self):
        """Return the number of reactants/products"""
        return len(self._reactants)

    def __str__(self):
        """Return a string version of all the reactants/products"""
        return str(self._reactants)

    def test(self):
        cdef void* handle
        handle = self.handle()

    def value(self):
        """Return all of the reactants/products"""
        return self._reactants


class AmnsException(Exception):
    pass