Added cmake installer for linmolfile+plugins.a

build/lib.macosx-10.12-x86_64-3.6/pymolfile/__init__.py

+
+from __future__ import absolute_import
+import warnings
+
+try:
+    from .molfile import libpymolfile
+except ImportError:
+    warnings.warn("libpymolfile package not available, pymolfile does not work without its library!")
+
+from . import plugin_list
+from . import pymolfile
+
+__all__ = [ "pymolfile" ]
+
+from .pymolfile import OpenMolfile, list_plugins
+

build/lib.macosx-10.12-x86_64-3.6/pymolfile/molfile/__init__.py

+
+# Stand-alone python bindings for libpymolfile
+# Copyright (c) 2017 Berk Onat <b.onat@warwick.ac.uk>
+# Published under the UIUC OpenSource LICENSE 
+"""libpymolfile library.
+
+"""

build/lib.macosx-10.12-x86_64-3.6/pymolfile/molfile/libpymolfile.py

+# This file was automatically generated by SWIG (http://www.swig.org).
+# Version 3.0.12
+#
+# Do not make changes to this file unless you know what you are doing--modify
+# the SWIG interface file instead.
+
+"""
+
+:Author:  Berk Onat <b.onat@warwick.ac.uk>
+:Year:    2017
+:Licence: UIUC LICENSE
+
+
+
+"""
+
+
+from sys import version_info as _swig_python_version_info
+if _swig_python_version_info >= (2, 7, 0):
+    def swig_import_helper():
+        import importlib
+        pkg = __name__.rpartition('.')[0]
+        mname = '.'.join((pkg, '_libpymolfile')).lstrip('.')
+        try:
+            return importlib.import_module(mname)
+        except ImportError:
+            return importlib.import_module('_libpymolfile')
+    _libpymolfile = swig_import_helper()
+    del swig_import_helper
+elif _swig_python_version_info >= (2, 6, 0):
+    def swig_import_helper():
+        from os.path import dirname
+        import imp
+        fp = None
+        try:
+            fp, pathname, description = imp.find_module('_libpymolfile', [dirname(__file__)])
+        except ImportError:
+            import _libpymolfile
+            return _libpymolfile
+        try:
+            _mod = imp.load_module('_libpymolfile', fp, pathname, description)
+        finally:
+            if fp is not None:
+                fp.close()
+        return _mod
+    _libpymolfile = swig_import_helper()
+    del swig_import_helper
+else:
+    import _libpymolfile
+del _swig_python_version_info
+
+try:
+    _swig_property = property
+except NameError:
+    pass  # Python < 2.2 doesn't have 'property'.
+
+try:
+    import builtins as __builtin__
+except ImportError:
+    import __builtin__
+
+def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
+    if (name == "thisown"):
+        return self.this.own(value)
+    if (name == "this"):
+        if type(value).__name__ == 'SwigPyObject':
+            self.__dict__[name] = value
+            return
+    method = class_type.__swig_setmethods__.get(name, None)
+    if method:
+        return method(self, value)
+    if (not static):
+        if _newclass:
+            object.__setattr__(self, name, value)
+        else:
+            self.__dict__[name] = value
+    else:
+        raise AttributeError("You cannot add attributes to %s" % self)
+
+
+def _swig_setattr(self, class_type, name, value):
+    return _swig_setattr_nondynamic(self, class_type, name, value, 0)
+
+
+def _swig_getattr(self, class_type, name):
+    if (name == "thisown"):
+        return self.this.own()
+    method = class_type.__swig_getmethods__.get(name, None)
+    if method:
+        return method(self)
+    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))
+
+
+def _swig_repr(self):
+    try:
+        strthis = "proxy of " + self.this.__repr__()
+    except __builtin__.Exception:
+        strthis = ""
+    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
+
+try:
+    _object = object
+    _newclass = 1
+except __builtin__.Exception:
+    class _object:
+        pass
+    _newclass = 0
+
+
+def molfile_plugin_list(maxsize: 'int') -> "PyObject *":
+    """molfile_plugin_list(maxsize) -> PyObject *"""
+    return _libpymolfile.molfile_plugin_list(maxsize)
+
+def molfile_init() -> "int":
+    """molfile_init() -> int"""
+    return _libpymolfile.molfile_init()
+
+def molfile_finish() -> "int":
+    """molfile_finish() -> int"""
+    return _libpymolfile.molfile_finish()
+
+def get_plugin(molcapsule: 'PyObject *', plug_no: 'int') -> "PyObject *":
+    """get_plugin(molcapsule, plug_no) -> PyObject *"""
+    return _libpymolfile.get_plugin(molcapsule, plug_no)
+
+def molfile_plugin_info(molcapsule: 'PyObject *', plugin_no: 'int') -> "PyObject *":
+    """molfile_plugin_info(molcapsule, plugin_no) -> PyObject *"""
+    return _libpymolfile.molfile_plugin_info(molcapsule, plugin_no)
+
+def open_file_read(molcapsule: 'PyObject *', fname: 'char *', ftype: 'char *', natoms: 'int') -> "PyObject *":
+    """open_file_read(molcapsule, fname, ftype, natoms) -> PyObject *"""
+    return _libpymolfile.open_file_read(molcapsule, fname, ftype, natoms)
+
+def close_file_read(molpack: 'PyObject *') -> "PyObject *":
+    """close_file_read(molpack) -> PyObject *"""
+    return _libpymolfile.close_file_read(molpack)
+
+def read_fill_structure(molpack: 'PyObject *', prototype: 'PyObject *') -> "PyObject *":
+    """read_fill_structure(molpack, prototype) -> PyObject *"""
+    return _libpymolfile.read_fill_structure(molpack, prototype)
+
+def read_fill_bonds(molpack: 'PyObject *') -> "PyObject *":
+    """read_fill_bonds(molpack) -> PyObject *"""
+    return _libpymolfile.read_fill_bonds(molpack)
+
+def read_fill_angles(molpack: 'PyObject *') -> "PyObject *":
+    """read_fill_angles(molpack) -> PyObject *"""
+    return _libpymolfile.read_fill_angles(molpack)
+
+def read_fill_next_timestep(molpack: 'PyObject *') -> "PyObject *":
+    """read_fill_next_timestep(molpack) -> PyObject *"""
+    return _libpymolfile.read_fill_next_timestep(molpack)
+
+def are_plugins_same(molpack_a: 'PyObject *', molpack_b: 'PyObject *') -> "PyObject *":
+    """are_plugins_same(molpack_a, molpack_b) -> PyObject *"""
+    return _libpymolfile.are_plugins_same(molpack_a, molpack_b)
+
+def are_filehandles_same(molpack_a: 'PyObject *', molpack_b: 'PyObject *') -> "PyObject *":
+    """are_filehandles_same(molpack_a, molpack_b) -> PyObject *"""
+    return _libpymolfile.are_filehandles_same(molpack_a, molpack_b)
+# This file is compatible with both classic and new-style classes.
+
+

build/lib.macosx-10.12-x86_64-3.6/pymolfile/plugin_list.py

+import warnings
+import sys
+
+from .molfile import libpymolfile
+try:
+    from .molfile import libpymolfile
+except ImportError:
+    warnings.warn("libpymolfile package not available, pymolfile does not work without its library!")
+
+MAX_NUM_PLUGINS = 200
+C_MOLFILE_PLUGINS = libpymolfile.molfile_plugin_list(MAX_NUM_PLUGINS)
+
+def byte_str_decode(data, dectype=None):
+    try:
+        return data.decode(dectype).replace('\x00', '')
+    except AttributeError:
+        return data
+
+def plugins():
+    """ Information on the available molfile plugins
+
+        Example tuple: ('psf', 'psf', 1, 1, 1, 0, 1, 1, 1, 0, 
+            'CHARMM,NAMD,XPLOR PSF', 'mol file reader', 
+            'Justin Gullingsrud, John Stone', 1, 9, 17, 1)
+
+        The fields in the tuple represent info in ordered as follows:
+            1: format extension
+            2: format name
+            3: read_structure is avaliable if 1
+            4: read_bonds is avaliable if 1
+            5: read_angles is avaliable if 1
+            6: read_next_timestep is avaliable if 1
+            7: write_structure is avaliable if 1
+            8: write_bonds is avaliable if 1
+            9: write_angles is avaliable if 1
+           10: write_timestep is avaliable if 1
+           11: long name of the plugin
+           12: type of plugin
+           13: authors of the plugin
+           14: major version of the plugin
+           15: minor version of the plugin
+           16: ABI version of the plugin
+           17: 1 if is reentrant (returns is_reentrant) 
+
+    Returns: A list of tuples that includes the information and 
+             capabilities of each molfile plugin. The information is 
+             extracted from molfile_plugin_t. 
+    """
+    global C_MOLFILE_PLUGINS
+    numlist = libpymolfile.molfile_init()
+    if sys.version_info > (3,):
+        basestring = str
+    plugins_list = [
+        [byte_str_decode(item, 
+            dectype="unicode_escape") for item in libpymolfile.molfile_plugin_info(
+            C_MOLFILE_PLUGINS, i)
+            ] for i in range(numlist)
+        ]
+    libpymolfile.molfile_finish()
+    return plugins_list
+
+MOLFILE_PLUGINS = plugins()
+

build/lib.macosx-10.12-x86_64-3.6/pymolfile/test_libpymolfile.py

+import numpy
+import molfile.libpymolfile as pym
+
+mylist  = pym.molfile_plugin_list(200)
+print(mylist)
+numlist = pym.molfile_init()
+print(numlist)
+for i in range(numlist):
+    testplugin = pym.molfile_plugin_info(mylist, i)
+    print(i, testplugin)
+
+#splugin = pym.get_plugin(mylist, 99) #pdb
+#cplugin = pym.get_plugin(mylist, 83) #trr
+#cplugin = pym.get_plugin(mylist, 85) #xtc
+splugin = pym.get_plugin(mylist, 105) #psf
+#splugin = pym.get_plugin(mylist, 81) #gro
+cplugin = pym.get_plugin(mylist, 69) #dcd
+#cplugin = pym.get_plugin(mylist, 126) #nc
+print(splugin)
+print(cplugin)
+natoms=0
+#sfname="../test/DPDP.pdb"
+#cfname="../test/DPDP.nc"
+
+#sfname="../test/ala3.pdb"
+sfname="../test/ala3.psf"
+cfname="../test/ala3.dcd"
+
+#sfname="../test/md.gro"
+#cfname="../test/md.trr"
+#cfname="../test/md.xtc"
+
+#sfname="../test/md_1u19.gro"
+#cfname="../test/md_1u19.xtc"
+
+#sftype="pdb"
+#cftype="trr"
+#cftype="xtc"
+sftype="psf"
+#sftype="gro"
+cftype="dcd"
+#cftype="nc"
+
+print("Structure plugin:")
+spluginhandle = pym.open_file_read(splugin, sfname, sftype, natoms)
+print("Coordinate plugin:")
+cpluginhandle = pym.open_file_read(cplugin, cfname, cftype, natoms)
+print(cpluginhandle)
+print(cpluginhandle.natoms)
+print(spluginhandle)
+print(spluginhandle.natoms)
+if cpluginhandle.natoms != spluginhandle.natoms:
+    print("Number of atoms do not match in structure and coordinate files.")
+    
+
+if pym.is_plugin_same(spluginhandle, cpluginhandle):
+    pym.close_file_read(cpluginhandle)
+    cpluginhandle = spluginhandle
+
+#if 0 && vmdplugin_ABIVERSION > 17
+#  /* The new PDB file formats allows for much larger structures, */
+#  /* which can therefore require longer chain ID strings.  The   */
+#  /* new PDBx/mmCIF file formats do not have length limits on    */
+#  /* fields, so PDB chains could be arbitrarily long strings     */
+#  /* in such files.  At present, we know we need at least 3-char */
+#  /* chains for existing PDBx/mmCIF files.                       */
+#  char chain[4];      /**< required chain name, or ""            */
+#else
+#  char chain[2];      /**< required chain name, or ""            */
+#endif
+# Change 'chain', 'S4' to S2 for PDB
+if 'pdb' in [sftype, cftype]:
+    print("file chain is set to S2")
+    chain_size = 'S2'
+else:
+    chain_size = 'S4'
+x = numpy.array([
+    ('C1','C','ACE',0,'','','','',1.0,1.0,1.0,1.0,1.0,6), 
+    ('C2','C','ACE',0,'','','','',1.0,1.0,1.0,1.0,1.0,6)
+    ],
+    dtype=[
+        ('name', 'S16'), ('type', 'S16'), ('resname', 'S8'),
+        ('resid', 'i4'), ('segid', 'S8'), ('chain', chain_size),
+        ('altloc', 'S2'), ('insertion', 'S2'), ('occupancy', 'f4'),
+        ('bfactor', 'f4'), ('mass', 'f4'), ('charge', 'f4'),
+        ('radius', 'f4'), ('atomicnumber', 'i4')
+        ]
+    )
+y = pym.read_fill_structure(spluginhandle, x)
+if y is not None:
+    print(y)
+    print(len(y))
+
+try:
+    z = pym.read_fill_bonds(spluginhandle)
+    if z is not None:
+        print(z)
+        print(len(z))
+except (AttributeError, SystemError):
+    pass
+
+try:
+    a = pym.read_fill_angles(spluginhandle)
+    if a is not None:
+        print(a)
+        print(len(a))
+except (AttributeError, SystemError):
+    pass
+
+if pym.is_plugin_same(spluginhandle, cpluginhandle):
+    pass
+else:
+    pym.close_file_read(spluginhandle)
+
+step=0
+while True:
+#while False:
+    try:
+        c = pym.read_fill_next_timestep(cpluginhandle)
+        if c is None:
+            break
+        step=step+1
+        print("Step:",step)
+        print(c)
+        if c["coords"] is not None:
+            print(len(c["coords"]))
+    except (AttributeError,OSError):
+        pass
+
+pym.close_file_read(cpluginhandle)
+pym.molfile_finish()
+
+

pymolfile/molfile/external/CMakeLists.txt

+cmake_minimum_required(VERSION 2.8.12)
+project(TNGBuilder)
+include(ExternalProject)
+
+set(TNG_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/tng")
+set(TNG_INSTALL_DIR "${CMAKE_CURRENT_BINARY_DIR}/tng")
+set(TNG_CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${TNG_INSTALL_DIR})
+
+message("TNG_PREFIX='${TNG_PREFIX}'")
+message("TNG_INSTALL_DIR='${TNG_INSTALL_DIR}'")
+message("TNG_CMAKE_ARGS='${TNG_CMAKE_ARGS}'")
+message("GIT_EXECUTABLE='${GIT_EXECUTABLE}'")
+
+ExternalProject_Add(tng
+    PREFIX ${TNG_PREFIX}
+    GIT_REPOSITORY https://github.com/gromacs/tng.git
+    INSTALL_DIR ${TNG_INSTALL_DIR}
+    CMAKE_ARGS ${TNG_CMAKE_ARGS}
+)

pymolfile/molfile/include/pymolfile.h

-/* Hey emacs this is -*- C -*- and this is my editor vim.
- * 
- * molfile.c : C and Fortran interfaces for molfile_plugins
- * Copyright (c) Berk Onat <b.onat@warwick.ac.uk> 2017
- *
- * This program is under BSD LICENSE
- */
-
-/*
- * The code is written following the plugin test 
- * context of f77_molfile.c by Axel Kohlmeyer and 
- * in molfile_plugin/src/f77 and catdcd.c by 
- * Justin Gullingsrud of VMD plugins.
- */
-
-#ifndef _MOLFILE_H_
-#define _MOLFILE_H_
-
-#ifdef __cplusplus
-extern "C"
-{
-
-#endif
-
-#include "molfile_plugin.h"
-#include "libmolfile_plugin.h"
-#include "vmdplugin.h"
-#include "Python.h"
-#include "structmember.h"
-#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
-#include <numpy/arrayobject.h>
-
-
-enum { pluginOK, pluginNOINIT, pluginCLOSE, pluginNOMEM, 
-       pluginENDOFFILE, pluginFILENOTFOUND, pluginFORMATERROR };
-
-#ifndef MAXPLUGINS
-#define MAXPLUGINS 200
-#endif
-
-struct MolObject {
-    PyObject_HEAD
-    molfile_plugin_t* plugin;
-    void* file_handle;
-    int natoms;
-    MolObject(void) {}
-};
-
-static void MolObject_dealloc(MolObject* self)
-{
-    Py_XDECREF(self->plugin);
-    Py_XDECREF(self->file_handle);
-    Py_TYPE(self)->tp_free((PyObject*)self);
-}
-
-static PyObject * MolObject_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-    MolObject *self;
-
-    self = (MolObject *)type->tp_alloc(type, 0);
-    if (self != NULL) {
-        self->plugin = NULL;
-        self->file_handle = NULL;
-        self->natoms = 0;
-    }
-
-    return (PyObject *)self;
-}
-
-static int MolObject_init(MolObject *self, PyObject *args, PyObject *kwds)
-{
-    molfile_plugin_t *plugin = NULL;
-    void *file_handle = NULL;
-    molfile_plugin_t *tmp1 = NULL;
-    void *tmp2 = NULL;
-
-    static char *kwlist[] = {"plugin", "file_handle", "natoms", NULL};
-
-    if (! PyArg_ParseTupleAndKeywords(args, kwds, "|OOi", kwlist,
-                                      &plugin, &file_handle,
-                                      &self->natoms))
-        return -1;
-
-    if (plugin) {
-        tmp1 = self->plugin;
-        Py_INCREF(plugin);
-        self->plugin = plugin;
-        Py_XDECREF(tmp1);
-    }
-
-    if (file_handle) {
-        tmp2 = self->file_handle;
-        Py_INCREF(file_handle);
-        self->file_handle = file_handle;
-        Py_XDECREF(tmp2);
-    }
-
-    return 0;
-}
-
-static molfile_plugin_t* MolObject_plugin(MolObject* self)
-{
-        return self->plugin;
-}
-
-static void* MolObject_file_handle(MolObject* self)
-{
-        return self->file_handle;
-}
-
-static PyObject* MolObject_natoms(MolObject* self)
-{
-        return PyLong_FromLong((long)self->natoms);
-}
-
-static PyMemberDef MolObject_members[] = {
-    {"plugin", T_OBJECT_EX, offsetof(MolObject, plugin), 0,
-     "molfile_plugin_t type plugin"},
-    {"file_handle", T_OBJECT_EX, offsetof(MolObject, file_handle), 0,
-     "file handle for plugin"},
-    {"natoms", T_INT, offsetof(MolObject, natoms), 0,
-     "number of atoms"},
-    {NULL, 0, 0, 0, NULL}  /* Sentinel */
-};
-
-static PyMethodDef MolObject_methods[] = {
-    {"get_plugin", (PyCFunction)MolObject_plugin, METH_NOARGS,
-     "Return the plugin"
-    },
-    {"get_file_handle", (PyCFunction)MolObject_file_handle, METH_NOARGS,
-     "Return the plugin"
-    },
-    {"get_natoms", (PyCFunction)MolObject_natoms, METH_NOARGS,
-     "Return the number of atoms"
-    },
-    {NULL, 0, 0, NULL}  /* Sentinel */
-};
-
-
-#ifndef PyVarObject_HEAD_INIT
-    #define PyVarObject_HEAD_INIT(type, size) \
-        PyObject_HEAD_INIT(type) size,
-#endif
-
-static PyTypeObject MolObjectType = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "molobject",                 /*tp_name*/
-    sizeof(MolObject),          /*tp_basicsize*/