CodeEntropy 2.3.0__py3-none-any.whl → 2.4.1__py3-none-any.whl

CodeEntropy/__init__.py

@@ -8,4 +8,4 @@ entropy estimates, supporting a wide range of applications in molecular simulati
 and statistical mechanics.
 """
 
-__version__ = "2.3.0"
+__version__ = "2.4.1"

CodeEntropy/levels/axes.py

@@ -61,13 +61,15 @@ class AxesCalculator:
         self._rot_axes = None
         self._number_of_beads = None
 
-    def get_residue_axes(self, data_container, index: int, residue=None):
+    def get_residue_axes(
+        self, data_container, index: int, relative_index: int, residue=None
+    ):
         """Compute residue-level translational and rotational axes.
 
         The translational and rotational axes at the residue level.
 
         - Identify the residue (either provided or selected by `resindex index`).
-        - Determine whether the residue is bonded to neighboring residues
+        - Determine whether the residue is bonded to neighbouring residues
           (previous/next in sequence) using MDAnalysis bonded selections.
         - If there are *no* bonds to other residues:
             * Use a custom principal axes, from a moment-of-inertia (MOI) tensor
@@ -76,13 +78,21 @@ class AxesCalculator:
             * Set translational axes equal to rotational axes (as per the original
               code convention).
         - If bonded to other residues:
-            * Use default axes and MOI (MDAnalysis principal axes / inertia).
+            * Translational axes are principal axes of data_container.
+            * Find edge heavy atoms (i.e. heavy atoms bonded to neighbour residues)
+              and find the shortest chain between them: the backbone. Edge
+              atoms + backbone COM are used to determine residue rotational axes.
+              (see get_residue_custom_axes).Compute a custom MOI, using heavy atom
+              positions and heavy atom + hydrogen masses.
 
         Args:
             data_container (MDAnalysis.Universe or AtomGroup):
                 Molecule and trajectory data (the fragment/molecule container).
             index (int):
                 Residue index (resindex) within `data_container`.
+            relative_index (int):
+                Index of first residue within 'data_container'.
+                This is used to obtain index in MDA Universe for atom selections.
             residue (MDAnalysis.AtomGroup, optional):
                 If provided, this residue selection will be used rather than
                 selecting again.
@@ -99,41 +109,75 @@ class AxesCalculator:
                 If the residue selection is empty.
         """
         # TODO refine selection so that it will work for branched polymers
-        index_prev = index - 1
-        index_next = index + 1
+
+        index_prev = index + relative_index - 1
+        index_next = index + relative_index + 1
 
         if residue is None:
-            residue = data_container.select_atoms(f"resindex {index}")
+            residue = data_container.select_atoms(f"resindex {index + relative_index}")
+            # residue of interest
         if len(residue) == 0:
-            raise ValueError(f"Empty residue selection for resindex={index}")
+            raise ValueError(
+                f"Empty residue selection for resindex={index + relative_index}"
+            )
 
-        center = residue.atoms.center_of_mass(unwrap=True)
-        atom_set = data_container.select_atoms(
-            f"(resindex {index_prev} or resindex {index_next}) and bonded resid {index}"
+        edge_atom_set = data_container.atoms.select_atoms(
+            f"resindex {index + relative_index} and "
+            f"(bonded resindex {index_prev} or "
+            f"resindex {index_next})"
         )
 
-        if len(atom_set) == 0:
-            # No bonds to other residues.
-            # Use a custom principal axes, from a MOI tensor that uses positions of
-            # heavy atoms only, but including masses of heavy atom + bonded H.
-            uas = residue.select_atoms("mass 2 to 999")
-            ua_masses = self.get_UA_masses(residue)
+        uas = residue.select_atoms("mass 2 to 999")
+        ua_masses = self.get_UA_masses(residue)
+
+        if len(edge_atom_set) == 0:
             moi_tensor = self.get_moment_of_inertia_tensor(
-                center_of_mass=center,
+                center_of_mass=np.array(residue.center_of_mass()),
                 positions=uas.positions,
                 masses=ua_masses,
                 dimensions=data_container.dimensions[:3],
             )
             rot_axes, moment_of_inertia = self.get_custom_principal_axes(moi_tensor)
             trans_axes = rot_axes  # per original convention
+            rot_center = np.array(residue.center_of_mass())
         else:
-            # If bonded to other residues, use default axes and MOI.
             make_whole(data_container.atoms)
             trans_axes = data_container.atoms.principal_axes()
-            rot_axes, moment_of_inertia = self.get_vanilla_axes(residue)
-            center = residue.center_of_mass(unwrap=True)
 
-        return trans_axes, rot_axes, center, moment_of_inertia
+            if len(edge_atom_set) == 1:
+                if index == 0:
+                    # first residue: use first heavy atom
+                    edges = [residue.atoms[0], edge_atom_set[0]]
+                    backbone = self.get_chain(
+                        residue, residue.atoms[0], edge_atom_set[0]
+                    )
+                else:
+                    # last residue: last heavy atom
+                    last_index = len(uas) - 1
+                    last = None
+                    if last_index > 0 and last is None:
+                        heavy_atom = uas[last_index]
+                        last = heavy_atom
+                    edges = [edge_atom_set[0], last]
+
+                    backbone = self.get_chain(residue, edge_atom_set[0], last)
+            else:
+                edges = [edge_atom_set[0], edge_atom_set[1]]
+                backbone = self.get_chain(residue, edge_atom_set[0], edge_atom_set[1])
+            backbone_center = np.zeros(3)
+            for heavy_atom in backbone:
+                backbone_center += heavy_atom.position
+            backbone_center = backbone_center / len(backbone)
+            rot_center, rot_axes = self.get_residue_custom_axes(edges, backbone_center)
+
+            moment_of_inertia = self.get_custom_residue_moment_of_inertia(
+                center_of_mass=rot_center,
+                positions=uas.positions,
+                masses=ua_masses,
+                custom_rot_axes=rot_axes,
+                dimensions=data_container.dimensions[:3],
+            )
+        return trans_axes, rot_axes, rot_center, moment_of_inertia
 
     def get_residue_axes_from_topology(
         self,
@@ -170,7 +214,6 @@ class AxesCalculator:
             if box is not None
             else np.asarray(u.dimensions[:3], dtype=float)
         )
-
         center = residue_atoms.center_of_mass(unwrap=True)
 
         if not topology.has_neighbor_bonds:
@@ -193,7 +236,7 @@ class AxesCalculator:
 
         return trans_axes, rot_axes, center, moment_of_inertia
 
-    def get_UA_axes(self, data_container, index: int):
+    def get_UA_axes(self, data_container, index: int, res_position):
         """Compute united-atom-level translational and rotational axes.
 
         The translational and rotational axes at the united-atom level.
@@ -201,22 +244,29 @@ class AxesCalculator:
         This preserves the original behaviour and its rationale:
 
         - Translational axes:
-            Use the same custom principal-axes approach as residue level:
-            compute a custom MOI tensor using heavy-atom coordinates but UA masses
-            (heavy + bonded H masses), then compute the principal axes from it.
+            Use the same approach as residue level rotational.
+            Identify residue of interest and neighbours, then select
+            edge heavy atoms (i.e. heavy atoms bonded to neighbour residues).
+            If there are no bonds to neighbouring residues, use residue
+            .principal axes Otherwise, find the shortest chain between edge
+            residues: the backbone. Edge atoms + backbone COM are used to
+            determine UA translational axes (see get_residue_custom_axes)
 
         - Rotational axes:
             Identify heavy atoms in the residue/molecule of interest and choose
             the `index`-th heavy atom (where index corresponds to the bead index).
             Use bonded topology around that heavy atom to determine UA rotational
             axes (see :meth:`get_bonded_axes`).
+            Compute a custom MOI tensor using heavy-atom coordinates but UA masses
+            (heavy + bonded H masses), then compute the principal axes from it.
 
         Args:
             data_container (MDAnalysis.Universe or AtomGroup):
                 Molecule and trajectory data.
             index (int):
                 Bead index (ordinal among heavy atoms).
-
+            res_position: where the residue of interest is
+                in data_container
         Returns:
             Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
                 - trans_axes: Translational axes (3, 3).
@@ -228,51 +278,124 @@ class AxesCalculator:
             IndexError:
                 If `index` does not correspond to an existing heavy atom.
             ValueError:
-                If bonded-axis construction fails.
+                If axis construction fails.
         """
 
-        index = int(index)  # bead index
-
+        index = int(index)  # UA bead index
+        heavy_atoms = data_container.select_atoms("mass 2 to 999")
         # use the same customPI trans axes as the residue level
-        heavy_atoms = data_container.select_atoms("prop mass > 1.1")
         if len(heavy_atoms) > 1:
-            UA_masses = self.get_UA_masses(data_container.atoms)
-            center = data_container.atoms.center_of_mass(unwrap=True)
-            moment_of_inertia_tensor = self.get_moment_of_inertia_tensor(
-                center, heavy_atoms.positions, UA_masses, data_container.dimensions[:3]
-            )
-            trans_axes, _moment_of_inertia = self.get_custom_principal_axes(
-                moment_of_inertia_tensor
+            if len(data_container.residues) == 1:
+                # only the one residue => use principal axes
+                residue = data_container
+                trans_center = data_container.atoms.center_of_mass(unwrap=True)
+                trans_axes = data_container.atoms.principal_axes()
+                residue_heavy_atoms = heavy_atoms
+            else:
+                # residue of interest has at least one neighbour
+                if res_position == -1:
+                    residue = data_container.residues[0]
+                    resindex = residue.resindex
+                    resindex_next = resindex + 1
+
+                    second_edge = data_container.select_atoms(
+                        f"resindex {resindex} and bonded resindex {resindex_next}"
+                    )
+
+                    edges = [residue.atoms[0], second_edge[0]]
+                    backbone = self.get_chain(
+                        residue, residue.atoms[0], second_edge.atoms[0]
+                    )
+
+                elif res_position == 0:
+                    # between 2 residues
+                    residue = data_container.residues[1]
+                    resindex = residue.resindex
+                    resindex_next = resindex + 1
+                    resindex_prev = resindex - 1
+
+                    edge_set = data_container.select_atoms(
+                        f"resindex {resindex} and "
+                        f"(bonded resindex {resindex_prev} or "
+                        f"resindex {resindex_next})"
+                    )
+
+                    edges = [edge_set[0], edge_set[1]]
+                    backbone = self.get_chain(residue, edge_set[0], edge_set[1])
+
+                else:
+                    # last resid
+                    # always resindex 1 in data_container
+                    residue = data_container.residues[1]
+                    resindex = residue.resindex
+                    resindex_prev = resindex - 1
+                    first_edge = data_container.select_atoms(
+                        f"resindex {resindex} and bonded resindex {resindex_prev}"
+                    )
+
+                    last_index = len(heavy_atoms) - 1
+                    last = None
+                    # look for last heavy atom
+                    # with only one bond to another
+                    if last_index > 0 and last is None:
+                        heavy_atom = heavy_atoms[last_index]
+                        last = heavy_atom
+
+                    edges = [first_edge.atoms[0], last]
+                    backbone = self.get_chain(residue, first_edge.atoms[0], last)
+
+                backbone_center = np.zeros(3)
+                for heavy_atom in backbone:
+                    backbone_center += heavy_atom.position
+                backbone_center = backbone_center / len(backbone)
+
+                trans_center, trans_axes = self.get_residue_custom_axes(
+                    edges, backbone_center
+                )
+                residue_heavy_atoms = residue.atoms.select_atoms("mass 2 to 999")
+
+            # look for heavy atoms in residue of interest
+            heavy_atom_indices = []
+            for atom in residue_heavy_atoms:
+                heavy_atom_indices.append(atom.index)
+            # we find the nth heavy atom
+            # where n is the bead index
+            heavy_atom_index = heavy_atom_indices[index]
+            heavy_atom = residue.atoms.select_atoms(f"index {heavy_atom_index}")[0]
+            rot_center = heavy_atom.position
+            rot_axes, moment_of_inertia = self.get_bonded_axes(
+                system=data_container,
+                atom=heavy_atom,
+                dimensions=data_container.dimensions[:3],
             )
+
         else:
-            # use standard PA for UA not bonded to anything else
-            make_whole(data_container.atoms)
-            trans_axes = data_container.atoms.principal_axes()
+            # 1 heavy atom in the data_container
+            heavy_atom = heavy_atoms[0]
+            # trans and rot centres are centre of mass
+            rot_center = data_container.center_of_mass()
+            rot_axes, moment_of_inertia = self.get_bonded_axes(
+                system=data_container,
+                atom=heavy_atom,
+                dimensions=data_container.dimensions[:3],
+            )
+            trans_center = rot_center
+            # principal axes
+            trans_axes = rot_axes
+
+        if trans_axes is None:
+            raise ValueError("Unable to compute translation axes for UA bead.")
 
-        # look for heavy atoms in residue of interest
-        heavy_atom_indices = []
-        for atom in heavy_atoms:
-            heavy_atom_indices.append(atom.index)
-        # we find the nth heavy atom
-        # where n is the bead index
-        heavy_atom_index = heavy_atom_indices[index]
-        heavy_atom = data_container.select_atoms(f"index {heavy_atom_index}")
-
-        center = heavy_atom.positions[0]
-        rot_axes, moment_of_inertia = self.get_bonded_axes(
-            system=data_container,
-            atom=heavy_atom[0],
-            dimensions=data_container.dimensions[:3],
-        )
         if rot_axes is None or moment_of_inertia is None:
             raise ValueError("Unable to compute bonded axes for UA bead.")
 
-        logger.debug(f"Translational Axes: {trans_axes}")
-        logger.debug(f"Rotational Axes: {rot_axes}")
-        logger.debug(f"Center: {center}")
-        logger.debug(f"Moment of Inertia: {moment_of_inertia}")
+        logger.debug("Translational Axes: %s", trans_axes)
+        logger.debug("Rotational Axes: %s", rot_axes)
+        logger.debug("Translational center: %s", trans_center)
+        logger.debug("Rotational center: %s", rot_center)
+        logger.debug("Moment of Inertia: %s", moment_of_inertia)
 
-        return trans_axes, rot_axes, center, moment_of_inertia
+        return trans_axes, rot_axes, rot_center, moment_of_inertia
 
     def get_UA_axes_from_topology(
         self,
@@ -429,6 +552,55 @@ class AxesCalculator:
 
         return custom_axes, custom_moment_of_inertia
 
+    def get_residue_custom_axes(self, edges, center):
+        """
+        Compute rotation axes at the residue level, given
+        two edge atoms of the residue (E1+E2),
+        and the centre of geometry of backbone atoms
+        that are not edges (C).
+        x axis is O-E1
+        y axis is O-C (perpendicular to O-E1 in the
+        same plane as E2)
+        z axis is perpendicular to the two other axes
+
+        ::
+
+                    C
+                    |
+                    |
+            E1 ---- O --- E2
+
+        Args:
+            edges: (2,3) positions of two edge atoms
+            center: (3,) coordinates of the inner backbone
+            centre of geometry
+
+        Returns:
+            rot_center: (3,) rotation centre,
+            lies on the E1-E2 vector
+            rot_axes: (3,3) rotation axes of residue
+        """
+        first_edge_centre_of_geometry_vector = center - edges[0].position
+        # look for projection of E1-O onto E1-E2 (E1-C)
+        first_edge_second_edge_vector = edges[1].position - edges[0].position
+        first_edge_origin_vector = (
+            np.dot(first_edge_second_edge_vector, first_edge_centre_of_geometry_vector)
+            / (np.linalg.norm(first_edge_second_edge_vector) ** 2)
+        ) * first_edge_second_edge_vector
+        x_axis = -first_edge_origin_vector
+        # O-C = O-E1 + E1-C
+        origin_centre_of_geometry_vector = (
+            -first_edge_origin_vector + first_edge_centre_of_geometry_vector
+        )
+        y_axis = origin_centre_of_geometry_vector
+        z_axis = np.cross(x_axis, y_axis)
+        x_axis /= np.linalg.norm(x_axis)
+        y_axis /= np.linalg.norm(y_axis)
+        z_axis /= np.linalg.norm(z_axis)
+        rot_axes = np.array([x_axis, y_axis, z_axis])
+        rot_center = first_edge_origin_vector + edges[0].position
+        return rot_center, rot_axes
+
     def get_bonded_axes(self, system, atom, dimensions: np.ndarray):
         r"""Compute UA rotational axes from bonded topology around a heavy atom.
 
@@ -659,6 +831,41 @@ class AxesCalculator:
         scaled_custom_axes = unscaled_custom_axes / mod[:, np.newaxis]
         return scaled_custom_axes
 
+    def get_custom_residue_moment_of_inertia(
+        self,
+        center_of_mass: np.ndarray,
+        positions: np.ndarray,
+        masses: np.ndarray,
+        custom_rot_axes: np.ndarray,
+        dimensions: np.ndarray,
+    ):
+        """
+        Compute moment of inertia around custom axes for a bead
+        formed of multiple UAs.
+
+        Args:
+            center_of_mass: (3, ) COM for bead
+            positions: (N,3) positions of the UAs in the bead
+            masses: (N,) masses of the UAs in the bead
+            custom_rot_axes: (3,3) array of residue rotation axes
+            dimensions: (3,) simulation_box_dimensions
+
+        Returns:
+            np.ndarray: (3,) moment of inertia array.
+
+        """
+
+        translated_coords = self.get_vector(center_of_mass, positions, dimensions)
+        custom_moment_of_inertia = np.zeros(3, dtype=float)
+
+        for coord, mass in zip(translated_coords, masses, strict=True):
+            axis_component = np.sum(
+                np.cross(custom_rot_axes, coord) ** 2 * mass, axis=1
+            )
+            custom_moment_of_inertia += axis_component
+
+        return custom_moment_of_inertia
+
     def get_custom_moment_of_inertia(
         self,
         UA,
@@ -849,3 +1056,78 @@ class AxesCalculator:
                     ua_mass += float(h.mass)
                 ua_masses.append(ua_mass)
         return ua_masses
+
+    def get_chain(self, residue, first, last):
+        """
+        For a given MDAnalysis AtomGroup and two given heavy atoms
+        within that AtomGroup, return the
+        shortest path between the two atoms.
+
+        Args:
+            residue: MDAnalysis AtomGroup representing
+            the residue/monomer of interest.
+            first: First heavy atom in the chain
+            last: Last heavy atom in the chain
+
+        Returns:
+            chain: Array containing chain atoms.
+        """
+
+        chain = []
+        # at the beggining we've only visited the first atom
+        visited_dict = {first: True}
+        # keep the previous atom to trace back the path
+        prev = {}
+        # queue of next heavy atoms to visit
+        next_to_visit = [first]
+        # all others heavy atoms in the residue, we have not yet visited
+        remaining_heavy_atoms = residue.atoms.select_atoms(
+            f"(mass 2 to 999) and not index {first.index}"
+        )
+        for atom in remaining_heavy_atoms:
+            visited_dict[atom] = False
+        current = first
+
+        while not visited_dict[last]:
+            # we haven't found a path to the last residue
+            next_to_visit.pop(0)
+            # we're visiting the current atom => we remove it from the queue
+            bonded_atoms = residue.atoms.select_atoms(
+                f"(mass 2 to 999) and bonded index {current.index}"
+            )
+
+            if last in bonded_atoms:
+                # we found a path to the last atom
+                visited_dict[last] = True
+                chain.append(last)
+                prev[last] = current
+
+            else:
+                for bonded_atom in bonded_atoms:
+                    # look for unvisited bonded atoms to the current atom we're visiting
+                    if not visited_dict[bonded_atom]:
+                        # we're going to want to visit the atoms
+                        next_to_visit.append(bonded_atom)
+                        prev[bonded_atom] = current
+                # we visit the next atom in the queue
+                current = next_to_visit[0]
+                visited_dict[current] = True
+
+        # we track the previous atom back to the first atom now
+        current = last
+        chain = [last]
+        # subtract index of first atom in resid
+        # most likely will coincide with first
+        # but this will work even if it doesn't
+        # accout for in-residue index
+        # start from last atom in chain
+        while chain[-1] != first:
+            # we haven't yet returned to the first atom
+            current = prev[current]
+            chain.append(current)
+
+        chain = np.flip(chain)
+        # only get in between residues
+        chain = chain[1:-1]
+        # accout for in-residue index
+        return chain

CodeEntropy/levels/nodes/accumulators.py

@@ -86,17 +86,24 @@ class InitCovarianceAccumulatorsNode:
 
     @staticmethod
     def _build_group_index(groups: dict[int, Any]) -> GroupIndex:
-        """Build group id <-> index mappings.
+        """Build deterministic mappings between group IDs and contiguous indices.
+
+        Group IDs are sorted before indices are assigned, ensuring that the
+        resulting mappings do not depend on dictionary insertion order.
 
         Args:
-            groups: Mapping of group id to group members.
+            groups: Mapping of group IDs to their members.
 
         Returns:
-            GroupIndex mapping object.
+            Bidirectional mappings between group IDs and contiguous indices.
         """
-        group_ids = list(groups.keys())
-        gid2i = {gid: i for i, gid in enumerate(group_ids)}
-        return GroupIndex(group_id_to_index=gid2i, index_to_group_id=list(group_ids))
+        group_ids = sorted(groups)
+        gid2i = {gid: index for index, gid in enumerate(group_ids)}
+
+        return GroupIndex(
+            group_id_to_index=gid2i,
+            index_to_group_id=group_ids,
+        )
 
     @staticmethod
     def _build_accumulators(n_groups: int) -> CovarianceAccumulators:

CodeEntropy/levels/nodes/covariance.py

@@ -185,6 +185,15 @@ class FrameCovarianceNode:
         molcount: dict[tuple[int, int], int],
     ) -> None:
         """Compute united-atom second moments for one molecule.
+        If there are multiple residues in the molecule, build
+        residue group and attribute res_position:
+            - First residue: residue_group contains first two
+            residues. res_position is -1.
+            - Last residue: residue_group contains last two
+            residues. res_position is 1.
+            - Non-terminal residue: residue_group contains
+            residue of interest + two neighbours. res_position
+            is 0.
 
         Args:
             u: Universe-like object used to resolve bead atom indices.
@@ -203,6 +212,32 @@ class FrameCovarianceNode:
             molcount: Per-residue group sample counters, mutated in place.
         """
         for local_res_i, res in enumerate(mol.residues):
+            if len(mol.residues) > 1:
+                if local_res_i == 0:
+                    relative_id = res.resindex
+                    # index relative to first in mda universe
+                    res_position = -1
+                    residue_group = mol.select_atoms(
+                        f"resindex {local_res_i + relative_id} "
+                        f"or resindex {local_res_i + 1 + relative_id}"
+                    )
+                elif local_res_i == len(mol.residues) - 1:
+                    res_position = 1
+                    residue_group = mol.select_atoms(
+                        f"resindex {local_res_i - 1 + relative_id} "
+                        f"or resindex {local_res_i + relative_id}"
+                    )
+                else:
+                    res_position = 0
+                    residue_group = mol.select_atoms(
+                        f"resindex {local_res_i - 1 + relative_id} "
+                        f"or resindex {local_res_i + relative_id} "
+                        f"or resindex {local_res_i + 1 + relative_id}"
+                    )
+
+            else:
+                res_position = None
+                residue_group = res
             bead_key = (mol_id, "united_atom", local_res_i)
             bead_idx_list = beads.get(bead_key, [])
             if not bead_idx_list:
@@ -216,7 +251,7 @@ class FrameCovarianceNode:
                 u=u,
                 mol_id=mol_id,
                 local_res_i=local_res_i,
-                residue_atoms=res.atoms,
+                residue_group=residue_group,
                 bead_groups=bead_groups,
                 axes_manager=axes_manager,
                 axes_topology=axes_topology,
@@ -224,6 +259,7 @@ class FrameCovarianceNode:
                 force_partitioning=force_partitioning,
                 customised_axes=customised_axes,
                 is_highest=is_highest,
+                res_position=res_position,
             )
 
             F, T = self._ft.compute_frame_covariance(force_vecs, torque_vecs)
@@ -406,13 +442,14 @@ class FrameCovarianceNode:
         mol_id: int,
         local_res_i: int,
         bead_groups: list[Any],
-        residue_atoms: Any,
+        residue_group: Any,
         axes_manager: Any,
         axes_topology: Any | None,
         box: np.ndarray | None,
         force_partitioning: float,
         customised_axes: bool,
         is_highest: bool,
+        res_position: int,
     ) -> tuple[list[np.ndarray], list[np.ndarray]]:
         """Build force and torque vectors for united-atom beads.
 
@@ -421,13 +458,14 @@ class FrameCovarianceNode:
             mol_id: Molecule index used in axes-topology lookup keys.
             local_res_i: Local residue index used in axes-topology lookup keys.
             bead_groups: Atom groups representing UA beads in a residue.
-            residue_atoms: Atom group for the parent residue.
+            residue_group: Atom group for the parent residue group.
             axes_manager: Axes helper used to select axes, centres, and moments.
             axes_topology: Optional cached axes topology generated during static setup.
             box: Optional periodic box vector.
             force_partitioning: Force partitioning factor for highest-level vectors.
             customised_axes: Whether customised UA axes should be used.
             is_highest: Whether UA is the highest active level.
+            res_position: Where the residue is in the residue group
 
         Returns:
             A tuple containing lists of force vectors and torque vectors.
@@ -436,29 +474,39 @@ class FrameCovarianceNode:
         torque_vecs: list[np.ndarray] = []
 
         for ua_i, bead in enumerate(bead_groups):
+            if res_position == -1:
+                residue = residue_group.residues[0]
+            elif res_position == 0 or res_position == 1:
+                residue = residue_group.residues[1]
+            else:
+                residue = residue_group
+
             if customised_axes:
                 ua_topology = None
                 if axes_topology is not None:
                     ua_topology = axes_topology.ua.get((mol_id, local_res_i, ua_i))
-
                 if ua_topology is not None:
                     trans_axes, rot_axes, center, moi = (
                         axes_manager.get_UA_axes_from_topology(
                             u=u,
-                            residue_atoms=residue_atoms,
+                            residue_atoms=residue.atoms,
                             topology=ua_topology,
                             box=box,
                         )
                     )
                 else:
+                    # we don't use the topology
+                    make_whole(residue_group)
+                    make_whole(bead)
                     trans_axes, rot_axes, center, moi = axes_manager.get_UA_axes(
-                        residue_atoms, ua_i
+                        residue_group, ua_i, res_position
                     )
+
             else:
-                make_whole(residue_atoms)
+                # principal axes
+                make_whole(residue.atoms)
                 make_whole(bead)
-
-                trans_axes = residue_atoms.principal_axes()
+                trans_axes = residue.atoms.principal_axes()
                 rot_axes, moi = axes_manager.get_vanilla_axes(bead)
                 center = bead.center_of_mass(unwrap=True)
 
@@ -518,6 +566,8 @@ class FrameCovarianceNode:
         force_vecs: list[np.ndarray] = []
         torque_vecs: list[np.ndarray] = []
 
+        relative_res_i = mol.residues[0].resindex
+
         for local_res_i, bead in enumerate(bead_groups):
             trans_axes, rot_axes, center, moi = self._get_residue_axes(
                 u=u,
@@ -525,6 +575,7 @@ class FrameCovarianceNode:
                 mol_id=mol_id,
                 bead=bead,
                 local_res_i=local_res_i,
+                relative_res_i=relative_res_i,
                 axes_manager=axes_manager,
                 axes_topology=axes_topology,
                 box=box,
@@ -561,6 +612,7 @@ class FrameCovarianceNode:
         mol_id: int,
         bead: Any,
         local_res_i: int,
+        relative_res_i: int,
         axes_manager: Any,
         axes_topology: Any | None,
         box: np.ndarray | None,
@@ -574,6 +626,8 @@ class FrameCovarianceNode:
             mol_id: Molecule index used in axes-topology lookup keys.
             bead: Atom group representing the residue bead.
             local_res_i: Residue index local to ``mol``.
+            relative_res_i: Residue index of first residue within ``mol``. This
+            might differ from residue index of first residue in topology.
             axes_manager: Axes helper used to select axes, centres, and moments.
             axes_topology: Optional cached axes topology generated during static setup.
             box: Optional periodic box vector.
@@ -597,7 +651,9 @@ class FrameCovarianceNode:
                     box=box,
                 )
 
-            return axes_manager.get_residue_axes(mol, local_res_i, residue=res.atoms)
+            return axes_manager.get_residue_axes(
+                mol, local_res_i, relative_res_i, residue=res.atoms
+            )
 
         make_whole(mol.atoms)
         make_whole(bead)

{codeentropy-2.3.0.dist-info → codeentropy-2.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: CodeEntropy
-Version: 2.3.0
+Version: 2.4.1
 Summary: CodeEntropy is a Python package for computing the configurational entropy of macromolecular systems using forces sampled from molecular dynamics (MD) simulations. It implements the multiscale cell correlation method to provide accurate and efficient entropy estimates, supporting a wide range of applications in molecular simulation and statistical mechanics.
 Keywords: entropy,macromolecular systems,MD simulation
 Author-email: Arghya 'Argo' Chakravorty <arghyac@umich.edu>, Donald Chung-HK <donald.chung@stfc.ac.uk>, Sarah Fegan <sarah.fegan@stfc.ac.uk>, James Gebbie-Rayet <james.gebbie@stfc.ac.uk>, Sarah Harris <sarah.harris@sheffield.ac.uk>, Richard Henchman <rhen7213@uni.sydney.edu.au>, Jonathan Higham <j.higham4@lancaster.ac.uk>, Jas Kalayan <jas.kalayan@stfc.ac.uk>, Ioana Papa <iapapa1@sheffield.ac.uk>
@@ -40,19 +40,19 @@ Requires-Dist: sphinx_copybutton>=0.5,<1.0 ; extra == "docs"
 Requires-Dist: furo>=2025.0,<2026.0 ; extra == "docs"
 Requires-Dist: markupsafe>=3.0,<4.0 ; extra == "docs"
 Requires-Dist: pre-commit>=4.5,<5.0 ; extra == "pre-commit"
-Requires-Dist: ruff>=0.15,<0.16 ; extra == "pre-commit"
+Requires-Dist: ruff>=0.16,<0.17 ; extra == "pre-commit"
 Requires-Dist: pylint>=4.0,<5.0 ; extra == "pre-commit"
 Requires-Dist: rstcheck>=6.2,<7.0 ; extra == "pre-commit"
 Requires-Dist: pytest>=9.0,<10.0 ; extra == "testing"
 Requires-Dist: pytest-cov>=7.0,<8.0 ; extra == "testing"
 Requires-Dist: pytest-sugar>=1.1,<2.0 ; extra == "testing"
-Requires-Dist: pytest-xdist ; extra == "testing"
 Project-URL: Documentation, https://codeentropy.readthedocs.io
 Project-URL: Homepage, https://ccpbiosim.github.io/CodeEntropy/
 Project-URL: Repository, https://github.com/CCPBioSim/CodeEntropy
 Provides-Extra: docs
 Provides-Extra: pre-commit
 Provides-Extra: testing
+Import-Name: CodeEntropy
 
 CodeEntropy
 ==============================

{codeentropy-2.3.0.dist-info → codeentropy-2.4.1.dist-info}/RECORD

@@ -1,65 +1,65 @@
-CodeEntropy/__init__.py,sha256=e1AFhzKDwidArRO8JqsGTV9enxo_YcQhZcfD2Kt9tAs,404
-CodeEntropy/__main__.py,sha256=5i_ZrxQaq0q2aPllbB4SZ6BApV6oUFCgx0cGyjfMPrU,108
-CodeEntropy/cli.py,sha256=xgSgagCV6HQ3CoXUpG7p7Ef5hCExgxp7orz6dZZWA6c,960
-CodeEntropy/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-CodeEntropy/config/argparse.py,sha256=Yjb2SWNdfKhHmfznU439cZPtdPM_QjhUD4uug2fnsek,19515
-CodeEntropy/config/runtime.py,sha256=iyeUrSAmz3eGpkAslAGsDzEzu7s4T8npy_Di3d8tnaU,14846
-CodeEntropy/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-CodeEntropy/core/dask_clusters.py,sha256=FsvLyYQPImTWRf9J4x7wUILqf3syS0Ji5JUsJN-Qp1A,8992
-CodeEntropy/core/logging.py,sha256=XLr2lSSC5kGPq7rQDhWCi7Vcvh3DGO9e5TDbI4l2Bvc,7775
-CodeEntropy/entropy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-CodeEntropy/entropy/configurational.py,sha256=3erd1Ul4sGL5BMBDYq33f27aRTZqiEb6hv1bVfWo9QA,2392
-CodeEntropy/entropy/graph.py,sha256=LeDF2KxxNVgpetrIE9j0dnW64UhGywDLqoBJEf54vtc,4612
-CodeEntropy/entropy/orientational.py,sha256=gfpYqCKQjAAx22rrUdbiLvzfEIXy1nwJoub1rgYKCvY,3415
-CodeEntropy/entropy/vibrational.py,sha256=jgPWWiUW6aRCx949cFrNKuLB1MJoawD-9Uk8OB04Cs8,9366
-CodeEntropy/entropy/water.py,sha256=Ob3V08DyQNSWDMqpQ27rqjgHeU5AlKZfjqf9EqUdgqc,8225
-CodeEntropy/entropy/workflow.py,sha256=bxg8AVXGk7uwlv4u2AZ4kTQ26PMge_Z5ubWghdLtn9U,16100
-CodeEntropy/entropy/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-CodeEntropy/entropy/nodes/aggregate.py,sha256=4SyXP1_bM0IesOuqflRLvPgEfFu0PmKiEm4EFgnNxwg,3062
-CodeEntropy/entropy/nodes/configurational.py,sha256=-3j2ji_p-twPjZyjQ1T3tgN0pYLSIof9any1w5NI2as,7135
-CodeEntropy/entropy/nodes/orientational.py,sha256=yPN_XRJ1LOxJ7hOE2cnsjIbgQlI2avM1g3mFbGhW6fM,2481
-CodeEntropy/entropy/nodes/vibrational.py,sha256=3uhRqaMpK8u7QK2SDQ6RLRcr2rS3sPh6-GlTaNdTFWw,16978
-CodeEntropy/levels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-CodeEntropy/levels/axes.py,sha256=lJuVj74IB0YVZCR2m-jrv5kOOxMNnhqBwPp_BKc9D_c,33222
-CodeEntropy/levels/forces.py,sha256=c7XnNIBTFCHHXllr1WxTIrxEV_CkUB2b1vdFO8hUofY,11595
-CodeEntropy/levels/hierarchy.py,sha256=3cd4t6Tywg7VMgw4TboFF5VAHdhG4FaGBXsMptchisY,5158
-CodeEntropy/levels/linalg.py,sha256=PJlrKtIOYcYDycW3Tbetm6k94FKFZTq-hm28qiu_tS0,3565
-CodeEntropy/levels/neighbors.py,sha256=vswveQCIVBlDPQBFGc0e3whzmTJD01GjEJTpJ2UMnZ0,6255
-CodeEntropy/levels/search.py,sha256=p4aqyj6GV7YGLDnlmZqi12cDbjfajSIB8IIcBAoUmaQ,8769
-CodeEntropy/levels/dihedrals/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-CodeEntropy/levels/dihedrals/angle_observations.py,sha256=ZsIaXRvNRzZQjBxafiWD2_3zn_GnKjc9EkN8GjrVh6Q,9861
-CodeEntropy/levels/dihedrals/conformational_state_builder.py,sha256=3ajT_v1Cga1JocIvuJtHPx2JZwGUtleemuF45S31iAQ,7598
-CodeEntropy/levels/dihedrals/kernels.py,sha256=gX75jgDDs-dv-IdI0V-u7NM-M4RVmpVppDAADFkHWxc,3594
-CodeEntropy/levels/dihedrals/peak_detection.py,sha256=h8j78gczkf9tlYFTMqITDc51K9l9NxS5Y-ul1gHytzw,9486
-CodeEntropy/levels/dihedrals/state_assignment.py,sha256=QtfYjXEBbW95lomT9linK1_5uU0nsHh1P6PyMT_VR1g,9672
-CodeEntropy/levels/dihedrals/topology.py,sha256=LJ_u6cY-N91A5CuNBYzk_I0xHEpvqYSC30u9T4aku7c,8825
-CodeEntropy/levels/execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-CodeEntropy/levels/execution/chunks.py,sha256=VD1LQA-thRaJZKVR_5qIQk5VZQWHGE2e2JzF5JspDe0,754
-CodeEntropy/levels/execution/policy.py,sha256=4Yoxd7wgjyIph8YwKYpS9vHDt1u-7X7GVcoOVo9k-9Q,2915
-CodeEntropy/levels/execution/reducers.py,sha256=7H3vXtV2Jhe7tCQLyjxEmSEhn6iYLwyXMXKsm9XiB2s,14751
-CodeEntropy/levels/execution/scheduler.py,sha256=luVBarqXNO24SWwQjKNJhecFO3fng6Yu8kcd5Ky_uOc,10629
-CodeEntropy/levels/execution/tasks.py,sha256=hGRbC2VmJOWndGX6PnZopUxdQhcLTL6RjAudXAESd2g,11125
-CodeEntropy/levels/graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-CodeEntropy/levels/graph/conformation_dag.py,sha256=2d9d9SwffYJn3ffRkPrL5HM_O5i5uiN0n_uRD-vt8O8,3147
-CodeEntropy/levels/graph/frame_dag.py,sha256=YxdFt81q6mhPBZuNWqN4MHZecyXpavfRw_tV3Jkv9MU,3683
-CodeEntropy/levels/graph/level_dag.py,sha256=RglkyLjvR0pYd4e_ScUXG75j-H9T0SWKmtLiBviiZK8,7324
-CodeEntropy/levels/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-CodeEntropy/levels/nodes/accumulators.py,sha256=PrfEFkyWC6pKB4ppjFnvCfjxblbNB5rjv-h_gpMBvT4,6002
-CodeEntropy/levels/nodes/axes_topology.py,sha256=QzrWbCL9YA8fzF4_WWpQGaIAAsOnjY6cVH7INDE40dk,11285
-CodeEntropy/levels/nodes/beads.py,sha256=9Ow065FY4jrIqPKCZJCvDNfIekJ17OBSX-bmEFsxtbc,8010
-CodeEntropy/levels/nodes/covariance.py,sha256=VWRRJbXbKviOPGqTiAcaZ8buylS9g3crb4G9WmOARPU,27670
-CodeEntropy/levels/nodes/detect_levels.py,sha256=YrM5SSceLiMqbOhr8Fy6SV-E_zkKRpvgHfDT8Grbin8,1864
-CodeEntropy/levels/nodes/detect_molecules.py,sha256=jILCddEicVngA7FjvQzafbG8HslaRICpT6hj2Uyi6YY,3059
-CodeEntropy/molecules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-CodeEntropy/molecules/grouping.py,sha256=rlRVbRcxS_bPCZV8yoOCZKSpLS1F5AdpdIhaK2nWf1U,6426
-CodeEntropy/results/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-CodeEntropy/results/reporter.py,sha256=ZmCEKhh_h7-0JGumlyrpH0Y-FaG8aGv-KkzdRAamEAQ,18368
-CodeEntropy/trajectory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-CodeEntropy/trajectory/frames.py,sha256=MSx_swzFjo4TgkZTR1y6W-1zuKNPg_C36I_uFqvOKpk,4354
-CodeEntropy/trajectory/mda.py,sha256=cWqgSgamdPnL4n3aWEKUgycjtzjpdgRgMVX6G5fln94,15803
-CodeEntropy/trajectory/source.py,sha256=NfYsdm1amr29h2tmJP-RKyCp3phb1SOAtAELJmGm740,1475
-codeentropy-2.3.0.dist-info/entry_points.txt,sha256=8Oa3H9ErsrGtx5Hc6hIHOw73wK3Ylkvfgtl_4cBb_GU,52
-codeentropy-2.3.0.dist-info/licenses/LICENSE,sha256=hgMaAAVW1Q6dL586OHoz8vFO-6BYn-d2aAFBpVQylFc,1072
-codeentropy-2.3.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-codeentropy-2.3.0.dist-info/METADATA,sha256=lg_zE5jQc0VXhFTOHyP_wFnHhUinI8FLTPpG0vlqjfM,6531
-codeentropy-2.3.0.dist-info/RECORD,,
+CodeEntropy/__init__.py,sha256=8puOcFWsWfTb7sI2KaqxNlWXHfuZIMrQBihf1qbsQAE,404
+CodeEntropy/__main__.py,sha256=5i_ZrxQaq0q2aPllbB4SZ6BApV6oUFCgx0cGyjfMPrU,108
+CodeEntropy/cli.py,sha256=xgSgagCV6HQ3CoXUpG7p7Ef5hCExgxp7orz6dZZWA6c,960
+CodeEntropy/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+CodeEntropy/config/argparse.py,sha256=Yjb2SWNdfKhHmfznU439cZPtdPM_QjhUD4uug2fnsek,19515
+CodeEntropy/config/runtime.py,sha256=iyeUrSAmz3eGpkAslAGsDzEzu7s4T8npy_Di3d8tnaU,14846
+CodeEntropy/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+CodeEntropy/core/dask_clusters.py,sha256=FsvLyYQPImTWRf9J4x7wUILqf3syS0Ji5JUsJN-Qp1A,8992
+CodeEntropy/core/logging.py,sha256=XLr2lSSC5kGPq7rQDhWCi7Vcvh3DGO9e5TDbI4l2Bvc,7775
+CodeEntropy/entropy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+CodeEntropy/entropy/configurational.py,sha256=3erd1Ul4sGL5BMBDYq33f27aRTZqiEb6hv1bVfWo9QA,2392
+CodeEntropy/entropy/graph.py,sha256=LeDF2KxxNVgpetrIE9j0dnW64UhGywDLqoBJEf54vtc,4612
+CodeEntropy/entropy/orientational.py,sha256=gfpYqCKQjAAx22rrUdbiLvzfEIXy1nwJoub1rgYKCvY,3415
+CodeEntropy/entropy/vibrational.py,sha256=jgPWWiUW6aRCx949cFrNKuLB1MJoawD-9Uk8OB04Cs8,9366
+CodeEntropy/entropy/water.py,sha256=Ob3V08DyQNSWDMqpQ27rqjgHeU5AlKZfjqf9EqUdgqc,8225
+CodeEntropy/entropy/workflow.py,sha256=bxg8AVXGk7uwlv4u2AZ4kTQ26PMge_Z5ubWghdLtn9U,16100
+CodeEntropy/entropy/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+CodeEntropy/entropy/nodes/aggregate.py,sha256=4SyXP1_bM0IesOuqflRLvPgEfFu0PmKiEm4EFgnNxwg,3062
+CodeEntropy/entropy/nodes/configurational.py,sha256=-3j2ji_p-twPjZyjQ1T3tgN0pYLSIof9any1w5NI2as,7135
+CodeEntropy/entropy/nodes/orientational.py,sha256=yPN_XRJ1LOxJ7hOE2cnsjIbgQlI2avM1g3mFbGhW6fM,2481
+CodeEntropy/entropy/nodes/vibrational.py,sha256=3uhRqaMpK8u7QK2SDQ6RLRcr2rS3sPh6-GlTaNdTFWw,16978
+CodeEntropy/levels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+CodeEntropy/levels/axes.py,sha256=PzFKuac22C_JQvkQamKB7j4W6OUXBx-YMAyKHXlw_E0,44699
+CodeEntropy/levels/forces.py,sha256=c7XnNIBTFCHHXllr1WxTIrxEV_CkUB2b1vdFO8hUofY,11595
+CodeEntropy/levels/hierarchy.py,sha256=3cd4t6Tywg7VMgw4TboFF5VAHdhG4FaGBXsMptchisY,5158
+CodeEntropy/levels/linalg.py,sha256=PJlrKtIOYcYDycW3Tbetm6k94FKFZTq-hm28qiu_tS0,3565
+CodeEntropy/levels/neighbors.py,sha256=vswveQCIVBlDPQBFGc0e3whzmTJD01GjEJTpJ2UMnZ0,6255
+CodeEntropy/levels/search.py,sha256=p4aqyj6GV7YGLDnlmZqi12cDbjfajSIB8IIcBAoUmaQ,8769
+CodeEntropy/levels/dihedrals/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+CodeEntropy/levels/dihedrals/angle_observations.py,sha256=ZsIaXRvNRzZQjBxafiWD2_3zn_GnKjc9EkN8GjrVh6Q,9861
+CodeEntropy/levels/dihedrals/conformational_state_builder.py,sha256=3ajT_v1Cga1JocIvuJtHPx2JZwGUtleemuF45S31iAQ,7598
+CodeEntropy/levels/dihedrals/kernels.py,sha256=gX75jgDDs-dv-IdI0V-u7NM-M4RVmpVppDAADFkHWxc,3594
+CodeEntropy/levels/dihedrals/peak_detection.py,sha256=h8j78gczkf9tlYFTMqITDc51K9l9NxS5Y-ul1gHytzw,9486
+CodeEntropy/levels/dihedrals/state_assignment.py,sha256=QtfYjXEBbW95lomT9linK1_5uU0nsHh1P6PyMT_VR1g,9672
+CodeEntropy/levels/dihedrals/topology.py,sha256=LJ_u6cY-N91A5CuNBYzk_I0xHEpvqYSC30u9T4aku7c,8825
+CodeEntropy/levels/execution/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+CodeEntropy/levels/execution/chunks.py,sha256=VD1LQA-thRaJZKVR_5qIQk5VZQWHGE2e2JzF5JspDe0,754
+CodeEntropy/levels/execution/policy.py,sha256=4Yoxd7wgjyIph8YwKYpS9vHDt1u-7X7GVcoOVo9k-9Q,2915
+CodeEntropy/levels/execution/reducers.py,sha256=7H3vXtV2Jhe7tCQLyjxEmSEhn6iYLwyXMXKsm9XiB2s,14751
+CodeEntropy/levels/execution/scheduler.py,sha256=luVBarqXNO24SWwQjKNJhecFO3fng6Yu8kcd5Ky_uOc,10629
+CodeEntropy/levels/execution/tasks.py,sha256=hGRbC2VmJOWndGX6PnZopUxdQhcLTL6RjAudXAESd2g,11125
+CodeEntropy/levels/graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+CodeEntropy/levels/graph/conformation_dag.py,sha256=2d9d9SwffYJn3ffRkPrL5HM_O5i5uiN0n_uRD-vt8O8,3147
+CodeEntropy/levels/graph/frame_dag.py,sha256=YxdFt81q6mhPBZuNWqN4MHZecyXpavfRw_tV3Jkv9MU,3683
+CodeEntropy/levels/graph/level_dag.py,sha256=RglkyLjvR0pYd4e_ScUXG75j-H9T0SWKmtLiBviiZK8,7324
+CodeEntropy/levels/nodes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+CodeEntropy/levels/nodes/accumulators.py,sha256=XM7phCAIo0RK9YAtx2wrdo2oinmpwXYrH9mp1_LQD7U,6259
+CodeEntropy/levels/nodes/axes_topology.py,sha256=QzrWbCL9YA8fzF4_WWpQGaIAAsOnjY6cVH7INDE40dk,11285
+CodeEntropy/levels/nodes/beads.py,sha256=9Ow065FY4jrIqPKCZJCvDNfIekJ17OBSX-bmEFsxtbc,8010
+CodeEntropy/levels/nodes/covariance.py,sha256=zwLPG_VRAH6hmCXeKkeQgqk7e_FRTBq0XXo-bNsR-U8,30210
+CodeEntropy/levels/nodes/detect_levels.py,sha256=YrM5SSceLiMqbOhr8Fy6SV-E_zkKRpvgHfDT8Grbin8,1864
+CodeEntropy/levels/nodes/detect_molecules.py,sha256=jILCddEicVngA7FjvQzafbG8HslaRICpT6hj2Uyi6YY,3059
+CodeEntropy/molecules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+CodeEntropy/molecules/grouping.py,sha256=rlRVbRcxS_bPCZV8yoOCZKSpLS1F5AdpdIhaK2nWf1U,6426
+CodeEntropy/results/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+CodeEntropy/results/reporter.py,sha256=ZmCEKhh_h7-0JGumlyrpH0Y-FaG8aGv-KkzdRAamEAQ,18368
+CodeEntropy/trajectory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+CodeEntropy/trajectory/frames.py,sha256=MSx_swzFjo4TgkZTR1y6W-1zuKNPg_C36I_uFqvOKpk,4354
+CodeEntropy/trajectory/mda.py,sha256=cWqgSgamdPnL4n3aWEKUgycjtzjpdgRgMVX6G5fln94,15803
+CodeEntropy/trajectory/source.py,sha256=NfYsdm1amr29h2tmJP-RKyCp3phb1SOAtAELJmGm740,1475
+codeentropy-2.4.1.dist-info/entry_points.txt,sha256=8Oa3H9ErsrGtx5Hc6hIHOw73wK3Ylkvfgtl_4cBb_GU,52
+codeentropy-2.4.1.dist-info/licenses/LICENSE,sha256=hgMaAAVW1Q6dL586OHoz8vFO-6BYn-d2aAFBpVQylFc,1072
+codeentropy-2.4.1.dist-info/WHEEL,sha256=_yMHPaBV-s6fQMwUoo83NSdTCM3c8xXWFXRhqafN-7Y,81
+codeentropy-2.4.1.dist-info/METADATA,sha256=Y3Cxq1oJet2Pq6A5xYm6tYu4R5-RI5quJh-IIR8I4r4,6507
+codeentropy-2.4.1.dist-info/RECORD,,

{codeentropy-2.3.0.dist-info → codeentropy-2.4.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: flit 3.12.0
+Generator: flit 4.0.2
 Root-Is-Purelib: true
 Tag: py3-none-any