MasterMSM 2.0.1__py3-none-any.whl

mastermsm/trajectory/traj_lib.py

@@ -0,0 +1,459 @@
+"""
+This file is part of the MasterMSM package.
+
+"""
+#import h5py
+import copy
+import sys
+import math
+import numpy as np
+import mdtraj as md
+import matplotlib.pyplot as plt
+
+def load_mdtraj(top=None, xtc=None, stride=None):
+    """ Loads trajectories using mdtraj.
+
+    Parameters
+    ----------
+    top: str
+        The topology file, may be a PDB or GRO file.
+    xtc : str
+        The trajectory filename.
+
+    Returns
+    -------
+    mdtrajs : list
+        A list of mdtraj Trajectory objects.
+
+    """
+    return md.load(xtc, top=top, stride=stride)
+
+def compute_rama(traj, shift=False, sincos=False):
+    """ Computes Ramachandran angles 
+
+    Parameters
+    ----------
+    traj : md.trajectory
+        An MDtraj trajectory object
+    shift : bool
+        Whether we want to shift the torsions or not
+    sincos : bool
+        Whether we are calculating the sines and cosines 
+
+    Returns
+    -------
+    phi : array
+        An array with phi torsions
+    psi : array
+        An array with psi torsions
+
+    """
+    _, phi = md.compute_phi(traj.mdt)
+    _, psi = md.compute_psi(traj.mdt)
+    if shift:
+        return _shift(phi, psi)
+    elif sincos:
+        return np.column_stack([np.sin(phi), np.cos(phi)]), \
+                np.column_stack([np.sin(psi), np.cos(psi)])
+    else:
+        return phi, psi
+
+def compute_contacts(traj, scheme=None, log=False):
+    """ Computes inter-residue contacts
+
+    Parameters
+    ----------
+    traj : md.trajectory
+        An MDtraj trajectory object
+    log : bool
+        Whether distances are in log scale
+
+    """
+    distances, pairs = md.compute_contacts(traj, scheme=scheme)
+    if not log:
+        return distances
+    else:
+        return np.log(distances)
+
+def _filter_states(states):
+    """
+    Fills not-assigned frames (negative labels) when using dbscan or
+    hdbscan. Each unassigned frame inherits the label of the previous
+    assigned frame; unassigned frames at the start of the trajectory,
+    which have no previous frame, inherit the first assigned label.
+    The output always has the same length as the input.
+
+    Raises
+    ------
+    ValueError
+        If no frame is assigned.
+
+    """
+    states = list(states)
+    first = next((s for s in states if s >= 0), None)
+    if first is None:
+        raise ValueError("no frame was assigned to any cluster")
+    fs = []
+    prev = first
+    for s in states:
+        if s >= 0:
+            prev = s
+        fs.append(prev)
+    return fs
+
+def _shift(phi, psi):
+    phi_s, psi_s = copy.deepcopy(phi), copy.deepcopy(psi)
+    for i in range(len(phi_s)):
+        phi_s[i] = [x + 2*np.pi if x < 0 else x for x in phi_s[i]]
+    for i in range(len(psi_s)):
+        psi_s[i] = [x + 2*np.pi if (x <-2) else x for x in psi_s[i]]
+    return phi_s, psi_s
+
+def _inrange(x, lo, hi):
+    return 1 if (x > lo and x < hi) else 0
+
+def _inbounds(bounds, phi, psi):
+    for i in range(0, len(bounds), 4):
+        if _inrange(phi, bounds[i], bounds[i+1]) and _inrange(psi, bounds[i+2], bounds[i+3]):
+            return 1
+    return 0
+
+def _state(phi, psi, bounds):
+    """ Assign phi, psi (in degrees) to a coarse state.
+
+    Parameters
+    ----------
+    phi : float
+        Phi dihedral angle in degrees.
+    psi : float
+        Psi dihedral angle in degrees.
+    bounds : dict
+        Dict mapping state labels to [phi_min, phi_max, psi_min, psi_max, ...] bounds.
+
+    Returns
+    -------
+    k : str
+        Assigned state label, or 'O' if unassigned.
+
+    """
+    for k, b in bounds.items():
+        if _inbounds(b, phi, psi):
+            return k, []
+    return 'O', [(phi, psi)]
+
+_DEFAULT_BOUNDS = {'A': [-130., -40., -50., 20.],
+                   'E': [-180., -40., 125., 180.],
+                   'L': [30., 100., -40., 70.]}
+
+def default_bounds(states=None):
+    """ Default Buchete-Hummer bounds for the requested states.
+
+    Parameters
+    ----------
+    states : list, optional
+        State labels, from 'A', 'E' and 'L'. Default is all three.
+
+    Returns
+    -------
+    bounds : dict
+        Maps each label to [phi_min, phi_max, psi_min, psi_max]
+        in degrees.
+
+    """
+    if states is None:
+        states = ['A', 'E', 'L']
+    unknown = [s for s in states if s not in _DEFAULT_BOUNDS]
+    if unknown:
+        raise ValueError("no default bounds for states %s"%unknown)
+    return {s: list(_DEFAULT_BOUNDS[s]) for s in states}
+
+def _validate_bounds(b):
+    """ Check one state's bounds list, returning it as floats. """
+    b = [float(x) for x in b]
+    if len(b) == 0 or len(b) % 4 != 0:
+        raise ValueError("bounds need groups of four values "\
+                "(phi_min, phi_max, psi_min, psi_max), got %i"%len(b))
+    for i in range(0, len(b), 4):
+        for lo, hi in [(b[i], b[i+1]), (b[i+2], b[i+3])]:
+            if not lo < hi:
+                raise ValueError("lower bound %g is not below "\
+                        "upper bound %g"%(lo, hi))
+            if lo < -180. or hi > 180.:
+                raise ValueError("bounds must lie within "\
+                        "[-180, 180] degrees")
+    return b
+
+def _overlaps(bounds):
+    """ Pairs of states whose rectangles overlap. """
+    rects = [(k, b[i:i+4]) for k, b in bounds.items() \
+            for i in range(0, len(b), 4)]
+    pairs = []
+    for n, (k1, r1) in enumerate(rects):
+        for k2, r2 in rects[n+1:]:
+            if k1 == k2:
+                continue
+            if r1[0] < r2[1] and r2[0] < r1[1] and \
+                    r1[2] < r2[3] and r2[2] < r1[3]:
+                if (k1, k2) not in pairs:
+                    pairs.append((k1, k2))
+    return pairs
+
+def rama_populations(phi, psi, bounds):
+    """ Fraction of (phi, psi) points falling in each state.
+
+    Counts direct assignments only, before unassigned points
+    inherit the previous state. Overlapping regions go to the
+    first state in ``bounds``, as in ``discrete_rama``.
+
+    Parameters
+    ----------
+    phi, psi : array
+        Angles in radians, any shape (all residues are pooled).
+    bounds : dict
+        State bounds in degrees.
+
+    Returns
+    -------
+    pops : dict
+        Fraction per state, plus 'O' for unassigned points.
+
+    """
+    f = np.degrees(np.ravel(phi))
+    y = np.degrees(np.ravel(psi))
+    free = np.ones(len(f), dtype=bool)
+    pops = {}
+    for k, b in bounds.items():
+        inside = np.zeros(len(f), dtype=bool)
+        for i in range(0, len(b), 4):
+            inside |= (f > b[i]) & (f < b[i+1]) & \
+                    (y > b[i+2]) & (y < b[i+3])
+        inside &= free
+        pops[k] = inside.mean() if len(f) else 0.
+        free &= ~inside
+    pops['O'] = free.mean() if len(f) else 0.
+    return pops
+
+def plot_rama_bounds(phi, psi, bounds, ax=None, bins=90):
+    """ Ramachandran histogram with the state bounds drawn on top.
+
+    Parameters
+    ----------
+    phi, psi : array
+        Angles in radians, any shape (all residues are pooled).
+    bounds : dict
+        State bounds in degrees.
+    ax : matplotlib Axes, optional
+        Axes to draw on. A new figure is made by default.
+    bins : int
+        Number of histogram bins per axis.
+
+    Returns
+    -------
+    ax : matplotlib Axes
+
+    """
+    from matplotlib.colors import LogNorm
+    from matplotlib.patches import Rectangle
+    if ax is None:
+        _, ax = plt.subplots(figsize=(5, 4.5))
+    f = np.degrees(np.ravel(phi))
+    y = np.degrees(np.ravel(psi))
+    h, xe, ye = np.histogram2d(f, y, bins=bins, \
+            range=[[-180, 180], [-180, 180]], density=True)
+    h = np.ma.masked_where(h == 0, h)
+    ax.pcolormesh(xe, ye, h.T, norm=LogNorm(), cmap='Greys')
+    pops = rama_populations(phi, psi, bounds)
+    colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
+    for n, (k, b) in enumerate(bounds.items()):
+        c = colors[n % len(colors)]
+        for i in range(0, len(b), 4):
+            ax.add_patch(Rectangle((b[i], b[i+2]), b[i+1] - b[i], \
+                    b[i+3] - b[i+2], fill=False, ec=c, lw=2, \
+                    label="%s (%.1f%%)"%(k, 100*pops[k]) \
+                    if i == 0 else None))
+    ax.set_xlim(-180, 180)
+    ax.set_ylim(-180, 180)
+    ax.set_xticks(range(-180, 181, 90))
+    ax.set_yticks(range(-180, 181, 90))
+    ax.set_xlabel(r'$\phi$ (deg)')
+    ax.set_ylabel(r'$\psi$ (deg)')
+    ax.set_title('unassigned: %.1f%%'%(100*pops['O']))
+    ax.legend(loc='upper right', fontsize='small')
+    ax.figure.tight_layout()
+    return ax
+
+def _interactive():
+    """ Whether a user can answer input() prompts. """
+    try:
+        from IPython import get_ipython
+        ip = get_ipython()
+        if ip is not None and getattr(ip, 'kernel', None) is not None:
+            return True
+    except ImportError:
+        pass
+    return sys.stdin is not None and sys.stdin.isatty()
+
+def _ask(prompt, input_fn):
+    """ Prompt the user; None if nobody can answer. """
+    try:
+        return input_fn(prompt).strip()
+    except (EOFError, OSError, NotImplementedError):
+        # pytest capture, closed stdin, or a kernel without stdin
+        # (e.g. notebooks executed by nbconvert)
+        return None
+
+def confirm_bounds(phi, psi, bounds, input_fn=None, plot=True):
+    """ Show the Ramachandran bounds and let the user revise them.
+
+    Draws the pooled Ramachandran histogram with each state's
+    region, reports the populations, and asks whether to accept.
+    On refusal, asks for new bounds state by state (blank keeps
+    the current ones) and shows the result again. When no user
+    can answer (scripts without a terminal, pytest, nbconvert),
+    the bounds are accepted with a warning.
+
+    Parameters
+    ----------
+    phi, psi : array
+        Angles in radians, any shape (all residues are pooled).
+    bounds : dict
+        Proposed state bounds in degrees.
+    input_fn : callable, optional
+        Replacement for ``input`` (used for testing). When given,
+        the session is assumed to be interactive.
+    plot : bool
+        Whether to draw the histogram (the populations are always
+        printed).
+
+    Returns
+    -------
+    bounds : dict
+        The accepted bounds.
+
+    """
+    import warnings
+    bounds = {k: _validate_bounds(b) for k, b in bounds.items()}
+    if input_fn is None:
+        input_fn = input
+        interactive = _interactive()
+    else:
+        interactive = True
+
+    while True:
+        if plot:
+            plot_rama_bounds(phi, psi, bounds)
+            plt.show()
+            plt.close()
+        pops = rama_populations(phi, psi, bounds)
+        for k, b in bounds.items():
+            print("  %s: %s  (%.1f%%)"%(k, b, 100*pops[k]))
+        print("  unassigned: %.1f%%"%(100*pops['O']))
+        for k1, k2 in _overlaps(bounds):
+            print("  warning: %s and %s overlap; points in both go "\
+                    "to %s"%(k1, k2, k1))
+
+        ans = _ask("Accept these bounds? [Y/n]: ", input_fn) \
+                if interactive else None
+        if ans is None:
+            warnings.warn("no interactive input available; using "\
+                    "Ramachandran bounds without confirmation: %s"\
+                    %bounds, stacklevel=2)
+            return bounds
+        if ans.lower() in ('', 'y', 'yes'):
+            return bounds
+        if ans.lower() not in ('n', 'no'):
+            print("Please answer y or n.")
+            continue
+
+        for k in bounds:
+            while True:
+                new = _ask("%s %s -> phi_min, phi_max, psi_min, "\
+                        "psi_max [, more groups of 4] (blank keeps): "\
+                        %(k, bounds[k]), input_fn)
+                if not new:
+                    break
+                try:
+                    bounds[k] = _validate_bounds( \
+                            new.replace(',', ' ').split())
+                    break
+                except ValueError as e:
+                    print("  invalid: %s"%e)
+
+def discrete_rama(phi, psi, bounds=None, states=None,
+                  return_unassigned=False):
+    """ Assign Ramachandran angles to coarse states.
+
+    Follows the Buchete-Hummer transition-based assignment: frames
+    outside every core inherit the state of the previous frame.
+    Leading frames, recorded before every dihedral has visited a core,
+    have no previous state and are dropped.
+
+    Parameters
+    ----------
+    phi : array
+        Phi angles, shape (n_frames, n_dihedrals), in radians.
+    psi : array
+        Psi angles, shape (n_frames, n_dihedrals), in radians.
+    bounds : dict, optional
+        Custom bounds dict. Default uses standard A/E/L regions.
+    states : list, optional
+        State labels to include. Defaults to all defined labels.
+    return_unassigned : bool, optional
+        Also return the fraction of frames outside every core, per
+        dihedral, and the number of leading frames dropped.
+
+    Returns
+    -------
+    cstates : list
+        Per-frame state string (one character per dihedral pair), with
+        the leading unassigned frames removed.
+    unassigned : array, optional
+        Fraction of frames (over the full input) outside every core,
+        one value per dihedral. Only if return_unassigned is True.
+    ndrop : int, optional
+        Number of leading frames dropped. Only if return_unassigned
+        is True.
+
+    Raises
+    ------
+    ValueError
+        If some dihedral never visits any core.
+
+    References
+    ----------
+    N.-V. Buchete and G. Hummer, J. Phys. Chem. B (2008).
+
+    """
+    if bounds is None:
+        bounds = default_bounds(states)
+
+    ndih = phi.shape[1]
+    if psi.shape[1] != ndih:
+        raise ValueError("phi and psi have different numbers of dihedrals")
+
+    raw = [[_state(f[n] * 180. / math.pi, y[n] * 180. / math.pi,
+                   bounds)[0] for n in range(ndih)]
+           for f, y in zip(phi, psi)]
+    raw = np.array(raw, dtype='<U1').reshape(len(raw), ndih)
+    unassigned = np.mean(raw == 'O', axis=0)
+
+    # first frame at which each dihedral is in a core
+    assigned = raw != 'O'
+    if not np.all(assigned.any(axis=0)):
+        never = np.where(~assigned.any(axis=0))[0].tolist()
+        raise ValueError("dihedral(s) %s never visit any core" % never)
+    ndrop = int(np.max(np.argmax(assigned, axis=0)))
+
+    # inherit over the full history, then drop the leading frames
+    cstates = []
+    prev_s_string = ['O'] * ndih
+    for row in raw:
+        s_string = [prev_s_string[n] if s == 'O' else s
+                    for n, s in enumerate(row)]
+        cstates.append(''.join(s_string))
+        prev_s_string = s_string
+    cstates = cstates[ndrop:]
+
+    if return_unassigned:
+        return cstates, unassigned, ndrop
+    return cstates

mastermsm-2.0.1.dist-info/METADATA

@@ -0,0 +1,205 @@
+Metadata-Version: 2.4
+Name: MasterMSM
+Version: 2.0.1
+Summary: Algorithms to construct master equation / Markov state models
+Author-email: David De Sancho <daviddesancho@gmail.com>
+License-Expression: GPL-2.0-or-later
+Project-URL: Homepage, https://github.com/BioKT/MasterMSM
+Project-URL: Documentation, https://mastermsm.readthedocs.io
+Project-URL: Changelog, https://github.com/BioKT/MasterMSM/blob/master/CHANGELOG.md
+Keywords: markov state model,master equation,molecular dynamics
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: networkx
+Requires-Dist: mdtraj
+Requires-Dist: scikit-learn
+Provides-Extra: hdbscan
+Requires-Dist: hdbscan; extra == "hdbscan"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: ipython; extra == "test"
+Dynamic: license-file
+
+[![CI](https://github.com/BioKT/MasterMSM/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/BioKT/MasterMSM/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/BioKT/MasterMSM/branch/master/graph/badge.svg)](https://codecov.io/gh/BioKT/MasterMSM)
+[![Documentation Status](https://readthedocs.org/projects/mastermsm/badge/?version=latest)](https://mastermsm.readthedocs.io/en/latest/?badge=latest)
+
+MasterMSM
+=========
+MasterMSM is a Python package for building Markov state models (MSMs)
+from molecular dynamics trajectories, using a formulation based on the
+chemical master equation. Besides the usual transition matrix, it
+estimates the rate matrix of the model, which gives direct access to
+rate coefficients, committors and reactive fluxes.
+
+Full documentation is at [mastermsm.readthedocs.io](https://mastermsm.readthedocs.io).
+
+Features
+--------
+*   **Trajectory handling**: read MD trajectories through
+    [MDTraj](https://mdtraj.org) or discrete state trajectories from
+    file.
+*   **Featurization and dimensionality reduction**: backbone torsions
+    and contacts; PCA and TICA.
+*   **Discretization**: assignment to Ramachandran basins with
+    transition-based assignment (suited to small peptides), k-means
+    and HDBSCAN clustering. Different protocols can be run on the same
+    data and compared.
+*   **Model estimation**: count and transition matrices at any lag
+    time; rate matrices from a Taylor expansion or from the maximum
+    likelihood propagator-based (MLPB) method; bootstrap errors for
+    relaxation times and equilibrium populations.
+*   **Validation**: convergence of relaxation times with lag time,
+    Chapman-Kolmogorov test, autocorrelation functions of the
+    eigenmodes.
+*   **Kinetics**: committors, reactive fluxes and rates between sets of
+    states; sensitivity analysis of the network.
+*   **Coarse-graining**: few-state models from the eigenvectors of the
+    MSM.
+
+Installation
+------------
+MasterMSM requires Python >= 3.10 and is installed from
+[PyPI](https://pypi.org/project/MasterMSM/) with `pip`:
+
+    pip install MasterMSM
+
+To work on the code, install it from source instead:
+
+    git clone https://github.com/BioKT/MasterMSM
+    cd MasterMSM
+    pip install -e .
+
+The dependencies are installed automatically by `pip`: numpy, scipy,
+matplotlib, networkx, [mdtraj](https://mdtraj.org) and scikit-learn.
+If you use conda, you may prefer to install them from conda-forge
+first:
+
+    conda install -c conda-forge numpy scipy matplotlib \
+        networkx mdtraj scikit-learn
+
+HDBSCAN clustering additionally needs the optional
+[hdbscan](https://github.com/scikit-learn-contrib/hdbscan) package
+(`pip install "MasterMSM[hdbscan]"`, or `pip install hdbscan`).
+
+Quick start
+-----------
+The script below builds an MSM for the alanine dipeptide from a short
+MD trajectory (downloaded from [OSF](https://osf.io/a2vc7) on first
+use).
+
+```python
+from mastermsm.trajectory import traj
+from mastermsm.msm import msm
+from mastermsm.fewsm import fewsm
+from mastermsm.test import download_data as dd
+
+if __name__ == "__main__":
+    # 1. Load the trajectory and assign frames to Ramachandran states
+    dd.download_osf_alaTB()
+    tr = traj.TimeSeries(top=dd._DATA_DIR + "/alaTB.gro",
+                         xtc=dd._DATA_DIR + "/alaTB.xtc")
+    tr.discretize(states=["A", "E", "L"])
+    tr.find_keys()
+
+    # 2. Build the MSM at a lag time of 10 ps (units of the trajectory)
+    smsm = msm.SuperMSM([tr])
+    lagt = 10
+    smsm.do_msm(lagt)
+    model = smsm.msms[lagt]
+    model.do_trans()          # transition matrix and its eigenvalues
+    model.boots()             # bootstrap errors
+    print(model.keep_keys)    # states in the model: ['A', 'E', 'L']
+    print(model.tauT)         # relaxation times, ~794 and ~55 ps
+    print(model.tau_std)
+    print(model.peqT)         # equilibrium populations
+
+    # 3. Rate matrix, committors and flux between E and A
+    model.do_rate()           # method='Taylor' (default) or 'MLPB'
+    print(model.rate)
+    model.do_pfold(FF=["A"], UU=["E"])
+    print(model.pfold, model.kf)
+
+    # 4. Coarse-grain into a two-state model
+    two_state = fewsm.FEWSM(parent=model, N=2)
+    print(two_state.macros)
+
+    # 5. Validate: relaxation times as a function of lag time
+    smsm.convergence_test(time=[5, 10, 20, 50, 100], error=True)
+    for lt in sorted(smsm.msms):
+        print(lt, smsm.msms[lt].tauT)
+```
+
+MasterMSM uses `multiprocessing`, so scripts need the
+`if __name__ == "__main__":` guard shown above. This is not required
+in a Jupyter notebook.
+
+Examples
+--------
+The [examples](examples) folder contains Jupyter notebooks:
+
+| Folder | Content |
+|--------|---------|
+| [alanine_dipeptide](examples/alanine_dipeptide) | Complete workflow on the simplest peptide model: discretization, MSM, validation, rate matrix (Taylor and MLPB) |
+| [alanine_pentapeptide](examples/alanine_pentapeptide) | Featurization, TICA and comparison of discretization protocols |
+| [bistable_potential](examples/bistable_potential) | Brownian dynamics on one and two dimensional two-state potentials |
+| [schutte_potential](examples/schutte_potential) | Brownian dynamics on the one dimensional Schütte potential |
+
+Most of the data are hosted at [OSF](https://osf.io/a2vc7); each
+notebook says where its data come from. The Brownian dynamics data
+for the bistable and Schütte potentials can be fetched with
+
+    python examples/download_data.py
+
+Testing
+-------
+The tests use `pytest` and download a small amount of MD data on the
+first run:
+
+    pip install pytest
+    pytest --pyargs mastermsm
+
+Contributing
+------------
+Development takes place on the `develop` branch; `master` holds the
+releases. Bug reports and pull requests (against `develop`) are welcome
+on [GitHub](https://github.com/BioKT/MasterMSM/issues).
+
+Citation
+--------
+If you use MasterMSM in your work, please cite:
+
+    @article{mastermsm,
+    author = "David De Sancho and Anne Aguirre",
+    title = "{MasterMSM: A Package for Constructing Master Equation Models of Molecular Dynamics}",
+    year = "2019",
+    month = "6",
+    journal = "J. Chem. Inf. Model.",
+    url = "https://doi.org/10.1021/acs.jcim.9b00468",
+    doi = "10.1021/acs.jcim.9b00468"
+    }
+
+Contributors
+------------
+*   David De Sancho
+*   Anne Aguirre
+*   Ion Mitxelena
+
+License
+-------
+MasterMSM is distributed under the GNU General Public License,
+version 2. See [LICENSE](LICENSE).

mastermsm-2.0.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+mastermsm/__init__.py,sha256=wAxkK8w13vqoF47A8iqWdSlIgRRXmZiQ0R4wePZfzhs,22
+mastermsm/fewsm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mastermsm/fewsm/fewsm.py,sha256=zdO45ccn4RpYIhbJ_uBRH-OdulskoJZU6wylb8qKcoI,9463
+mastermsm/fewsm/fewsm_lib.py,sha256=vB7wzAG7T8aSODEhiJxNobp6OJ1tn_NLn9Wwvz7ELy8,3091
+mastermsm/msm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mastermsm/msm/msm.py,sha256=fUHUeFV5ZWbDYm03P3ZZLo2SndXpU11LUkV4BR4xLhs,38007
+mastermsm/msm/msm_lib.py,sha256=qf5ocQMVLG4J_-Gw8ERnJKjY0JrGOxXSIRwovBR6DvY,36972
+mastermsm/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mastermsm/test/download_data.py,sha256=Z6gjz4WWeLsf9yAyrSezH36dJYptpsFKPmcYWHbJtO0,2359
+mastermsm/test/test_fewsm.py,sha256=c04T-ox6G18v8mSE4M1HH2WiU1go1-0xpLOeTAlpnP8,3546
+mastermsm/test/test_msm.py,sha256=RiymRaQqQEE59wQ3k9RVEEqp8XruFFqCGl8DV0YhWRs,42292
+mastermsm/test/test_trajectory.py,sha256=oUo-xiwJDxaVNNXNpyeDHGUj6vZU56_L71d8AxFTKSA,42437
+mastermsm/trajectory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mastermsm/trajectory/traj.py,sha256=cZD_eP4jGn-TDNRhpTwiIgD0BaNp_HYNKYn8YM1b81Y,24612
+mastermsm/trajectory/traj_lib.py,sha256=dSoA5Zd1D_i4VjE6lCOIjGmiwBGtIJp6_a-7v0_j5Kg,14539
+mastermsm-2.0.1.dist-info/licenses/LICENSE,sha256=wDzqAntLQORAL6vQhVdzZyfsPVvFStZKtkct5DIZjK0,18047
+mastermsm-2.0.1.dist-info/METADATA,sha256=-Xh4K4gEa3YPpeyrCQSaKKHecb-8f1DBzTiXY4SoIc4,7832
+mastermsm-2.0.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+mastermsm-2.0.1.dist-info/top_level.txt,sha256=RGqtnrMyaRvEZW8KrTGYFrTBQkmLGi_hg3YW6ZrtsjU,10
+mastermsm-2.0.1.dist-info/RECORD,,

mastermsm-2.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+