westpa 2022.13__cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl

westpa/mclib/_mclib.pyx

@@ -0,0 +1,226 @@
+
+from __future__ import division
+import numpy, sys, math, os
+cimport numpy, cython
+from cpython.buffer cimport *
+from numpy cimport *
+
+from libc.math cimport floor, ceil, log10
+#from libc.stdlib cimport RAND_MAX, rand, srand
+
+
+cpdef msort(input_array):
+    return numpy.sort(input_array, axis=0)
+
+
+ctypedef fused _fptype:
+    numpy.float32_t
+    numpy.float64_t
+
+# Number of bytes in a dataset above which correlation time estimates are
+# not performed by generating synthetic data sets once and then evaluating
+# the autocorrelation elements on them, but rather by generating a new
+# synthetic dataset each time an autocorrelation element is required.
+# Essentially, this limits the RAM used during the correlation time
+# calculation to approximately CORRELTIME_CROSSOVER.  Keep in mind that
+# the space savings is at the cost of needing *many* more random numbers,
+# which will almost certainly become the rate-limiting step of the
+# calculation.
+cdef Py_ssize_t CORRELTIME_CROSSOVER = 512*1024*1024
+
+numpy.random.seed()
+
+@cython.cdivision(True)
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef _fptype _autocorrel_elem(_fptype[:] xs, long k):
+    cdef:
+        long N = xs.shape[0]
+        long i
+        double cdif
+        double xbar = 0.0
+        double norm = 0.0
+        double rho = 0.0
+
+    with nogil:
+        # calculate the mean manually, because it's faster than calling out to
+        # numpy.mean
+        for i in range(N):
+            xbar += xs[i]
+        xbar /= N
+
+        for i in range(N):
+            cdif = xs[i] - xbar
+            norm += cdif*cdif
+
+            if i < N-k:
+                rho += cdif * (xs[i+k]-xbar)
+
+        rho *= N / ((N-k)*norm)
+
+    return <_fptype> rho
+
+cpdef autocorrel_elem(xs, k):
+    '''Calculate the ``k``-lag sample autocorrelation of ``xs``. ``xs`` must be float32 or float64.'''
+
+    cdef:
+        int typecode = PyArray_TYPE(xs)
+
+    if typecode == NPY_FLOAT64:
+        return _autocorrel_elem[numpy.float64_t](xs,k)
+    elif typecode == NPY_FLOAT32:
+        return _autocorrel_elem[numpy.float32_t](xs,k)
+    else:
+        raise TypeError('unsupported type')
+
+cpdef Py_ssize_t get_bssize(double alpha) nogil:
+    '''Return a bootstrap data set size appropriate for the given confidence level.'''
+
+    cdef:
+        Py_ssize_t bssize=1, i
+
+    #return int(10**(math.ceil(-math.log10(alpha)) + 1))
+    for i in range(<long> ceil(-log10(alpha)) + 1):
+        bssize *= 10
+    return bssize
+
+cpdef mcbs_ci(dataset, estimator, alpha, dlen, n_sets=None, args=None, kwargs=None, sort=msort):
+    '''Perform a Monte Carlo bootstrap estimate for the (1-``alpha``) confidence interval
+    on the given ``dataset`` with the given ``estimator``.  This routine is not appropriate
+    for time-correlated data.
+
+    Returns ``(estimate, ci_lb, ci_ub)`` where ``estimate`` is the application of the
+    given ``estimator`` to the input ``dataset``, and ``ci_lb`` and ``ci_ub`` are the
+    lower and upper limits, respectively, of the (1-``alpha``) confidence interval on
+    ``estimate``.
+
+    ``estimator`` is called as ``estimator(dataset, *args, **kwargs)``. Common estimators include:
+      * numpy.mean -- calculate the confidence interval on the mean of ``dataset``
+      * numpy.median -- calculate a confidence interval on the median of ``dataset``
+      * numpy.std -- calculate a confidence interval on the standard deviation of ``datset``.
+
+    ``n_sets`` is the number of synthetic data sets to generate using the given ``estimator``,
+    which will be chosen using `get_bssize()`_ if ``n_sets`` is not given.
+
+    ``sort`` can be used
+    to override the sorting routine used to calculate the confidence interval, which should
+    only be necessary for estimators returning vectors rather than scalars.
+    '''
+
+    if alpha > 0.5:
+        raise ValueError('alpha ({}) > 0.5'.format(alpha))
+
+    args = args or ()
+    kwargs = kwargs or {}
+
+    # dataset SHOULD be a dictionary.
+    d_input = dataset.copy()
+    # Here, we're dumping in any extra kwarg arguments to pass in to the estimator.
+    try:
+        d_input.update(kwargs)
+    except Exception:
+        pass
+
+    fhat = estimator(**d_input)
+
+    try:
+        estimator_shape = fhat.shape
+    except AttributeError:
+        estimator_shape = ()
+
+    try:
+        estimator_dtype = fhat.dtype
+    except AttributeError:
+        estimator_dtype = type(fhat)
+
+    n_sets = n_sets or get_bssize(alpha)
+
+    f_synth = numpy.empty((n_sets,) + estimator_shape, dtype=estimator_dtype)
+
+    for i in xrange(n_sets):
+        indices = numpy.random.randint(dlen, size=(dlen,))
+        d_synth = {}
+        for key, dset in dataset.iteritems():
+            d_synth[key] = numpy.take(dset, indices, axis=0)
+        d_input = d_synth.copy()
+        try:
+            d_input.update(kwargs)
+        except Exception:
+            pass
+        f_synth[i] = estimator(**d_input)
+        del indices
+
+    f_synth_sorted = sort(f_synth)
+    lbi = math.floor(n_sets*alpha/2.0)
+    ubi = math.ceil(n_sets*(1-alpha/2.0))
+    lb = f_synth_sorted[lbi]
+    ub = f_synth_sorted[ubi]
+    sterr = numpy.std(f_synth_sorted)
+
+    del f_synth_sorted, f_synth
+    return (fhat, lb, ub, sterr)
+
+cpdef mcbs_correltime(dataset, alpha, n_sets = None):
+    '''Calculate the correlation time of the given ``dataset``, significant to the
+    (1-``alpha``) level, using the method described in Huber & Kim, "Weighted-ensemble
+    Brownian dynamics simulations for protein association reactions" (1996),
+    doi:10.1016/S0006-3495(96)79552-8. An appropriate balance between space and speed
+    is chosen based on the size of the input data.
+
+    Returns 0 for data statistically uncorrelated with (1-alpha) confidence, otherwise
+    the correlation length. (Thus, the appropriate stride for blocking is the
+    result of this function plus one.)'''
+
+    n_sets = n_sets or get_bssize(alpha)
+    if dataset.nbytes * n_sets > CORRELTIME_CROSSOVER:
+        return mcbs_correltime_fullauto(dataset, alpha, n_sets)
+    else:
+        return mcbs_correltime_small(dataset, alpha, n_sets)
+
+cpdef mcbs_correltime_fullauto(dataset, alpha, n_sets):
+    '''Specialization of `mcbs_correltime`_ for large datasets, where rather than generating
+    ``n_sets`` synthetic datasets and then evaluating autocorrelation elements on them, a
+    synthetic data set is generated for each autocorrelation element required. This trades time
+    for space.'''
+
+    for k in xrange(1,len(dataset)//2):
+        data_rho, synrho_lb, synrho_ub = mcbs_ci(dataset, autocorrel_elem, alpha, n_sets, args=(k,))
+        if data_rho > synrho_lb and data_rho < synrho_ub:
+            return k-1
+    else:
+        return len(dataset)
+        #raise ValueError('correlation length exceeds half the data set length')
+
+cpdef mcbs_correltime_small(dataset, alpha, n_sets):
+    '''Specialization of `mcbs_correltime`_ for small-to-mediam datasets, where ``n_sets``
+    synthetic datasets are generated and stored, and then autocorrelation elements
+    calculated on them. This implementation trades space for time.'''
+
+    if alpha > 0.5:
+        raise ValueError('alpha ({}) > 0.5'.format(alpha))
+
+    dlen = len(dataset)
+    lbi = math.floor(n_sets*alpha/2.0)
+    ubi = math.ceil(n_sets*(1-alpha/2.0))
+
+    synth_sets = numpy.empty((n_sets,)+dataset.shape, dtype=dataset.dtype)
+    synth_acf_elems = numpy.empty((n_sets,), numpy.float64)
+
+    for i in xrange(n_sets):
+        synth_sets[i] = numpy.take(dataset,numpy.random.randint(dlen,size=(dlen,)))
+
+    for k in xrange(1,dlen//2):
+        data_rho = autocorrel_elem(dataset, k)
+
+        for i in xrange(n_sets):
+            synth_acf_elems[i] = autocorrel_elem(synth_sets[i],k)
+
+        synth_acf_elems.sort()
+
+        if data_rho > synth_acf_elems[lbi] and data_rho < synth_acf_elems[ubi]:
+            return k-1
+    else:
+        #raise ValueError('correlation length exceeds half the data set length')
+        return len(dataset)
+
+

westpa/oldtools/__init__.py

@@ -0,0 +1,4 @@
+from . import aframe, miscfn
+
+
+__all__ = ['aframe', 'miscfn']

westpa/oldtools/aframe/__init__.py

@@ -0,0 +1,35 @@
+"""WEST Analyis framework -- an unholy mess of classes exploiting each other"""
+
+from . import atool
+from .atool import WESTAnalysisTool
+from .base_mixin import ArgumentError, AnalysisMixin
+from .binning import BinningMixin
+from .data_reader import WESTDataReaderMixin, ExtDataReaderMixin, BFDataManager
+from .iter_range import IterRangeMixin
+from .kinetics import KineticsAnalysisMixin
+from .mcbs import MCBSMixin
+from .output import CommonOutputMixin
+from .plotting import PlottingMixin
+from .trajwalker import TrajWalker
+from .transitions import TransitionAnalysisMixin, TransitionEventAccumulator, BFTransitionAnalysisMixin
+
+
+__all__ = [
+    'atool',
+    'AnalysisMixin',
+    'ArgumentError',
+    'WESTAnalysisTool',
+    'IterRangeMixin',
+    'WESTDataReaderMixin',
+    'ExtDataReaderMixin',
+    'BFDataManager',
+    'BinningMixin',
+    'MCBSMixin',
+    'TrajWalker',
+    'TransitionAnalysisMixin',
+    'TransitionEventAccumulator',
+    'BFTransitionAnalysisMixin',
+    'KineticsAnalysisMixin',
+    'CommonOutputMixin',
+    'PlottingMixin',
+]

westpa/oldtools/aframe/atool.py

@@ -0,0 +1,75 @@
+import logging
+
+
+import h5py
+
+log = logging.getLogger(__name__)
+
+
+class WESTAnalysisTool:
+    def __init__(self):
+        super().__init__()
+        # Whether a west.cfg is required to run a program based on this tool
+        self.config_required = False
+
+        # Analysis HDF5 filename and object
+        self.anal_h5name = None
+        self.anal_h5file = None
+
+        # Whether this is being used in a brute analysis
+        self.bf_mode = False
+
+        # A way to override some arguments on a per-mixin basis without having to subclass
+        # (messy, but it doesn't seem crucial enough so far to make it cleaner)
+        self.include_args = {}
+
+    def add_args(self, parser, upcall=True):
+        '''Add arguments to a parser common to all analyses of this type.'''
+        if upcall:
+            try:
+                upfunc = super().add_args
+            except AttributeError:
+                pass
+            else:
+                upfunc(parser)
+
+        group = parser.add_argument_group('general analysis options')
+        group.add_argument(
+            '-A',
+            '--analysis-file',
+            dest='anal_h5name',
+            metavar='H5FILE',
+            default='analysis.h5',
+            help='Store intermediate and final results in H5FILE (default: %(default)s).',
+        )
+
+    def process_args(self, args, upcall=True):
+        self.anal_h5name = args.anal_h5name
+
+        if upcall:
+            try:
+                upfunc = super().process_args
+            except AttributeError:
+                pass
+            else:
+                upfunc(args)
+
+    def open_analysis_backing(self):
+        if self.anal_h5file is None:
+            self.anal_h5file = h5py.File(self.anal_h5name)
+
+    def close_analysis_backing(self):
+        try:
+            self.anal_h5file.close()
+            self.anal_h5file = None
+        except AttributeError:
+            pass
+
+    def require_analysis_group(self, groupname, replace=False):
+        self.open_analysis_backing()
+        if replace:
+            try:
+                del self.anal_h5file[groupname]
+            except KeyError:
+                pass
+        return self.anal_h5file.require_group(groupname)

westpa/oldtools/aframe/base_mixin.py

@@ -0,0 +1,26 @@
+class ArgumentError(RuntimeError):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+
+class AnalysisMixin:
+    def __init__(self):
+        super().__init__()
+
+    def add_args(self, parser, upcall=True):
+        if upcall:
+            try:
+                upfunc = super().add_args
+            except AttributeError:
+                pass
+            else:
+                upfunc(parser)
+
+    def process_args(self, args, upcall=True):
+        if upcall:
+            try:
+                upfunc = super().process_args
+            except AttributeError:
+                pass
+            else:
+                upfunc(args)

westpa/oldtools/aframe/binning.py

@@ -0,0 +1,178 @@
+import logging
+
+import numpy as np
+
+import westpa
+from westpa.oldtools.aframe import AnalysisMixin
+
+log = logging.getLogger(__name__)
+
+
+class BinningMixin(AnalysisMixin):
+    '''A mixin for performing binning on WEST data.'''
+
+    def __init__(self):
+        super().__init__()
+
+        self.mapper = None
+        self.n_bins = None
+
+        self.discard_bin_assignments = False
+        self.binning_h5gname = 'binning'
+        self.binning_h5group = None
+        self.mapper_hash = None
+
+    def add_args(self, parser, upcall=True):
+        if upcall:
+            try:
+                upfunc = super().add_args
+            except AttributeError:
+                pass
+            else:
+                upfunc(parser)
+
+        group = parser.add_argument_group('binning options')
+        egroup = group.add_mutually_exclusive_group()
+        egroup.add_argument(
+            '--binexpr',
+            '--binbounds',
+            dest='binexpr',
+            help='''Construct rectilinear bins from BINEXPR. This must be a list of lists of bin boundaries
+                            (one list of bin boundaries for each dimension of the progress coordinate), formatted as a Python
+                            expression. E.g. "[[0,1,2,4,inf], [-inf,0,inf]]".''',
+        )
+        group.add_argument(
+            '--discard-bin-assignments',
+            dest='discard_bin_assignments',
+            action='store_true',
+            help='''Discard any existing bin assignments stored in the analysis HDF5 file.''',
+        )
+
+    def process_args(self, args, upcall=True):
+        if args.binexpr:
+            westpa.rc.pstatus("Constructing rectilinear bin boundaries from the following expression: '{}'".format(args.binexpr))
+            self.mapper = self.mapper_from_expr(args.binexpr)
+        else:
+            westpa.rc.pstatus('Loading bin boundaries from WEST system')
+            system = westpa.rc.get_system_driver()
+            self.mapper = system.bin_mapper
+
+        self.n_bins = self.mapper.nbins
+        _pdat, self.mapper_hash = self.mapper.pickle_and_hash()
+        westpa.rc.pstatus('  {:d} bins'.format(self.n_bins))
+        westpa.rc.pstatus('  identity hash {}'.format(self.mapper_hash))
+
+        self.discard_bin_assignments = bool(args.discard_bin_assignments)
+
+        if upcall:
+            try:
+                upfunc = super().process_args
+            except AttributeError:
+                pass
+            else:
+                upfunc(args)
+
+    def mapper_from_expr(self, expr):
+        from westpa.core.binning import RectilinearBinMapper
+
+        namespace = {'numpy': np, 'np': np, 'inf': float('inf')}
+
+        try:
+            return RectilinearBinMapper(eval(expr, namespace))
+        except TypeError as e:
+            if 'has no len' in str(e):
+                raise ValueError('invalid bin boundary specification; you probably forgot to make a list of lists')
+
+    def write_bin_labels(self, dest, header='# bin labels:\n', format='# bin {bin_index:{max_iwidth}d} -- {label!s}\n'):
+        '''Print labels for all bins in ``self.mapper`` to ``dest``.  If provided, ``header``
+        is printed before any labels.   The ``format`` string specifies how bin labels are to be printed.  Valid entries are:
+          * ``bin_index`` -- the zero-based index of the bin
+          * ``label`` -- the label, as obtained by ``bin.label``
+          * ``max_iwidth`` -- the maximum width (in characters) of the bin index, for pretty alignment
+        '''
+        dest.write(header or '')
+        max_iwidth = len(str(self.mapper.nbins - 1))
+        for ibin, label in enumerate(self.mapper.labels):
+            dest.write(format.format(bin_index=ibin, label=label, max_iwidth=max_iwidth))
+
+    def require_binning_group(self):
+        if self.binning_h5group is None:
+            self.binning_h5group = self.anal_h5file.require_group(self.binning_h5gname)
+        return self.binning_h5group
+
+    def delete_binning_group(self):
+        self.binning_h5group = None
+        del self.anal_h5file[self.binning_h5gname]
+
+    def record_data_binhash(self, h5object):
+        '''Record the identity hash for self.mapper as an attribute on the given HDF5 object (group or dataset)'''
+        h5object.attrs['binhash'] = self.mapper_hash
+
+    def check_data_binhash(self, h5object):
+        '''Check whether the recorded bin identity hash on the given HDF5 object matches the identity hash for self.mapper'''
+        return h5object.attrs.get('binhash') == self.mapper_hash
+
+    def assign_to_bins(self):
+        '''Assign WEST segment data to bins.  Requires the DataReader mixin to be in the inheritance tree'''
+        self.require_binning_group()
+
+        n_iters = self.last_iter - self.first_iter + 1
+        max_n_segs = self.max_iter_segs_in_range(self.first_iter, self.last_iter)
+        pcoord_len = self.get_pcoord_len(self.first_iter)
+
+        assignments = np.zeros((n_iters, max_n_segs, pcoord_len), np.min_scalar_type(self.n_bins))
+        populations = np.zeros((n_iters, pcoord_len, self.n_bins), np.float64)
+
+        westpa.rc.pstatus('Assigning to bins...')
+
+        for iiter, n_iter in enumerate(range(self.first_iter, self.last_iter + 1)):
+            westpa.rc.pstatus('\r  Iteration {:d}'.format(n_iter), end='')
+            seg_index = self.get_seg_index(n_iter)
+            pcoords = self.get_iter_group(n_iter)['pcoord'][...]
+            weights = seg_index['weight']
+
+            for seg_id in range(len(seg_index)):
+                assignments[iiter, seg_id, :] = self.mapper.assign(pcoords[seg_id, :, :])
+
+            for it in range(pcoord_len):
+                populations[iiter, it, :] = np.bincount(assignments[iiter, : len(seg_index), it], weights, minlength=self.n_bins)
+
+            westpa.rc.pflush()
+            del pcoords, weights, seg_index
+
+        assignments_ds = self.binning_h5group.create_dataset('bin_assignments', data=assignments, compression='gzip')
+        populations_ds = self.binning_h5group.create_dataset('bin_populations', data=populations, compression='gzip')
+
+        for h5object in (self.binning_h5group, assignments_ds, populations_ds):
+            self.record_data_iter_range(h5object)
+            self.record_data_iter_step(h5object, 1)
+            self.record_data_binhash(h5object)
+
+        westpa.rc.pstatus()
+
+    def require_bin_assignments(self):
+        self.require_binning_group()
+        do_assign = False
+        if self.discard_bin_assignments:
+            westpa.rc.pstatus('Discarding existing bin assignments.')
+            do_assign = True
+        elif 'bin_assignments' not in self.binning_h5group:
+            do_assign = True
+        elif not self.check_data_iter_range_least(self.binning_h5group):
+            westpa.rc.pstatus('Existing bin assignments are for incompatible first/last iterations; deleting assignments.')
+            do_assign = True
+        elif not self.check_data_binhash(self.binning_h5group):
+            westpa.rc.pstatus('Bin definitions have changed; deleting existing bin assignments.')
+            do_assign = True
+
+        if do_assign:
+            self.delete_binning_group()
+            self.assign_to_bins()
+        else:
+            westpa.rc.pstatus('Using existing bin assignments.')
+
+    def get_bin_assignments(self, first_iter=None, last_iter=None):
+        return self.slice_per_iter_data(self.binning_h5group['bin_assignments'], first_iter, last_iter)
+
+    def get_bin_populations(self, first_iter=None, last_iter=None):
+        return self.slice_per_iter_data(self.binning_h5group['bin_populations'], first_iter, last_iter)