Changed C API Numpy library to directly access molfile structure data

pymolfile/molfile/1

+import numpy
+import ctypes
+import _libpymolfile
+
+class molatom_t(ctypes.Structure):
+    _fields_ = [
+        ('name', ctypes.c_char * 16),
+        ('type', ctypes.c_char * 16),
+        ('resname', ctypes.c_char * 8),
+        ('resid', ctypes.c_uint8),
+        ('segid', ctypes.c_char * 8),
+        ('chain', ctypes.c_char * 2),
+        ('altloc', ctypes.c_char * 2),
+        ('insertion', ctypes.c_char *2),
+        ('occupancy', ctypes.c_float),
+        ('bfactor', ctypes.c_float),
+        ('mass', ctypes.c_float),
+        ('charge', ctypes.c_float),
+        ('radius', ctypes.c_float),
+        ('atomicnumber', ctypes.c_uint8),
+        ('ctnumber', ctypes.c_uint8),
+    ]
+
+class molplugin_t(ctypes.Structure):
+    _fields_ = [
+        ('abiversion', ctypes.c_uint8),
+        ('type', ctypes.c_char_p),
+        ('name', ctypes.c_char_p),
+        ('prettyname', ctypes.c_char_p),
+        ('author', ctypes.c_char_p),
+        ('majorv', ctypes.c_uint8),
+        ('minorv', ctypes.c_uint8),
+        ('is_reentrant', ctypes.c_uint8), 
+        ('filename_extension', ctypes.c_char_p),
+        ('open_file_read', ctypes.CFUNCTYPE(ctypes.c_char_p, 
+            ctypes.c_char_p, ctypes.POINTER(ctypes.c_uint8))),
+        ('read_structure', ctypes.CFUNCTYPE(ctypes.c_void_p, 
+            ctypes.POINTER(ctypes.c_uint), ctypes.POINTER(molatom_t))),
+        ('read_bonds', ctypes.CFUNCTYPE(ctypes.c_void_p,
+            ctypes.POINTER(ctypes.c_uint), ctypes.POINTER(ctypes.c_uint), ctypes.POINTER(ctypes.c_uint),
+            ctypes.POINTER(ctypes.c_float), ctypes.POINTER(ctypes.c_uint), ctypes.POINTER(ctypes.c_uint),
+            ctypes.c_char_p)),
+        ('read_next_timestep', ctypes.c_int8),
+        ('close_file_read', ctypes.c_void_p),
+        ('open_file_write', ctypes.c_void_p),
+        ('write_structure', ctypes.c_int8),
+        ('write_timestep', ctypes.c_int8),
+        ('close_file_write', ctypes.c_void_p),
+        ('read_volumetric_metadata', ctypes.c_int8),
+        ('read_volumetric_data', ctypes.c_int8),
+        ('read_volumetric_data_ex', ctypes.c_int8),
+        ('read_rawgraphics', ctypes.c_int8),
+        ('read_molecule_metadata', ctypes.c_int8),
+        ('write_bonds', ctypes.c_int8),
+        ('write_volumetric_data', ctypes.c_int8),
+        ('write_volumetric_data_ex', ctypes.c_int8),
+        ('read_angles', ctypes.c_int8),
+        ('write_angles', ctypes.c_int8),
+        ('read_qm_metadata', ctypes.c_int8),
+        ('read_qm_rundata', ctypes.c_int8),
+        ('read_timestep', ctypes.c_int8),
+        ('read_timestep_metadata', ctypes.c_int8),
+        ('read_qm_timestep_metadata', ctypes.c_int8),
+        ('read_timestep2', ctypes.c_int8),
+        ('read_times', ctypes.c_ssize_t),
+        ('cons_fputs', ctypes.c_uint8)
+    ]
+
+class moltimestep_t(ctypes.Structure):
+    _fields_ = [
+        ('coords', ctypes.POINTER(ctypes.c_float)),
+        ('velocities', ctypes.POINTER(ctypes.c_float)),
+        ('A', ctypes.c_float),
+        ('B', ctypes.c_float),
+        ('C', ctypes.c_float),
+        ('alpha', ctypes.c_float),
+        ('beta', ctypes.c_float),
+        ('gamma', ctypes.c_float),
+        ('physical_time', ctypes.c_double),
+        ('total_energy', ctypes.c_double),
+        ('potential_energy', ctypes.c_double),
+        ('kinetic_energy', ctypes.c_double),
+        ('extended_energy', ctypes.c_double),
+        ('force_energy', ctypes.c_double),
+        ('total_pressure', ctypes.c_double)
+    ]
+
+class molhandle_t(ctypes.Structure):
+    _fields_ = [
+        ('plugin', ctypes.POINTER(molplugin_t)),
+        ('file_handle', ctypes.c_void_p),
+        ('natoms', ctypes.c_int)
+    ]
+
+class molnatoms(ctypes.Structure):
+    _fields_ = [
+        ('natoms', ctypes.c_int)
+    ]
+
+#callback_t = ctypes.CFUNCTYPE(None, ctypes.POINTER(molatom_t))
+
+def get_open_file_read(output):
+    ctypes.open_file_read.restype = ctypes.POINTER(molhandle_t)
+    ctypes.open_file_read.argtypes = [ctypes.POINTER(molplugin_t), ctypes.c_void_p, ctypes.c_uint8]
+    return ctypes.pythonapi.PyCapsule_GetPointer(output, "plugin")
+
+def get_capsule(capsule):
+    ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.c_void_p
+    ctypes.pythonapi.PyCapsule_GetPointer.argtypes = [ctypes.py_object, ctypes.c_char_p]
+    return ctypes.pythonapi.PyCapsule_GetPointer(capsule, b"plugin")
+
+def get_plugincapsule(capsule):
+    data = ctypes.POINTER(molhandle_t)
+    ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.POINTER(molhandle_t)
+    ctypes.pythonapi.PyCapsule_GetPointer.argtypes = [ctypes.py_object, ctypes.c_char_p]
+    data = ctypes.pythonapi.PyCapsule_GetPointer(capsule, b"plugin")
+    return data
+
+def get_plugindata(capsule):
+    data = ctypes.POINTER(molhandle_t)
+    ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.POINTER(molhandle_t)
+    ctypes.pythonapi.PyCapsule_GetPointer.argtypes = [ctypes.py_object, ctypes.c_char_p]
+    data = ctypes.pythonapi.PyCapsule_GetPointer(capsule, b"plugin")
+    return data
+
+mylib = _libpymolfile
+mylist  = mylib.molfile_plugin_list(200)
+numlist = mylib.molfile_init()
+print(numlist)
+for i in range(numlist):
+    testplugin = mylib.molfile_plugin_info(mylist, i)
+    print(i, testplugin)
+
+plugin = mylib.get_plugin(mylist, 81)
+print(plugin)
+natoms=0
+numatoms=molnatoms(natoms)
+fname="../../test/md.gro"
+ftype="gro"
+
+pluginhandle = mylib.open_file_read(plugin, fname, ftype, natoms)
+print("This passed")
+print(pluginhandle)
+print("This passed too")
+print(pluginhandle.natoms)
+print("Here")
+
+x = numpy.array([
+    ('C1','C','ACE',0,'','','','',1.0,1.0,12.011,6,1.0,6), 
+    ('C2','C','ACE',0,'','','','',1.0,1.0,12.011,6,1.0,6)
+    ],
+    dtype=[
+        ('name', 'S16'), ('type', 'S16'), ('resname', 'S8'),
+        ('resid', 'i4'), ('segid', 'S8'), ('chain', 'S2'),
+        ('altloc', 'S2'), ('insertion', 'S2'), ('occupancy', 'f8'),
+        ('bfactor', 'f8'), ('mass', 'f8'), ('charge', 'f8'),
+        ('radius', 'f8'), ('atomicnumber', 'i4')
+        ]
+    )
+print(x)
+print(x.__array_interface__)
+print(x.__array_interface__["descr"])
+print(x.__array_struct__)
+#y = mylib.read_fill_structure(pluginhandle, x)
+y = mylib.print_array_struct(x)
+print('Test')
+print(y)
+#outarray = mylib.get_structure(pluginhandle)
+#print(outarray)
+#print(type(outarray))
+#for i in outarray:
+#    print(i)
+
+

pymolfile/molfile/compile-numind.sh

+Cython -a numind.pyx --cplus
+g++ -fPIC -Wall -Wextra -Wunused-function -shared -I/labEnv3/lib/python3.6/site-packages/numpy/core/include/ numind.cpp -o numind.so -I/labEnv3/include/python3.6m/ -L/usr/local/Cellar/python3/3.6.1/Frameworks/Python.framework/Versions/3.6/lib -lpython3.6

pymolfile/molfile/compile-signedintbuf.sh

+swig -py3 -Wall -c++ -python numpy_swig.i
+g++ -fPIC -Wall -Wextra -Wunused-function -shared -I/labEnv3/lib/python3.6/site-packages/numpy/core/include/ -I. numpy_swig_wrap.cxx -o _numpy_swig.so -I/labEnv3/include/python3.6m/ -L/usr/local/Cellar/python3/3.6.1/Frameworks/Python.framework/Versions/3.6/lib -lpython3.6

pymolfile/molfile/compile.sh

 swig -py3 -Wall -c++ -python libpymolfile.i
-g++ -fPIC -Wall -Wextra -Wunused-function -shared -I/labEnv3/lib/python3.6/site-packages/numpy/core/include/ -I. libpymolfile_wrap.cxx pymolfile.c -o _libpymolfile.so -Ivmd_molfile_plugins/include/ -Ilib/ -L. lib/libmolfile_plugin.a  -I/labEnv3/include/python3.6m/ -L/usr/local/Cellar/python3/3.6.1/Frameworks/Python.framework/Versions/3.6/lib -lpython3.6
+g++ -fPIC -Wall -Wextra -Wunused-function -shared -g -I/labEnv3/lib/python3.6/site-packages/numpy/core/include/ -I. libpymolfile_wrap.cxx pymolfile.c -o _libpymolfile.so -Ivmd_molfile_plugins/include/ -Ilib/ -L. lib/libmolfile_plugin.a  -I/labEnv3/include/python3.6m/ -L/usr/local/Cellar/python3/3.6.1/Frameworks/Python.framework/Versions/3.6/lib -lpython3.6

pymolfile/molfile/libpymolfile-backup2.i

+/* -*- C -*-  (not really, but good for syntax highlighting) */
+/* SWIG interface for libpymolfile of VMD molfile_plugins
+   Copyright (c) 2017 Berk Onat <b.onat@warwick.ac.uk>
+   Published under UIUC LICENSE
+
+   swig -c++ -python -outdir . molfile/libpymolfile.i
+*/
+%define DOCSTRING
+"
+:Author:  Berk Onat <b.onat@warwick.ac.uk>
+:Year:    2017
+:Licence: UIUC LICENSE
+
+
+"
+%enddef
+
+%module(docstring=DOCSTRING) libpymolfile
+
+
+%{
+/* Python SWIG interface to libpymolfile
+   Copyright (c) 2017 Berk Onat <b.onat@warwick.ac.uk>
+   Published under BSD LICENSE
+ */
+#define SWIG_FILE_WITH_INIT
+#define __STDC_FORMAT_MACROS
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include <inttypes.h>
+#include "molfile_plugin.h"
+#include "libmolfile_plugin.h"
+#include "vmdplugin.h"
+#include "pymolfile.h"
+%}
+
+%include "numpy.i"
+
+%init %{
+Py_Initialize();
+import_array();
+%}
+
+
+/* 
+  Wrapping only high-level plugin functions to register VMD 
+  plugins and to retrive the data through molfile_plugin interface.
+
+  Only modifing call signatures. This will help one to access functions 
+  without dealing with pointers from python.
+*/
+
+
+/* plugin status codes for error handling */
+enum { pluginOK, pluginNOINIT, pluginCLOSE, pluginNOMEM, 
+       pluginENDOFFILE, pluginFILENOTFOUND, pluginFORMATERROR };
+
+
+/* Definition of molfile_atoms_t from molfile_plugin.h */
+%inline %{
+
+/*
+struct MolAtoms {
+    char name[16]; 
+    char type[16]; 
+    char resname[8];
+    int resid;
+    char segid[8];
+    char chain[2];
+    char altloc[2];
+    char insertion[2];
+    float occupancy;
+    float bfactor;
+    float mass;
+    float charge;
+    float radius;
+    float atomicnumber;
+    float ctnumber;
+};
+
+void del_plugin_structure(PyObject* pymolfile_atoms){
+    delete (MolAtoms*)PyCapsule_GetPointer(pymolfile_atoms, "plugin_structure");
+}
+
+static PyObject* alloc_plugin_structure(PyObject *self, PyObject *args) {
+    return PyCapsule_New((void*)new MolAtoms(), "plugin_structure", del_plugin_structure);
+}
+*/
+void del_plugin(PyObject* pymolfile_plugin){
+    delete (MolObject*)PyCapsule_GetPointer(pymolfile_plugin, "plugin");
+}
+
+void del_atoms(PyObject* pymolfile_atoms){
+    delete (PyObject*)PyCapsule_GetPointer(pymolfile_atoms, "atoms");
+}
+
+void del_atomname(PyObject* pymolfile_atoms){
+    delete (PyObject*)PyCapsule_GetPointer(pymolfile_atoms, "atomname");
+}
+
+
+static PyObject* alloc_plugin(PyObject *self, PyObject *args) {
+    return PyCapsule_New((void*)new MolObject(), "plugin_handle", del_plugin);
+}
+
+%}
+
+
+/* pymolfile.c 
+   initialize and finalize molfile plugins
+*/
+%feature("autodoc", "0") molfile_plugin_list;
+extern molfile_plugin_t** molfile_plugin_list(int maxsize);
+
+%feature("autodoc", "0") molfile_init;
+extern int molfile_init(void);
+
+%feature("autodoc", "0") molfile_finish;
+extern int molfile_finish(void);
+
+%feature("autodoc", "0") get_plugin;
+extern molfile_plugin_t* get_plugin(molfile_plugin_t** plugin_list, int plugin_no);
+
+%feature("autodoc", "0") molfile_plugin_info;
+%exception molfile_plugin_info {
+  $action
+  if (PyErr_Occurred()) SWIG_fail;
+}
+%inline %{
+PyObject * molfile_plugin_info(molfile_plugin_t** plugin_list, int plugin_no) {
+    molfile_plugin_t *plugin;
+    int *plugno = &plugin_no;
+    int has_readstructure = 0;
+    int has_readbonds = 0;
+    int has_readangles = 0;
+    int has_writestructure = 0;
+    int has_writebonds = 0;
+    int has_writeangles = 0;
+    int has_readnexttimestep = 0;
+    int has_writetimestep = 0;
+    int plugin_list_size = sizeof(plugin_list) / sizeof(molfile_plugin_t**);
+    if (plugno==NULL || plugin_no<0){
+      PyErr_Format(PyExc_IOError, "[%d] Error: molfile plugin handle no should be given, be positive value and should not exceed the list length'%d'. You set '%d'", pluginNOINIT, plugin_list_size, plugin_no);
+      return 0;
+    }
+    plugin = plugin_list[plugin_no];
+    if(plugin==NULL || !plugin->open_file_read){
+      PyErr_Format(PyExc_IOError, "[%d] Error: molfile plugin '%d' is not initialized.", pluginNOINIT, plugin_no);
+      return 0;
+    }
+    if (plugin->read_structure) has_readstructure = 1;
+    if (plugin->read_bonds) has_readbonds = 1;
+    if (plugin->read_angles) has_readangles = 1;
+    if (plugin->read_next_timestep) has_readnexttimestep = 1;
+    if (plugin->write_structure) has_writestructure = 1;
+    if (plugin->write_bonds) has_writebonds = 1;
+    if (plugin->write_angles) has_writeangles = 1;
+    if (plugin->write_timestep) has_writetimestep = 1;
+    PyObject *tuple = PyTuple_New(17);
+    PyTuple_SET_ITEM(tuple, 0, PyString_FromString(plugin->filename_extension));
+    PyTuple_SET_ITEM(tuple, 1, PyString_FromString(plugin->name));
+    PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong((long)has_readstructure));
+    PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong((long)has_readbonds));
+    PyTuple_SET_ITEM(tuple, 4, PyInt_FromLong((long)has_readangles));
+    PyTuple_SET_ITEM(tuple, 5, PyInt_FromLong((long)has_readnexttimestep));
+    PyTuple_SET_ITEM(tuple, 6, PyInt_FromLong((long)has_writestructure));
+    PyTuple_SET_ITEM(tuple, 7, PyInt_FromLong((long)has_writebonds));
+    PyTuple_SET_ITEM(tuple, 8, PyInt_FromLong((long)has_writeangles));
+    PyTuple_SET_ITEM(tuple, 9, PyInt_FromLong((long)has_writetimestep));
+    PyTuple_SET_ITEM(tuple, 10, PyString_FromString(plugin->prettyname));
+    PyTuple_SET_ITEM(tuple, 11, PyString_FromString(plugin->type));
+    PyTuple_SET_ITEM(tuple, 12, PyString_FromString(plugin->author));
+    PyTuple_SET_ITEM(tuple, 13, PyInt_FromLong((long)plugin->majorv));
+    PyTuple_SET_ITEM(tuple, 14, PyInt_FromLong((long)plugin->minorv));
+    PyTuple_SET_ITEM(tuple, 15, PyInt_FromLong((long)plugin->abiversion));
+    PyTuple_SET_ITEM(tuple, 16, PyInt_FromLong((long)plugin->is_reentrant));
+    return tuple;
+  }
+%}
+
+
+%feature("autodoc", "0") my_open_file_read;
+%rename (open_file_read) my_open_file_read;
+%exception my_open_file_read {
+  $action
+  if (PyErr_Occurred()) SWIG_fail;
+}
+%inline %{
+PyObject * my_open_file_read(molfile_plugin_t* plugin, char* fname, char* ftype, int natoms) {
+    if (PyType_Ready(&MolObjectType) < 0)
+        return NULL;
+    PyTypeObject *type = &MolObjectType;
+    /*plugin_handle = PyCapsule_New((void*)new MolObject(), "plugin", del_plugin); */
+    /*MolObject* plugin_c = new MolObject;*/
+    MolObject *plugin_c;
+    plugin_c = (MolObject *)type->tp_alloc(type, 0);
+    /*PyObject * plugin_c = MolObject_new(&MolObjectType, args, kwds);*/
+    plugin_c->plugin = plugin;
+    plugin_c->file_handle = plugin->open_file_read(fname, ftype, &natoms);
+    plugin_c->natoms = natoms;
+    /* PyCapsule_SetPointer(plugin_handle, &plugin_c); */
+    /* PyObject* plugin_handle = PyCapsule_New((void*)plugin_c, "plugin", del_plugin); */
+    PyObject* plugin_handle = (PyObject *)plugin_c;
+    /*if(!plugin_handle) printf("Not assigned\n");*/
+    /*PyObject *tuple = PyTuple_New(2);
+    PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong((long)natoms));
+    PyTuple_SET_ITEM(tuple, 1, plugin_handle);*/
+    return plugin_handle;
+  }
+%}
+
+/*
+%typemap( argout ) ( char **MolfileAtomT_CharArray )
+{
+    // The result variable is the return value from
+    // c_ephcom_read_constants, the number of actual values that are
+    // defined for cnames/values.
+    npy_intp     dims[] = { result };
+    PyArray_Dims newshape_location;
+    PyArray_Dims * newshape = &newshape_location;
+    PyObject * status_check;
+    newshape->len = 1;
+    newshape->ptr = dims;
+
+    // resize array$argnum to actual size needed.
+    // Follow directions at http://www.mail-archive.com/numpy-discussion@scipy.org/msg13013.html
+    status_check = PyArray_Resize( (PyArrayObject *) array$argnum, newshape, 0, NPY_CORDER );
+    if ( !status_check )
+        SWIG_fail;
+    Py_DECREF( status_check );
+    $result = SWIG_Python_AppendOutput( $result, array$argnum );
+}
+%typemap( freearg ) ( char **MolfileAtomT_CharArray )
+{
+    free( $1 );
+}
+*/
+
+/*
+#define DIM 3
+typedef int imatrix[DIM][DIM];
+typedef int ivec[DIM];
+typedef float fmatrix[DIM][DIM];
+typedef float fvec[DIM];
+*/
+
+/* Reading from xdr files */
+/*
+%apply (float INPLACE_ARRAY2[ANY][ANY]) {(matrix box)}
+%apply (int DIM1, int DIM2, float* INPLACE_ARRAY2) {(int natoms,  int _DIM,  float *x),
+                                                    (int vnatoms, int v_DIM, float *v),
+                                                    (int fnatoms, int f_DIM, float *f)}
+*/
+/*
+%apply (int INPLACE_IARRAY2[ANY][ANY]) {(imatrix intdata)}
+%apply (float INPLACE_FARRAY2[ANY][ANY]) {(fmatrix floatdata)}
+%apply (int DIM1, int* INPLACE_IARRAY2) {(int rnatoms, int* MolAtom_resid)}
+%apply (int DIM1, float* INPLACE_FARRAY2) {(int mnatoms, float* MolAtom_mass),
+                                           (int anatoms, float* MolAtom_atomicnumber)}
+*/
+/*
+%inline %{
+int structure_read(molfile_plugin_t* plugin, void* fhandle, int *options, 
+                   int* natoms, char** MolAtom_name, 
+                   int* natoms, char** MolAtom_type, 
+                   int* natoms, char** MolAtom_resname,
+                   int* natoms, int**  MolAtom_resid, 
+                   int* natoms, char** MolAtom_segid,
+                   int* natoms, char** MolAtom_chain,
+                   int* natoms, char** MolAtom_altloc,
+                   int* natoms, char** MolAtom_insertion,
+                   int* natoms, float** MolAtom_occupancy,
+                   int* natoms, float** MolAtom_bfactor,
+                   int* natoms, float** MolAtom_mass,
+                   int* natoms, float** MolAtom_charge,
+                   int* natoms, float** MolAtom_radius,
+                   int* natoms, float** MolAtom_atomicnumber,
+                   int* natoms, float** MolAtom_ctnumber) {
+    molfile_atom_t* atoms;
+    atoms = (molfile_atom_t *)calloc(natoms,sizeof(molfile_atom_t));
+    plugin->read_structure(fhandle, options, atoms);
+    MolAtom_name = (char **)malloc(natoms,sizeof(char*));
+    MolAtom_type = (char **)malloc(natoms,sizeof(char*));
+    MolAtom_resname = (char **)malloc(natoms,sizeof(char*));
+    MolAtom_resid = (int **)malloc(natoms,sizeof(int*));
+%}
+*/
+/*
+%inline %{
+int structure_read(molfile_plugin_t* plugin, void* fhandle, int *options, 
+                   int natoms, char** MolAtom_name, 
+                   int tnatoms, char** MolAtom_type, 
+                   int rnatoms, int*  MolAtom_resid, 
+                   int mnatoms, float* MolAtom_mass,
+                   int anatoms, float* MolAtom_atomicnumber) {
+    int i;
+    molfile_atom_t* atoms;
+    molfile_atom_t atm;
+    atoms = (molfile_atom_t *)calloc(natoms,sizeof(molfile_atom_t));
+    plugin->read_structure(fhandle, options, atoms);
+    if(atoms == NULL) { free(atoms); return 1; }
+    if(atoms->type == NULL || atoms->name == NULL){ free(atoms); return 1; }
+    MolAtom_name = (char **)malloc(natoms,sizeof(char*));
+    MolAtom_type = (char **)malloc(natoms,sizeof(char*));
+    MolAtom_resid = (int *)malloc(natoms,sizeof(int));
+    MolAtom_mass = (float *)malloc(natoms,sizeof(float));
+    MolAtom_atomicnumber = (float *)malloc(natoms,sizeof(float));
+    for (i=0;i<natoms;i++){
+        atm = atoms[i];
+        MolAtom_name[i] = atm.name;
+        MolAtom_type[i] = atm.type;
+        MolAtom_resid[i] = atm.resid;
+        MolAtom_mass[i] = atm.mass;
+        MolAtom_atomicnumber[i] = atm.atomicnumber;
+    }
+    return 0;
+    }
+%}
+*/
+
+%feature("autodoc", "0") my_read_structure;
+%rename (read_structure) my_read_structure;
+extern PyObject * my_read_structure(PyObject* molpack);
+
+%feature("autodoc", "0") get_structure;
+extern PyObject * get_structure(PyObject* molpack);
+
+/*
+%feature("autodoc", "0") my_read_structure;
+%rename (read_structure) my_read_structure;
+%exception my_read_structure {
+  $action
+  if (PyErr_Occurred()) SWIG_fail;
+}
+%inline %{
+PyObject * my_read_structure(PyObject* molpack) {
+    int options = 0;
+    int i;
+    molfile_plugin_t* plugin;
+    void* file_handle;
+    molfile_atom_t* atoms;
+    int numatoms, status;
+    char** atom_names;
+    char** atom_types;
+    PyObject *npatoms = NULL; */
+    /*MolObject* plugin_handle = (MolObject*)PyCapsule_GetPointer(molpack, "plugin");*/
+/*    MolObject* plugin_handle = (MolObject*)molpack;
+    plugin = plugin_handle->plugin;
+    file_handle = plugin_handle->file_handle;
+    numatoms = plugin_handle->natoms;
+    atoms = (molfile_atom_t *)calloc(numatoms,sizeof(molfile_atom_t));
+    printf("Test1\n");
+    status = plugin->read_structure(file_handle, &options, atoms);
+    printf("Test2 %d\n",status);
+    if (status!=0){
+      PyErr_Format(PyExc_IOError, "Error copying molfile_atom_t into Python.");
+      return NULL;
+    }
+    printf("Test3\n");
+    npy_intp natoms[1] = { numatoms };
+    
+    PyArrayObject* oresid;
+    int64_t* cresid;
+    
+    int typenum;
+    int nd = 1;
+    npy_intp dims[1] = { numatoms }; */
+    /*dims[0] = numatoms;*/
+/*    oresid = (PyArrayObject*) PyArray_SimpleNew(nd, dims, NPY_INT64);
+    npy_intp* n = PyArray_DIMS(oresid);
+    printf("dimensions %ld\n", n[0]);
+    cresid = (int64_t*) PyArray_DATA(oresid);
+    
+    PyObject* npatomresid = NULL;
+    char** MolAtom_name = (char **)malloc(numatoms*sizeof(char*));
+    char** MolAtom_type = (char **)malloc(numatoms*sizeof(char*));
+    int64_t* MolAtom_resid = NULL; */
+    /*int64_t* MolAtom_resid = (int64_t *)malloc(numatoms*sizeof(int64_t));*/
+/*    float* MolAtom_mass = (float *)malloc(numatoms*sizeof(float));
+    float* MolAtom_atomicnumber = (float *)malloc(numatoms*sizeof(float));
+    for (i=0;i<numatoms;i++){
+        MolAtom_name[i] = atoms[i].name;
+        MolAtom_type[i] = atoms[i].type;
+        cresid[i] = (int64_t) atoms[i].resid;
+        MolAtom_mass[i] = atoms[i].mass;
+        MolAtom_atomicnumber[i] = atoms[i].atomicnumber;
+    } */
+    /*Py_DECREF( obj );*/
+    /*npy_intp dims[3];*/ /* PyArray_AsCArray is for ndim <= 3 */
+/*    PyArray_Descr *descr;
+    npatoms = PyArray_SimpleNewFromData(1, natoms, NPY_USERDEF, atoms);
+    printf("Test4 numatoms=%d\n", numatoms);
+    PyObject* npatomname = NULL;
+    npatomname = PyArray_SimpleNewFromData(1, natoms, NPY_STRING, MolAtom_name[0]);
+    PyObject* npatomtype = PyArray_SimpleNewFromData(1, natoms, NPY_STRING, MolAtom_type); */
+    /*PyObject* npatomresname = PyArray_SimpleNewFromData(1, natoms, NPY_STRING, atoms->resname);*/
+    /*PyObject* npatomsegid = PyArray_SimpleNewFromData(1, natoms, NPY_STRING, atoms->segid);*/
+    /*PyObject* npatomchain = PyArray_SimpleNewFromData(1, natoms, NPY_STRING, atoms->chain);*/
+    /*PyObject* npatomaltloc = PyArray_SimpleNewFromData(1, natoms, NPY_STRING, atoms->altloc);*/
+    /*PyObject* npatominsert = PyArray_SimpleNewFromData(1, natoms, NPY_STRING, atoms->insertion);*/
+    /*PyObject* npatomoccup = PyArray_SimpleNewFromData(1, natoms, NPY_FLOAT64, &atoms->occupancy);*/
+    /*PyObject* npatombfact = PyArray_SimpleNewFromData(1, natoms, NPY_FLOAT64, &atoms->bfactor);*/
+/*    PyObject* npatommass = PyArray_SimpleNewFromData(1, natoms, NPY_FLOAT64, MolAtom_mass);    */
+    /*PyObject* npatomcharge = PyArray_SimpleNewFromData(1, natoms, NPY_FLOAT64, &atoms->charge);*/
+    /*PyObject* npatomradius = PyArray_SimpleNewFromData(1, natoms, NPY_FLOAT64, &atoms->radius);*/
+/*    PyObject* npatomicnumber = PyArray_SimpleNewFromData(1, natoms, NPY_INT64, MolAtom_atomicnumber); */
+    /*if (npatomname==NULL   || npatomtype==NULL     || npatomresname==NULL || 
+        npatomresid==NULL  || npatomsegid==NULL    || npatomchain==NULL   )
+    {
+      free(atoms);
+      Py_XDECREF(npatomname);   Py_XDECREF(npatomtype);
+      Py_XDECREF(npatomresname); Py_XDECREF(npatomresid);  Py_XDECREF(npatomsegid); 
+      Py_XDECREF(npatomchain);   Py_XDECREF(npatomaltloc); Py_XDECREF(npatominsert); 
+      Py_XDECREF(npatomoccup);   Py_XDECREF(npatombfact);  Py_XDECREF(npatommass); 
+      Py_XDECREF(npatomcharge);  Py_XDECREF(npatomradius); Py_XDECREF(npatomicnumber); 
+      PyErr_Format(PyExc_IOError, "Error copying molfile_atom_t into Python.");
+      return 0;
+    }
+    PyArray_BASE(npatomname) = PyCObject_FromVoidPtr(*atoms, free);
+    PyArray_BASE(npatomtype) = PyCObject_FromVoidPtr(*atoms, free);
+    PyArray_BASE(npatomresname) = PyCObject_FromVoidPtr(*atoms, free); 
+    PyArray_BASE(npatomresid) = PyCObject_FromVoidPtr(*atoms, free);  
+    PyArray_BASE(npatomsegid) = PyCObject_FromVoidPtr(*atoms, free); 
+    PyArray_BASE(npatomchain) = PyCObject_FromVoidPtr(*atoms, free);   
+    PyArray_BASE(npatomaltloc) = PyCObject_FromVoidPtr(*atoms, free); 
+    PyArray_BASE(npatominsert) = PyCObject_FromVoidPtr(*atoms, free); 
+    PyArray_BASE(npatomoccup) = PyCObject_FromVoidPtr(*atoms, free);   
+    PyArray_BASE(npatombfact) = PyCObject_FromVoidPtr(*atoms, free);  
+    PyArray_BASE(npatommass) = PyCObject_FromVoidPtr(*atoms, free); 
+    PyArray_BASE(npatomcharge) = PyCObject_FromVoidPtr(*atoms, free);  
+    PyArray_BASE(npatomradius) = PyCObject_FromVoidPtr(*atoms, free); 
+    PyArray_BASE(npatomicnumber) = PyCObject_FromVoidPtr(*atoms, free);
+    PyArray_BASE(npatoms) = PyCObject_FromVoidPtr(atoms, free);