"keyword","repo_name","file_path","file_extension","file_size","line_count","content","language" "Conformation","ntampellini/prism_pruner","prism_pruner/algebra.py",".py","4951","164","""""""Algebra utilities."""""" from typing import Sequence import numpy as np from prism_pruner.typing import Array1D_float, Array2D_float, Array3D_float def normalize(vec: Array1D_float) -> Array1D_float: """"""Normalize a vector."""""" return vec / np.linalg.norm(vec) def vec_angle(v1: Array1D_float, v2: Array1D_float) -> float: """"""Return the planar angle defined by two 3D vectors."""""" return float( np.degrees( np.arccos( np.clip( np.dot( v1 / np.linalg.norm(v1), v2 / np.linalg.norm(v2), ), -1.0, 1.0, ), ) ) ) def dihedral(p: Array2D_float) -> float: """""" Find dihedral angle in degrees from 4 3D vecs. Praxeolitic formula: 1 sqrt, 1 cross product. """""" p0, p1, p2, p3 = p b0 = -1.0 * (p1 - p0) b1 = p2 - p1 b2 = p3 - p2 # normalize b1 so that it does not influence magnitude of vector # rejections that come next b1 /= np.linalg.norm(b1) # vector rejections # v = projection of b0 onto plane perpendicular to b1 # = b0 minus component that aligns with b1 # w = projection of b2 onto plane perpendicular to b1 # = b2 minus component that aligns with b1 v = b0 - np.dot(b0, b1) * b1 w = b2 - np.dot(b2, b1) * b1 # angle between v and w in a plane is the torsion angle # v and w may not be normalized but that's fine since tan is y/x x = np.dot(v, w) y = np.dot(np.cross(b1, v), w) return float(np.degrees(np.arctan2(y, x))) def rot_mat_from_pointer(pointer: Array1D_float, angle: float) -> Array2D_float: """""" Get the rotation matrix from the rotation pivot using a quaternion. :param pointer: 3D vector representing the rotation pivot :param angle: rotation angle in degrees :return rotation_matrix: matrix that applied to a point, rotates it along the pointer """""" assert pointer.shape[0] == 3 angle_2 = np.radians(angle) / 2 sin = np.sin(angle_2) pointer = pointer / np.linalg.norm(pointer) return quaternion_to_rotation_matrix( [ sin * pointer[0], sin * pointer[1], sin * pointer[2], np.cos(angle_2), ] ) def quaternion_to_rotation_matrix(quat: Array1D_float | Sequence[float]) -> Array2D_float: """""" Convert a quaternion into a full three-dimensional rotation matrix. This rotation matrix converts a point in the local reference frame to a point in the global reference frame. :param quat: 4-element array representing the quaternion (q0, q1, q2, q3) :return: 3x3 element array representing the full 3D rotation matrix """""" # Extract the values from Q (adjusting for scalar last in input) q1, q2, q3, q0 = quat # First row of the rotation matrix r00 = 2 * (q0 * q0 + q1 * q1) - 1 r01 = 2 * (q1 * q2 - q0 * q3) r02 = 2 * (q1 * q3 + q0 * q2) # Second row of the rotation matrix r10 = 2 * (q1 * q2 + q0 * q3) r11 = 2 * (q0 * q0 + q2 * q2) - 1 r12 = 2 * (q2 * q3 - q0 * q1) # Third row of the rotation matrix r20 = 2 * (q1 * q3 - q0 * q2) r21 = 2 * (q2 * q3 + q0 * q1) r22 = 2 * (q0 * q0 + q3 * q3) - 1 # 3x3 rotation matrix return np.array([[r00, r01, r02], [r10, r11, r12], [r20, r21, r22]]) def get_inertia_moments(coords: Array3D_float, masses: Array1D_float) -> Array1D_float: """"""Compute the principal moments of inertia of a molecule. Returns a length-3 array [I_x, I_y, I_z], sorted ascending. """""" # Shift to center of mass com = np.sum(coords * masses[:, np.newaxis], axis=0) / np.sum(masses) coords = coords - com # Compute inertia tensor norms_sq = np.einsum(""ni,ni->n"", coords, coords) total = np.sum(masses * norms_sq) I_matrix = total * np.eye(3) - np.einsum(""n,ni,nj->ij"", masses, coords, coords) # Principal moments via symmetric eigendecomposition moments, _ = np.linalg.eigh(I_matrix) return np.sort(moments) def diagonalize(a: Array2D_float) -> Array2D_float: """"""Build the diagonalized matrix."""""" eigenvalues_of_a, eigenvectors_of_a = np.linalg.eig(a) b = eigenvectors_of_a[:, np.abs(eigenvalues_of_a).argsort()] return np.dot(np.linalg.inv(b), np.dot(a, b)) # type: ignore[no-any-return] def get_alignment_matrix(p: Array1D_float, q: Array1D_float) -> Array2D_float: """""" Build the rotation matrix that aligns vectors q to p (Kabsch algorithm). Assumes centered vector sets (i.e. their mean is the origin). """""" # calculate the covariance matrix cov_mat = p.T @ q # Compute the SVD v, _, w = np.linalg.svd(cov_mat) # Ensure proper rotation (det = 1, not -1) if np.linalg.det(v) * np.linalg.det(w) < 0.0: v[:, -1] *= -1 return v @ w # type: ignore[no-any-return] ","Python" "Conformation","ntampellini/prism_pruner","prism_pruner/__init__.py",".py","55","2","""""""PRISM - Pruning Interface for Similar Molecules."""""" ","Python" "Conformation","ntampellini/prism_pruner","prism_pruner/conformer_ensemble.py",".py","1860","58","""""""ConformerEnsemble class."""""" import re from dataclasses import dataclass, field from pathlib import Path from typing import Self import numpy as np from prism_pruner.typing import Array1D_float, Array1D_str, Array2D_float, Array3D_float @dataclass class ConformerEnsemble: """"""Class representing a conformer ensemble."""""" coords: Array3D_float atoms: Array1D_str energies: Array1D_float = field(default_factory=lambda: np.array([])) @classmethod def from_xyz(cls, file: Path | str, read_energies: bool = False) -> Self: """"""Generate ensemble from a multiple conformer xyz file."""""" coords = [] atoms = [] energies = [] with Path(file).open() as f: for num in f: if read_energies: energy = next(re.finditer(r""-*\d+\.\d+"", next(f))).group() energies.append(float(energy)) else: _comment = next(f) conf_atoms = [] conf_coords = [] for _ in range(int(num)): atom, *xyz = next(f).split() conf_atoms.append(atom) conf_coords.append([float(x) for x in xyz]) atoms.append(conf_atoms) coords.append(conf_coords) return cls(coords=np.array(coords), atoms=np.array(atoms[0]), energies=np.array(energies)) def to_xyz(self, file: Path | str) -> None: """"""Write ensemble to an xyz file."""""" def to_xyz(coords: Array2D_float) -> str: return f""{len(coords)}\n\n"" + ""\n"".join( f""{atom} {x:15.8f} {y:15.8f} {z:15.8f}"" for atom, (x, y, z) in zip(self.atoms, coords, strict=True) ) with Path(file).open(""w"") as f: f.write(""\n"".join(map(to_xyz, self.coords))) ","Python" "Conformation","ntampellini/prism_pruner","prism_pruner/torsion_module.py",".py","17259","507","""""""PRISM - Pruning Interface for Similar Molecules."""""" from copy import deepcopy from dataclasses import dataclass from typing import Callable, Iterable, Sequence import numpy as np from networkx import ( Graph, connected_components, has_path, is_isomorphic, minimum_spanning_tree, shortest_path, subgraph, ) from prism_pruner.algebra import vec_angle from prism_pruner.graph_manipulations import ( get_phenyl_ids, get_sp_n, is_amide_n, is_ester_o, ) from prism_pruner.rmsd import rmsd_and_max from prism_pruner.typing import Array1D_bool, Array1D_str, Array2D_float, Array2D_int from prism_pruner.utils import rotate_dihedral @dataclass class Torsion: """"""Torsion class."""""" i1: int i2: int i3: int i4: int mode: str | None = None @property def torsion(self) -> tuple[int, int, int, int]: """"""Return tuple of indices defining the torsion."""""" return (self.i1, self.i2, self.i3, self.i4) def in_cycle(torsion: Torsion, graph: Graph) -> bool: """"""Return True if the torsion is part of a cycle."""""" graph.remove_edge(torsion.i2, torsion.i3) cyclical: bool = has_path(graph, torsion.i1, torsion.i4) graph.add_edge(torsion.i2, torsion.i3) return cyclical def is_rotable( torsion: Torsion, graph: Graph, hydrogen_bonds: list[list[int]], keepdummy: bool = False, ) -> bool: """"""Return True if the Torsion object is rotatable. hydrogen bonds: iterable with pairs of sorted atomic indices. """""" if sorted((torsion.i2, torsion.i3)) in hydrogen_bonds: # self.n_fold = 6 # # This has to be an intermolecular HB: rotate it # return True return False if _is_free(torsion.i2, graph) or (_is_free(torsion.i3, graph)): if keepdummy or ( is_nondummy(torsion.i2, torsion.i3, graph) and (is_nondummy(torsion.i3, torsion.i2, graph)) ): return True return False def get_n_fold(torsion: Torsion, graph: Graph) -> int: """"""Return the n-fold of the rotation."""""" atoms = (graph.nodes[torsion.i2][""atoms""], graph.nodes[torsion.i3][""atoms""]) if ""H"" in atoms: return 6 # H-N, H-O hydrogen bonds if is_amide_n(torsion.i2, graph, mode=2) or (is_amide_n(torsion.i3, graph, mode=2)): # tertiary amides rotations are 2-fold return 2 if (""C"" in atoms) or (""N"" in atoms) or (""S"" in atoms): # if C, N or S atoms sp_n_i2 = get_sp_n(torsion.i2, graph) sp_n_i3 = get_sp_n(torsion.i3, graph) if 3 == sp_n_i2 == sp_n_i3: return 3 if 3 in (sp_n_i2, sp_n_i3): # Csp3-X, Nsp3-X, Ssulfone-X if torsion.mode == ""csearch"": return 3 elif torsion.mode == ""symmetry"": return sp_n_i3 or 2 if 2 in (sp_n_i2, sp_n_i3): return 2 return 4 # O-O, S-S, Ar-Ar, Ar-CO, and everything else def is_linear(torsion: Torsion, coords: Array2D_float, max_dev_deg: float = 5.0) -> bool: """""" Return wether three or more of the four atoms involved in the torsion are in line. :type torsion: Torsion :type coords: Array2D_float :type max_dev_deg: float :rtype: bool """""" p1, p2, p3, p4 = coords[list(torsion.torsion)] v21 = p1 - p2 v23 = p3 - p2 a1 = vec_angle(v21, v23) if abs(180 - a1) < max_dev_deg: return True v34 = p4 - p3 a2 = vec_angle(v34, -v23) if abs(180 - a2) < max_dev_deg: return True return False def get_angles(torsion: Torsion, graph: Graph) -> tuple[int, ...]: """"""Return the angles associated with the torsion."""""" d = { 1: (0,), # in case some sp carbons make it to here 2: (0, 180), 3: (0, 120, 240), 4: (0, 90, 180, 270), 6: (0, 60, 120, 180, 240, 300), } n_fold = get_n_fold(torsion, graph) return d[n_fold] def _is_free(index: int, graph: Graph) -> bool: """"""Return whether the torsion is free to rotate. Return True if the index specified satisfies all of the following: - Is not a sp2 carbonyl carbon atom - Is not the oxygen atom of an ester - Is not the nitrogen atom of a secondary amide (CONHR) """""" if all( ( graph.nodes[index][""atoms""] == ""C"", 2 == get_sp_n(index, graph), ""O"" in (graph.nodes[n][""atoms""] for n in graph.neighbors(index)), ) ): return False if is_amide_n(index, graph, mode=1): return False if is_ester_o(index, graph): return False return True def is_nondummy(i: int, root: int, graph: Graph) -> bool: """"""Return whether the torsion is not dummy. Checks that a molecular rotation along the dihedral angle (*, root, i, *) is non-dummy, that is the atom at index i, in the direction opposite to the one leading to root, has different substituents. i.e. methyl, CF3 and tBu rotations should return False. """""" if graph.nodes[i][""atoms""] not in (""C"", ""N""): return True # for now, we only discard rotations around carbon # and nitrogen atoms, like methyl/tert-butyl/triphenyl # and flat symmetrical rings like phenyl, N-pyrrolyl... G = deepcopy(graph) nb = list(G.neighbors(i)) nb.remove(root) if len(nb) == 1: if len(list(G.neighbors(nb[0]))) == 2: return False # if node i has two bonds only (one with root and one with a) # and the other atom (a) has two bonds only (one with i) # the rotation is considered dummy: some other rotation # will account for its freedom (i.e. alkynes, hydrogen bonds) # check if it is a phenyl-like rotation if len(nb) == 2: # get the 6 indices of the aromatic atoms (i1-i6) phenyl_indices = get_phenyl_ids(i, G) # compare the two halves of the 6-membered ring (indices i2-i3 region with i5-i6 region) if phenyl_indices is not None: i1, i2, i3, i4, i5, i6 = phenyl_indices G.remove_edge(i3, i4) G.remove_edge(i4, i5) G.remove_edge(i1, i2) G.remove_edge(i1, i6) subgraphs = [ subgraph(G, _set) for _set in connected_components(G) if i2 in _set or i6 in _set ] if len(subgraphs) == 2: return not is_isomorphic( subgraphs[0], subgraphs[1], node_match=lambda n1, n2: n1[""atoms""] == n2[""atoms""], ) # We should not end up here, but if we do, rotation should not be dummy return True # if not, compare immediate neighbors of i for n in nb: G.remove_edge(i, n) # make a set of each fragment around the chopped n-i bonds, # but only for fragments that are not root nor contain other random, # disconnected parts of the graph subgraphs_nodes = [ _set for _set in connected_components(G) if root not in _set and any(n in _set for n in nb) ] if len(subgraphs_nodes) == 1: return True # if not, the torsion is likely to be rotable # (tetramethylguanidyl alanine C(β)-N bond) subgraphs = [subgraph(G, s) for s in subgraphs_nodes] for sub in subgraphs[1:]: if not is_isomorphic( subgraphs[0], sub, node_match=lambda n1, n2: n1[""atoms""] == n2[""atoms""] ): return True # Care should be taken because chiral centers are not taken into account: a rotation # involving an index where substituents only differ by stereochemistry, and where a # rotation is not an element of symmetry of the subsystem, the rotation is considered # dummy even if it would be more correct not to. For rotaionally corrected RMSD this # should only cause small inefficiencies and not lead to discarding any good conformer. return False def get_hydrogen_bonds( coords: Array2D_float, atoms: Array1D_str, graph: Graph, d_min: float = 2.5, d_max: float = 3.3, max_angle: int = 45, elements: Sequence[Sequence[str]] | None = None, fragments: Sequence[Sequence[int]] | None = None, ) -> list[list[int]]: """"""Return a list of tuples with the indices of hydrogen bonding partners. An HB is a pair of atoms: - with one H and one X (N or O) atom - with an Y-X distance between d_min and d_max (i.e. N-O, Angstroms) - with an Y-H-X angle below max_angle (i.e. N-H-O, degrees) elements: iterable of two iterables with donor atomic symbols in the first element and acceptors in the second. default: ((""N"", ""O""), (""N"", ""O"")) If fragments is specified (iterable of iterable of indices for each fragment) the function only returns inter-fragment hydrogen bonds. """""" hbs = [] # initializing output list if elements is None: elements = ((""N"", ""O""), (""N"", ""O"", ""F"")) het_idx_from = np.array([i for i, a in enumerate(atoms) if a in elements[0]], dtype=int) het_idx_to = np.array([i for i, a in enumerate(atoms) if a in elements[1]], dtype=int) # indices where N or O (or user-specified elements) atoms are present. for i1 in het_idx_from: for i2 in het_idx_to: # if inter-fragment HBs are requested, skip intra-HBs if fragments is not None: if any(((i1 in f and i2 in f) for f in fragments)): continue # keep close pairs if d_min < np.linalg.norm(coords[i1] - coords[i2]) < d_max: # getting the indices of all H atoms attached to them Hs = [i for i in graph.neighbors(i1) if graph.nodes[i][""atoms""] == ""H""] # versor connectring the two Heteroatoms versor = coords[i2] - coords[i1] versor = versor / np.linalg.norm(versor) for iH in Hs: # vectors connecting heteroatoms to H v1 = coords[iH] - coords[i1] v2 = coords[iH] - coords[i2] # lengths of these vectors d1 = np.linalg.norm(v1) d2 = np.linalg.norm(v2) # scalar projection in the heteroatom direction l1 = v1 @ versor l2 = v2 @ -versor # largest planar angle between Het-H and Het-Het, in degrees (0 to 90°) alfa = vec_angle(v1, versor) if l1 < l2 else vec_angle(v2, -versor) # if the three atoms are not too far from being in line if alfa < max_angle: # adding the correct pair of atoms to results if d1 < d2: hbs.append(sorted((iH, i2))) else: hbs.append(sorted((iH, i1))) break return hbs def _get_rotation_mask(graph: Graph, torsion: Iterable[int]) -> Array1D_bool: """"""Return the rotation mask to be applied to coordinates before rotation. Get mask for the atoms that will rotate in a torsion: all the ones in the graph reachable from the last index of the torsion but not going through the central two atoms in the torsion quadruplet. """""" _, i2, i3, i4 = torsion graph.remove_edge(i2, i3) reachable_indices = shortest_path(graph, i4).keys() # get all indices reachable from i4 not going through i2-i3 graph.add_edge(i2, i3) # restore modified graph mask = np.array([i in reachable_indices for i in graph.nodes], dtype=bool) # generate boolean mask # if np.count_nonzero(mask) > int(len(mask)/2): # mask = ~mask # if we want to rotate more than half of the indices, # invert the selection so that we do less math mask[i3] = False # do not rotate i3: it would not move, # since it lies on the rotation axis return mask def _get_quadruplets(graph: Graph) -> Array2D_int: """"""Return list of quadruplets that indicate potential torsions."""""" # Step 1: Find spanning tree spanning_tree = minimum_spanning_tree(graph) # Step 2: Add dihedrals for spanning tree dihedrals = [] # For each edge in the spanning tree, we can potentially define a dihedral # We need edges that have at least 2 neighbors each to form a 4-point dihedral for edge in spanning_tree.edges(): i, j = edge # Find neighbors of i and j in the original graph i_neighbors = [n for n in graph.neighbors(i) if n not in (i, j)] j_neighbors = [n for n in graph.neighbors(j) if n not in (i, j)] if len(i_neighbors) > 0 and len(j_neighbors) > 0: # Form dihedral: neighbor_of_i - i - j - neighbor_of_j k = i_neighbors[0] # Choose first available neighbor m = j_neighbors[0] # Choose first available neighbor dihedrals.append((k, i, j, m)) return np.array(dihedrals) def get_torsions( coords: Array2D_float, graph: Graph, hydrogen_bonds: list[list[int]], double_bonds: list[tuple[int, int]], keepdummy: bool = False, mode: str = ""csearch"", ) -> list[Torsion]: """"""Return list of Torsion objects."""""" torsions = [] for path in _get_quadruplets(graph): _, i2, i3, _ = path bt = tuple(sorted((i2, i3))) if bt not in double_bonds: t = Torsion(*path) t.mode = mode # not including linear torsions (i.e. where three or more of the four atoms # are in line) will ignore all rotations involving alkynes and adjacent positions. # This will miss some potentially dummy rotations (i.e X-C#C-tBu) at the cost of # avoiding some more complex and potentially brittle way to account for these. # In any case, MOI-based pruning should account for such dummy rotations. if not is_linear(t, coords): # avoid torsions that are part of a cycle if not in_cycle(t, graph): if is_rotable(t, graph, hydrogen_bonds, keepdummy=keepdummy): torsions.append(t) # Create non-redundant torsion objects # Rejects (4,3,2,1) if (1,2,3,4) is present # Rejects torsions that do not represent a rotable bond return torsions def rotationally_corrected_rmsd_and_max( ref: Array2D_float, coord: Array2D_float, atoms: Array1D_str, torsions: Array2D_int, graph: Graph, angles: Sequence[Sequence[int]], heavy_atoms_only: bool = True, debugfunction: Callable[..., object] | None = None, return_type: str = ""rmsd"", ) -> tuple[float, float] | Array2D_float: """"""Return RMSD and max deviation, corrected for degenerate torsions. Return a tuple with the RMSD between p and q and the maximum deviation of their positions. """""" assert return_type in (""rmsd"", ""coords"") torsion_corrections = [0 for _ in torsions] mask = ( np.array([a != ""H"" for a in atoms]) if heavy_atoms_only else np.ones(len(atoms), dtype=bool) ) # Now rotate every dummy torsion by the appropriate increment until we minimize local RMSD for i, torsion in enumerate(torsions): best_rmsd = 1e10 # Look for the rotational angle set that minimizes the torsion RMSD and save it for later for angle in angles[i]: coord = rotate_dihedral(coord, torsion, angle, indices_to_be_moved=[torsion[3]]) locally_corrected_rmsd, _ = rmsd_and_max(ref[torsion], coord[torsion]) if locally_corrected_rmsd < best_rmsd: best_rmsd = locally_corrected_rmsd torsion_corrections[i] = angle # it is faster to undo the rotation rather than working with a copy of coords coord = rotate_dihedral(coord, torsion, -angle, indices_to_be_moved=[torsion[3]]) # now rotate that angle to the desired orientation before going to the next angle if torsion_corrections[i] != 0: coord = rotate_dihedral( coord, torsion, torsion_corrections[i], mask=_get_rotation_mask(graph, torsion) ) if debugfunction is not None: global_rmsd = rmsd_and_max(ref[mask], coord[mask])[0] debugfunction( f"" Torsion {i + 1} - {torsion}: best θ = {torsion_corrections[i]}°, "" + f""4-atom RMSD: {best_rmsd:.3f} Å, global RMSD: {global_rmsd:.3f} Å"" ) # we should have the optimal orientation on all torsions now: # calculate the RMSD rmsd, maxdev = rmsd_and_max(ref[mask], coord[mask]) # since we could have segmented graphs, and therefore potentially only rotate # subsets of the graph where the torsion last two indices are, # we have to undo the final rotation too (would not be needed for connected graphs) for torsion, optimal_angle in zip( reversed(torsions), reversed(torsion_corrections), strict=False ): coord = rotate_dihedral( coord, torsion, -optimal_angle, mask=_get_rotation_mask(graph, torsion) ) if return_type == ""rmsd"": return rmsd, maxdev return coord ","Python" "Conformation","ntampellini/prism_pruner","prism_pruner/utils.py",".py","4594","154","""""""PRISM - Pruning Interface for Similar Molecules."""""" from typing import Any, Sequence import numpy as np from numpy.linalg import LinAlgError from numpy.typing import ArrayLike from prism_pruner.algebra import get_alignment_matrix, rot_mat_from_pointer from prism_pruner.typing import Array1D_bool, Array1D_int, Array1D_str, Array2D_float, Array3D_float EH_TO_EV = 27.211399 EH_TO_KCAL = 627.5096080305927 EV_TO_KCAL = 23.060541945329334 def align_structures( structures: Array3D_float, indices: Array1D_int | None = None ) -> Array3D_float: """"""Align structures. Aligns molecules of a structure array (shape is (n_structures, n_atoms, 3)) to the first one, based on the indices. If not provided, all atoms are used to get the best alignment. Return is the aligned array. """""" reference = structures[0] targets = structures[1:] if isinstance(indices, (list, tuple)): indices = np.array(indices) indices = indices if indices is not None else np.array([i for i, _ in enumerate(structures[0])]) reference -= np.mean(reference[indices], axis=0) for t, _ in enumerate(targets): targets[t] -= np.mean(targets[t, indices], axis=0) output = np.zeros(structures.shape) output[0] = reference for t, target in enumerate(targets): try: matrix = get_alignment_matrix(reference[indices], target[indices]) except LinAlgError: # it is actually possible for the kabsch alg not to converge matrix = np.eye(3) # output[t+1] = np.array([matrix @ vector for vector in target]) output[t + 1] = (matrix @ target.T).T return output def time_to_string(total_time: float, verbose: bool = False, digits: int = 1) -> str: """"""Convert totaltime (float) to a timestring with hours, minutes and seconds."""""" timestring = """" names = (""days"", ""hours"", ""minutes"", ""seconds"") if verbose else (""d"", ""h"", ""m"", ""s"") if total_time > 24 * 3600: d = total_time // (24 * 3600) timestring += f""{int(d)} {names[0]} "" total_time %= 24 * 3600 if total_time > 3600: h = total_time // 3600 timestring += f""{int(h)} {names[1]} "" total_time %= 3600 if total_time > 60: m = total_time // 60 timestring += f""{int(m)} {names[2]} "" total_time %= 60 timestring += f""{round(total_time, digits):{2 + digits}} {names[3]}"" return timestring double_bonds_thresholds_dict = { ""CC"": 1.4, ""CN"": 1.3, } def get_double_bonds_indices(coords: Array2D_float, atoms: Array1D_str) -> list[tuple[int, int]]: """"""Return a list containing 2-elements tuples of indices involved in any double bond."""""" mask = atoms != ""H"" numbering = np.arange(len(coords))[mask] coords = coords[mask] atoms_masked = atoms[mask] output = [] for i1, _ in enumerate(coords): for i2 in range(i1 + 1, len(coords)): dist = np.linalg.norm(coords[i1] - coords[i2]) tag = """".join(sorted([atoms_masked[i1], atoms_masked[i2]])) threshold = double_bonds_thresholds_dict.get(tag) if threshold is not None and dist < threshold: output.append((numbering[i1], numbering[i2])) return output def rotate_dihedral( coords: Array2D_float, dihedral: list[int] | tuple[int, ...], angle: float, mask: Array1D_bool | None = None, indices_to_be_moved: ArrayLike | None = None, ) -> Array2D_float: """"""Rotate a molecule around a given bond. Atoms that will move are the ones specified by mask or indices_to_be_moved. If both are None, only the first index of the dihedral iterable is moved. angle: angle, in degrees """""" i1, i2, i3, *_ = dihedral if indices_to_be_moved is not None: mask = np.isin(np.arange(len(coords)), indices_to_be_moved) if mask is None: mask = np.zeros(len(coords), dtype=bool) mask[i1] = True axis = coords[i2] - coords[i3] mat = rot_mat_from_pointer(axis, angle) center = coords[i3] coords[mask] = (coords[mask] - center) @ mat.T + center return coords def flatten(array: Sequence[Any], typefunc: type = float) -> list[Any]: """"""Return the unraveled sequence, with items coerced into the typefunc type."""""" out = [] def rec(_l: Any) -> None: """"""Recursive unraveling function."""""" for e in _l: if type(e) in [list, tuple, np.ndarray]: rec(e) else: out.append(typefunc(e)) rec(array) return out ","Python" "Conformation","ntampellini/prism_pruner","prism_pruner/graph_manipulations.py",".py","6321","196","""""""Graph manipulation utilities for molecular structures."""""" from functools import lru_cache import numpy as np from networkx import Graph, all_simple_paths, from_numpy_array, set_node_attributes from periodictable import elements from scipy.spatial.distance import cdist from prism_pruner.algebra import dihedral from prism_pruner.typing import Array1D_bool, Array1D_str, Array2D_float @lru_cache() def d_min_bond(a1: str, a2: str, factor: float = 1.2) -> float: """"""Return the bond distance between two atoms."""""" return factor * (elements.symbol(a1).covalent_radius + elements.symbol(a2).covalent_radius) # type: ignore [no-any-return] def graphize( atoms: Array1D_str, coords: Array2D_float, mask: Array1D_bool | None = None, ) -> Graph: """""" Return a NetworkX undirected graph of molecular connectivity. :param atoms: atomic symbols :param coords: atomic coordinates as 3D vectors :param mask: bool array, with False for atoms to be excluded in the bond evaluation :return: connectivity graph """""" mask = np.array([True for _ in atoms], dtype=bool) if mask is None else mask assert len(coords) == len(atoms) assert len(coords) == len(mask) matrix = np.zeros((len(coords), len(coords))) for i, mask_i in enumerate(mask): if not mask_i: continue for j, mask_j in enumerate(mask[i + 1 :], start=i + 1): if not mask_j: continue if np.linalg.norm(coords[i] - coords[j]) < d_min_bond(atoms[i], atoms[j]): matrix[i][j] = 1 graph = from_numpy_array(matrix) set_node_attributes(graph, dict(enumerate(atoms)), ""atoms"") return graph def get_sp_n(index: int, graph: Graph) -> int | None: """""" Get hybridization of selected atom. Return n, that is the apex of sp^n hybridization for CONPS atoms. This is just an assimilation to the carbon geometry in relation to sp^n: - sp¹ is linear - sp² is planar - sp³ is tetrahedral This is mainly used to understand if a torsion is to be rotated or not. """""" atom = graph.nodes[index][""atoms""] if atom not in {""C"", ""N"", ""O"", ""P"", ""S""}: return None # Relationship of number of neighbors to sp^n hybridization d: dict[str, dict[int, int | None]] = { ""C"": {2: 1, 3: 2, 4: 3}, ""N"": {2: 2, 3: None, 4: 3}, # 3 could mean sp3 or sp2 ""O"": {1: 2, 2: 3, 3: 3, 4: 3}, ""P"": {2: 2, 3: 3, 4: 3}, ""S"": {2: 2, 3: 3, 4: 3}, } return d[atom].get(len(set(graph.neighbors(index)))) def is_amide_n(index: int, graph: Graph, mode: int = -1) -> bool: """""" Assess if the atom is an amide-like nitrogen. Note: carbamates and ureas are considered amides. mode: -1 - any amide 0 - primary amide (CONH2) 1 - secondary amide (CONHR) 2 - tertiary amide (CONR2) """""" # Must be a nitrogen atom if graph.nodes[index][""atoms""] == ""N"": nb = set(graph.neighbors(index)) nb_atoms = [graph.nodes[j][""atoms""] for j in nb] if mode != -1: # Primary amides need to have 1H, secondary amides none if nb_atoms.count(""H"") != (2, 1, 0)[mode]: return False for n in nb: # There must be at least one carbon atom next to N if graph.nodes[n][""atoms""] == ""C"": nb_nb = set(graph.neighbors(n)) # Bonded to three atoms if len(nb_nb) == 3: # and at least one of them has to be an oxygen if ""O"" in {graph.nodes[i][""atoms""] for i in nb_nb}: return True return False def is_ester_o(index: int, graph: Graph) -> bool: """""" Assess if the index is an ester-like oxygen. Note: carbamates and carbonates return True, carboxylic acids return False. """""" if graph.nodes[index][""atoms""] == ""O"": if ""H"" in (nb := set(graph.neighbors(index))): return False for n in nb: if graph.nodes[n][""atoms""] == ""C"": nb_nb = set(graph.neighbors(n)) if len(nb_nb) == 3: nb_nb_sym = [graph.nodes[i][""atoms""] for i in nb_nb] if nb_nb_sym.count(""O"") > 1: return True return False def is_phenyl(coords: Array2D_float) -> bool: """""" Assess if the six atomic coords refer to a phenyl-like ring. Note: quinones evaluate to True :param coords: six coordinates of C/N atoms :return: bool indicating if the six atoms look like part of a phenyl/naphtyl/pyridine system, coordinates for the center of that ring """""" # if any atomic couple is more than 3 A away from each other, this is not a Ph if np.max(cdist(coords, coords)) > 3: return False threshold_delta: float = 1 - np.cos(10 * np.pi / 180) flat_delta: float = 1 - np.abs(np.cos(dihedral(coords[[0, 1, 2, 3]]) * np.pi / 180)) return flat_delta < threshold_delta def get_phenyl_ids(index: int, graph: Graph) -> list[int] | None: """"""If index is part of a phenyl, return the six heavy atoms ids associated with the ring."""""" for n in graph.neighbors(index): for path in all_simple_paths(graph, source=index, target=n, cutoff=6): if len(path) != 6 or any(graph.nodes[n][""atoms""] == ""H"" for n in path): continue if all(len(set(graph.neighbors(i))) == 3 for i in path): return path # type: ignore [no-any-return] return None def find_paths( graph: Graph, u: int, n: int, exclude_set: set[int] | None = None, ) -> list[list[int]]: """""" Find paths in graph. Recursively find all paths of a NetworkX graph with length = n, starting from node u. :param graph: NetworkX graph :param u: starting node :param n: path length :param exclude_set: set of nodes to exclude from the paths :return: list of paths (each path is a list of node indices) """""" exclude_set = (exclude_set or set()) | {u} if n == 0: return [[u]] return [ [u, *path] for neighbor in graph.neighbors(u) if neighbor not in exclude_set for path in find_paths(graph, neighbor, n - 1, exclude_set) ] ","Python" "Conformation","ntampellini/prism_pruner","prism_pruner/pruner.py",".py","24132","740","""""""PRISM - Pruning Interface for Similar Molecules."""""" from dataclasses import dataclass, field from time import perf_counter from typing import Any, Callable, Sequence import numpy as np from networkx import Graph, connected_components from periodictable import elements from scipy.spatial.distance import cdist from prism_pruner.algebra import get_inertia_moments from prism_pruner.graph_manipulations import graphize from prism_pruner.rmsd import rmsd_and_max from prism_pruner.torsion_module import ( get_angles, get_hydrogen_bonds, get_torsions, is_nondummy, rotationally_corrected_rmsd_and_max, ) from prism_pruner.typing import ( Array1D_bool, Array1D_float, Array1D_int, Array1D_str, Array2D_float, Array2D_int, Array3D_float, ) from prism_pruner.utils import flatten, get_double_bonds_indices, time_to_string @dataclass class PrunerConfig: """"""Configuration dataclass for Pruner."""""" structures: Array3D_float # Optional parameters that get initialized energies: Array1D_float = field(default_factory=lambda: np.array([])) max_dE: float = field(default=0.0) debugfunction: Callable[[str], None] | None = field(default=None) # Computed fields eval_calls: int = field(default=0, init=False) cache_calls: int = field(default=0, init=False) cache: set[tuple[int, int]] = field(default_factory=lambda: set(), init=False) def __post_init__(self) -> None: """"""Validate inputs and initialize computed fields."""""" # validate input types assert type(self.structures) is np.ndarray self.mask = np.ones(shape=(self.structures.shape[0],), dtype=np.bool_) if len(self.energies) != 0: assert self.max_dE > 0.0, ( ""If you provide energies, please also provide an appropriate energy window max_dE."" ) # Set defaults for optional parameters if len(self.energies) == 0: assert type(self.energies) is np.ndarray self.energies = np.zeros(self.structures.shape[0], dtype=float) assert len(self.energies) == len(self.structures), ( ""Please make sure that the energies "" + ""provided have the same len as the input structures."" ) if self.max_dE == 0.0: self.max_dE = 1.0 def evaluate_sim(self, *args: Any, **kwargs: Any) -> bool: """"""Stub method - override in subclasses as needed."""""" raise NotImplementedError @dataclass class RMSDRotCorrPrunerConfig(PrunerConfig): """"""Configuration dataclass for Pruner."""""" atoms: Array1D_str = field(kw_only=True) max_rmsd: float = field(kw_only=True) max_dev: float = field(kw_only=True) angles: Sequence[Sequence[int]] = field(kw_only=True) torsions: Array2D_int = field(kw_only=True) graph: Graph = field(kw_only=True) heavy_atoms_only: bool = True def __post_init__(self) -> None: """"""Add type enforcing to the parent's __post_init__."""""" super().__post_init__() # validate input types assert type(self.atoms) is np.ndarray assert type(self.graph) is Graph def evaluate_sim(self, i1: int, i2: int) -> bool: """"""Return whether the structures are similar."""""" rmsd, max_dev = rotationally_corrected_rmsd_and_max( self.structures[i1], self.structures[i2], atoms=self.atoms, torsions=self.torsions, graph=self.graph, angles=self.angles, # debugfunction=self.debugfunction, # lots of printout heavy_atoms_only=self.heavy_atoms_only, ) if rmsd > self.max_rmsd: return False if max_dev > self.max_dev: return False return True @dataclass class RMSDPrunerConfig(PrunerConfig): """"""Configuration dataclass for Pruner."""""" atoms: Array1D_str = field(kw_only=True) max_rmsd: float = field(kw_only=True) max_dev: float = field(kw_only=True) heavy_atoms_only: bool = True def __post_init__(self) -> None: """"""Add type enforcing to the parent's __post_init__."""""" super().__post_init__() # validate input types assert type(self.atoms) is np.ndarray def evaluate_sim(self, i1: int, i2: int) -> bool: """"""Return whether the structures are similar."""""" if self.heavy_atoms_only: mask = self.atoms != ""H"" else: mask = np.ones(self.structures[0].shape[0], dtype=bool) rmsd, max_dev = rmsd_and_max( self.structures[i1][mask], self.structures[i2][mask], center=True, ) if rmsd > self.max_rmsd: return False if max_dev > self.max_dev: return False return True @dataclass class MOIPrunerConfig(PrunerConfig): """"""Configuration dataclass for Pruner."""""" masses: Array1D_float = field(kw_only=True) max_dev: float = 0.01 def __post_init__(self) -> None: """"""Add type enforcing and moi_vecs to the parent's __post_init__."""""" super().__post_init__() # validate input types assert type(self.masses) is np.ndarray self.moi_vecs = { c: get_inertia_moments( coord, self.masses, ) for c, coord in enumerate(self.structures) } def evaluate_sim(self, i1: int, i2: int) -> bool: """"""Return whether the structures are similar."""""" im_1 = self.moi_vecs[i1] im_2 = self.moi_vecs[i2] # compare the three MOIs via a Python loop: # apparently much faster than numpy array operations # for such a small array! for j in range(3): if np.abs(im_1[j] - im_2[j]) / im_1[j] >= self.max_dev: return False return True def _main_compute_subrow( prunerconfig: PrunerConfig, in_mask: Array1D_bool, first_abs_index: int, num_str_in_row: int, ) -> bool: """"""Evaluate the similarity of a subrow of the similarity matrix. Return True if ref is similar to any structure in structures, returning at the first instance of a match. Ignores structures that are False (0) in in_mask and does not perform the comparison if the energy difference between the structures is less than self.max_dE. Saves dissimilar structural pairs (i.e. that evaluate to False (0)) by adding them to self.cache, avoiding redundant calculations. """""" i1 = first_abs_index # iterate over target structures for i in range(num_str_in_row): # only compare active structures if in_mask[i]: # check if we have performed this comparison already: # if so, we already know that those two structures are not similar, # since the in_mask attribute is not False for ref nor for i i2 = first_abs_index + 1 + i hash_value = (i1, i2) if hash_value in prunerconfig.cache: prunerconfig.cache_calls += 1 continue # if we have not computed the value before, check if the two # structures have close enough energy before running the comparison elif ( np.abs(prunerconfig.energies[i1] - prunerconfig.energies[i2]) < prunerconfig.max_dE ): # function will return True whether the structures are similar, # and will stop iterating on this row, returning prunerconfig.eval_calls += 1 if prunerconfig.evaluate_sim(i1, i2): return True # if structures are not similar, add the result to the # cache, because they will return here, # while similar structures are discarded and won't come back else: prunerconfig.cache.add(hash_value) # if energy is not similar enough, also add to cache else: prunerconfig.cache.add(hash_value) return False def _main_compute_row( prunerconfig: PrunerConfig, row_indices: Array1D_int, in_mask: Array1D_bool, first_abs_index: int, ) -> Array1D_bool: """"""Evaluate the similarity of a row of the similarity matrix. For a given set of structures, check if each is similar to any other after itself. Return a boolean mask to slice the array, only retaining the structures that are dissimilar. The inner subrow function caches computed non-similar pairs. """""" # initialize the result container out_mask = np.ones(shape=in_mask.shape, dtype=np.bool_) line_len = len(row_indices) # loop over the structures for i in range(line_len): # only check for similarity if the structure is active if in_mask[i]: # reject structure i if it is similar to any other after itself similar = _main_compute_subrow( prunerconfig, in_mask[i + 1 :], first_abs_index=first_abs_index + i, num_str_in_row=line_len - i - 1, ) out_mask[i] = not similar else: out_mask[i] = False return out_mask def _main_compute_group( prunerconfig: PrunerConfig, in_mask: Array1D_bool, k: int, ) -> Array1D_bool: """"""Evaluate the similarity of each chunk of the similarity matrix. Acts individually on k chunks of the structures array, returning the updated mask. """""" # initialize final result container out_mask = np.ones(shape=in_mask.shape, dtype=np.bool_) # calculate the size of each chunk chunksize = int(len(prunerconfig.structures) // k) # iterate over chunks (multithreading here?) for chunk in range(int(k)): first = chunk * chunksize if chunk == k - 1: last = len(prunerconfig.structures) else: last = chunksize * (chunk + 1) # get the structure indices chunk indices_chunk = np.arange(first, last, 1, dtype=int) # compare structures within that chunk and save results to the out_mask out_mask[first:last] = _main_compute_row( prunerconfig, indices_chunk, in_mask[first:last], first_abs_index=first, ) return out_mask def _run(prunerconfig: PrunerConfig) -> tuple[Array2D_float, Array1D_bool]: """"""Perform the similarity pruning. Remove similar structures by repeatedly grouping them into k subgroups and removing similar ones. A cache is present to avoid repeating RMSD computations. Similarity occurs for structures with both rmsd < self.max_rmsd and maximum absolute atomic deviation < self.max_dev. Sets the self.structures and the corresponding self.mask attributes. """""" start_t = perf_counter() # initialize the output mask out_mask = np.ones(shape=prunerconfig.structures.shape[0], dtype=np.bool_) prunerconfig.cache = set() # sort structures by ascending energy: this will have the effect of # having energetically similar structures end up in the same chunk # and therefore being pruned early if np.abs(prunerconfig.energies[-1]) > 0: sorting_indices = np.argsort(prunerconfig.energies) prunerconfig.structures = prunerconfig.structures[sorting_indices] prunerconfig.energies = prunerconfig.energies[sorting_indices] # split the structure array in subgroups and prune them internally for k in ( 500_000, 200_000, 100_000, 50_000, 20_000, 10_000, 5000, 2000, 1000, 500, 200, 100, 50, 20, 10, 5, 2, 1, ): # choose only k values such that every subgroup # has on average at least twenty active structures in it if k == 1 or 20 * k < np.count_nonzero(out_mask): before = np.count_nonzero(out_mask) start_t_k = perf_counter() # compute similarities and get back the out_mask # and the pairings to be added to cache out_mask = _main_compute_group( prunerconfig, out_mask, k=k, ) after = np.count_nonzero(out_mask) newly_discarded = before - after if prunerconfig.debugfunction is not None: elapsed = perf_counter() - start_t_k prunerconfig.debugfunction( f""DEBUG: {prunerconfig.__class__.__name__} - k={k}, rejected {newly_discarded} "" + f""(keeping {after}/{len(out_mask)}), in {time_to_string(elapsed)}"" ) del prunerconfig.cache if prunerconfig.debugfunction is not None: elapsed = perf_counter() - start_t prunerconfig.debugfunction( f""DEBUG: {prunerconfig.__class__.__name__} - keeping "" + f""{after}/{len(out_mask)} "" + f""({time_to_string(elapsed)})"" ) if prunerconfig.eval_calls == 0: fraction = 0.0 else: fraction = prunerconfig.cache_calls / ( prunerconfig.eval_calls + prunerconfig.cache_calls ) prunerconfig.debugfunction( f""DEBUG: {prunerconfig.__class__.__name__} - Used cached data "" + f""{prunerconfig.cache_calls}/{prunerconfig.eval_calls + prunerconfig.cache_calls}"" + f"" times, {100 * fraction:.2f}% of total calls"" ) return prunerconfig.structures[out_mask], out_mask def prune_by_rmsd( structures: Array3D_float, atoms: Array1D_str, max_rmsd: float = 0.25, max_dev: float | None = None, energies: Array1D_float | None = None, max_dE: float = 0.0, heavy_atoms_only: bool = True, debugfunction: Callable[[str], None] | None = None, ) -> tuple[Array3D_float, Array1D_bool]: """"""Remove duplicate structures using a heavy-atom RMSD metric. Remove similar structures by repeatedly grouping them into k subgroups and removing similar ones. A cache is present to avoid repeating RMSD computations. Similarity occurs for structures with both RMSD < max_rmsd and maximum deviation < max_dev. max_dev by default is 2 * max_rmsd. """""" if energies is None: energies = np.array([]) # set default max_dev if not provided max_dev = max_dev or 2 * max_rmsd # set up PrunerConfig dataclass prunerconfig = RMSDPrunerConfig( structures=structures, atoms=atoms, max_rmsd=max_rmsd, max_dev=max_dev, energies=energies, max_dE=max_dE, debugfunction=debugfunction, heavy_atoms_only=heavy_atoms_only, ) # run the pruning return _run(prunerconfig) def prune_by_rmsd_rot_corr( structures: Array3D_float, atoms: Array1D_str, graph: Graph, max_rmsd: float = 0.25, max_dev: float | None = None, energies: Array1D_float | None = None, max_dE: float = 0.0, heavy_atoms_only: bool = True, logfunction: Callable[[str], None] | None = None, debugfunction: Callable[[str], None] | None = None, ) -> tuple[Array3D_float, Array1D_bool]: """"""Remove duplicates using a heavy-atom RMSD metric, corrected for degenerate torsions. Remove similar structures by repeatedly grouping them into k subgroups and removing similar ones. A cache is present to avoid repeating RMSD computations. Similarity occurs for structures with both RMSD < max_rmsd and maximum deviation < max_dev. max_dev by default is 2 * max_rmsd. The RMSD and maximum deviation metrics used are the lowest ones of all the degenerate rotamers of the input structure. """""" # center structures temp_structures = np.array([s - s.mean(axis=0) for s in structures]) ref = temp_structures[0] # get the number of molecular fragments subgraphs = list(connected_components(graph)) # if they are more than two, give up on pruning by rot corr rmsd if len(subgraphs) > 2: return structures, np.ones(structures.shape[0], dtype=bool) # if they are two, we can add a fictitious bond between the closest # atoms on the two molecular fragment in the provided graph, and # then removing it before returning if len(subgraphs) == 2: subgraphs = [list(vals) for vals in connected_components(graph)] all_dists_array = cdist(ref[list(subgraphs[0])], ref[list(subgraphs[1])]) min_d = np.min(all_dists_array) s1, s2 = np.where(all_dists_array == min_d) i1, i2 = subgraphs[0][s1[0]], subgraphs[1][s2[0]] graph.add_edge(i1, i2) if debugfunction is not None: debugfunction( f""DEBUG: prune_by_rmsd_rot_corr - temporarily added "" f""edge {i1}-{i2} to the graph (will be removed before returning)"" ) # set default max_dev if not provided max_dev = max_dev or 2 * max_rmsd # add hydrogen bonds to molecular graph hydrogen_bonds = get_hydrogen_bonds(ref, atoms, graph) for hb in hydrogen_bonds: graph.add_edge(*hb) # keep an unraveled set of atoms in hbs flat_hbs = set(flatten(hydrogen_bonds)) # get all rotable bonds in the molecule, including dummy rotations torsions = get_torsions( ref, graph, hydrogen_bonds=hydrogen_bonds, double_bonds=get_double_bonds_indices(ref, atoms), keepdummy=True, mode=""symmetry"", ) # only keep dummy rotations (checking both directions) torsions = [ t for t in torsions if not (is_nondummy(t.i2, t.i3, graph) and (is_nondummy(t.i3, t.i2, graph))) ] # since we only compute RMSD based on heavy atoms, discard # quadruplets that involve hydrogen atom as termini, unless # they are involved in hydrogen bonding torsions = [ t for t in torsions if (""H"" not in [atoms[i] for i in t.torsion]) or (t.torsion[0] in flat_hbs or t.torsion[3] in flat_hbs) ] # get torsions angles angles = [get_angles(t, graph) for t in torsions] # Used specific directionality of torsions so that we always # rotate the dummy portion (the one attached to the last index) torsions_ids = np.asarray( [ list(t.torsion) if is_nondummy(t.i2, t.i3, graph) else list(reversed(t.torsion)) for t in torsions ] ) # Set up final mask and cache final_mask = np.ones(structures.shape[0], dtype=bool) # Halt the run if there are too many structures or no subsymmetrical bonds if len(torsions_ids) == 0: if debugfunction is not None: debugfunction( ""DEBUG: prune_by_rmsd_rot_corr - No subsymmetrical torsions found: skipping "" ""symmetry-corrected RMSD pruning"" ) return structures[final_mask], final_mask # Print out torsion information if logfunction is not None: logfunction(""\n >> Dihedrals considered for rotamer corrections:"") for i, (torsion, angle) in enumerate(zip(torsions_ids, angles, strict=False)): logfunction( "" {:2s} - {:21s} : {}{}{}{} : {}-fold"".format( str(i + 1), str(torsion), atoms[torsion[0]], atoms[torsion[1]], atoms[torsion[2]], atoms[torsion[3]], len(angle), ) ) logfunction(""\n"") if energies is None: energies = np.array([]) # Initialize PrunerConfig prunerconfig = RMSDRotCorrPrunerConfig( structures=temp_structures, atoms=atoms, energies=energies, max_dE=max_dE, graph=graph, torsions=torsions_ids, debugfunction=debugfunction, heavy_atoms_only=heavy_atoms_only, angles=angles, max_rmsd=max_rmsd, max_dev=max_dev, ) # run pruning _temp_structures_out, mask = _run(prunerconfig) # remove the extra bond in the molecular graph if len(subgraphs) == 2: graph.remove_edge(i1, i2) # return the original coordinates (and not the temp) # to make sure they return untouched by the function return structures[mask], mask def prune_by_moment_of_inertia( structures: Array3D_float, atoms: Array1D_str, max_deviation: float = 1e-2, energies: Array1D_float | None = None, max_dE: float = 0.0, debugfunction: Callable[[str], None] | None = None, ) -> tuple[Array3D_float, Array1D_bool]: """"""Remove duplicate structures using a moments of inertia-based metric. Remove duplicate structures (enantiomeric or rotameric) based on the moment of inertia on the principal axes. If all three deviate less than max_deviation percent from another one, the structure is removed from the ensemble (i.e. max_deviation = 0.1 is 10% relative deviation). """""" if energies is None: energies = np.array([]) # set up PrunerConfig dataclass prunerconfig = MOIPrunerConfig( structures=structures, energies=energies, max_dE=max_dE, debugfunction=debugfunction, max_dev=max_deviation, masses=np.array([elements.symbol(a).mass for a in atoms]), ) return _run(prunerconfig) def prune( structures: Array3D_float, atoms: Array1D_str, moi_pruning: bool = True, rmsd_pruning: bool = True, rot_corr_rmsd_pruning: bool = False, energies: Array1D_float | None = None, max_dE: float = 0.0, debugfunction: Callable[[str], None] | None = None, logfunction: Callable[[str], None] | None = None, ) -> tuple[Array3D_float, Array1D_bool]: """"""Remove duplicate structures. Chains the three main pruning modes on the input ensemble, unless prompted otherwise. Will only compare structures less than max_dE apart in energy, if energies and max_dE are provided. Note: will use automatic pruning thresholds. """""" if energies is None: energies = np.array([0.0 for _ in range(len(structures))]) max_dE = 1.0 active_ens = structures active_indices = np.arange(structures.shape[0]) if moi_pruning: active_ens, mask = prune_by_moment_of_inertia( structures=active_ens, atoms=atoms, max_deviation=0.01, energies=energies, max_dE=max_dE, debugfunction=debugfunction, ) energies = energies[mask] active_indices = active_indices[mask] # add space between different logs if debugfunction is not None: debugfunction("""") if rmsd_pruning: active_ens, mask = prune_by_rmsd( structures=active_ens, atoms=atoms, max_rmsd=0.25, max_dev=0.5, energies=energies, max_dE=max_dE, debugfunction=debugfunction, ) energies = energies[mask] active_indices = active_indices[mask] # add space between different logs if debugfunction is not None: debugfunction("""") if rot_corr_rmsd_pruning: graph = graphize(atoms, active_ens[0]) active_ens, mask = prune_by_rmsd_rot_corr( structures=active_ens, atoms=atoms, graph=graph, max_rmsd=0.25, max_dev=0.5, energies=energies, max_dE=max_dE, debugfunction=debugfunction, logfunction=logfunction, ) active_indices = active_indices[mask] # now backtrack the effect of all the pruning # so that we know which structures we got rid of # and we can return the appropriate boolean mask cumulative_mask = np.zeros(structures.shape[0], dtype=np.bool_) cumulative_mask[active_indices] = True return active_ens, cumulative_mask ","Python" "Conformation","ntampellini/prism_pruner","prism_pruner/rmsd.py",".py","877","39","""""""PRISM - Pruning Interface for Similar Molecules."""""" import numpy as np from prism_pruner.algebra import get_alignment_matrix from prism_pruner.typing import Array2D_float def rmsd_and_max( p: Array2D_float, q: Array2D_float, center: bool = True, ) -> tuple[float, float]: """"""Return RMSD and max deviation. Return a tuple with the RMSD between p and q and the maximum deviation of their positions. """""" if center: p = p - p.mean(axis=0) q = q - q.mean(axis=0) # get alignment matrix rot_mat = get_alignment_matrix(p, q) # Apply it to p p = np.ascontiguousarray(p) @ rot_mat # Calculate deviations diff = p - q # Calculate RMSD rmsd = np.sqrt(np.sum(diff * diff) / len(diff)) # Calculate max deviation max_delta = np.max(np.linalg.norm(diff, axis=1)) return rmsd, max_delta ","Python" "Conformation","ntampellini/prism_pruner","prism_pruner/typing.py",".py","676","16","""""""PRISM - Pruning Interface for Similar Molecules."""""" from typing import Annotated, Any, Union import numpy as np from numpy.typing import NDArray Array3D_float = Annotated[NDArray[np.float64], ""shape: (nconfs, natoms, 3)""] Array2D_float = Annotated[NDArray[np.float64], ""shape: (natoms, 3)""] Array2D_int = Annotated[NDArray[np.int32], ""shape: (a, b)""] Array1D_float = Annotated[NDArray[np.float64], ""shape: (energy,)""] Array1D_int = Annotated[NDArray[np.int32], ""shape: (natoms,)""] Array1D_str = Annotated[NDArray[np.str_], ""shape: (natoms,)""] Array1D_bool = Annotated[NDArray[np.bool_], ""shape: (n,)""] FloatIterable = Union[tuple[float, ...], NDArray[np.floating[Any]]] ","Python" "Conformation","ntampellini/prism_pruner","examples/example_notebook.ipynb",".ipynb","7948","238","{ ""cells"": [ { ""cell_type"": ""markdown"", ""id"": ""638ffd44"", ""metadata"": {}, ""source"": [ ""The module uses numpy arrays for atomic positions and atomic numbers. You can read structures with ConformerEnsemble.from_xyz. The ensemble object uses ASE variable names, exposing the \""coords\"" and \""atoms\"" properties."" ] }, { ""cell_type"": ""code"", ""execution_count"": 1, ""id"": ""0167110d"", ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/plain"": [ ""(1086, 136, 3)"" ] }, ""execution_count"": 1, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from prism_pruner.conformer_ensemble import ConformerEnsemble\n"", ""\n"", ""ensemble = ConformerEnsemble.from_xyz(\""ensemble.xyz\"")\n"", ""ensemble.coords.shape"" ] }, { ""cell_type"": ""markdown"", ""id"": ""e33993c0"", ""metadata"": {}, ""source"": [ ""The simplest way to prune your ensemble is via the prune function, which chains the execution of the two main pruning routines with reasonble default thresholds."" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""id"": ""900f3133"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""DEBUG: MOIPrunerConfig - k=50, rejected 449 (keeping 637/1086), in 0.1 s\n"", ""DEBUG: MOIPrunerConfig - k=20, rejected 109 (keeping 528/1086), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=10, rejected 27 (keeping 501/1086), in 0.1 s\n"", ""DEBUG: MOIPrunerConfig - k=5, rejected 28 (keeping 473/1086), in 0.1 s\n"", ""DEBUG: MOIPrunerConfig - k=2, rejected 38 (keeping 435/1086), in 0.2 s\n"", ""DEBUG: MOIPrunerConfig - k=1, rejected 10 (keeping 425/1086), in 0.4 s\n"", ""DEBUG: MOIPrunerConfig - keeping 425/1086 (1.0 s)\n"", ""DEBUG: MOIPrunerConfig - Used cached data 105595/211707 times, 49.88% of total calls\n"", ""\n"", ""DEBUG: RMSDPrunerConfig - k=20, rejected 13 (keeping 412/425), in 0.7 s\n"", ""DEBUG: RMSDPrunerConfig - k=10, rejected 7 (keeping 405/425), in 0.9 s\n"", ""DEBUG: RMSDPrunerConfig - k=5, rejected 9 (keeping 396/425), in 1.4 s\n"", ""DEBUG: RMSDPrunerConfig - k=2, rejected 5 (keeping 391/425), in 4.5 s\n"", ""DEBUG: RMSDPrunerConfig - k=1, rejected 4 (keeping 387/425), in 6.4 s\n"", ""DEBUG: RMSDPrunerConfig - keeping 387/425 (14.0 s)\n"", ""DEBUG: RMSDPrunerConfig - Used cached data 65553/142874 times, 45.88% of total calls\n"", ""\n"" ] } ], ""source"": [ ""from prism_pruner.pruner import prune\n"", ""\n"", ""pruned, mask = prune(\n"", "" ensemble.coords,\n"", "" ensemble.atoms,\n"", "" # the third pruning routine can be\n"", "" # slow and it is off by default\n"", "" rot_corr_rmsd_pruning=False,\n"", "" debugfunction=print,\n"", "")"" ] }, { ""cell_type"": ""markdown"", ""id"": ""02e9a054"", ""metadata"": {}, ""source"": [ ""The three main pruning functions are the following: first, the fastest, a principal moments of inertia-based mode. Similarity between two structures occurs for all three principal MOI under a relative threshold:"" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""id"": ""31198a3f"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""DEBUG: MOIPrunerConfig - k=50, rejected 449 (keeping 637/1086), in 0.1 s\n"", ""DEBUG: MOIPrunerConfig - k=20, rejected 109 (keeping 528/1086), in 0.1 s\n"", ""DEBUG: MOIPrunerConfig - k=10, rejected 27 (keeping 501/1086), in 0.2 s\n"", ""DEBUG: MOIPrunerConfig - k=5, rejected 28 (keeping 473/1086), in 0.1 s\n"", ""DEBUG: MOIPrunerConfig - k=2, rejected 38 (keeping 435/1086), in 0.2 s\n"", ""DEBUG: MOIPrunerConfig - k=1, rejected 10 (keeping 425/1086), in 0.5 s\n"", ""DEBUG: MOIPrunerConfig - keeping 425/1086 (1.2 s)\n"", ""DEBUG: MOIPrunerConfig - Used cached data 105595/211707 times, 49.88% of total calls\n"" ] } ], ""source"": [ ""from prism_pruner.pruner import prune_by_moment_of_inertia\n"", ""\n"", ""pruned, mask = prune_by_moment_of_inertia(\n"", "" ensemble.coords,\n"", "" ensemble.atoms,\n"", "" max_deviation=0.01, # 1% relative difference\n"", "" debugfunction=print,\n"", "")"" ] }, { ""cell_type"": ""markdown"", ""id"": ""7862e029"", ""metadata"": {}, ""source"": [ ""Second, a classic RMSD implementation (by default, using \""heavy\"" non-H atoms only) . Similarity between two structures, after optimal alignment, occurs for both RMSD and maximum atomic deviation under the specified thresholds. If unspecified, the maximum deviation threshold (max_dev) is taken as 2*max_rmsd."" ] }, { ""cell_type"": ""code"", ""execution_count"": 14, ""id"": ""0a857ea0"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""DEBUG: RMSDPrunerConfig - k=50, rejected 389 (keeping 697/1086), in 1.6 s\n"", ""DEBUG: RMSDPrunerConfig - k=20, rejected 115 (keeping 582/1086), in 1.6 s\n"", ""DEBUG: RMSDPrunerConfig - k=10, rejected 48 (keeping 534/1086), in 1.8 s\n"", ""DEBUG: RMSDPrunerConfig - k=5, rejected 66 (keeping 468/1086), in 3.0 s\n"", ""DEBUG: RMSDPrunerConfig - k=2, rejected 63 (keeping 405/1086), in 7.4 s\n"", ""DEBUG: RMSDPrunerConfig - k=1, rejected 32 (keeping 373/1086), in 4.4 s\n"", ""DEBUG: RMSDPrunerConfig - keeping 373/1086 (19.9 s)\n"", ""DEBUG: RMSDPrunerConfig - Used cached data 107904/207984 times, 51.88% of total calls\n"" ] } ], ""source"": [ ""from prism_pruner.pruner import prune_by_rmsd\n"", ""\n"", ""pruned, mask = prune_by_rmsd(\n"", "" ensemble.coords,\n"", "" ensemble.atoms,\n"", "" max_rmsd=1.0, # 1 Å\n"", "" debugfunction=print,\n"", "")"" ] }, { ""cell_type"": ""markdown"", ""id"": ""d7213086"", ""metadata"": {}, ""source"": [ ""Lastly, another RMSD pruning implementation, this time featuring rotationally corrected results to correct for the artificially high RMSD values for rotameric structures."" ] }, { ""cell_type"": ""code"", ""execution_count"": 15, ""id"": ""dc0261ac"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", "" >> Dihedrals considered for rotamer corrections:\n"", "" 1 - [ 8 10 11 12] : CCCC : 2-fold\n"", "" 2 - [116 70 14 13] : CCCC : 2-fold\n"", "" 3 - [25 26 28 29] : CCCC : 3-fold\n"", "" 4 - [ 19 73 111 113] : CCCF : 3-fold\n"", ""\n"", ""\n"", ""DEBUG: RMSDRotCorrPrunerConfig - k=2, rejected 97 (keeping 3/100), in 0.9 s\n"", ""DEBUG: RMSDRotCorrPrunerConfig - k=1, rejected 2 (keeping 1/100), in 0.0 s\n"", ""DEBUG: RMSDRotCorrPrunerConfig - keeping 1/100 (0.9 s)\n"", ""DEBUG: RMSDRotCorrPrunerConfig - Used cached data 1/123 times, 0.81% of total calls\n"" ] } ], ""source"": [ ""from prism_pruner.graph_manipulations import graphize\n"", ""from prism_pruner.pruner import prune_by_rmsd_rot_corr\n"", ""\n"", ""graph = graphize(ensemble.atoms, ensemble.coords[0])\n"", ""\n"", ""pruned, mask = prune_by_rmsd_rot_corr(\n"", "" ensemble.coords[0:100],\n"", "" ensemble.atoms,\n"", "" graph,\n"", "" max_rmsd=1.0, # 1 Å\n"", "" logfunction=print,\n"", "" debugfunction=print,\n"", "")"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""dev"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.14.0"" } }, ""nbformat"": 4, ""nbformat_minor"": 5 } ","Unknown" "Conformation","ntampellini/prism_pruner","examples/energy_aware_pruning.ipynb",".ipynb","6156","180","{ ""cells"": [ { ""cell_type"": ""markdown"", ""id"": ""d9f6e0be"", ""metadata"": {}, ""source"": [ ""The ConformerEnsemble class can also read energies from the comment line on .xyz files."" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""id"": ""4043bf31"", ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/plain"": [ ""(675, 220, 3)"" ] }, ""execution_count"": 1, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from prism_pruner.conformer_ensemble import ConformerEnsemble\n"", ""from prism_pruner.pruner import prune\n"", ""from prism_pruner.utils import EH_TO_KCAL # 627.5096080305927\n"", ""\n"", ""ensemble = ConformerEnsemble.from_xyz(\""../tests/crest_conformers.xyz\"", read_energies=True)\n"", ""ensemble.coords.shape"" ] }, { ""cell_type"": ""markdown"", ""id"": ""466dc74d"", ""metadata"": {}, ""source"": [ ""\n"", ""Energy-aware pruning can be useful for larger arrays: using a max_dE of 0.5 kcal/mol, a 28% speedup is observed relative to the normal mode, as a consequence of the fewer number of calls to the similarity evaluation functions. This is of course accompanied by a obtaining a larger, \""less pruned\"" ensemble (132 vs 64 structures)."" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""id"": ""c7ec20b3"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""DEBUG: MOIPrunerConfig - k=20, rejected 455 (keeping 220/675), in 0.1 s\n"", ""DEBUG: MOIPrunerConfig - k=10, rejected 49 (keeping 171/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=5, rejected 18 (keeping 153/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=2, rejected 13 (keeping 140/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=1, rejected 0 (keeping 140/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - keeping 140/675 (0.1 s)\n"", ""DEBUG: MOIPrunerConfig - Used cached data 9902/16071 times, 61.61% of total calls\n"", ""\n"", ""DEBUG: RMSDPrunerConfig - k=5, rejected 4 (keeping 136/140), in 0.3 s\n"", ""DEBUG: RMSDPrunerConfig - k=2, rejected 0 (keeping 136/140), in 0.1 s\n"", ""DEBUG: RMSDPrunerConfig - k=1, rejected 0 (keeping 136/140), in 0.1 s\n"", ""DEBUG: RMSDPrunerConfig - keeping 136/140 (0.5 s)\n"", ""DEBUG: RMSDPrunerConfig - Used cached data 6341/7717 times, 82.17% of total calls\n"", ""\n"", ""DEBUG: prune_by_rmsd_rot_corr - temporarily added edge 92-179 to the graph (will be removed before returning)\n"", ""DEBUG: RMSDRotCorrPrunerConfig - k=5, rejected 2 (keeping 134/136), in 27.0 s\n"", ""DEBUG: RMSDRotCorrPrunerConfig - k=2, rejected 2 (keeping 132/136), in 7.1 s\n"", ""DEBUG: RMSDRotCorrPrunerConfig - k=1, rejected 0 (keeping 132/136), in 0.1 s\n"", ""DEBUG: RMSDRotCorrPrunerConfig - keeping 132/136 (34.2 s)\n"", ""DEBUG: RMSDRotCorrPrunerConfig - Used cached data 6019/7299 times, 82.46% of total calls\n"", ""CPU times: user 35.8 s, sys: 26 ms, total: 35.8 s\n"", ""Wall time: 35.8 s\n"" ] } ], ""source"": [ ""%%time\n"", ""pruned, mask = prune(\n"", "" ensemble.coords,\n"", "" ensemble.atoms,\n"", "" energies=ensemble.energies, # energies were provided in Eh: max_dE should be, too\n"", "" max_dE=0.5 / EH_TO_KCAL, # 0.5 kcal, in Eh (7.968...10^-4 Eh)\n"", "" rot_corr_rmsd_pruning=True,\n"", "" debugfunction=print,\n"", "")"" ] }, { ""cell_type"": ""code"", ""execution_count"": 8, ""id"": ""d8c8c551"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""DEBUG: MOIPrunerConfig - k=20, rejected 456 (keeping 219/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=10, rejected 56 (keeping 163/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=5, rejected 38 (keeping 125/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=2, rejected 46 (keeping 79/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=1, rejected 15 (keeping 64/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - keeping 64/675 (0.1 s)\n"", ""DEBUG: MOIPrunerConfig - Used cached data 5780/15111 times, 38.25% of total calls\n"", ""\n"", ""DEBUG: RMSDPrunerConfig - k=2, rejected 0 (keeping 64/64), in 0.2 s\n"", ""DEBUG: RMSDPrunerConfig - k=1, rejected 0 (keeping 64/64), in 0.2 s\n"", ""DEBUG: RMSDPrunerConfig - keeping 64/64 (0.4 s)\n"", ""DEBUG: RMSDPrunerConfig - Used cached data 992/3008 times, 32.98% of total calls\n"", ""\n"", ""DEBUG: prune_by_rmsd_rot_corr - temporarily added edge 35-182 to the graph (will be removed before returning)\n"", ""DEBUG: RMSDRotCorrPrunerConfig - k=2, rejected 0 (keeping 64/64), in 23.4 s\n"", ""DEBUG: RMSDRotCorrPrunerConfig - k=1, rejected 0 (keeping 64/64), in 25.4 s\n"", ""DEBUG: RMSDRotCorrPrunerConfig - keeping 64/64 (48.8 s)\n"", ""DEBUG: RMSDRotCorrPrunerConfig - Used cached data 992/3008 times, 32.98% of total calls\n"", ""CPU times: user 50 s, sys: 40.1 ms, total: 50 s\n"", ""Wall time: 50 s\n"" ] } ], ""source"": [ ""%%time\n"", ""pruned, mask = prune(\n"", "" ensemble.coords,\n"", "" ensemble.atoms,\n"", "" rot_corr_rmsd_pruning=True,\n"", "" debugfunction=print,\n"", "")"" ] }, { ""cell_type"": ""code"", ""execution_count"": 17, ""id"": ""6e83f8b0"", ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/plain"": [ ""'28.4 % speedup'"" ] }, ""execution_count"": 17, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""f\""{(1 - (35.8 / 50)) * 100:.1f} % speedup\"""" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""dev"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.14.0"" } }, ""nbformat"": 4, ""nbformat_minor"": 5 } ","Unknown" "Conformation","ntampellini/prism_pruner","tests/performance_notebook.ipynb",".ipynb","67620","815","{ ""cells"": [ { ""cell_type"": ""code"", ""execution_count"": 1, ""id"": ""77d80ab1"", ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/plain"": [ ""(675, 220, 3)"" ] }, ""execution_count"": 1, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from prism_pruner.conformer_ensemble import ConformerEnsemble\n"", ""from prism_pruner.pruner import prune_by_moment_of_inertia, prune_by_rmsd\n"", ""from prism_pruner.utils import EH_TO_KCAL\n"", ""\n"", ""# ensemble = ConformerEnsemble.from_xyz(\""../examples/ensemble.xyz\"")\n"", ""ensemble = ConformerEnsemble.from_xyz(\""../tests/crest_conformers.xyz\"", read_energies=True)\n"", ""ensemble.coords.shape"" ] }, { ""cell_type"": ""code"", ""execution_count"": 21, ""id"": ""a52bffc3"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""DEBUG: MOIPrunerConfig - k=20, rejected 456 (keeping 219/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=10, rejected 56 (keeping 163/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=5, rejected 38 (keeping 125/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=2, rejected 46 (keeping 79/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=1, rejected 15 (keeping 64/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - keeping 64/675 (0.1 s)\n"", ""DEBUG: MOIPrunerConfig - Used cached data 5780/15111 times, 38.25% of total calls\n"" ] } ], ""source"": [ ""# %%prun -s cumtime\n"", ""_ = prune_by_moment_of_inertia(\n"", "" ensemble.coords,\n"", "" ensemble.atoms,\n"", "" max_deviation=0.01, # 1% difference\n"", "" debugfunction=print,\n"", "")"" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""id"": ""4c8032ca"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""DEBUG: MOIPrunerConfig - k=20, rejected 456 (keeping 219/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=10, rejected 50 (keeping 169/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=5, rejected 34 (keeping 135/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=2, rejected 27 (keeping 108/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=1, rejected 0 (keeping 108/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - keeping 108/675 (0.1 s)\n"", ""DEBUG: MOIPrunerConfig - Used cached data 7335/19209 times, 38.19% of total calls\n"" ] } ], ""source"": [ ""_ = prune_by_moment_of_inertia(\n"", "" ensemble.coords,\n"", "" ensemble.atoms,\n"", "" energies=ensemble.energies, # in Eh\n"", "" max_dE=1 / EH_TO_KCAL, # 1 kcal/mol\n"", "" max_deviation=0.01, # 1% difference\n"", "" debugfunction=print,\n"", "")"" ] }, { ""cell_type"": ""code"", ""execution_count"": 10, ""id"": ""450e30ec"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""DEBUG: RMSDPrunerConfig - k=20, rejected 152 (keeping 523/675), in 1.5 s\n"", ""DEBUG: RMSDPrunerConfig - k=10, rejected 73 (keeping 450/675), in 1.1 s\n"", ""DEBUG: RMSDPrunerConfig - k=5, rejected 62 (keeping 388/675), in 1.3 s\n"", ""DEBUG: RMSDPrunerConfig - k=2, rejected 76 (keeping 312/675), in 2.9 s\n"", ""DEBUG: RMSDPrunerConfig - k=1, rejected 36 (keeping 276/675), in 2.7 s\n"", ""DEBUG: RMSDPrunerConfig - keeping 276/675 (9.6 s)\n"", ""DEBUG: RMSDPrunerConfig - Used cached data 55967/118708 times, 47.15% of total calls\n"" ] } ], ""source"": [ ""pruned, mask = prune_by_rmsd(\n"", "" ensemble.coords,\n"", "" ensemble.atoms,\n"", "" max_rmsd=1.0, # Will reject below 1 Å\n"", "" debugfunction=print,\n"", "")"" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""id"": ""52b381b9"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""DEBUG: RMSDPrunerConfig - k=20, rejected 153 (keeping 522/675), in 1.4 s\n"", ""DEBUG: RMSDPrunerConfig - k=10, rejected 67 (keeping 455/675), in 0.9 s\n"", ""DEBUG: RMSDPrunerConfig - k=5, rejected 55 (keeping 400/675), in 1.1 s\n"", ""DEBUG: RMSDPrunerConfig - k=2, rejected 44 (keeping 356/675), in 1.1 s\n"", ""DEBUG: RMSDPrunerConfig - k=1, rejected 1 (keeping 355/675), in 0.2 s\n"", ""DEBUG: RMSDPrunerConfig - keeping 355/675 (4.8 s)\n"", ""DEBUG: RMSDPrunerConfig - Used cached data 64182/141454 times, 45.37% of total calls\n"" ] } ], ""source"": [ ""# %%prun -s cumtime\n"", ""pruned, mask = prune_by_rmsd(\n"", "" ensemble.coords,\n"", "" ensemble.atoms,\n"", "" energies=ensemble.energies, # in Eh\n"", "" max_dE=1 / EH_TO_KCAL, # 1 kcal/mol\n"", "" max_rmsd=1.0, # Will reject below 1 Å\n"", "" debugfunction=print,\n"", "")"" ] }, { ""cell_type"": ""code"", ""execution_count"": 12, ""id"": ""d018cba6"", ""metadata"": {}, ""outputs"": [], ""source"": [ ""from prism_pruner.graph_manipulations import graphize\n"", ""from prism_pruner.pruner import prune_by_rmsd_rot_corr"" ] }, { ""cell_type"": ""code"", ""execution_count"": 13, ""id"": ""33d6958e"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""DEBUG: prune_by_rmsd_rot_corr - temporarily added edge 35-181 to the graph (will be removed before returning)\n"" ] }, { ""ename"": ""KeyboardInterrupt"", ""evalue"": """", ""output_type"": ""error"", ""traceback"": [ ""\u001b[31m---------------------------------------------------------------------------\u001b[39m"", ""\u001b[31mKeyboardInterrupt\u001b[39m Traceback (most recent call last)"", ""\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[13]\u001b[39m\u001b[32m, line 5\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# %%prun -s cumtime\u001b[39;00m\n\u001b[32m 3\u001b[39m graph = graphize(ensemble.atoms, ensemble.coords[\u001b[32m0\u001b[39m])\n\u001b[32m----> \u001b[39m\u001b[32m5\u001b[39m pruned, mask = \u001b[43mprune_by_rmsd_rot_corr\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 6\u001b[39m \u001b[43m \u001b[49m\u001b[43mstructures\u001b[49m\u001b[43m=\u001b[49m\u001b[43mensemble\u001b[49m\u001b[43m.\u001b[49m\u001b[43mcoords\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 7\u001b[39m \u001b[43m \u001b[49m\u001b[43matoms\u001b[49m\u001b[43m=\u001b[49m\u001b[43mensemble\u001b[49m\u001b[43m.\u001b[49m\u001b[43matoms\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 8\u001b[39m \u001b[43m \u001b[49m\u001b[43mgraph\u001b[49m\u001b[43m=\u001b[49m\u001b[43mgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 9\u001b[39m \u001b[43m \u001b[49m\u001b[43mmax_rmsd\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m1.0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;66;43;03m# 1 Å\u001b[39;49;00m\n\u001b[32m 10\u001b[39m \u001b[43m \u001b[49m\u001b[43mdebugfunction\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mprint\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 11\u001b[39m \u001b[43m)\u001b[49m\n"", ""\u001b[36mFile \u001b[39m\u001b[32m/home/Coding/prism_pruner/prism_pruner/pruner.py:577\u001b[39m, in \u001b[36mprune_by_rmsd_rot_corr\u001b[39m\u001b[34m(structures, atoms, graph, max_rmsd, max_dev, energies, ewin, logfunction, debugfunction)\u001b[39m\n\u001b[32m 563\u001b[39m prunerconfig = RMSDRotCorrPrunerConfig(\n\u001b[32m 564\u001b[39m structures=structures,\n\u001b[32m 565\u001b[39m atoms=atoms,\n\u001b[32m (...)\u001b[39m\u001b[32m 573\u001b[39m max_dev=max_dev,\n\u001b[32m 574\u001b[39m )\n\u001b[32m 576\u001b[39m \u001b[38;5;66;03m# run pruning\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m577\u001b[39m structures_out, mask = \u001b[43mprune\u001b[49m\u001b[43m(\u001b[49m\u001b[43mprunerconfig\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 579\u001b[39m \u001b[38;5;66;03m# remove the extra bond in the molecular graph\u001b[39;00m\n\u001b[32m 580\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(subgraphs) == \u001b[32m2\u001b[39m:\n"", ""\u001b[36mFile \u001b[39m\u001b[32m/home/Coding/prism_pruner/prism_pruner/pruner.py:353\u001b[39m, in \u001b[36mprune\u001b[39m\u001b[34m(prunerconfig)\u001b[39m\n\u001b[32m 349\u001b[39m start_t_k = perf_counter()\n\u001b[32m 351\u001b[39m \u001b[38;5;66;03m# compute similarities and get back the out_mask\u001b[39;00m\n\u001b[32m 352\u001b[39m \u001b[38;5;66;03m# and the pairings to be added to cache\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m353\u001b[39m out_mask = \u001b[43m_main_compute_group\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 354\u001b[39m \u001b[43m \u001b[49m\u001b[43mprunerconfig\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 355\u001b[39m \u001b[43m \u001b[49m\u001b[43mout_mask\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 356\u001b[39m \u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[43m=\u001b[49m\u001b[43mk\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 357\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 359\u001b[39m after = np.count_nonzero(out_mask)\n\u001b[32m 360\u001b[39m newly_discarded = before - after\n"", ""\u001b[36mFile \u001b[39m\u001b[32m/home/Coding/prism_pruner/prism_pruner/pruner.py:288\u001b[39m, in \u001b[36m_main_compute_group\u001b[39m\u001b[34m(prunerconfig, in_mask, k)\u001b[39m\n\u001b[32m 285\u001b[39m indices_chunk = np.arange(first, last, \u001b[32m1\u001b[39m, dtype=\u001b[38;5;28mint\u001b[39m)\n\u001b[32m 287\u001b[39m \u001b[38;5;66;03m# compare structures within that chunk and save results to the out_mask\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m288\u001b[39m out_mask[first:last] = \u001b[43m_main_compute_row\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 289\u001b[39m \u001b[43m \u001b[49m\u001b[43mprunerconfig\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 290\u001b[39m \u001b[43m \u001b[49m\u001b[43mindices_chunk\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 291\u001b[39m \u001b[43m \u001b[49m\u001b[43min_mask\u001b[49m\u001b[43m[\u001b[49m\u001b[43mfirst\u001b[49m\u001b[43m:\u001b[49m\u001b[43mlast\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 292\u001b[39m \u001b[43m \u001b[49m\u001b[43mfirst_abs_index\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfirst\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 293\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 294\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m out_mask\n"", ""\u001b[36mFile \u001b[39m\u001b[32m/home/Coding/prism_pruner/prism_pruner/pruner.py:246\u001b[39m, in \u001b[36m_main_compute_row\u001b[39m\u001b[34m(prunerconfig, row_indices, in_mask, first_abs_index)\u001b[39m\n\u001b[32m 242\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(line_len):\n\u001b[32m 243\u001b[39m \u001b[38;5;66;03m# only check for similarity if the structure is active\u001b[39;00m\n\u001b[32m 244\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m in_mask[i]:\n\u001b[32m 245\u001b[39m \u001b[38;5;66;03m# reject structure i if it is similar to any other after itself\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m246\u001b[39m similar = \u001b[43m_main_compute_subrow\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 247\u001b[39m \u001b[43m \u001b[49m\u001b[43mprunerconfig\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 248\u001b[39m \u001b[43m \u001b[49m\u001b[43min_mask\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m \u001b[49m\u001b[43m+\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m1\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m:\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 249\u001b[39m \u001b[43m \u001b[49m\u001b[43mfirst_abs_index\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfirst_abs_index\u001b[49m\u001b[43m \u001b[49m\u001b[43m+\u001b[49m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 250\u001b[39m \u001b[43m \u001b[49m\u001b[43mnum_str_in_row\u001b[49m\u001b[43m=\u001b[49m\u001b[43mline_len\u001b[49m\u001b[43m \u001b[49m\u001b[43m-\u001b[49m\u001b[43m \u001b[49m\u001b[43mi\u001b[49m\u001b[43m \u001b[49m\u001b[43m-\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m1\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 251\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 252\u001b[39m out_mask[i] = \u001b[38;5;129;01mnot\u001b[39;00m similar\n\u001b[32m 254\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n"", ""\u001b[36mFile \u001b[39m\u001b[32m/home/Coding/prism_pruner/prism_pruner/pruner.py:207\u001b[39m, in \u001b[36m_main_compute_subrow\u001b[39m\u001b[34m(prunerconfig, in_mask, first_abs_index, num_str_in_row)\u001b[39m\n\u001b[32m 202\u001b[39m \u001b[38;5;66;03m# if we have not computed the value before, check if the two\u001b[39;00m\n\u001b[32m 203\u001b[39m \u001b[38;5;66;03m# structures have close enough energy before running the comparison\u001b[39;00m\n\u001b[32m 204\u001b[39m \u001b[38;5;28;01melif\u001b[39;00m np.abs(prunerconfig.energies[i1] - prunerconfig.energies[i2]) < prunerconfig.ewin:\n\u001b[32m 205\u001b[39m \u001b[38;5;66;03m# function will return True whether the structures are similar,\u001b[39;00m\n\u001b[32m 206\u001b[39m \u001b[38;5;66;03m# and will stop iterating on this row, returning\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m207\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[43mprunerconfig\u001b[49m\u001b[43m.\u001b[49m\u001b[43mevaluate_sim\u001b[49m\u001b[43m(\u001b[49m\u001b[43mi1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mi2\u001b[49m\u001b[43m)\u001b[49m:\n\u001b[32m 208\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[32m 210\u001b[39m \u001b[38;5;66;03m# if structures are not similar, add the result to the\u001b[39;00m\n\u001b[32m 211\u001b[39m \u001b[38;5;66;03m# cache, because they will return here,\u001b[39;00m\n\u001b[32m 212\u001b[39m \u001b[38;5;66;03m# while similar structures are discarded and won't come back\u001b[39;00m\n\u001b[32m 213\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n"", ""\u001b[36mFile \u001b[39m\u001b[32m/home/Coding/prism_pruner/prism_pruner/pruner.py:87\u001b[39m, in \u001b[36mRMSDRotCorrPrunerConfig.evaluate_sim\u001b[39m\u001b[34m(self, i1, i2)\u001b[39m\n\u001b[32m 85\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mevaluate_sim\u001b[39m(\u001b[38;5;28mself\u001b[39m, i1: \u001b[38;5;28mint\u001b[39m, i2: \u001b[38;5;28mint\u001b[39m) -> \u001b[38;5;28mbool\u001b[39m:\n\u001b[32m 86\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\""\""\""Return whether the structures are similar.\""\""\""\u001b[39;00m\n\u001b[32m---> \u001b[39m\u001b[32m87\u001b[39m rmsd, max_dev = \u001b[43mrotationally_corrected_rmsd_and_max\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 88\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mstructures\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi1\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 89\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mstructures\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi2\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 90\u001b[39m \u001b[43m \u001b[49m\u001b[43matoms\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43matoms\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 91\u001b[39m \u001b[43m \u001b[49m\u001b[43mtorsions\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mtorsions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 92\u001b[39m \u001b[43m \u001b[49m\u001b[43mgraph\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mgraph\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 93\u001b[39m \u001b[43m \u001b[49m\u001b[43mangles\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mangles\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 94\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;66;43;03m# debugfunction=self.debugfunction, # lots of printout\u001b[39;49;00m\n\u001b[32m 95\u001b[39m \u001b[43m \u001b[49m\u001b[43mheavy_atoms_only\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mheavy_atoms_only\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 96\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 98\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m rmsd > \u001b[38;5;28mself\u001b[39m.max_rmsd:\n\u001b[32m 99\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m\n"", ""\u001b[36mFile \u001b[39m\u001b[32m/home/Coding/prism_pruner/prism_pruner/torsion_module.py:429\u001b[39m, in \u001b[36mrotationally_corrected_rmsd_and_max\u001b[39m\u001b[34m(ref, coord, atoms, torsions, graph, angles, heavy_atoms_only, debugfunction, return_type)\u001b[39m\n\u001b[32m 426\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m angle \u001b[38;5;129;01min\u001b[39;00m angles[i]:\n\u001b[32m 427\u001b[39m coord = rotate_dihedral(coord, torsion, angle, indices_to_be_moved=[torsion[\u001b[32m3\u001b[39m]])\n\u001b[32m--> \u001b[39m\u001b[32m429\u001b[39m locally_corrected_rmsd, _ = \u001b[43mrmsd_and_max\u001b[49m\u001b[43m(\u001b[49m\u001b[43mref\u001b[49m\u001b[43m[\u001b[49m\u001b[43mtorsion\u001b[49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcoord\u001b[49m\u001b[43m[\u001b[49m\u001b[43mtorsion\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 431\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m locally_corrected_rmsd < best_rmsd:\n\u001b[32m 432\u001b[39m best_rmsd = locally_corrected_rmsd\n"", ""\u001b[36mFile \u001b[39m\u001b[32m/home/Coding/prism_pruner/prism_pruner/rmsd.py:9\u001b[39m, in \u001b[36mrmsd_and_max\u001b[39m\u001b[34m(p, q, center)\u001b[39m\n\u001b[32m 5\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mprism_pruner\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01malgebra\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m get_alignment_matrix\n\u001b[32m 6\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mprism_pruner\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mtyping\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Array2D_float\n\u001b[32m----> \u001b[39m\u001b[32m9\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mrmsd_and_max\u001b[39m(\n\u001b[32m 10\u001b[39m p: Array2D_float,\n\u001b[32m 11\u001b[39m q: Array2D_float,\n\u001b[32m 12\u001b[39m center: \u001b[38;5;28mbool\u001b[39m = \u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[32m 13\u001b[39m ) -> \u001b[38;5;28mtuple\u001b[39m[\u001b[38;5;28mfloat\u001b[39m, \u001b[38;5;28mfloat\u001b[39m]:\n\u001b[32m 14\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33;03m\""\""\""Return RMSD and max deviation.\u001b[39;00m\n\u001b[32m 15\u001b[39m \n\u001b[32m 16\u001b[39m \u001b[33;03m Return a tuple with the RMSD between p and q\u001b[39;00m\n\u001b[32m 17\u001b[39m \u001b[33;03m and the maximum deviation of their positions.\u001b[39;00m\n\u001b[32m 18\u001b[39m \u001b[33;03m \""\""\""\u001b[39;00m\n\u001b[32m 19\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m center:\n"", ""\u001b[31mKeyboardInterrupt\u001b[39m: "" ] } ], ""source"": [ ""# %%prun -s cumtime\n"", ""\n"", ""graph = graphize(ensemble.atoms, ensemble.coords[0])\n"", ""\n"", ""pruned, mask = prune_by_rmsd_rot_corr(\n"", "" structures=ensemble.coords,\n"", "" atoms=ensemble.atoms,\n"", "" graph=graph,\n"", "" max_rmsd=1.0, # 1 Å\n"", "" debugfunction=print,\n"", "")"" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""id"": ""e55358a3"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", "" >> Dihedrals considered for rotamer corrections:\n"", "" 1 - [37 38 74 72] : NPCC : 2-fold\n"", "" 2 - [37 38 79 78] : NPCC : 2-fold\n"", "" 3 - [37 38 86 84] : NPCC : 2-fold\n"", "" 4 - [ 68 67 114 115] : CCCC : 3-fold\n"", "" 5 - [ 68 70 71 102] : CCCC : 3-fold\n"", "" 6 - [ 78 77 154 167] : CCCC : 3-fold\n"", "" 7 - [ 80 81 153 155] : CCCC : 3-fold\n"", "" 8 - [ 84 83 127 129] : CCCC : 3-fold\n"", "" 9 - [ 87 88 128 141] : CCCC : 3-fold\n"", "" 10 - [189 193 197 218] : CCNO : 2-fold\n"", ""\n"", ""\n"", ""DEBUG: RMSDRotCorrPrunerConfig - k=2, rejected 80 (keeping 20/100), in 10.6 s\n"", ""DEBUG: RMSDRotCorrPrunerConfig - k=1, rejected 1 (keeping 19/100), in 0.3 s\n"", ""DEBUG: RMSDRotCorrPrunerConfig - keeping 19/100 (10.9 s)\n"", ""DEBUG: RMSDRotCorrPrunerConfig - Used cached data 90/771 times, 11.67% of total calls\n"", "" "" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ "" 4738464 function calls (4453553 primitive calls) in 12.405 seconds\n"", ""\n"", "" Ordered by: cumulative time\n"", ""\n"", "" ncalls tottime percall cumtime percall filename:lineno(function)\n"", "" 2/1 0.000 0.000 12.398 12.398 {built-in method builtins.exec}\n"", "" 2/1 0.001 0.000 10.888 10.888 :1()\n"", "" 1 0.000 0.000 10.888 10.888 pruner.py:429(prune_by_rmsd_rot_corr)\n"", "" 1 0.000 0.000 10.888 10.888 pruner.py:297(prune)\n"", "" 2 0.000 0.000 10.886 5.443 pruner.py:260(_main_compute_group)\n"", "" 3 0.001 0.000 10.886 3.629 pruner.py:223(_main_compute_row)\n"", "" 537 0.005 0.000 10.846 0.020 pruner.py:85(evaluate_sim)\n"", "" 537 0.355 0.001 10.836 0.020 torsion_module.py:401(rotationally_corrected_rmsd_and_max)\n"", "" 120 0.009 0.000 10.660 0.089 pruner.py:170(_main_compute_subrow)\n"", "" 36059 1.384 0.000 5.776 0.000 utils.py:105(rotate_dihedral)\n"", "" 14499 0.351 0.000 3.170 0.000 rmsd.py:9(rmsd_and_max)\n"", "" 27924 0.128 0.000 2.687 0.000 _arraysetops_impl.py:1060(isin)\n"", "" 27924 1.320 0.000 2.497 0.000 _arraysetops_impl.py:908(_in1d)\n"", "" 14499 0.347 0.000 2.110 0.000 algebra.py:151(get_alignment_matrix)\n"", "" 9 0.000 0.000 1.741 0.193 base_events.py:1966(_run_once)\n"", "" 36059 0.651 0.000 1.557 0.000 algebra.py:65(rot_mat_from_pointer)\n"", "" 8135 0.292 0.000 1.548 0.000 torsion_module.py:315(_get_rotation_mask)\n"", "" 9 0.001 0.000 1.536 0.171 selectors.py:435(select)\n"", "" 91 0.011 0.000 1.364 0.015 torsion_module.py:152(is_nondummy)\n"", "" 14499 0.706 0.000 1.151 0.000 _linalg.py:1689(svd)\n"", ""218148/84 0.380 0.000 1.126 0.013 copy.py:110(deepcopy)\n"", "" 336/84 0.005 0.000 1.124 0.013 copy.py:228(_reconstruct)\n"", "" 57036/84 0.325 0.000 1.121 0.013 copy.py:198(_deepcopy_dict)\n"", ""16748/8471 0.042 0.000 1.045 0.000 backends.py:525(_call_if_no_backends_installed)\n"", "" 8205 0.031 0.000 0.940 0.000 compilation 42:1(argmap_shortest_path_39)\n"", "" 8205 0.024 0.000 0.890 0.000 generic.py:42(shortest_path)\n"", "" 8135 0.023 0.000 0.857 0.000 compilation 62:1(argmap_single_source_shortest_path_59)\n"", "" 56375 0.483 0.000 0.857 0.000 _linalg.py:2623(norm)\n"", "" 8135 0.060 0.000 0.813 0.000 unweighted.py:304(single_source_shortest_path)\n"", "" 8135 0.384 0.000 0.743 0.000 unweighted.py:355(_single_shortest_path)\n"", "" 84866 0.273 0.000 0.676 0.000 fromnumeric.py:69(_wrapreduction)\n"", "" 28998 0.280 0.000 0.594 0.000 _linalg.py:2380(det)\n"", "" 99465 0.445 0.000 0.445 0.000 {method 'reduce' of 'numpy.ufunc' objects}\n"", "" 36059 0.244 0.000 0.391 0.000 algebra.py:88(quaternion_to_rotation_matrix)\n"", "" 72659 0.366 0.000 0.366 0.000 {built-in method numpy.array}\n"", "" 42433 0.079 0.000 0.358 0.000 fromnumeric.py:3052(max)\n"", "" 27934 0.063 0.000 0.298 0.000 fromnumeric.py:3190(min)\n"", "" 27924 0.203 0.000 0.260 0.000 numeric.py:98(zeros_like)\n"", "" 43497 0.131 0.000 0.248 0.000 _linalg.py:207(_commonType)\n"", "" 14499 0.048 0.000 0.223 0.000 fromnumeric.py:2338(sum)\n"", "" 149736 0.161 0.000 0.206 0.000 coreviews.py:81(__getitem__)\n"", "" 87612 0.100 0.000 0.159 0.000 copy.py:212(_keep_alive)\n"", "" 149403 0.085 0.000 0.135 0.000 coreviews.py:50(__iter__)\n"", "" 118 0.001 0.000 0.128 0.001 compilation 50:1(argmap_is_isomorphic_47)\n"", "" 118 0.002 0.000 0.127 0.001 isomorph.py:225(is_isomorphic)\n"", "" 128870 0.090 0.000 0.126 0.000 _linalg.py:187(isComplexType)\n"", "" 41876 0.126 0.000 0.126 0.000 {method 'dot' of 'numpy.ndarray' objects}\n"", "" 27928 0.120 0.000 0.120 0.000 {built-in method numpy.arange}\n"", "" 268895 0.111 0.000 0.111 0.000 {method 'get' of 'dict' objects}\n"", "" 183655 0.110 0.000 0.110 0.000 {built-in method numpy.asarray}\n"", "" 27924 0.105 0.000 0.105 0.000 getlimits.py:698(__init__)\n"", "" 14499 0.041 0.000 0.098 0.000 _ufunc_config.py:448(__enter__)\n"", "" 118 0.002 0.000 0.098 0.001 isomorphvf2.py:292(is_isomorphic)\n"", "" 28998 0.096 0.000 0.096 0.000 {method 'astype' of 'numpy.generic' objects}\n"", "" 30240 0.088 0.000 0.088 0.000 {method '__deepcopy__' of 'numpy.generic' objects}\n"", "" 259806 0.087 0.000 0.087 0.000 {built-in method builtins.issubclass}\n"", "" 1465 0.002 0.000 0.086 0.000 {built-in method builtins.next}\n"", "" 1 0.032 0.032 0.086 0.086 utils.py:85(get_double_bonds_indices)\n"", "" 97724 0.083 0.000 0.083 0.000 {method 'ravel' of 'numpy.ndarray' objects}\n"", "" 8212 0.055 0.000 0.081 0.000 graph.py:906(add_edge)\n"", "" 57996 0.051 0.000 0.079 0.000 _linalg.py:201(_realType)\n"", "" 154 0.000 0.000 0.079 0.001 isomorphvf2.py:315(isomorphisms_iter)\n"", "" 467/269 0.003 0.000 0.078 0.000 isomorphvf2.py:322(match)\n"", "" 252682 0.073 0.000 0.073 0.000 {built-in method builtins.id}\n"", "" 8472 0.051 0.000 0.069 0.000 graph.py:1107(remove_edge)\n"", "" 83772 0.064 0.000 0.064 0.000 _arraysetops_impl.py:922()\n"", "" 142675 0.063 0.000 0.063 0.000 {method 'items' of 'dict' objects}\n"", "" 55848 0.061 0.000 0.061 0.000 {built-in method numpy.zeros}\n"", "" 160120 0.048 0.000 0.056 0.000 {built-in method builtins.iter}\n"", "" 27924 0.052 0.000 0.052 0.000 {method 'reshape' of 'numpy.ndarray' objects}\n"", "" 412 0.003 0.000 0.051 0.000 connected.py:16(connected_components)\n"", "" 14499 0.022 0.000 0.051 0.000 _ufunc_config.py:464(__exit__)\n"", ""83304/82197 0.040 0.000 0.049 0.000 {built-in method builtins.len}\n"", "" 136912 0.048 0.000 0.048 0.000 unweighted.py:345(join)\n"", "" 14499 0.032 0.000 0.047 0.000 _linalg.py:182(_makearray)\n"", "" 327 0.031 0.000 0.046 0.000 connected.py:201(_plain_bfs)\n"", "" 296 0.007 0.000 0.040 0.000 isomorphvf2.py:498(syntactic_feasibility)\n"", "" 109489 0.039 0.000 0.039 0.000 {method 'append' of 'list' objects}\n"", "" 43497 0.038 0.000 0.038 0.000 {method 'astype' of 'numpy.ndarray' objects}\n"", "" 149935 0.036 0.000 0.036 0.000 coreviews.py:44(__init__)\n"", "" 28998 0.033 0.000 0.033 0.000 _linalg.py:256(_assert_stacked_square)\n"", "" 14499 0.033 0.000 0.033 0.000 {built-in method numpy._core._multiarray_umath._make_extobj}\n"", "" 1 0.000 0.000 0.032 0.032 decorator.py:232(fun)\n"", "" 1 0.007 0.007 0.032 0.032 history.py:92(only_when_enabled)\n"", "" 14499 0.017 0.000 0.032 0.000 :1()\n"", "" 62133 0.031 0.000 0.031 0.000 {built-in method builtins.getattr}\n"", "" 16686 0.021 0.000 0.030 0.000 misc.py:593(_clear_cache)\n"", "" 14499 0.029 0.000 0.029 0.000 {method 'reset' of '_contextvars.ContextVar' objects}\n"", "" 393 0.007 0.000 0.029 0.000 isomorphvf2.py:1056(__init__)\n"", "" 118 0.001 0.000 0.027 0.000 vf2userfunc.py:76(__init__)\n"", "" 23 0.001 0.000 0.027 0.001 graph_manipulations.py:156(get_phenyl_ids)\n"", "" 9 0.001 0.000 0.026 0.003 {method 'poll' of 'select.epoll' objects}\n"", "" 118 0.007 0.000 0.025 0.000 isomorphvf2.py:160(__init__)\n"", "" 14499 0.025 0.000 0.025 0.000 {method 'set' of '_contextvars.ContextVar' objects}\n"", "" 27924 0.025 0.000 0.025 0.000 getlimits.py:722(max)\n"", "" 62 0.000 0.000 0.025 0.000 simple_paths.py:94(all_simple_paths)\n"", "" 81 0.000 0.000 0.024 0.000 simple_paths.py:260(all_simple_edge_paths)\n"", "" 16519 0.012 0.000 0.024 0.000 coreviews.py:300()\n"", "" 62 0.006 0.000 0.024 0.000 simple_paths.py:362(_all_simple_edge_paths)\n"", ""31432/31420 0.023 0.000 0.023 0.000 {built-in method builtins.isinstance}\n"", "" 1 0.001 0.001 0.023 0.023 torsion_module.py:373(get_torsions)\n"", "" 56375 0.022 0.000 0.022 0.000 _linalg.py:2619(_norm_dispatcher)\n"", "" 28998 0.021 0.000 0.021 0.000 {method '__array_wrap__' of 'numpy.ndarray' objects}\n"", "" 55848 0.018 0.000 0.018 0.000 multiarray.py:115(empty_like)\n"", "" 222 0.000 0.000 0.017 0.000 function.py:342(subgraph)\n"", "" 3322 0.003 0.000 0.017 0.000 graph.py:498(__getitem__)\n"", "" 222 0.002 0.000 0.017 0.000 graph.py:1783(subgraph)\n"", "" 42433 0.017 0.000 0.017 0.000 fromnumeric.py:3047(_max_dispatcher)\n"", "" 14499 0.016 0.000 0.016 0.000 _linalg.py:250(_assert_stacked_2d)\n"", "" 5987 0.005 0.000 0.016 0.000 {built-in method builtins.sorted}\n"", "" 14499 0.016 0.000 0.016 0.000 {method 'conj' of 'numpy.ndarray' objects}\n"", "" 14837 0.015 0.000 0.015 0.000 {built-in method __new__ of type object at 0x573bc18aa1e0}\n"", "" 27924 0.014 0.000 0.014 0.000 _arraysetops_impl.py:1055(_isin_dispatcher)\n"", "" 10 0.000 0.000 0.014 0.001 events.py:92(_run)\n"", "" 10 0.000 0.000 0.013 0.001 {method 'run' of '_contextvars.Context' objects}\n"", "" 4860 0.010 0.000 0.013 0.000 coreviews.py:351(__getitem__)\n"", "" 6395 0.009 0.000 0.012 0.000 coreviews.py:354(new_node_ok)\n"", "" 27932 0.012 0.000 0.012 0.000 multiarray.py:1106(copyto)\n"", "" 9065 0.012 0.000 0.012 0.000 graph.py:462(__contains__)\n"", "" 27934 0.012 0.000 0.012 0.000 fromnumeric.py:3185(_min_dispatcher)\n"", "" 8372 0.007 0.000 0.011 0.000 reportviews.py:187(__iter__)\n"", "" 28998 0.011 0.000 0.011 0.000 _linalg.py:553(_unary_dispatcher)\n"", "" 27924 0.011 0.000 0.011 0.000 numeric.py:92(_zeros_like_dispatcher)\n"", "" 5 0.001 0.000 0.011 0.002 asyncio.py:206(_handle_events)\n"", "" 70 0.000 0.000 0.011 0.000 torsion_module.py:46(in_cycle)\n"", "" 538 0.003 0.000 0.010 0.000 reportviews.py:531(__iter__)\n"", "" 14499 0.010 0.000 0.010 0.000 _ufunc_config.py:438(__init__)\n"", "" 6 0.000 0.000 0.010 0.002 zmqstream.py:573(_handle_events)\n"", "" 70 0.000 0.000 0.010 0.000 compilation 38:1(argmap_has_path_35)\n"", "" 70 0.000 0.000 0.010 0.000 generic.py:21(has_path)\n"", "" 506 0.001 0.000 0.009 0.000 simple_paths.py:373()\n"", "" 1 0.003 0.003 0.009 0.009 history.py:1024(writeout_cache)\n"", "" 70 0.000 0.000 0.009 0.000 compilation 46:1(argmap_bidirectional_shortest_path_43)\n"", "" 1 0.001 0.001 0.009 0.009 torsion_module.py:347(_get_quadruplets)\n"", "" 1013 0.005 0.000 0.009 0.000 coreviews.py:284(__len__)\n"", "" 70 0.000 0.000 0.009 0.000 unweighted.py:186(bidirectional_shortest_path)\n"", "" 1154 0.002 0.000 0.009 0.000 graph.py:1950(number_of_edges)\n"", "" 100 0.000 0.000 0.009 0.000 {method 'mean' of 'numpy.ndarray' objects}\n"", "" 14499 0.009 0.000 0.009 0.000 {built-in method numpy.ascontiguousarray}\n"", "" 6 0.000 0.000 0.009 0.001 zmqstream.py:614(_handle_recv)\n"", "" 3420 0.008 0.000 0.009 0.000 coreviews.py:293(__iter__)\n"", "" 100 0.002 0.000 0.008 0.000 _methods.py:117(_mean)\n"", "" 508 0.005 0.000 0.008 0.000 reportviews.py:1102(__call__)\n"", "" 70 0.005 0.000 0.008 0.000 unweighted.py:252(_bidirectional_pred_succ)\n"", "" 6 0.000 0.000 0.008 0.001 zmqstream.py:546(_run_callback)\n"", "" 6 0.000 0.000 0.008 0.001 iostream.py:158(_handle_event)\n"", "" 4 0.001 0.000 0.007 0.002 iostream.py:277()\n"", "" 9408 0.007 0.000 0.007 0.000 {method 'update' of 'dict' objects}\n"", "" 14499 0.007 0.000 0.007 0.000 fromnumeric.py:2333(_sum_dispatcher)\n"", "" 222 0.003 0.000 0.007 0.000 graphviews.py:136(subgraph_view)\n"", "" 1 0.000 0.000 0.007 0.007 compilation 25:1(argmap_minimum_spanning_tree_22)\n"", "" 1 0.000 0.000 0.007 0.007 mst.py:558(minimum_spanning_tree)\n"", "" 9313 0.007 0.000 0.007 0.000 {method 'keys' of 'dict' objects}\n"", "" 1871 0.002 0.000 0.007 0.000 :799(__contains__)\n"", "" 269 0.000 0.000 0.007 0.000 isomorphvf2.py:304()\n"", "" 1 0.002 0.002 0.007 0.007 torsion_module.py:237(get_hydrogen_bonds)\n"", "" 18983 0.006 0.000 0.006 0.000 {method 'add' of 'set' objects}\n"", "" 14499 0.006 0.000 0.006 0.000 _linalg.py:1685(_svd_dispatcher)\n"", "" 20891 0.006 0.000 0.006 0.000 filters.py:70(__call__)\n"", "" 1161 0.002 0.000 0.006 0.000 simple_paths.py:384()\n"", "" 222 0.003 0.000 0.006 0.000 filters.py:67(__init__)\n"", "" 1 0.001 0.001 0.005 0.005 graph.py:975(add_edges_from)\n"", "" 2267 0.003 0.000 0.005 0.000 coreviews.py:302(__getitem__)\n"", "" 4 0.000 0.000 0.005 0.001 iostream.py:279(_really_send)\n"", "" 269 0.000 0.000 0.004 0.000 isomorphvf2.py:305()\n"", "" 1777 0.003 0.000 0.004 0.000 reportviews.py:856(__iter__)\n"", "" 220 0.001 0.000 0.004 0.000 mst.py:143(kruskal_mst_edges)\n"", "" 478 0.001 0.000 0.004 0.000 graph.py:476(__len__)\n"", "" 519 0.002 0.000 0.004 0.000 functools.py:1111(__get__)\n"", "" 728 0.002 0.000 0.004 0.000 graph.py:2002(nbunch_iter)\n"", "" 507 0.001 0.000 0.004 0.000 reportviews.py:771(__init__)\n"", "" 336 0.003 0.000 0.003 0.000 {method '__reduce_ex__' of 'object' objects}\n"", "" 1309 0.002 0.000 0.003 0.000 reportviews.py:190(__getitem__)\n"", "" 236 0.000 0.000 0.003 0.000 graph.py:859(order)\n"", "" 8980 0.003 0.000 0.003 0.000 graph.py:2048(bunch_iter)\n"", "" 223 0.002 0.000 0.003 0.000 graph.py:339(__init__)\n"", "" 100 0.002 0.000 0.003 0.000 _methods.py:75(_count_reduce_items)\n"", "" 198 0.001 0.000 0.002 0.000 vf2userfunc.py:39(_semantic_feasibility)\n"", "" 5468 0.002 0.000 0.002 0.000 {method 'join' of 'str' objects}\n"", "" 384 0.001 0.000 0.002 0.000 {built-in method builtins.sum}\n"", "" 302 0.001 0.000 0.002 0.000 isomorphvf2.py:228(candidate_pairs_iter)\n"", "" 3 0.000 0.000 0.002 0.001 ioloop.py:750(_run_callback)\n"", "" 16 0.000 0.000 0.002 0.000 {built-in method builtins.print}\n"", "" 33 0.002 0.000 0.002 0.000 socket.py:623(send)\n"", "" 32 0.000 0.000 0.002 0.000 interactiveshell.py:3043(write)\n"", "" 672 0.001 0.000 0.002 0.000 copy.py:233()\n"", "" 42 0.000 0.000 0.002 0.000 torsion_module.py:54(is_rotable)\n"", "" 10 0.000 0.000 0.002 0.000 arrayprint.py:1704(_array_str_implementation)\n"", "" 219 0.001 0.000 0.002 0.000 union_find.py:91(union)\n"", "" 10 0.000 0.000 0.002 0.000 arrayprint.py:619(array2string)\n"", "" 2 0.000 0.000 0.002 0.001 iostream.py:611(_flush)\n"", "" 195 0.001 0.000 0.002 0.000 isomorphvf2.py:261(initialize)\n"", "" 848 0.001 0.000 0.002 0.000 coreviews.py:291()\n"", "" 43 0.000 0.000 0.002 0.000 torsion_module.py:125(_is_free)\n"", "" 1799 0.001 0.000 0.001 0.000 {method 'update' of 'set' objects}\n"", "" 85 0.001 0.000 0.001 0.000 compilation 21:1(argmap_connected_components_17)\n"", "" 2848 0.001 0.000 0.001 0.000 {built-in method builtins.hasattr}\n"", "" 5082 0.001 0.000 0.001 0.000 coreviews.py:280(__init__)\n"", "" 10 0.000 0.000 0.001 0.000 arrayprint.py:564(wrapper)\n"", "" 1 0.001 0.001 0.001 0.001 graph.py:573(add_nodes_from)\n"", "" 336 0.001 0.000 0.001 0.000 copyreg.py:103(__newobj__)\n"", "" 801 0.001 0.000 0.001 0.000 graph.py:1333(neighbors)\n"", "" 10 0.000 0.000 0.001 0.000 arrayprint.py:581(_array2string)\n"", "" 6395 0.001 0.000 0.001 0.000 filters.py:21(no_filter)\n"", "" 32 0.001 0.000 0.001 0.000 iostream.py:650(write)\n"", "" 333 0.000 0.000 0.001 0.000 coreviews.py:53(__getitem__)\n"", "" 22 0.000 0.000 0.001 0.000 algebra.py:15(vec_angle)\n"", "" 2 0.000 0.000 0.001 0.001 session.py:754(send)\n"", "" 280 0.000 0.000 0.001 0.000 graph.py:444(__iter__)\n"", "" 6 0.001 0.000 0.001 0.000 socket.py:771(recv_multipart)\n"", "" 12 0.000 0.000 0.001 0.000 attrsettr.py:43(__getattr__)\n"", "" 900 0.001 0.000 0.001 0.000 union_find.py:46(__getitem__)\n"", "" 1628 0.001 0.000 0.001 0.000 coreviews.py:299()\n"", "" 2 0.000 0.000 0.001 0.000 session.py:690(serialize)\n"", "" 120 0.000 0.000 0.001 0.000 graph.py:1499(degree)\n"", "" 506 0.001 0.000 0.001 0.000 reportviews.py:779()\n"", "" 10 0.000 0.000 0.001 0.000 arrayprint.py:842(_formatArray)\n"", "" 6 0.000 0.000 0.001 0.000 zmqstream.py:653(_rebuild_io_state)\n"", "" 50/10 0.000 0.000 0.001 0.000 arrayprint.py:851(recurser)\n"", "" 63 0.000 0.000 0.001 0.000 graph_manipulations.py:55(get_sp_n)\n"", "" 199 0.000 0.000 0.001 0.000 graph.py:382(adj)\n"", "" 5 0.000 0.000 0.001 0.000 iostream.py:260(schedule)\n"", "" 4 0.000 0.000 0.001 0.000 socket.py:700(send_multipart)\n"", "" 199 0.000 0.000 0.001 0.000 graph.py:745(nodes)\n"", "" 10 0.000 0.000 0.001 0.000 arrayprint.py:510(_get_format_function)\n"", "" 445 0.001 0.000 0.001 0.000 graph.py:38(__set__)\n"", "" 12 0.000 0.000 0.001 0.000 attrsettr.py:66(_get_attr_opt)\n"", "" 10 0.000 0.000 0.001 0.000 torsion_module.py:111(get_angles)\n"", "" 222 0.001 0.000 0.001 0.000 function.py:173(freeze)\n"", "" 30 0.000 0.000 0.001 0.000 enum.py:1582(__or__)\n"", "" 10 0.000 0.000 0.001 0.000 torsion_module.py:80(get_n_fold)\n"", "" 154 0.000 0.000 0.000 0.000 coreviews.py:342(__iter__)\n"", "" 445 0.000 0.000 0.000 0.000 graph.py:63(__set__)\n"", "" 32 0.000 0.000 0.000 0.000 iostream.py:572(_schedule_flush)\n"", "" 198 0.000 0.000 0.000 0.000 {built-in method builtins.min}\n"", "" 133 0.000 0.000 0.000 0.000 graph_manipulations.py:162()\n"", "" 6 0.000 0.000 0.000 0.000 zmqstream.py:676(_update_handler)\n"", "" 10 0.000 0.000 0.000 0.000 arrayprint.py:468()\n"", "" 8 0.000 0.000 0.000 0.000 session.py:92(json_packer)\n"", "" 1 0.000 0.000 0.000 0.000 zmqstream.py:684()\n"", "" 120 0.000 0.000 0.000 0.000 reportviews.py:421(__init__)\n"", "" 98 0.000 0.000 0.000 0.000 traitlets.py:676(__get__)\n"", "" 1134 0.000 0.000 0.000 0.000 reportviews.py:787()\n"", "" 10 0.000 0.000 0.000 0.000 arrayprint.py:1301(__init__)\n"", "" 506 0.000 0.000 0.000 0.000 {built-in method fromkeys}\n"", "" 22 0.000 0.000 0.000 0.000 fromnumeric.py:2241(clip)\n"", "" 23 0.000 0.000 0.000 0.000 fromnumeric.py:51(_wrapfunc)\n"", "" 100 0.000 0.000 0.000 0.000 {built-in method numpy.lib.array_utils.normalize_axis_index}\n"", "" 221 0.000 0.000 0.000 0.000 :881(__iter__)\n"", "" 133 0.000 0.000 0.000 0.000 graph_manipulations.py:160()\n"", "" 66 0.000 0.000 0.000 0.000 enum.py:676(__call__)\n"", "" 205 0.000 0.000 0.000 0.000 torsion_module.py:138()\n"", "" 8 0.000 0.000 0.000 0.000 __init__.py:183(dumps)\n"", "" 18 0.000 0.000 0.000 0.000 enum.py:1593(__and__)\n"", "" 63 0.000 0.000 0.000 0.000 graph_manipulations.py:82(is_amide_n)\n"", "" 144 0.000 0.000 0.000 0.000 enum.py:1575(_get_value)\n"", "" 31 0.000 0.000 0.000 0.000 compilation 54:1(argmap_all_simple_paths_51)\n"", "" 504 0.000 0.000 0.000 0.000 {method 'copy' of 'dict' objects}\n"", "" 1204 0.000 0.000 0.000 0.000 graph.py:1577(is_directed)\n"", "" 4 0.000 0.000 0.000 0.000 traitlets.py:708(__set__)\n"", "" 86 0.000 0.000 0.000 0.000 decorators.py:83(_not_implemented_for)\n"", "" 12 0.000 0.000 0.000 0.000 typing.py:184(_type_check)\n"", "" 538 0.000 0.000 0.000 0.000 coreviews.py:348()\n"", "" 8 0.000 0.000 0.000 0.000 encoder.py:183(encode)\n"", "" 4 0.000 0.000 0.000 0.000 traitlets.py:689(set)\n"", "" 136 0.000 0.000 0.000 0.000 torsion_module.py:225()\n"", "" 220 0.000 0.000 0.000 0.000 reportviews.py:1274(__iter__)\n"", "" 423 0.000 0.000 0.000 0.000 {method 'pop' of 'list' objects}\n"", "" 84 0.000 0.000 0.000 0.000 {method 'remove' of 'list' objects}\n"", "" 8 0.000 0.000 0.000 0.000 encoder.py:205(iterencode)\n"", "" 40 0.000 0.000 0.000 0.000 arrayprint.py:815(_extendLine_pretty)\n"", "" 369 0.000 0.000 0.000 0.000 torsion_module.py:214()\n"", "" 22 0.000 0.000 0.000 0.000 {method 'clip' of 'numpy.generic' objects}\n"", "" 2 0.000 0.000 0.000 0.000 iostream.py:272(send_multipart)\n"", "" 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects}\n"", "" 2 0.000 0.000 0.000 0.000 session.py:675(sign)\n"", "" 2 0.000 0.000 0.000 0.000 traitlets.py:3631(set)\n"", "" 1 0.000 0.000 0.000 0.000 history.py:1008(_writeout_input_cache)\n"", "" 423 0.000 0.000 0.000 0.000 {method 'popitem' of 'dict' objects}\n"", "" 118 0.000 0.000 0.000 0.000 {built-in method sys.getrecursionlimit}\n"", "" 2 0.000 0.000 0.000 0.000 session.py:649(msg)\n"", "" 98 0.000 0.000 0.000 0.000 traitlets.py:629(get)\n"", "" 2 0.000 0.000 0.000 0.000 iostream.py:582(_schedule_in_thread)\n"", "" 4 0.000 0.000 0.000 0.000 traitlets.py:718(_validate)\n"", "" 2 0.000 0.000 0.000 0.000 {method '__exit__' of 'sqlite3.Connection' objects}\n"", "" 8 0.000 0.000 0.000 0.000 numeric.py:171(ones)\n"", "" 2 0.000 0.000 0.000 0.000 ioloop.py:604(call_later)\n"", "" 84 0.000 0.000 0.000 0.000 reportviews.py:174(__getstate__)\n"", "" 84 0.000 0.000 0.000 0.000 reportviews.py:1053(__getstate__)\n"", "" 154 0.000 0.000 0.000 0.000 reportviews.py:428(__call__)\n"", "" 199 0.000 0.000 0.000 0.000 reportviews.py:180(__init__)\n"", "" 1 0.000 0.000 0.000 0.000 decorator.py:200(fix)\n"", "" 10 0.000 0.000 0.000 0.000 arrayprint.py:57(_make_options_dict)\n"", "" 1 0.000 0.000 0.000 0.000 iostream.py:119(_run_event_pipe_gc)\n"", "" 6 0.000 0.000 0.000 0.000 typing.py:1278(__instancecheck__)\n"", "" 3 0.000 0.000 0.000 0.000 base_events.py:775(call_later)\n"", "" 22 0.000 0.000 0.000 0.000 _methods.py:98(_clip)\n"", "" 2 0.000 0.000 0.000 0.000 session.py:645(msg_header)\n"", "" 2 0.000 0.000 0.000 0.000 asyncio.py:216(call_at)\n"", "" 40 0.000 0.000 0.000 0.000 arrayprint.py:801(_extendLine)\n"", "" 66 0.000 0.000 0.000 0.000 enum.py:1145(__new__)\n"", "" 40 0.000 0.000 0.000 0.000 arrayprint.py:1316(__call__)\n"", "" 50 0.000 0.000 0.000 0.000 {method 'format' of 'str' objects}\n"", "" 438 0.000 0.000 0.000 0.000 union_find.py:96()\n"", "" 84 0.000 0.000 0.000 0.000 reportviews.py:1056(__setstate__)\n"", "" 4 0.000 0.000 0.000 0.000 jsonutil.py:107(json_default)\n"", "" 31 0.000 0.000 0.000 0.000 compilation 58:1(argmap_all_simple_edge_paths_55)\n"", "" 6 0.000 0.000 0.000 0.000 typing.py:1569(__subclasscheck__)\n"", "" 7 0.000 0.000 0.000 0.000 {method 'extend' of 'list' objects}\n"", "" 84 0.000 0.000 0.000 0.000 coreviews.py:38(__getstate__)\n"", "" 84 0.000 0.000 0.000 0.000 reportviews.py:177(__setstate__)\n"", "" 236 0.000 0.000 0.000 0.000 reportviews.py:207(__call__)\n"", "" 4 0.000 0.000 0.000 0.000 iostream.py:705(_flush_buffers)\n"", "" 96 0.000 0.000 0.000 0.000 typing.py:1341(__eq__)\n"", "" 3 0.000 0.000 0.000 0.000 base_events.py:799(call_at)\n"", "" 222 0.000 0.000 0.000 0.000 coreviews.py:328(__init__)\n"", "" 255 0.000 0.000 0.000 0.000 graph.py:1573(is_multigraph)\n"", "" 32 0.000 0.000 0.000 0.000 iostream.py:545(_is_master_process)\n"", "" 6 0.000 0.000 0.000 0.000 isomorphvf2.py:1119(restore)\n"", "" 1 0.000 0.000 0.000 0.000 fromnumeric.py:1129(argsort)\n"", "" 6 0.000 0.000 0.000 0.000 zmqstream.py:532(sending)\n"", "" 1 0.000 0.000 0.000 0.000 inspect.py:3220(bind)\n"", "" 2 0.000 0.000 0.000 0.000 tasks.py:687(sleep)\n"", "" 42 0.000 0.000 0.000 0.000 graph_manipulations.py:116(is_ester_o)\n"", "" 21 0.000 0.000 0.000 0.000 base_events.py:766(time)\n"", "" 1 0.000 0.000 0.000 0.000 {method 'argsort' of 'numpy.ndarray' objects}\n"", "" 12 0.000 0.000 0.000 0.000 :1401(_handle_fromlist)\n"", "" 3 0.000 0.000 0.000 0.000 utils.py:53(time_to_string)\n"", "" 6 0.000 0.000 0.000 0.000 queue.py:115(empty)\n"", "" 4 0.000 0.000 0.000 0.000 {method 'isoformat' of 'datetime.datetime' objects}\n"", "" 84 0.000 0.000 0.000 0.000 coreviews.py:41(__setstate__)\n"", "" 32 0.000 0.000 0.000 0.000 {method 'write' of '_io.StringIO' objects}\n"", "" 1 0.000 0.000 0.000 0.000 {method 'execute' of 'sqlite3.Connection' objects}\n"", "" 1 0.000 0.000 0.000 0.000 inspect.py:3078(_bind)\n"", "" 42 0.000 0.000 0.000 0.000 {built-in method posix.getpid}\n"", "" 100 0.000 0.000 0.000 0.000 {built-in method numpy.asanyarray}\n"", "" 12 0.000 0.000 0.000 0.000 {built-in method builtins.locals}\n"", "" 62 0.000 0.000 0.000 0.000 torsion_module.py:200()\n"", "" 232 0.000 0.000 0.000 0.000 {built-in method math.isnan}\n"", "" 2 0.000 0.000 0.000 0.000 session.py:272(msg_header)\n"", "" 1 0.000 0.000 0.000 0.000 asyncio.py:231(add_callback)\n"", "" 10 0.000 0.000 0.000 0.000 selector_events.py:744(_process_events)\n"", "" 32 0.000 0.000 0.000 0.000 iostream.py:510(parent_header)\n"", "" 21 0.000 0.000 0.000 0.000 numeric.py:484(count_nonzero)\n"", "" 36 0.000 0.000 0.000 0.000 typing.py:1347(__hash__)\n"", "" 231 0.000 0.000 0.000 0.000 reportviews.py:785()\n"", "" 1 0.000 0.000 0.000 0.000 traitlets.py:1512(_notify_trait)\n"", "" 12 0.000 0.000 0.000 0.000 typing.py:396(inner)\n"", "" 2 0.000 0.000 0.000 0.000 base_events.py:817(call_soon)\n"", "" 1 0.000 0.000 0.000 0.000 utils.py:139(flatten)\n"", "" 8 0.000 0.000 0.000 0.000 threading.py:1176(is_alive)\n"", "" 6 0.000 0.000 0.000 0.000 :121(__subclasscheck__)\n"", "" 5 0.000 0.000 0.000 0.000 events.py:41(__init__)\n"", "" 2 0.000 0.000 0.000 0.000 traitlets.py:3474(validate)\n"", "" 3 0.000 0.000 0.000 0.000 events.py:146(__init__)\n"", "" 218 0.000 0.000 0.000 0.000 typing.py:2286(cast)\n"", "" 118 0.000 0.000 0.000 0.000 isomorphvf2.py:212(_is_directed_matcher)\n"", "" 8/1 0.000 0.000 0.000 0.000 utils.py:143(rec)\n"", "" 4 0.000 0.000 0.000 0.000 traitlets.py:727(_cross_validate)\n"", "" 2 0.000 0.000 0.000 0.000 hmac.py:154(copy)\n"", "" 1 0.000 0.000 0.000 0.000 futures.py:319(_set_result_unless_cancelled)\n"", "" 1 0.000 0.000 0.000 0.000 traitlets.py:1523(notify_change)\n"", "" 2 0.000 0.000 0.000 0.000 base_events.py:846(_call_soon)\n"", "" 8 0.000 0.000 0.000 0.000 {built-in method numpy.empty}\n"", "" 1 0.000 0.000 0.000 0.000 iostream.py:128(_event_pipe_gc)\n"", "" 1 0.000 0.000 0.000 0.000 pruner.py:49(__post_init__)\n"", "" 10 0.000 0.000 0.000 0.000 arrayprint.py:460(_get_formatdict)\n"", "" 50 0.000 0.000 0.000 0.000 {method 'values' of 'dict' objects}\n"", "" 2 0.000 0.000 0.000 0.000 iostream.py:713(_rotate_buffers)\n"", "" 2 0.000 0.000 0.000 0.000 session.py:600(msg_id)\n"", "" 34 0.000 0.000 0.000 0.000 {method '__enter__' of '_thread.RLock' objects}\n"", "" 110 0.000 0.000 0.000 0.000 torsion_module.py:40(torsion)\n"", "" 1 0.000 0.000 0.000 0.000 traitlets.py:1527(_notify_observers)\n"", "" 2 0.000 0.000 0.000 0.000 session.py:198(utcnow)\n"", "" 12 0.000 0.000 0.000 0.000 typing.py:175(_type_convert)\n"", "" 1 0.000 0.000 0.000 0.000 compilation 30:1(argmap_minimum_spanning_edges_26)\n"", "" 2 0.000 0.000 0.000 0.000 {method 'copy' of '_hashlib.HMAC' objects}\n"", "" 4 0.000 0.000 0.000 0.000 iostream.py:217(_check_mp_mode)\n"", "" 34 0.000 0.000 0.000 0.000 {method '__exit__' of '_thread.RLock' objects}\n"", "" 2 0.000 0.000 0.000 0.000 hmac.py:193(hexdigest)\n"", "" 6 0.000 0.000 0.000 0.000 {built-in method _abc._abc_subclasscheck}\n"", "" 2 0.000 0.000 0.000 0.000 traitlets.py:2635(validate)\n"", "" 43 0.000 0.000 0.000 0.000 {built-in method builtins.all}\n"", "" 52 0.000 0.000 0.000 0.000 {method 'get' of '_contextvars.ContextVar' objects}\n"", "" 21 0.000 0.000 0.000 0.000 {built-in method numpy._core._multiarray_umath.count_nonzero}\n"", "" 8 0.000 0.000 0.000 0.000 hmac.py:149(update)\n"", "" 1 0.000 0.000 0.000 0.000 {method 'set_result' of '_asyncio.Future' objects}\n"", "" 3 0.000 0.000 0.000 0.000 {built-in method builtins.round}\n"", "" 21 0.000 0.000 0.000 0.000 {built-in method time.monotonic}\n"", "" 32 0.000 0.000 0.000 0.000 {built-in method builtins.any}\n"", "" 5 0.000 0.000 0.000 0.000 base_events.py:1951(_add_callback)\n"", "" 11 0.000 0.000 0.000 0.000 {method '__enter__' of '_thread.lock' objects}\n"", "" 2 0.000 0.000 0.000 0.000 {built-in method now}\n"", "" 4 0.000 0.000 0.000 0.000 iostream.py:214(_is_master_process)\n"", "" 2 0.000 0.000 0.000 0.000 traitlets.py:3624(validate_elements)\n"", "" 1 0.000 0.000 0.000 0.000 inspect.py:2882(apply_defaults)\n"", "" 5 0.000 0.000 0.000 0.000 iostream.py:139(_event_pipe)\n"", "" 24 0.000 0.000 0.000 0.000 {built-in method builtins.max}\n"", "" 40 0.000 0.000 0.000 0.000 {method 'splitlines' of 'str' objects}\n"", "" 1 0.000 0.000 0.000 0.000 contextlib.py:303(helper)\n"", "" 1 0.000 0.000 0.000 0.000 history.py:1016(_writeout_output_cache)\n"", "" 16 0.000 0.000 0.000 0.000 {method 'popleft' of 'collections.deque' objects}\n"", "" 28 0.000 0.000 0.000 0.000 {method 'reverse' of 'list' objects}\n"", "" 1 0.000 0.000 0.000 0.000 threading.py:325(_acquire_restore)\n"", "" 2 0.000 0.000 0.000 0.000 {method 'hexdigest' of '_hashlib.HMAC' objects}\n"", "" 8 0.000 0.000 0.000 0.000 {built-in method math.ceil}\n"", "" 1 0.000 0.000 0.000 0.000 contextlib.py:145(__exit__)\n"", "" 16 0.000 0.000 0.000 0.000 {method 'append' of 'collections.deque' objects}\n"", "" 6 0.000 0.000 0.000 0.000 queue.py:267(_qsize)\n"", "" 12 0.000 0.000 0.000 0.000 {method 'upper' of 'str' objects}\n"", "" 36 0.000 0.000 0.000 0.000 {built-in method builtins.hash}\n"", "" 1 0.000 0.000 0.000 0.000 mst.py:369(minimum_spanning_edges)\n"", "" 8 0.000 0.000 0.000 0.000 {method 'update' of '_hashlib.HMAC' objects}\n"", "" 2 0.000 0.000 0.000 0.000 iostream.py:720(_hooks)\n"", "" 4 0.000 0.000 0.000 0.000 ioloop.py:549(time)\n"", "" 1 0.000 0.000 0.000 0.000 events.py:190(cancel)\n"", "" 32 0.000 0.000 0.000 0.000 displaypub.py:172(is_publishing)\n"", "" 3 0.000 0.000 0.000 0.000 {built-in method _heapq.heappush}\n"", "" 22 0.000 0.000 0.000 0.000 fromnumeric.py:2236(_clip_dispatcher)\n"", "" 2 0.000 0.000 0.000 0.000 session.py:281(extract_header)\n"", "" 10 0.000 0.000 0.000 0.000 {method 'encode' of 'str' objects}\n"", "" 22 0.000 0.000 0.000 0.000 multiarray.py:769(dot)\n"", "" 11 0.000 0.000 0.000 0.000 {method '__exit__' of '_thread.lock' objects}\n"", "" 1 0.000 0.000 0.000 0.000 inspect.py:2829(args)\n"", "" 1 0.000 0.000 0.000 0.000 contextlib.py:136(__enter__)\n"", "" 2 0.000 0.000 0.000 0.000 traitlets.py:2304(validate)\n"", "" 32 0.000 0.000 0.000 0.000 displayhook.py:118(is_active)\n"", "" 1 0.000 0.000 0.000 0.000 threading.py:641(clear)\n"", "" 1 0.000 0.000 0.000 0.000 graph.py:1376(edges)\n"", "" 1 0.000 0.000 0.000 0.000 contextlib.py:108(__init__)\n"", "" 1 0.000 0.000 0.000 0.000 :811(items)\n"", "" 8 0.000 0.000 0.000 0.000 {method 'is_done' of '_thread._ThreadHandle' objects}\n"", "" 4 0.000 0.000 0.000 0.000 {built-in method _contextvars.copy_context}\n"", "" 4 0.000 0.000 0.000 0.000 {method 'count' of 'list' objects}\n"", "" 12 0.000 0.000 0.000 0.000 zmqstream.py:528(receiving)\n"", "" 3 0.000 0.000 0.000 0.000 {built-in method _heapq.heappop}\n"", "" 6 0.000 0.000 0.000 0.000 {built-in method time.perf_counter}\n"", "" 1 0.000 0.000 0.000 0.000 compilation 34:1(argmap_kruskal_mst_edges_31)\n"", "" 4 0.000 0.000 0.000 0.000 jsonutil.py:38(_ensure_tzinfo)\n"", "" 1 0.000 0.000 0.000 0.000 base_events.py:457(create_future)\n"", "" 2 0.000 0.000 0.000 0.000 {method 'getvalue' of '_io.StringIO' objects}\n"", "" 2 0.000 0.000 0.000 0.000 threading.py:313(__enter__)\n"", "" 2 0.000 0.000 0.000 0.000 threading.py:316(__exit__)\n"", "" 8 0.000 0.000 0.000 0.000 encoder.py:105(__init__)\n"", "" 10 0.000 0.000 0.000 0.000 {method 'rstrip' of 'str' objects}\n"", "" 4 0.000 0.000 0.000 0.000 {method 'replace' of 'str' objects}\n"", "" 10 0.000 0.000 0.000 0.000 {built-in method _thread.get_ident}\n"", "" 21 0.000 0.000 0.000 0.000 numeric.py:480(_count_nonzero_dispatcher)\n"", "" 10 0.000 0.000 0.000 0.000 {method 'discard' of 'set' objects}\n"", "" 1 0.000 0.000 0.000 0.000 threading.py:322(_release_save)\n"", "" 3 0.000 0.000 0.000 0.000 {method 'acquire' of '_thread.lock' objects}\n"", "" 3 0.000 0.000 0.000 0.000 tz.py:74(utcoffset)\n"", "" 2 0.000 0.000 0.000 0.000 traitlets.py:3486(validate_elements)\n"", "" 1 0.000 0.000 0.000 0.000 inspect.py:2852(kwargs)\n"", "" 1 0.000 0.000 0.000 0.000 reportviews.py:1067(__init__)\n"", "" 2 0.000 0.000 0.000 0.000 {method 'close' of '_io.StringIO' objects}\n"", "" 1 0.000 0.000 0.000 0.000 {method 'values' of 'mappingproxy' objects}\n"", "" 2 0.000 0.000 0.000 0.000 events.py:162(__lt__)\n"", "" 8 0.000 0.000 0.000 0.000 threading.py:615(is_set)\n"", "" 4 0.000 0.000 0.000 0.000 {built-in method time.time}\n"", "" 1 0.000 0.000 0.000 0.000 threading.py:328(_is_owned)\n"", "" 5 0.000 0.000 0.000 0.000 base_events.py:548(_check_closed)\n"", "" 4 0.000 0.000 0.000 0.000 iostream.py:256(closed)\n"", "" 7 0.000 0.000 0.000 0.000 base_events.py:2064(get_debug)\n"", "" 3 0.000 0.000 0.000 0.000 {method 'items' of 'mappingproxy' objects}\n"", "" 2 0.000 0.000 0.000 0.000 {method '__enter__' of 'sqlite3.Connection' objects}\n"", "" 2 0.000 0.000 0.000 0.000 {built-in method _asyncio.get_running_loop}\n"", "" 10 0.000 0.000 0.000 0.000 inspect.py:2735(kind)\n"", "" 1 0.000 0.000 0.000 0.000 union_find.py:31(__init__)\n"", "" 1 0.000 0.000 0.000 0.000 events.py:78(cancel)\n"", "" 2 0.000 0.000 0.000 0.000 history.py:1065(hold)\n"", "" 1 0.000 0.000 0.000 0.000 pruner.py:47()\n"", "" 1 0.000 0.000 0.000 0.000 {built-in method _thread.allocate_lock}\n"", "" 2 0.000 0.000 0.000 0.000 traitlets.py:2558(_validate_bounds)\n"", "" 1 0.000 0.000 0.000 0.000 {method 'cancelled' of '_asyncio.Future' objects}\n"", "" 2 0.000 0.000 0.000 0.000 hmac.py:171(_current)\n"", "" 4 0.000 0.000 0.000 0.000 inspect.py:2723(name)\n"", "" 4 0.000 0.000 0.000 0.000 inspect.py:3032(parameters)\n"", "" 1 0.000 0.000 0.000 0.000 :834(__init__)\n"", "" 1 0.000 0.000 0.000 0.000 inspect.py:2821(__init__)\n"", "" 1 0.000 0.000 0.000 0.000 :2(__init__)\n"", "" 1 0.000 0.000 0.000 0.000 {method 'release' of '_thread.lock' objects}\n"", "" 1 0.000 0.000 0.000 0.000 base_events.py:1961(_timer_handle_cancelled)\n"", "" 1 0.000 0.000 0.000 0.000 fromnumeric.py:1125(_argsort_dispatcher)"" ] } ], ""source"": [ ""%%prun -s cumtime\n"", ""pruned, mask = prune_by_rmsd_rot_corr(\n"", "" structures=ensemble.coords[0:100],\n"", "" atoms=ensemble.atoms,\n"", "" graph=graph,\n"", "" energies=ensemble.energies[0:100], # in Eh\n"", "" max_dE=1 / EH_TO_KCAL, # 1 kcal/mol\n"", "" max_rmsd=1.0, # 1 Å\n"", "" debugfunction=print,\n"", "" logfunction=print,\n"", "")"" ] }, { ""cell_type"": ""code"", ""execution_count"": 4, ""id"": ""9bdcd627"", ""metadata"": {}, ""outputs"": [], ""source"": [ ""import numpy as np\n"", ""\n"", ""rand = np.random.rand(5, 100, 3)\n"", ""nos = np.array([12 for _ in range(100)])\n"", ""energies = np.array([0, 1, 2, 3, 4])"" ] }, { ""cell_type"": ""code"", ""execution_count"": 7, ""id"": ""85044759"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""DEBUG: RMSDPrunerConfig - k=1, rejected 4 (keeping 1/5), in 0.0 s\n"", ""DEBUG: RMSDPrunerConfig - keeping 1/5 (0.0 s)\n"", ""DEBUG: RMSDPrunerConfig - Used cached data 0/4 times, 0.00% of total calls\n"" ] } ], ""source"": [ ""pruned, mask = prune_by_rmsd(\n"", "" rand,\n"", "" nos,\n"", "" energies=energies, # in Eh\n"", "" max_dE=2, # 1 kcal/mol\n"", "" max_rmsd=1.0, # Will reject below 1 Å\n"", "" debugfunction=print,\n"", "")"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""dev"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.13.7"" } }, ""nbformat"": 4, ""nbformat_minor"": 5 } ","Unknown" "Conformation","ntampellini/prism_pruner","tests/__init__.py",".py","42","2","""""""Tests for the prism_pruner package."""""" ","Python" "Conformation","ntampellini/prism_pruner","tests/helper_notebook.ipynb",".ipynb","6581","266","{ ""cells"": [ { ""cell_type"": ""code"", ""execution_count"": 1, ""id"": ""1a80c249"", ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/plain"": [ ""(1, 33, 3)"" ] }, ""execution_count"": 1, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""import os\n"", ""\n"", ""from prism_pruner.utils import read_xyz\n"", ""\n"", ""os.chdir(\""/home/Coding\"")\n"", ""\n"", ""ensemble = read_xyz(\""t1.xyz\"")\n"", ""ensemble.atomcoords.shape"" ] }, { ""cell_type"": ""code"", ""execution_count"": 2, ""id"": ""dfe133c9"", ""metadata"": {}, ""outputs"": [], ""source"": [ ""from prism_pruner.graph_manipulations import graphize\n"", ""from prism_pruner.torsion_module import _get_rotation_mask, rotate_dihedral\n"", ""from prism_pruner.utils import write_xyz\n"", ""\n"", ""graph = graphize(ensemble.atomcoords[0], ensemble.atomnos)\n"", ""graph.add_edge(32, 4)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 4, ""id"": ""b22da67f"", ""metadata"": {}, ""outputs"": [], ""source"": [ ""from copy import deepcopy\n"", ""\n"", ""import numpy as np\n"", ""\n"", ""from prism_pruner.utils import align_structures\n"", ""\n"", ""structs = []\n"", ""for angle in (120, 240):\n"", "" for dihedral in (\n"", "" (2, 0, 4, 14),\n"", "" (32, 27, 25, 23),\n"", "" ):\n"", "" mask = _get_rotation_mask(graph, dihedral)\n"", "" newcoords = deepcopy(ensemble.atomcoords[0])\n"", "" rotate_dihedral(newcoords, dihedral, angle, mask)\n"", "" structs.append(newcoords)\n"", ""\n"", ""\n"", ""with open(\""bimol_ens.xyz\"", \""w\"") as f:\n"", "" for c in align_structures(np.array(structs), np.array([4, 14, 15])):\n"", "" write_xyz(c, ensemble.atomnos, f)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 5, ""id"": ""aeb56e6d"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""rmsd: 2.06, maxdev: 3.62\n"", ""rmsd: 1.78, maxdev: 3.20\n"", ""rmsd: 2.68, maxdev: 4.39\n"" ] } ], ""source"": [ ""from prism_pruner.rmsd import rmsd_and_max_numba\n"", ""\n"", ""for tgt in structs[1:]:\n"", "" rmsd, maxdev = rmsd_and_max_numba(structs[0], tgt, center=True)\n"", "" print(f\""rmsd: {rmsd:.2f}, maxdev: {maxdev:.2f}\"")"" ] }, { ""cell_type"": ""code"", ""execution_count"": 6, ""id"": ""8c14487a"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""rmsd: 0.03, maxdev: 0.03\n"", ""rmsd: 0.03, maxdev: 0.03\n"", ""rmsd: 0.03, maxdev: 0.03\n"" ] } ], ""source"": [ ""from prism_pruner.torsion_module import (\n"", "" _get_hydrogen_bonds,\n"", "" _get_torsions,\n"", "" _is_nondummy,\n"", "" get_angles,\n"", "" rotationally_corrected_rmsd_and_max,\n"", "")\n"", ""from prism_pruner.utils import get_double_bonds_indices\n"", ""\n"", ""graph.remove_edge(32, 4)\n"", ""\n"", ""hbs = _get_hydrogen_bonds(structs[0], ensemble.atomnos, graph)\n"", ""\n"", ""torsions = _get_torsions(\n"", "" graph,\n"", "" hydrogen_bonds=hbs,\n"", "" double_bonds=get_double_bonds_indices(structs[0], ensemble.atomnos),\n"", "" keepdummy=True,\n"", "" mode=\""symmetry\"",\n"", "")\n"", ""\n"", ""# only keep dummy rotations (checking both directions)\n"", ""torsions = [\n"", "" t\n"", "" for t in torsions\n"", "" if not (_is_nondummy(t.i2, t.i3, graph) and (_is_nondummy(t.i3, t.i2, graph)))\n"", ""]\n"", ""# print(f\""1: {torsions}\"")\n"", ""# since we only compute RMSD based on heavy atoms, discard\n"", ""# quadruplets that involve hydrogen atoms\n"", ""torsions = [\n"", "" t\n"", "" for t in torsions\n"", "" if (1 not in [ensemble.atomnos[i] for i in t.torsion])\n"", "" or (\n"", "" 1 in [ensemble.atomnos[i] for i in t.torsion]\n"", "" and (t.torsion[0] in hbs[0] or t.torsion[3] in hbs[0])\n"", "" )\n"", ""]\n"", ""# print(f\""2: {torsions}\"")\n"", ""# get torsions angles\n"", ""angles = [get_angles(t, graph) for t in torsions]\n"", ""\n"", ""# Used specific directionality of torsions so that we always\n"", ""# rotate the dummy portion (the one attached to the last index)\n"", ""torsions_ids = [\n"", "" list(t.torsion) if _is_nondummy(t.i2, t.i3, graph) else list(reversed(t.torsion))\n"", "" for t in torsions\n"", ""]\n"", ""\n"", ""for tgt in structs[1:]:\n"", "" rmsd, maxdev = rotationally_corrected_rmsd_and_max(\n"", "" structs[0],\n"", "" tgt,\n"", "" ensemble.atomnos,\n"", "" torsions_ids,\n"", "" graph,\n"", "" angles,\n"", "" # debugfunction=print,\n"", "" )\n"", "" print(f\""rmsd: {rmsd:.2f}, maxdev: {maxdev:.2f}\"")"" ] }, { ""cell_type"": ""code"", ""execution_count"": 7, ""id"": ""0e9b6229"", ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/plain"": [ ""[[4, 32]]"" ] }, ""execution_count"": 7, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""hbs"" ] }, { ""cell_type"": ""code"", ""execution_count"": 8, ""id"": ""868f0366"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", "" >> Dihedrals considered for rotamer corrections:\n"", "" 1 - [14, 4, 0, 1] : COCC : 3-fold\n"", "" 2 - [32, 27, 25, 21] : HOCC : 3-fold\n"", ""\n"", ""\n"" ] }, { ""data"": { ""text/plain"": [ ""(1, 33, 3)"" ] }, ""execution_count"": 8, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from prism_pruner import prune_by_rmsd_rot_corr\n"", ""\n"", ""c, _ = prune_by_rmsd_rot_corr(\n"", "" structs,\n"", "" ensemble.atomnos,\n"", "" graph,\n"", "" logfunction=print,\n"", "")\n"", ""\n"", ""c.shape"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""dev"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.13.9"" } }, ""nbformat"": 4, ""nbformat_minor"": 5 } ","Unknown" "Conformation","ntampellini/prism_pruner","tests/cregen_comparison_notebook.ipynb",".ipynb","6817","214","{ ""cells"": [ { ""cell_type"": ""code"", ""execution_count"": 1, ""id"": ""77d80ab1"", ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/plain"": [ ""(675, 220, 3)"" ] }, ""execution_count"": 1, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from prism_pruner.conformer_ensemble import ConformerEnsemble\n"", ""from prism_pruner.graph_manipulations import graphize\n"", ""from prism_pruner.pruner import prune_by_moment_of_inertia, prune_by_rmsd, prune_by_rmsd_rot_corr\n"", ""from prism_pruner.utils import EH_TO_KCAL\n"", ""\n"", ""ensemble = ConformerEnsemble.from_xyz(\""../tests/crest_conformers.xyz\"", read_energies=True)\n"", ""ensemble.coords.shape"" ] }, { ""cell_type"": ""code"", ""execution_count"": 13, ""id"": ""a52bffc3"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""DEBUG: MOIPrunerConfig - k=20, rejected 456 (keeping 219/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=10, rejected 56 (keeping 163/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=5, rejected 38 (keeping 125/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=2, rejected 46 (keeping 79/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - k=1, rejected 15 (keeping 64/675), in 0.0 s\n"", ""DEBUG: MOIPrunerConfig - keeping 64/675 (0.1 s)\n"", ""DEBUG: MOIPrunerConfig - Used cached data 5780/15111 times, 38.25% of total calls\n"", ""\n"", ""DEBUG: RMSDPrunerConfig - k=2, rejected 3 (keeping 61/64), in 0.1 s\n"", ""DEBUG: RMSDPrunerConfig - k=1, rejected 0 (keeping 61/64), in 0.0 s\n"", ""DEBUG: RMSDPrunerConfig - keeping 61/64 (0.1 s)\n"", ""DEBUG: RMSDPrunerConfig - Used cached data 900/1732 times, 51.96% of total calls\n"", ""\n"", ""CPU times: user 303 ms, sys: 12.5 ms, total: 315 ms\n"", ""Wall time: 309 ms\n"" ] } ], ""source"": [ ""%%time\n"", ""pruned, mask = prune_by_moment_of_inertia(\n"", "" ensemble.coords,\n"", "" ensemble.atoms,\n"", "" max_deviation=0.01, # 1% difference\n"", "" debugfunction=print,\n"", "")\n"", ""energies = ensemble.energies[mask]\n"", ""print()\n"", ""\n"", ""pruned, mask = prune_by_rmsd(\n"", "" pruned,\n"", "" ensemble.atoms,\n"", "" energies=energies, # in Eh\n"", "" max_dE=1 / EH_TO_KCAL, # 1 kcal/mol\n"", "" max_rmsd=1.0, # 1 Å\n"", "" debugfunction=print,\n"", "")\n"", ""energies = energies[mask]\n"", ""print()"" ] }, { ""cell_type"": ""code"", ""execution_count"": 14, ""id"": ""c2d35681"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""DEBUG: prune_by_rmsd_rot_corr - temporarily added edge 35-182 to the graph (will be removed before returning)\n"", ""\n"", "" >> Dihedrals considered for rotamer corrections:\n"", "" 1 - [13 14 16 17] : NCCC : 3-fold\n"", "" 2 - [21 22 23 24] : NCCC : 2-fold\n"", "" 3 - [21 22 29 30] : NCCC : 2-fold\n"", "" 4 - [37 38 74 72] : NPCC : 2-fold\n"", "" 5 - [37 38 79 78] : NPCC : 2-fold\n"", "" 6 - [37 38 86 84] : NPCC : 2-fold\n"", "" 7 - [ 68 67 114 115] : CCCC : 3-fold\n"", "" 8 - [ 68 70 71 102] : CCCC : 3-fold\n"", "" 9 - [ 78 77 154 167] : CCCC : 3-fold\n"", "" 10 - [ 80 81 153 155] : CCCC : 3-fold\n"", "" 11 - [ 84 83 127 129] : CCCC : 3-fold\n"", "" 12 - [ 87 88 128 141] : CCCC : 3-fold\n"", "" 13 - [189 193 197 218] : CCNO : 2-fold\n"", ""\n"", ""\n"", ""DEBUG: RMSDRotCorrPrunerConfig - k=2, rejected 14 (keeping 47/61), in 9.6 s\n"", ""DEBUG: RMSDRotCorrPrunerConfig - k=1, rejected 2 (keeping 45/61), in 1.1 s\n"", ""DEBUG: RMSDRotCorrPrunerConfig - keeping 45/61 (10.7 s)\n"", ""DEBUG: RMSDRotCorrPrunerConfig - Used cached data 531/1175 times, 45.19% of total calls\n"" ] } ], ""source"": [ ""graph = graphize(ensemble.atoms, ensemble.coords[0])\n"", ""\n"", ""pruned, mask = prune_by_rmsd_rot_corr(\n"", "" structures=pruned,\n"", "" atoms=ensemble.atoms,\n"", "" graph=graph,\n"", "" energies=energies, # in Eh\n"", "" max_dE=1 / EH_TO_KCAL, # 1 kcal/mol\n"", "" max_rmsd=1.0, # 1 Å\n"", "" debugfunction=print,\n"", "" logfunction=print,\n"", "")"" ] }, { ""cell_type"": ""code"", ""execution_count"": 8, ""id"": ""958ec59a"", ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/plain"": [ ""(10125, 220, 3)"" ] }, ""execution_count"": 8, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""import numpy as np\n"", ""\n"", ""morecoords = np.concatenate([ensemble.coords for _ in range(15)])\n"", ""morecoords.shape"" ] }, { ""cell_type"": ""code"", ""execution_count"": 11, ""id"": ""e0e31b99"", ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""DEBUG: MOIPrunerConfig - k=500, rejected 5990 (keeping 4135/10125), in 0.4 s\n"", ""DEBUG: MOIPrunerConfig - k=200, rejected 1349 (keeping 2786/10125), in 0.2 s\n"", ""DEBUG: MOIPrunerConfig - k=100, rejected 747 (keeping 2039/10125), in 0.1 s\n"", ""DEBUG: MOIPrunerConfig - k=50, rejected 450 (keeping 1589/10125), in 0.2 s\n"", ""DEBUG: MOIPrunerConfig - k=20, rejected 529 (keeping 1060/10125), in 0.3 s\n"", ""DEBUG: MOIPrunerConfig - k=10, rejected 404 (keeping 656/10125), in 0.2 s\n"", ""DEBUG: MOIPrunerConfig - k=5, rejected 313 (keeping 343/10125), in 0.1 s\n"", ""DEBUG: MOIPrunerConfig - k=2, rejected 200 (keeping 143/10125), in 0.1 s\n"", ""DEBUG: MOIPrunerConfig - k=1, rejected 71 (keeping 72/10125), in 0.1 s\n"", ""DEBUG: MOIPrunerConfig - keeping 72/10125 (1.6 s)\n"", ""DEBUG: MOIPrunerConfig - Used cached data 143688/314950 times, 45.62% of total calls\n"", ""CPU times: user 2.71 s, sys: 18.1 ms, total: 2.73 s\n"", ""Wall time: 2.72 s\n"" ] } ], ""source"": [ ""%%time\n"", ""pruned, mask = prune_by_moment_of_inertia(\n"", "" morecoords,\n"", "" ensemble.atoms,\n"", "" max_deviation=0.01, # 1% difference\n"", "" debugfunction=print,\n"", "")"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""dev"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.13.7"" } }, ""nbformat"": 4, ""nbformat_minor"": 5 } ","Unknown" "Conformation","ntampellini/prism_pruner","tests/test_suite.py",".py","4202","142","""""""Tests for the prism_pruner package."""""" from pathlib import Path import numpy as np from prism_pruner.conformer_ensemble import ConformerEnsemble from prism_pruner.graph_manipulations import graphize from prism_pruner.pruner import ( prune, prune_by_moment_of_inertia, prune_by_rmsd, prune_by_rmsd_rot_corr, ) HERE = Path(__file__).resolve().parent def test_two_identical() -> None: """"""Test that two identical structures evaluate as similar under all metrics."""""" ensemble = ConformerEnsemble.from_xyz(HERE / ""P4_folded.xyz"") coords = np.stack((ensemble.coords[0], ensemble.coords[0])) pruned, _ = prune_by_moment_of_inertia(coords, ensemble.atoms) assert len(pruned) == 1 pruned, _ = prune_by_rmsd(coords, ensemble.atoms) assert len(pruned) == 1 graph = graphize(ensemble.atoms, ensemble.coords[0]) pruned, _ = prune_by_rmsd_rot_corr(coords, ensemble.atoms, graph) assert len(pruned) == 1 def test_two_different() -> None: """"""Test that two different structures evaluate as different under all metrics."""""" ensemble1 = ConformerEnsemble.from_xyz(HERE / ""P4_folded.xyz"") ensemble2 = ConformerEnsemble.from_xyz(HERE / ""P4_hairpin.xyz"") coords = np.stack((ensemble1.coords[0], ensemble2.coords[0])) pruned, _ = prune_by_moment_of_inertia(coords, ensemble1.atoms) assert len(pruned) == 2 pruned, _ = prune_by_rmsd(coords, ensemble1.atoms) assert len(pruned) == 2 graph1 = graphize(ensemble1.atoms, ensemble1.coords[0]) pruned, _ = prune_by_rmsd_rot_corr(coords, ensemble1.atoms, graph1) assert len(pruned) == 2 def test_ensemble_moi() -> None: """"""Assert that an ensemble of structures is reduced in size after MOI pruning."""""" ensemble = ConformerEnsemble.from_xyz(HERE / ""ensemble_100.xyz"") pruned, _ = prune_by_moment_of_inertia( ensemble.coords, ensemble.atoms, ) assert pruned.shape[0] < ensemble.coords.shape[0] def test_ensemble_rmsd() -> None: """"""Assert that an ensemble of structures is reduced in size after RMSD pruning."""""" ensemble = ConformerEnsemble.from_xyz(HERE / ""ensemble_100.xyz"") pruned, _ = prune_by_rmsd( ensemble.coords, ensemble.atoms, max_rmsd=1.0, ) assert pruned.shape[0] < ensemble.coords.shape[0] def test_ensemble_rmsd_rot_corr() -> None: """"""Assert that an ensemble of structures is reduced in size after rot. corr. RMSD pruning."""""" ensemble = ConformerEnsemble.from_xyz(HERE / ""ensemble_100.xyz"") graph = graphize(ensemble.atoms, ensemble.coords[0]) pruned, _ = prune_by_rmsd_rot_corr( ensemble.coords, ensemble.atoms, graph, max_rmsd=1.0, ) assert pruned.shape[0] < ensemble.coords.shape[0] def test_rmsd_rot_corr_segmented_graph_2_mols() -> None: """"""Assert that an ensemble of structures is reduced in size after rot. corr. RMSD pruning. The provided ensemble has four different rotamers and two connected components in its graph (i.e. two separate molecules). The expected behavior is that this fact should not stump the rotamer-invariant function. """""" ensemble = ConformerEnsemble.from_xyz(HERE / ""MTBE_tBuOH_ens.xyz"") graph = graphize(ensemble.atoms, ensemble.coords[0]) pruned, _ = prune_by_rmsd_rot_corr( ensemble.coords, ensemble.atoms, graph, max_rmsd=0.1, ) assert pruned.shape[0] == 1 def test_chained_pruning_1() -> None: """"""Assert that chained pruning works and masking is consistent."""""" ensemble = ConformerEnsemble.from_xyz(HERE / ""ensemble_100.xyz"") n = 50 pruned, mask = prune( ensemble.coords[0:n], ensemble.atoms, ) np.testing.assert_array_equal(ensemble.coords[0:n][mask], pruned) def test_chained_pruning_2() -> None: """"""Assert that chained pruning works and masking is consistent."""""" ensemble = ConformerEnsemble.from_xyz(HERE / ""ensemble_100.xyz"") n = 20 pruned, mask = prune( ensemble.coords[0:n], ensemble.atoms, rot_corr_rmsd_pruning=True, ) np.testing.assert_array_equal(ensemble.coords[0:n][mask], pruned) ","Python" "Conformation","ntampellini/prism_pruner","tests/conftest.py",".py","931","27","""""""Confguration for pytest."""""" import pytest from _pytest.config.argparsing import Parser from _pytest.nodes import Item from pytest import Config def pytest_addoption(parser: Parser) -> None: """"""Add max duration option."""""" parser.addoption( ""--timing"", action=""store_true"", help=""Run timing tests [default: False]."", ) def pytest_collection_modifyitems(config: Config, items: list[Item]) -> None: """"""Modify which tests are run."""""" # If --timing is set, only run tests marked as timing for item in items: if config.getoption(""--timing""): if ""timing"" not in (marker.name for marker in item.iter_markers()): item.add_marker(pytest.mark.skip(reason=""Skipping non-timing test due to --timing"")) elif ""timing"" in (marker.name for marker in item.iter_markers()): item.add_marker(pytest.mark.skip(reason=""Skipping timing test"")) ","Python" "Conformation","ncasetti7/multiple_minimum_monte_carlo","examples/run_monte_carlo.ipynb",".ipynb","6146","166","{ ""cells"": [ { ""cell_type"": ""code"", ""execution_count"": null, ""id"": ""108e6c6c"", ""metadata"": {}, ""outputs"": [], ""source"": [ ""from ase.optimize.fire import FIRE\n"", ""from ase.io import write\n"", ""from multiple_minimum_monte_carlo.conformer import Conformer\n"", ""from multiple_minimum_monte_carlo.calculation import ASEOptimization\n"", ""from multiple_minimum_monte_carlo.conformer_ensemble import ConformerEnsemble"" ] }, { ""cell_type"": ""markdown"", ""id"": ""ee7be6fd"", ""metadata"": {}, ""source"": [ ""To use this code, you need an ASE calculator. For this example, we'll use the AIMNet2 calculator. This isn't installed with this package so you'll need to install it separately to run this example! (pip install git+https://github.com/isayevlab/aimnetcentral.git)"" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""id"": ""01646623"", ""metadata"": {}, ""outputs"": [], ""source"": [ ""from aimnet.calculators import AIMNet2ASE"" ] }, { ""cell_type"": ""markdown"", ""id"": ""e3e24581"", ""metadata"": {}, ""source"": [ ""Run a multiple minimum monte carlo search from a SMILES string (will work for any ase calculator and optimizer combination, here we use xtb and FIRE)"" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""id"": ""d849ca89"", ""metadata"": {}, ""outputs"": [], ""source"": [ ""smiles = \""CC(=O)Oc1ccccc1C(=O)O\""\n"", ""conformer = Conformer(smiles=smiles)\n"", ""optimizer = ASEOptimization(calc=AIMNet2ASE(), optimizer=FIRE, fmax=0.03, verbose=False)\n"", ""conformer_ensemble = ConformerEnsemble(conformer=conformer, calc=optimizer, verbose=True, num_iterations=10)\n"", ""conformer_ensemble.run_monte_carlo()\n"", ""conformer.atoms.set_positions(conformer_ensemble.final_ensemble[0])\n"", ""write(\""lowest_energy_conformer.xyz\"", conformer.atoms, format=\""xyz\"")\n"", ""print(f\""Lowest energy conformer energy: {conformer_ensemble.final_energies[0]} kcal/mol\"")"" ] }, { ""cell_type"": ""markdown"", ""id"": ""06baa2db"", ""metadata"": {}, ""source"": [ ""Run a multiple minimum monte carlos search from an input XYZ file. If you don't have a SMILES string, it will attempt to generate a mol from the XYZ file (this may fail for more complex molecules)"" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""id"": ""942126c6"", ""metadata"": {}, ""outputs"": [], ""source"": [ ""input_xyz = \""example.xyz\""\n"", ""conformer = Conformer(input_xyz=input_xyz, charge=0)\n"", ""optimizer = ASEOptimization(calc=AIMNet2ASE(), optimizer=FIRE)\n"", ""conformer_ensemble = ConformerEnsemble(conformer=conformer, calc=optimizer, verbose=True, num_iterations=30, initial_optimization=False)\n"", ""conformer_ensemble.run_monte_carlo()\n"", ""conformer.atoms.set_positions(conformer_ensemble.final_ensemble[0])\n"", ""write(\""lowest_energy_conformer_from_xyz.xyz\"", conformer.atoms, format=\""xyz\"")"" ] }, { ""cell_type"": ""markdown"", ""id"": ""1e22bd9a"", ""metadata"": {}, ""source"": [ ""Parallel calculations are implemented specifically with the \""fork\"" start method from multiprocessing to get around pickling errors. If this is incompatible with your workflow, parallel calculations won't work!"" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""id"": ""64ac2c5c"", ""metadata"": {}, ""outputs"": [], ""source"": [ ""import multiprocessing as mp\n"", ""\n"", ""print(mp.get_start_method()) # Should print 'fork'\n"", ""smiles = \""CC(=O)Oc1ccccc1C(=O)O\""\n"", ""conformer = Conformer(smiles=smiles)\n"", ""optimizer = ASEOptimization(calc=AIMNet2ASE(), optimizer=FIRE, fmax=0.03, verbose=False)\n"", ""conformer_ensemble = ConformerEnsemble(conformer=conformer, calc=optimizer, verbose=True, num_iterations=10, parallel=True, num_cpus=4)\n"", ""conformer_ensemble.run_monte_carlo()\n"", ""conformer.atoms.set_positions(conformer_ensemble.final_ensemble[0])\n"", ""write(\""lowest_energy_conformer.xyz\"", conformer.atoms, format=\""xyz\"")\n"", ""print(f\""Lowest energy conformer energy: {conformer_ensemble.final_energies[0]} kcal/mol\"")"" ] }, { ""cell_type"": ""markdown"", ""id"": ""ee87203c"", ""metadata"": {}, ""source"": [ ""To run batch calculations, we will need to use a batch calculator which will involve installing a couple more packages that aren't installed with this package. We will use the TorchSim calculator here (to use, pip install torch-sim-atomistic). For this example, we will use the uma-s-1 (to use, pip install fairchem-core and request access through HuggingFace)."" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""id"": ""c263a048"", ""metadata"": {}, ""outputs"": [], ""source"": [ ""from multiple_minimum_monte_carlo.batch_calculation import TorchSimCalculation\n"", ""from torch_sim.models.fairchem import FairChemModel\n"", ""from torch_sim.optimizers import Optimizer\n"", ""\n"", ""\n"", ""smiles = \""CC(=O)Oc1ccccc1C(=O)O\""\n"", ""conformer = Conformer(smiles=smiles)\n"", ""model = FairChemModel(model=None, model_name=\""uma-s-1\"",task_name=\""omol\"", cpu=True)\n"", ""calc = TorchSimCalculation(model=model, optimizer=Optimizer.fire, max_cycles=500)\n"", ""conformer_ensemble = ConformerEnsemble(conformer=conformer, calc=calc, verbose=True, num_iterations=10, batch_size=5)\n"", ""conformer_ensemble.run_monte_carlo()\n"", ""conformer.atoms.set_positions(conformer_ensemble.final_ensemble[0])\n"", ""write(\""lowest_energy_conformer_batch.xyz\"", conformer.atoms, format=\""xyz\"")\n"", ""print(f\""Lowest energy conformer energy: {conformer_ensemble.final_energies[0]} kcal/mol\"")"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""torchsim"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.12.12"" } }, ""nbformat"": 4, ""nbformat_minor"": 5 } ","Unknown" "Conformation","ncasetti7/multiple_minimum_monte_carlo","multiple_minimum_monte_carlo/multiproc.py",".py","5091","161","""""""Module for running functions in parallel on a single node"""""" import os import shutil from typing import List, Dict, Callable import torch.multiprocessing as mp import math import torch from pathlib import Path def batch_dicts(dicts: List[Dict], num_workers: int) -> List[List[Dict]]: """""" Batch a list of dictionaries into a list of lists of dictionaries, and add a batch number to each dictionary Args: dicts (list): list of dictionaries num_workers (int): number of workers Returns: batched_dicts (list): list of lists of dictionaries """""" batch_size = math.ceil(len(dicts) / num_workers) if batch_size == 0: batch_size = 1 batched_dicts = [] # Batch the dictionaries and add a batch number to each dictionary start_index = 0 for i in range(num_workers): if start_index + batch_size > len(dicts): for d in dicts[start_index:]: d[""batch""] = i batched_dicts.append(dicts[start_index:]) else: for d in dicts[start_index : start_index + batch_size]: d[""batch""] = i batched_dicts.append(dicts[start_index : start_index + batch_size]) start_index += batch_size # Recalculate the batch size to ensure that the last batch is not empty number_of_items_in_batched_dicts = 0 for dict in batched_dicts: number_of_items_in_batched_dicts += len(dict) if i != num_workers - 1: batch_size = math.ceil( (len(dicts) - number_of_items_in_batched_dicts) / (num_workers - (i + 1)) ) # Remove any empty lists # batched_dicts = [x for x in batched_dicts if x != []] return batched_dicts def _get_temp_base_dir() -> Path: """"""Get the best temporary directory: TMPDIR > /tmp > cwd."""""" if tmpdir := os.environ.get('TMPDIR'): tmp_path = Path(tmpdir) if tmp_path.exists() and tmp_path.is_dir(): return tmp_path tmp_path = Path('/tmp') if tmp_path.exists() and tmp_path.is_dir(): return tmp_path return Path.cwd() def run_func(func: Callable, input_list: List[Dict], queue: mp.Queue) -> None: """""" Run a function in parallel with a list of arguments and puts the results in a queue. Do this in a directory named from the batch number Args: func (function): function to run input_list (list): list of dictionaries with arguments for the function queue (mp.Queue): queue to put the results in Returns: None """""" torch.set_num_threads(1) # Make and cd into a batch folder to run calculations in batch = input_list[0][""batch""] original_dir = Path.cwd().resolve() # Use local temp directory (TMPDIR or /tmp) if available temp_base = _get_temp_base_dir() batch_dir = temp_base / f""mmmc_batch_{batch}_{os.getpid()}"" batch_dir.mkdir(parents=True, exist_ok=True) results = [] try: os.chdir(batch_dir) # Run the function on each input dictionary # Remove the batch number from the input dictionary for input_dict in input_list: del input_dict[""batch""] for input_dict in input_list: try: result = func(**input_dict) except Exception as e: print(""Error in batch"", batch, "":"", e) continue results.append(result) finally: # Change directory back to the original directory and remove the batch folder # Use absolute path to return - avoids stale file handle on "".."" try: os.chdir(original_dir) except OSError: pass # Original directory may no longer exist shutil.rmtree(batch_dir, ignore_errors=True) final_dict = {batch: results} queue.put_nowait(final_dict) def parallel_run_proc(func: Callable, input_list: List[Dict], num_workers: int) -> List: """""" Run a function in parallel with a list of arguments Returns: results (list): list of results from the function """""" # Batch the input list batched_dicts = batch_dicts(input_list, num_workers) # Set up the queue and processes queue = mp.Queue() num_processes = len(batched_dicts) processes = [] rets = [] for i in range(num_processes): p = mp.Process(target=run_func, args=(func, batched_dicts[i], queue)) p.start() processes.append(p) for p in processes: try: ret = queue.get() except Exception as e: print(f""Error in consumer: {e}"") rets.append(ret) for p in processes: p.join() queue.close() # Sort the results new_rets = [] for i in range(len(rets)): for j in range(len(rets)): if i == list(rets[j].keys())[0]: new_rets.append(rets[j]) break results = [] for ret in new_rets: results.extend(list(ret.values())[0]) return results ","Python" "Conformation","ncasetti7/multiple_minimum_monte_carlo","multiple_minimum_monte_carlo/cheminformatics.py",".py","9794","319","""""""Module for handling cheminformatics tasks"""""" from typing import List, Tuple, Set import math import random from rdkit import Chem from rdkit.Chem import rdMolTransforms from ase import Atoms from ase.geometry.analysis import Analysis import numpy as np def make_mol(smi: str) -> Chem.Mol: """""" Initialize a rdkit molecule from a SMILES string while preserving atom mapping Args: smi: str, SMILES string Returns: mol: rdkit.Chem.Mol """""" ps = Chem.SmilesParserParams() ps.removeHs = False og = Chem.MolFromSmiles(smi, ps) fake_map = [] for atom in og.GetAtoms(): if atom.GetAtomMapNum() == 0: fake_map.append(og.GetNumAtoms() - 1) else: fake_map.append(atom.GetAtomMapNum() - 1) indices_order = sorted(range(len(fake_map)), key=lambda x: fake_map[x]) mol = Chem.RenumberAtoms(og, indices_order) return mol def mol_to_ase_atoms(mol: Chem.Mol) -> Atoms: """""" Converts an RDKit molecule object to an ASE Atoms object. Args: mol : Chem.Mol, An RDKit molecule object with 3D coordinates (conformer). Returns: atoms: ase.Atoms, An ase atoms object """""" symbols = [atom.GetSymbol() for atom in mol.GetAtoms()] assert mol.GetNumConformers() > 0 positions = mol.GetConformer().GetPositions() atoms = Atoms(symbols=symbols, positions=np.array(positions)) return atoms def add_ase_coords_to_mol(atoms: Atoms, mol: Chem.Mol) -> Chem.Mol: """""" Add a conformer to an RDKit molecule using coordinates from an ASE Atoms object. Args: atoms: ase.Atoms, An ASE atoms object with positions and chemical symbols. mol: Chem.Mol, An RDKit molecule to which the conformer will be added. Returns: mol: Chem.Mol, The same RDKit molecule with a new conformer added. """""" positions = atoms.get_positions() if len(positions) != mol.GetNumAtoms(): raise ValueError(""Number of atoms in ASE Atoms and RDKit Mol do not match."") conf = mol.GetConformer() for i, pos in enumerate(positions): conf.SetAtomPosition(i, pos) return mol def add_coords_to_mol(coords: np.array, mol: Chem.Mol) -> Chem.Mol: if len(coords) != mol.GetNumAtoms(): raise ValueError(""Number of atoms in ASE Atoms and RDKit Mol do not match."") conf = mol.GetConformer() for i, pos in enumerate(coords): conf.SetAtomPosition(i, pos) return mol def get_bonds(mol: Chem.Mol) -> Set[Tuple[int, int]]: """""" Get the bond strings of a molecule. Args: mol (Chem.Mol): Molecule. Returns: set: Set of bond strings. """""" bonds = set() for bond in mol.GetBonds(): atom_1 = mol.GetAtomWithIdx(bond.GetBeginAtomIdx()).GetAtomMapNum() atom_2 = mol.GetAtomWithIdx(bond.GetEndAtomIdx()).GetAtomMapNum() if atom_1 < atom_2: bonds.add((atom_1, atom_2)) else: bonds.add((atom_2, atom_1)) return bonds def get_dihedral_matches(mol: Chem.Mol, heavy: bool) -> List[Tuple[int, int, int, int]]: """""" Identify unique dihedral (torsion) atom quartets in a molecule based on a strict SMARTS pattern. This function searches for all sets of four connected atoms (a, b, c, d) in the given molecule that match a predefined dihedral SMARTS pattern. The matches are filtered to ensure uniqueness based on the central bond (b, c). The selection of matches can be further refined based on the `heavy` parameter: - If `heavy` is True, only dihedrals where both terminal atoms (a and d) are not hydrogens are included. - If `heavy` is False, dihedrals where the third atom is carbon and the fourth atom is hydrogen are excluded. Args: mol : Chem.Mol An RDKit molecule object to search for dihedral matches. heavy : bool If True, only include dihedrals with heavy atom terminals (no hydrogens). If False, include all dihedrals except those ending with a C-H pair. Returns: uniqmatches : list of tuple of int A list of unique tuples (a, b, c, d), where each tuple contains the atom indices of a dihedral match in the molecule. """""" # this is rdkit's ""strict"" pattern pattern = r""*~[!$(*#*)&!D1&!$(C(F)(F)F)&!$(C(Cl)(Cl)Cl)&!$(C(Br)(Br)Br)&!$(C([CH3])([CH3])[CH3])&!$([CD3](=[N,O,S])-!@[#7,O,S!D1])&!$([#7,O,S!D1]-!@[CD3]=[N,O,S])&!$([CD3](=[N+])-!@[#7!D1])&!$([#7!D1]-!@[CD3]=[N+])]-!@[!$(*#*)&!D1&!$(C(F)(F)F)&!$(C(Cl)(Cl)Cl)&!$(C(Br)(Br)Br)&!$(C([CH3])([CH3])[CH3])]~*"" qmol = Chem.MolFromSmarts(pattern) matches = mol.GetSubstructMatches(qmol) # these are all sets of 4 atoms, uniquify by middle two uniqmatches = [] seen = set() for a, b, c, d in matches: if (b, c) not in seen and (c, b) not in seen: if heavy: if ( mol.GetAtomWithIdx(a).GetSymbol() != ""H"" and mol.GetAtomWithIdx(d).GetSymbol() != ""H"" ): seen.add((b, c)) uniqmatches.append((a, b, c, d)) if not heavy: if ( mol.GetAtomWithIdx(c).GetSymbol() == ""C"" and mol.GetAtomWithIdx(d).GetSymbol() == ""H"" ): pass else: seen.add((b, c)) uniqmatches.append((a, b, c, d)) return uniqmatches def rotate_dihedrals( conformer: Chem.rdchem.Conformer, dihedrals: List[Tuple[int, int, int, int]], stepsize: float, ) -> None: """""" Applies a random rotation to all the dihedrals Parameters ---------- conformer : rdkit.Chem.rdchem.Conformer The conformer whose angles are going to be rotated (conformer = mol.GetConformer(cid)) dihedrals : list A list of tuples of all the dihedrals that are going to be rotated. stepsize : float Angle in Degrees to do the steps between 0.0 and 360.0 """""" rad_range = np.arange(stepsize, 360.0, stepsize) for dihedral in dihedrals: rad_ang = random.choice(rad_range) rad = math.pi * rad_ang / 180.0 rdMolTransforms.SetDihedralRad(conformer, *dihedral, value=rad) def get_bonded_atoms(mol: Chem.Mol) -> List[Tuple[int, int]]: """""" Get the indices of bonded atoms in the molecule. Args: mol: Chem.Mol, An RDKit molecule object Returns: list: List of indices of bonded atoms. """""" bonded_atoms = [] for bond in mol.GetBonds(): atom_1 = bond.GetBeginAtomIdx() atom_2 = bond.GetEndAtomIdx() bonded_atoms.append((atom_1, atom_2)) return bonded_atoms def get_metal_atoms(mol: Chem.Mol) -> List[int]: """""" Get the indices of metal atoms in the reactant molecule. Returns: list: List of indices of metal atoms. """""" metal_list = [ ""Al"", ""Sb"", ""Ag"", ""As"", ""Ba"", ""Be"", ""Bi"", ""Cd"", ""Ca"", ""Cr"", ""Co"", ""Cu"", ""Au"", ""Fe"", ""Pb"", ""Mg"", ""Mn"", ""Hg"", ""Mo"", ""Ni"", ""Pd"", ""Pt"", ""K"", ""Rh"", ""Rb"", ""Ru"", ""Sc"", ""Na"", ""Sr"", ""Ta"", ""Tl"", ""Th"", ""Ti"", ""U"", ""V"", ""Y"", ""Zn"", ""Zr"", ] metal_atoms = [] for atom in mol.GetAtoms(): if atom.GetSymbol() in metal_list: metal_atoms.append(atom.GetIdx()) return metal_atoms def initialize_mc_identity_check( atoms: Atoms, original_mol: Chem.Mol ) -> Tuple[List, List, List]: """""" Initialize the identity check for the Monte Carlo conformer Args: atoms: ase.Atoms original_mol (rdkit.Chem.rdchem.Mol): Original molecule Returns: tuple: Set of bonds in the original molecule, indices of metal atoms, indices of halide atoms """""" metal_atoms = get_metal_atoms(original_mol) metal_atoms = [atom for atom in metal_atoms] halides = [ atom.GetIdx() for atom in original_mol.GetAtoms() if atom.GetSymbol() in [""F"", ""Cl"", ""Br"", ""I""] ] original_bonds = [] ana = Analysis(atoms) bonds = ana.all_bonds for b in bonds: for i, atoms in enumerate(b): for atom in atoms: if i not in metal_atoms and atom not in metal_atoms: if i not in halides or atom not in halides: if i > atom: continue original_bonds.append((i, atom)) return original_bonds, metal_atoms, halides def check_identity_mc( original_bonds: List, metal_atoms: List, halide_atoms: List, atoms: Atoms ) -> bool: """""" Check if the monte carlo conformer corresponds to the input molecule Args: original_bonds (list): Set of bonds in the original molecule metal_atoms (list): List of indices of metal atoms in the original molecule halide_atoms (list): List of indices of halide atoms in the original molecule atoms (ase.Atoms): Returns: bool: True if the conformer corresponds to the input molecule, False otherwise """""" ana = Analysis(atoms) bonds = ana.all_bonds mc_bonds = [] for b in bonds: for i, atoms in enumerate(b): for atom in atoms: if i not in metal_atoms and atom not in metal_atoms: if i not in halide_atoms or atom not in halide_atoms: if i > atom: continue mc_bonds.append((i, atom)) return set(original_bonds) == set(mc_bonds) ","Python" "Conformation","ncasetti7/multiple_minimum_monte_carlo","multiple_minimum_monte_carlo/__init__.py",".py","0","0","","Python" "Conformation","ncasetti7/multiple_minimum_monte_carlo","multiple_minimum_monte_carlo/conformer.py",".py","3584","91","""""""Module for managing conformer generation"""""" from typing import Optional, List from ase.io import read from rdkit import Chem from rdkit.Chem import AllChem, rdDetermineBonds from multiple_minimum_monte_carlo import cheminformatics class Conformer: def __init__( self, smiles: Optional[str] = None, mapped: Optional[bool] = False, input_xyz: Optional[str] = None, charge: Optional[int] = None, spin: Optional[int] = 1, constrained_atoms: Optional[List[int]] = None, ) -> None: """""" Initializes a conformer object from a SMILES string, with optional atom mapping, input coordinates, and constrained atoms. Parameters: smiles (str): The SMILES string representing the molecule. mapped (Optional[bool], default=False): Whether the SMILES string is atom-mapped. If True, uses a custom molecule creation function; otherwise, hydrogens are added to the molecule. input_xyz (Optional[str], default=None): Path to an XYZ file containing input coordinates. If None, a conformer is generated. charge (Optional[int], default=None): spin (Optional[int], default=1): constrained_atoms (Optional[List[int]], default=[]): List of atom indices to be constrained during conformer generation or optimization. """""" self.smiles = smiles self.mapped = mapped self.input_xyz = input_xyz self.charge = charge self.spin = spin self.constrained_atoms = constrained_atoms # Check whether atom rearrangement is necessary if self.smiles is not None: if self.mapped: self.mol = cheminformatics.make_mol(self.smiles) else: self.mol = Chem.AddHs(Chem.MolFromSmiles(self.smiles)) # Check whether conformer generation/mapping is necessary if self.input_xyz is None and self.smiles is None: raise ValueError(""Conformer needs either smiles or input_xyz!"") elif self.input_xyz is None: self.generate_conformer() elif self.smiles is None: if self.charge is None: raise ValueError( ""Charge must be specified if no SMILES string provided!"" ) self.mol_from_xyz() self.atoms = read(input_xyz) else: self.atoms = read(input_xyz) self.add_xyz_to_mol() if self.charge is None: self.charge = Chem.GetFormalCharge(self.mol) self.bonded_atoms = cheminformatics.get_bonded_atoms(self.mol) self.atoms.info[""charge""] = self.charge self.atoms.info[""spin""] = self.spin def generate_conformer(self) -> None: """""" Generate a conformer with rdkit ETKDG """""" AllChem.EmbedMolecule(self.mol) AllChem.UFFOptimizeMolecule(self.mol) self.atoms = cheminformatics.mol_to_ase_atoms(self.mol) def mol_from_xyz(self) -> None: """""" Generate an rdkit mol from an xyz file """""" raw_mol = Chem.MolFromXYZFile(self.input_xyz) mol = Chem.Mol(raw_mol) rdDetermineBonds.DetermineBonds(mol, charge=self.charge) self.mol = mol self.smiles = Chem.MolToSmiles(mol) def add_xyz_to_mol(self) -> None: """""" Add coordinates from an xyz file to the rdkit mol """""" raw_mol = Chem.MolFromXYZFile(self.input_xyz) conf = raw_mol.GetConformer() self.mol.AddConformer(conf, assignId=True) ","Python" "Conformation","ncasetti7/multiple_minimum_monte_carlo","multiple_minimum_monte_carlo/conformer_ensemble.py",".py","19243","407","""""""Module for running multiple minimum monte carlo"""""" import os import sys from typing import Optional, List, Tuple, Union import random from copy import copy import logging import numpy as np from scipy.spatial import distance_matrix from rdkit import Chem from rdkit.Chem import PeriodicTable, rdMolAlign import ase from multiple_minimum_monte_carlo.conformer import Conformer from multiple_minimum_monte_carlo.calculation import Calculation from multiple_minimum_monte_carlo.batch_calculation import BatchCalculation from multiple_minimum_monte_carlo import cheminformatics, multiproc def run_class_func(cls, func_name, args): func = getattr(cls, func_name) return func(**args) class ConformerEnsemble: def __init__( self, conformer: Conformer, calc: Union[Calculation, BatchCalculation], num_iterations: Optional[int] = 100, energy_window: Optional[float] = 10.0, max_bonds_rotate: Optional[int] = 3, max_attempts: Optional[int] = 1000, angle_step: Optional[float] = 30.0, rmsd_threshold: Optional[float] = 0.3, initial_optimization: Optional[bool] = True, random_walk: Optional[bool] = False, reduce_angle: Optional[bool] = False, reduce_angle_every: Optional[int] = 50, reduce_angle_by: Optional[int] = 2, only_heavy: Optional[bool] = False, parallel: Optional[bool] = False, num_cpus: Optional[int] = 0, batch_size: Optional[int] = 10, verbose: Optional[bool] = False, ) -> None: """""" Initializes the conformer ensemble generator. Args: conformer (Conformer): The initial conformer structure to start the ensemble generation. calc (Calculation): A calculation object to perform energy minimizations num_iterations (int, optional): Number of Monte Carlo iterations to perform. Default is 100. energy_window (float, optional): Maximum energy window (in kcal/mol) above the minimum energy conformer to retain conformers. Default is 10.0. max_bonds_rotate (int, optional): Maximum number of rotatable bonds to rotate in each step. Default is 3. max_attempts (int, optional): Maximum number of times to try and rotate dihedrals per iteration. Default is 1000 angle_step (float, optional): Step size (in degrees) for bond rotation. Default is 30.0.W rmsd_threshold (float, optional): RMSD threshold (in Å) for distinguishing unique conformers. Default is 0.3. initial_optimization (bool, optional): If True, perform a structure optimization before performin Monte Carlo. Default is True random_walk (bool, optional): If True, use random walk for bond rotations. Default is False. reduce_angle (bool, optional): If True, reduce angle step size during the search. Default is False. reduce_angle_every (int, optional): The number of iterations between reducing angle step size. Default is 50 (only accessed when reduce_angle is True) reduce_angle_by (int, optional): The amount to divide the angle step size by. Default is 2 (only accessed when reduce_angle is True) only_heavy (bool, optional): If True, only rotate dihedrals associated with heavy atoms parallel (bool, optional): If True, perform calculations in parallel. Default is False num_cpus (int, optional): Number of CPUs to use for parallel calculations. If 0, use all available CPUs. Default is 0. batch_size (int, optional): Number of conformers to process in each batch. Default is 10. verbose (bool, optional): Whether to log Monte Carlo progress """""" self.conformer = conformer self.calc = calc self.num_iterations = num_iterations self.energy_window = energy_window self.max_bonds_rotate = max_bonds_rotate self.max_attempts = max_attempts self.angle_step = angle_step self.rmsd_threshold = rmsd_threshold self.initial_optimization = initial_optimization self.random_walk = random_walk self.reduce_angle = reduce_angle self.reduce_angle_every = reduce_angle_every self.reduce_angle_by = reduce_angle_by self.only_heavy = only_heavy self.parallel = parallel self.num_cpus = num_cpus self.batch = isinstance(self.calc, BatchCalculation) self.batch_size = batch_size self.verbose = verbose if self.num_cpus == 0: self.num_cpus = os.cpu_count() if self.verbose: logging.basicConfig(stream=sys.stdout, level=logging.INFO) self.final_ensemble = [] self.final_energies = [] if self.parallel and self.batch: self.parallel = False self.log_warning( ""Parallel calculations not supported with batch calculations"" ) def log_info(self, message: str) -> None: """""" Logs a message Args: message (str): Message to log """""" if self.verbose: logging.info(message) def log_warning(self, message: str) -> None: """""" Logs a warning message Args: message (str): Message to log """""" if self.verbose: logging.warning(message) def run_monte_carlo(self) -> None: """""" Runs a Monte Carlo search to generate a conformer ensemble by iteratively sampling, modifying, and optimizing molecular conformers. The method performs the following steps: 1. Optionally runs an initial optimization on the starting conformer. 2. Identifies rotatable dihedral angles, excluding those associated with constrained atoms. 3. Iteratively samples conformers, applies random dihedral rotations, and optimizes the resulting structures. 4. Filters out high-energy and duplicate conformers. 5. Sorts the ensemble by energy and returns the final set of unique, low-energy conformers. """""" # Run the initial optimization if self.initial_optimization: self.log_info(""Running intitial optimization"") positions_and_energies = self.run_optimizations([self.conformer.atoms]) self.conformer.atoms.positions = positions_and_energies[0][0] energy = positions_and_energies[0][1] else: if self.batch: energies = self.calc.energy([self.conformer.atoms]) energy = energies[0] else: energy = self.calc.energy(self.conformer.atoms) # Get the dihedrals to rotate dihedrals = cheminformatics.get_dihedral_matches( self.conformer.mol, self.only_heavy ) self.max_bonds_rotate = min(len(dihedrals), self.max_bonds_rotate) # Remove any dihedrals associated with constrained atoms final_dihedrals = [] for dihedral in dihedrals: if self.conformer.constrained_atoms is not None and ( dihedral[1] in self.conformer.constrained_atoms and dihedral[2] in self.conformer.constrained_atoms ): # If the bond is constrained, we need to remove it from the list of rotatable bonds continue else: final_dihedrals.append(dihedral) dihedrals = final_dihedrals # Initialize information for identity checking # TODO: halides are weird with bond formation occasionally so they are currently gnore self.original_bonds, self.metal_atoms, self.halides = ( cheminformatics.initialize_mc_identity_check( self.conformer.atoms, self.conformer.mol ) ) final_ensemble = [self.conformer.atoms.get_positions()] final_energies = [energy] used = [0] current_iter = 0 samples_per_batch = 1 if self.batch: samples_per_batch = self.batch_size elif self.parallel: samples_per_batch = self.num_cpus while current_iter < self.num_iterations: self.log_info( f""Iteration: {current_iter} Current min energy: {min(final_energies)}"" ) # Reduce angle if reduce_angle true if self.reduce_angle: if current_iter % self.reduce_angle_every == 0: self.angle_step = self.angle_step / self.reduce_angle_by # Sample a conformer, rotate its dihedrals, and optimize it (if parallel, do this num_cpus times) calculation_input = [] for _ in range(samples_per_batch): current_iter += 1 success = False index = self.sample_conformer(used) success, positions = self.modify_conformer( final_ensemble[index], dihedrals ) if success: used[index] += 1 atoms_to_optimize = copy(self.conformer.atoms) atoms_to_optimize.set_positions(positions) calculation_input.append(atoms_to_optimize) if len(calculation_input) == 0: continue positions_and_energies = self.run_optimizations(calculation_input) # Filter out high energy and duplicate conformers for positions, energy in positions_and_energies: if self.check_conformer( final_ensemble, final_energies, positions, energy ): final_ensemble.append(positions) final_energies.append(energy) used.append(0) # Sort all of the lists by energies final_ensemble, used, final_energies = zip( *sorted(zip(final_ensemble, used, final_energies), key=lambda x: x[2]) ) final_ensemble = list(final_ensemble) used = list(used) final_energies = list(final_energies) self.final_ensemble = final_ensemble self.final_energies = final_energies def run_optimizations( self, atoms_list: List[ase.Atoms] ) -> List[Tuple[np.ndarray, float]]: """""" Runs optimizations on a list of ASE Atoms objects using the provided calculation method. Args: atoms_list (List[ase.Atoms]): List of ASE Atoms objects to optimize. Returns: List[Tuple[np.ndarray, float]]: List of tuples containing optimized positions and energies. """""" if self.parallel: calculation_input = [] for atoms in atoms_list: calculation_input.append( { ""cls"": self.calc, ""func_name"": ""run"", ""args"": { ""atoms"": atoms, ""constrained_atoms"": self.conformer.constrained_atoms, }, } ) workers = min(self.num_cpus, len(calculation_input)) results = multiproc.parallel_run_proc( run_class_func, calculation_input, workers ) elif self.batch: if self.conformer.constrained_atoms is not None: constrained_atoms = [self.conformer.constrained_atoms] * len(atoms_list) else: constrained_atoms = None positions_list, energies = self.calc.run( atoms_list=atoms_list, constrained_atoms_list=constrained_atoms, ) results = list(zip(positions_list, energies)) else: results = [] for atoms in atoms_list: positions, energy = self.calc.run( atoms, self.conformer.constrained_atoms ) results.append((positions, energy)) return results def sample_conformer(self, used: List[int]) -> int: """""" Selects a conformer index based on the sampling strategy. If random_walk is enabled, randomly selects an index from the provided list of used indices. Otherwise, selects the index corresponding to the minimum value in the used list. Args: used (list or array-like): A list of indices or values representing conformer usage. Returns: int: The selected conformer index. """""" if self.random_walk: index = random.choice(range(len(used))) else: index = np.argmin(np.array(used)) return index def modify_conformer( self, conformer: np.ndarray, all_dihedrals: List[Tuple[int, int, int, int]] ) -> Tuple[bool, np.ndarray]: """""" Attempts to modify a given conformer by randomly rotating a subset of its dihedral angles. For a maximum number of attempts (`self.max_attempts`), this method: - Copies the input conformer and its associated molecule. - Randomly selects a subset of dihedral angles to rotate. - Applies a rotation to the selected dihedrals by a fixed angle step (`self.angle_step`). - Tests the modified conformer against a set of constraints (`self.constraint_test`). If a valid conformer is found that passes the constraint test, the process stops early. Args: conformer (np.ndarray): The input conformer coordinates to be modified. all_dihedrals (List[Tuple[int, int, int, int]]): List of all possible dihedral angles (as atom index tuples) in the molecule. Returns: Tuple[bool, np.ndarray]: - A boolean indicating whether a valid conformer was found. - The resulting np.ndarray with the coordinates of the modified conformer. """""" success = False for _ in range(self.max_attempts): temp_mol = copy(self.conformer.mol) temp_mol = cheminformatics.add_coords_to_mol(conformer, temp_mol) num_dihedrals = random.randint(1, self.max_bonds_rotate) dihedrals = random.choices(all_dihedrals, k=num_dihedrals) cheminformatics.rotate_dihedrals( temp_mol.GetConformer(), dihedrals, self.angle_step ) if self.constraint_test(temp_mol.GetConformer()): success = True break atoms = cheminformatics.mol_to_ase_atoms(temp_mol) return success, atoms.get_positions() def constraint_test(self, conf: Chem.rdchem.Conformer) -> bool: """""" Determine whether the conformer meets the constraint test 2 as defined in CITATION. This function checks whether the interatomic distances between non-bonded atoms is under 1/4 of the van der Waals radius of the atoms. If the distance is under this threshold, the conformer is considered invalid. Parameters ---------- conf : rdkit.Chem.rdchem.Conformer The conformer to be tested. Returns ------- bool True if the conformer passes the constraint test, False otherwise. """""" # Get the 3D coordinates of the atoms in the conformer coords = conf.GetPositions() # Calculate the distance matrix between all pairs of atoms dist_matrix = distance_matrix(coords, coords) # Get the van der Waals radii for each atom in the conformer vdw_radii = [ PeriodicTable.GetRvdw(Chem.GetPeriodicTable(), atom.GetAtomicNum()) for atom in self.conformer.mol.GetAtoms() ] # Make a matrix of the van der Waals radii vdw_matrix = np.array( [ [vdw_radii[i] + vdw_radii[j] for j in range(len(vdw_radii))] for i in range(len(vdw_radii)) ] ) vdw_matrix = vdw_matrix / 4.0 # Scale the van der Waals radii by 1/4 # Set the distances between bonded atoms to zero (to ignore them in the test) for bonded_atom_pair in self.conformer.bonded_atoms: i, j = bonded_atom_pair vdw_matrix[i][j] = 0.0 vdw_matrix[j][i] = 0.0 # Set the diagonal of the van der Waals matrix to zero (to ignore self-distances) np.fill_diagonal(vdw_matrix, 0.0) # Check if the distance between any two non-bonded atoms is less than 1/4 of the van der Waals radius difference_matrix = dist_matrix - vdw_matrix # If any distance is less than 0, the conformer fails the constraint test if np.any(difference_matrix < 0): return False # If all distances are greater than or equal to 0, the conformer passes the constraint test return True def check_conformer( self, ensemble: List[np.ndarray], energies: List[float], conf: np.ndarray, energy: float, ) -> bool: """""" Checks whether a given conformer should be added to the ensemble based on energy and structural similarity. This function evaluates if the provided conformer (`conf`) with its associated energy (`energy`) is sufficiently low in energy and structurally distinct from all conformers already present in the ensemble. The conformer is accepted if: - Its energy is within `self.energy_window` of the minimum energy in the current ensemble. - Its root-mean-square deviation (RMSD) from all conformers in the ensemble is greater than `self.rmsd_threshold`. Args: ensemble (list): List of conformers cooordinates currently in the ensemble, each represented as np.ndarray objects. energies (list): List of energies corresponding to the conformers in the ensemble. conf (np.ndarray): The candidate conformer to be evaluated. energy (float): The energy of the candidate conformer. Returns: bool: True if the conformer passes both the energy and RMSD criteria and should be added to the ensemble, False otherwise. """""" if energy > min(energies) + self.energy_window: return False temp_atoms = copy(self.conformer.atoms) temp_atoms.set_positions(conf) if not cheminformatics.check_identity_mc( self.original_bonds, self.metal_atoms, self.halides, temp_atoms ): return False temp_mol = copy(self.conformer.mol) temp_mol = cheminformatics.add_coords_to_mol(conf, temp_mol) temp_reference_mol = copy(self.conformer.mol) atom_map = [(i, i) for i in range(len(temp_mol.GetAtoms()))] for reference_conf in ensemble: temp_reference_mol = cheminformatics.add_coords_to_mol( reference_conf, temp_reference_mol ) rmsd = rdMolAlign.AlignMol(temp_mol, temp_reference_mol, atomMap=atom_map) if rmsd < self.rmsd_threshold: return False return True ","Python" "Conformation","ncasetti7/multiple_minimum_monte_carlo","multiple_minimum_monte_carlo/batch_calculation.py",".py","2940","87","from typing import Optional, List, Tuple, Any import numpy as np import ase from ase.constraints import FixAtoms import torch EV_TO_KCAL = 23.0605 class BatchCalculation: def __init__(self): pass def run( self, atoms_list: List[ase.Atoms], constrained_atoms_list: Optional[List[List[int]]] = None, ) -> Tuple[np.ndarray, float]: pass def energy(self, atoms: ase.Atoms) -> float: pass class TorchSimCalculation(BatchCalculation): def __init__( self, model: Any, optimizer: Any, device: Optional[str] = ""cpu"", dtype: Optional[Any] = torch.float32, max_cycles: Optional[int] = 1000, ) -> None: try: from torch_sim.models.interface import ModelInterface from torch_sim.optimizers import Optimizer except ImportError: raise ImportError(""TorchSim is not installed"") self.model = model if not isinstance(self.model, ModelInterface): raise TypeError(""model must be an instance of ModelInterface"") self.optimizer = optimizer if not isinstance(self.optimizer, Optimizer): raise TypeError(""optimizer must be an instance of Optimizer"") self.device = device self.dtype = dtype self.max_cycles = max_cycles def run( self, atoms_list: List[ase.Atoms], constrained_atoms_list: Optional[List[List[int]]] = None, ): try: import torch_sim as ts except ImportError: raise ImportError(""TorchSim is not installed"") if constrained_atoms_list is not None: if len(atoms_list) != len(constrained_atoms_list): raise ValueError( ""Length of atoms_list and constrained_atoms_list must be the same"" ) for atoms, constrained_atoms in zip(atoms_list, constrained_atoms_list): if len(constrained_atoms) > 0: atoms.set_constraint(FixAtoms(constrained_atoms)) final_state = ts.optimize( system=atoms_list, model=self.model, optimizer=self.optimizer ) positions = final_state.positions.detach().numpy().astype(np.float64) positions = positions.reshape(len(atoms_list), -1, 3) energies = list( final_state.energy.detach().numpy().astype(np.float64) * EV_TO_KCAL ) return positions, energies def energy(self, atoms_list: List[ase.Atoms]) -> float: try: import torch_sim as ts except ImportError: raise ImportError(""TorchSim is not installed"") state = ts.io.atoms_to_state(atoms_list, device=self.device, dtype=self.dtype) result = self.model(state) energies = list( result[""energy""].detach().numpy().astype(np.float64) * EV_TO_KCAL ) return energies ","Python" "Conformation","ncasetti7/multiple_minimum_monte_carlo","multiple_minimum_monte_carlo/calculation.py",".py","2512","85","""""""Module for running geometry optimizations"""""" import os import contextlib from typing import Optional, List, Tuple import numpy as np import ase import ase.calculators.calculator from ase.optimize import BFGS import ase.optimize.optimize from ase.constraints import FixAtoms EV_TO_KCAL = 23.0605 class Calculation: def __init__(self): pass def run( self, atoms: ase.Atoms, constrained_atoms: Optional[List[int]] = None ) -> Tuple[np.ndarray, float]: pass def energy(self, atoms: ase.Atoms) -> float: pass class ASEOptimization(Calculation): def __init__( self, calc: ase.calculators.calculator.Calculator, optimizer: Optional[ase.optimize.optimize.Optimizer] = BFGS, fmax: Optional[float] = 0.01, max_cycles: Optional[int] = 1000, verbose: Optional[bool] = False, ) -> None: self.calc = calc self.optimizer = optimizer self.fmax = fmax self.max_cycles = max_cycles self.verbose = verbose def run( self, atoms: ase.Atoms, constrained_atoms: Optional[List[int]] = None ) -> Tuple[ase.Atoms, float]: """""" Perform constrained optimization using ASE. Args: atoms (ase.Atoms): Molecule to optimize. constrained_atoms: Atomic indices to constrain Returns: atoms (ase.Atoms): Optimized ASE atoms object. energy (float): Energy of the optimized atoms object. """""" atoms.calc = self.calc if constrained_atoms is not None and len(constrained_atoms) > 0: atoms.set_constraint(FixAtoms(constrained_atoms)) # Perform optimization if self.verbose: opt = self.optimizer(atoms) opt.run(fmax=self.fmax, steps=self.max_cycles) else: with open( os.devnull, ""w"", encoding=""utf-8"" ) as f, contextlib.redirect_stdout(f): opt = self.optimizer(atoms) opt.run(fmax=self.fmax, steps=self.max_cycles) return atoms.get_positions(), atoms.get_potential_energy() * EV_TO_KCAL def energy(self, atoms: ase.Atoms) -> float: """""" Return the energy of the input atoms object Args: atoms (ase.Atoms): Input atoms object Returns: energy (float): Energy of the atoms object """""" atoms.calc = self.calc return atoms.get_potential_energy() * EV_TO_KCAL ","Python" "Conformation","ncasetti7/multiple_minimum_monte_carlo","tests/test_calculation.py",".py","1474","53","from multiple_minimum_monte_carlo.calculation import ASEOptimization import numpy as np EV_TO_KCAL = 23.0605 class DummyCalc: def __init__(self, energy=1.23): self._energy = energy def get_potential_energy(self, atoms=None): return self._energy class DummyAtoms: def __init__(self): self.calc = None def set_constraint(self, constraints): self._constraints = constraints def get_potential_energy(self): return self.calc.get_potential_energy(self) def get_positions(self): # return a dummy positions array compatible with ASE return np.zeros((1, 3)) def test_energy_returns_calculator_energy(): atoms = DummyAtoms() calc = DummyCalc(4.56) ao = ASEOptimization(calc=calc) atoms.calc = calc assert ao.energy(atoms) == 4.56 * EV_TO_KCAL def test_run_applies_constraints_and_returns_tuple(): atoms = DummyAtoms() calc = DummyCalc(7.89) # Provide a dummy optimizer that accepts atoms and has run() class DummyOpt: def __init__(self, atoms): self.atoms = atoms def run(self, fmax=None, steps=None): return None ao = ASEOptimization(calc=calc, optimizer=DummyOpt) atoms.calc = calc out_positions, energy = ao.run(atoms, constrained_atoms=[1, 2, 3]) # run now returns positions array and energy scaled by EV_TO_KCAL assert hasattr(out_positions, ""shape"") assert energy == 7.89 * EV_TO_KCAL ","Python" "Conformation","ncasetti7/multiple_minimum_monte_carlo","tests/test_conformer.py",".py","1726","54","import pytest # skip module if rdkit not available pytest.importorskip(""rdkit"") from rdkit import Chem from multiple_minimum_monte_carlo.conformer import Conformer def test_conformer_creates_mol_for_unmapped(monkeypatch): # ensure Chem.MolFromSmiles is called when not mapped called = {} real_mf = Chem.MolFromSmiles def fake_mol_from_smiles(smi): called['smi'] = smi return real_mf(""CC"") monkeypatch.setattr(Chem, ""MolFromSmiles"", fake_mol_from_smiles) # avoid heavy conformer generation in initializer by providing a minimal atoms object def fake_generate(self): class MinimalAtoms: def __init__(self): self.info = {} def get_positions(self): return [] self.atoms = MinimalAtoms() monkeypatch.setattr(Conformer, ""generate_conformer"", fake_generate) c = Conformer(""CC"", mapped=False) assert c.smiles == ""CC"" def test_conformer_uses_make_mol_when_mapped(monkeypatch): from multiple_minimum_monte_carlo import cheminformatics called = {} def fake_make_mol(smi): called['smi'] = smi return Chem.MolFromSmiles(""CC"") monkeypatch.setattr(cheminformatics, ""make_mol"", fake_make_mol) # avoid heavy conformer generation by providing minimal atoms def fake_generate(self): class MinimalAtoms: def __init__(self): self.info = {} def get_positions(self): return [] self.atoms = MinimalAtoms() monkeypatch.setattr(Conformer, ""generate_conformer"", fake_generate) c = Conformer(""[CH3:1][CH3:2]"", mapped=True) assert hasattr(c, ""mol"") assert called['smi'].startswith(""[CH3"") ","Python" "Conformation","ncasetti7/multiple_minimum_monte_carlo","tests/test_cheminformatics.py",".py","2352","67","import pytest import numpy as np # skip entire module if rdkit missing pytest.importorskip(""rdkit"") from rdkit import Chem from multiple_minimum_monte_carlo import cheminformatics def test_make_mol_basic(): smi = ""CCO"" mol = cheminformatics.make_mol(smi) assert mol.GetNumAtoms() == Chem.MolFromSmiles(smi).GetNumAtoms() def test_get_bonds_and_metal_atoms(): # create a molecule with atom mapping so get_bonds uses atom map nums smi = ""[CH3:1][CH3:2]"" mol = cheminformatics.make_mol(smi) bonds = cheminformatics.get_bonds(mol) assert isinstance(bonds, set) # metal detection on a simple metal mol metal_mol = Chem.MolFromSmiles(""[Fe]"") metals = cheminformatics.get_metal_atoms(metal_mol) assert all(isinstance(i, int) for i in metals) def test_rotate_dihedrals_runs_without_error(): # Use a simple molecule with a rotatable bond (but we only ensure no exception) mol = Chem.AddHs(Chem.MolFromSmiles(""CCCC"")) Chem.AllChem.EmbedMolecule(mol) conf = mol.GetConformer() # pick an example dihedral (0,1,2,3) which exists for a 4-carbon chain cheminformatics.rotate_dihedrals(conf, [(0, 1, 2, 3)], 30.0) # position changed for at least one atom (float values) pos = conf.GetPositions() assert isinstance(pos, np.ndarray) or hasattr(pos, ""__len__"") def test_mol_to_ase_and_add_coords(): mol = Chem.AddHs(Chem.MolFromSmiles(""CC"")) Chem.AllChem.EmbedMolecule(mol) atoms = cheminformatics.mol_to_ase_atoms(mol) assert hasattr(atoms, ""get_positions"") # test add_coords_to_mol with explicit numpy array coords = atoms.get_positions() newmol = cheminformatics.add_coords_to_mol(coords, mol) assert newmol is mol def test_identity_checks(tmp_path): # Build a small molecule and ASE Atoms via mol_to_ase_atoms mol = cheminformatics.make_mol(""CCO"") Chem.AllChem.EmbedMolecule(mol) atoms = cheminformatics.mol_to_ase_atoms(mol) original_bonds, metal_atoms, halides = cheminformatics.initialize_mc_identity_check(atoms, mol) # returned types assert isinstance(original_bonds, list) assert isinstance(metal_atoms, list) assert isinstance(halides, list) # check_identity_mc on same atoms should be True assert cheminformatics.check_identity_mc(original_bonds, metal_atoms, halides, atoms) is True ","Python" "Conformation","ncasetti7/multiple_minimum_monte_carlo","tests/test_batch_calculation.py",".py","4670","146","import sys import types import numpy as np import pytest pytest.importorskip(""torch"") import torch from ase import Atoms from multiple_minimum_monte_carlo.batch_calculation import TorchSimCalculation def _make_fake_torch_sim(monkeypatch, *, optimize_ret=None, energy_ret=None): """"""Install a fake torch_sim package into sys.modules with the pieces used by the code."""""" ts = types.ModuleType(""torch_sim"") # submodules models = types.ModuleType(""torch_sim.models"") interface = types.ModuleType(""torch_sim.models.interface"") optim_mod = types.ModuleType(""torch_sim.optimizers"") # Define ModelInterface and Optimizer base classes class ModelInterface: pass class Optimizer: pass interface.ModelInterface = ModelInterface optim_mod.Optimizer = Optimizer # Top-level ts.optimize function def optimize(system, model, optimizer): # Return a simple object with positions and energy tensors if optimize_ret is not None: return optimize_ret n = len(system) # assume each atoms object has 1 atom for simplicity positions = torch.zeros((n, 1, 3), dtype=torch.float32) energy = torch.tensor([1.0] * n, dtype=torch.float32) obj = types.SimpleNamespace(positions=positions, energy=energy) return obj ts.optimize = optimize # io submodule io = types.ModuleType(""torch_sim.io"") def atoms_to_state(atoms_list, device=""cpu"", dtype=torch.float32): # return a dummy state object accepted by model return {""atoms"": atoms_list} io.atoms_to_state = atoms_to_state # pack modules into sys.modules # attach submodules as attributes and pack modules into sys.modules ts.models = models ts.models.interface = interface ts.optimizers = optim_mod ts.io = io sys.modules[""torch_sim""] = ts sys.modules[""torch_sim.models""] = models sys.modules[""torch_sim.models.interface""] = interface sys.modules[""torch_sim.optimizers""] = optim_mod sys.modules[""torch_sim.io""] = io return ModelInterface, Optimizer def test_init_raises_if_torchsim_missing(monkeypatch): # Ensure torch_sim is not present # Remove any existing torch_sim entries from sys.modules for k in list(sys.modules.keys()): if k.startswith(""torch_sim""): monkeypatch.delitem(sys.modules, k, raising=False) # Importing class is fine, but instantiation should raise ImportError with pytest.raises(ImportError): TorchSimCalculation(model=None, optimizer=None) def test_init_type_check(monkeypatch): ModelInterface, Optimizer = _make_fake_torch_sim(monkeypatch) # Pass objects that are not instances of the expected types with pytest.raises(TypeError): TorchSimCalculation(model=object(), optimizer=object()) def test_run_returns_positions_and_energies(monkeypatch): ModelInterface, Optimizer = _make_fake_torch_sim(monkeypatch) # create dummy model/optimizer instances of the required types class MyModel(ModelInterface): def __call__(self, state): return {""energy"": torch.tensor([2.0])} my_model = MyModel() class MyOpt(Optimizer): pass my_opt = MyOpt() # instantiate calculation calc = TorchSimCalculation(model=my_model, optimizer=my_opt) # create two tiny ASE Atoms (1 atom each) atoms_list = [Atoms(""H""), Atoms(""H"")] # matching constrained list positions, energies = calc.run(atoms_list, constrained_atoms_list=[[], []]) assert isinstance(positions, np.ndarray) assert isinstance(energies, list) assert positions.shape[0] == len(atoms_list) assert len(energies) == len(atoms_list) def test_run_mismatched_constrained_list_raises(monkeypatch): ModelInterface, Optimizer = _make_fake_torch_sim(monkeypatch) class MyModel(ModelInterface): pass class MyOpt(Optimizer): pass calc = TorchSimCalculation(model=MyModel(), optimizer=MyOpt()) atoms_list = [Atoms(""H"")] with pytest.raises(ValueError): calc.run(atoms_list, constrained_atoms_list=[[], []]) def test_energy_returns_list(monkeypatch): ModelInterface, Optimizer = _make_fake_torch_sim(monkeypatch) class MyModel(ModelInterface): def __call__(self, state): return {""energy"": torch.tensor([3.0, 4.0])} my_model = MyModel() class MyOpt(Optimizer): pass calc = TorchSimCalculation(model=my_model, optimizer=MyOpt()) atoms_list = [Atoms(""H""), Atoms(""H"")] energies = calc.energy(atoms_list) assert isinstance(energies, list) assert len(energies) == len(atoms_list) ","Python" "Conformation","ncasetti7/multiple_minimum_monte_carlo","tests/test_conformer_ensemble.py",".py","1982","59","import pytest pytest.importorskip(""rdkit"") from rdkit import Chem from multiple_minimum_monte_carlo.conformer_ensemble import ConformerEnsemble, run_class_func from multiple_minimum_monte_carlo.conformer import Conformer def test_run_class_func_calls_method(): class C: def add(self, x, y): return x + y assert run_class_func(C(), ""add"", {""x"": 1, ""y"": 2}) == 3 def make_dummy_conformer(monkeypatch): # Create a minimal Conformer-like object # prevent heavy generation def fake_generate(self): class MinimalAtoms: def __init__(self): self.info = {} def get_positions(self): return [] self.atoms = MinimalAtoms() try: # if a pytest monkeypatch fixture is provided monkeypatch.setattr(Conformer, ""generate_conformer"", fake_generate) except Exception: # otherwise, monkeypatch by direct assignment Conformer.generate_conformer = fake_generate c = Conformer(""CC"") c.atoms = None c.mol = Chem.AddHs(Chem.MolFromSmiles(""CC"")) c.constrained_atoms = [] c.bonded_atoms = [] return c def test_sample_conformer_minimum(): c = make_dummy_conformer(None) ensemble = ConformerEnsemble(c, calc=None, num_iterations=1, parallel=False) # when used is [0,0,0], argmin is 0 assert ensemble.sample_conformer([1, 2, 3]) == 0 or isinstance(ensemble.sample_conformer([1,2,3]), int) def test_constraint_test_detects_close_atoms(monkeypatch): c = make_dummy_conformer(monkeypatch) # create a fake conformer with positions that are extremely close mol = c.mol Chem.AllChem.EmbedMolecule(mol) conf = mol.GetConformer() # set all positions to zero to force failure for i in range(mol.GetNumAtoms()): conf.SetAtomPosition(i, (0.0, 0.0, 0.0)) ensemble = ConformerEnsemble(c, calc=None, num_iterations=1, parallel=False) assert ensemble.constraint_test(conf) is False ","Python" "Conformation","ncasetti7/multiple_minimum_monte_carlo","tests/test_multiproc.py",".py","760","23","from multiple_minimum_monte_carlo import multiproc def test_batch_dicts_even_split(): dicts = [{'a': i} for i in range(6)] batched = multiproc.batch_dicts(dicts.copy(), 3) # Expect roughly even distribution lengths = [len(b) for b in batched] assert sum(lengths) == 6 def test_parallel_run_proc_single_worker(tmp_path): # Define a simple function that will be called def func(x, y): return x + y # Wrap the callable to match expected call signature in multiproc.run_func def wrapper(**kwargs): return func(**kwargs['args']) if 'args' in kwargs else func(kwargs['x'], kwargs['y']) results = multiproc.parallel_run_proc(wrapper, [{'args': {'x': 3, 'y': 4}}], num_workers=1) assert results == [7] ","Python" "Conformation","ncasetti7/multiple_minimum_monte_carlo","tests/conftest.py",".py","222","8","import os import sys # Ensure the repository root is on sys.path so tests can import the package ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "".."")) if ROOT not in sys.path: sys.path.insert(0, ROOT) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","setup.py",".py","7292","213","""""""MSMBuilder: a python library for Markov state models of conformational dynamics MSMBuilder (https://simtk.org/home/msmbuilder) is a library that provides tools for analyzing molecular dynamics simulations, particularly through the construction of Markov state models for conformational dynamics. """""" from __future__ import print_function from __future__ import division from __future__ import absolute_import DOCLINES = __doc__.split(""\n"") import os import sys import tempfile import shutil import subprocess from glob import glob from distutils.version import LooseVersion from distutils.command.build_scripts import build_scripts from setuptools import setup PY3 = sys.version_info >= (3,0) ######################################### VERSION = ""2.8.3"" ISRELEASED = False __author__ = ""MSMBuilder Team"" __version__ = VERSION ######################################## def warn_on_version(module_name, minimum=None, package_name=None, recommend_conda=True): if package_name is None: package_name = module_name class VersionError(Exception): pass msg = None try: package = __import__(module_name) if minimum is not None: try: v = package.version.short_version except AttributeError: v = package.__version__ if LooseVersion(v) < LooseVersion(minimum): raise VersionError except ImportError: if minimum is None: msg = 'MSMBuilder requires the python package ""%s"", which is not installed.' % package_name else: msg = 'MSMBuilder requires the python package ""%s"", version %s or later.' % (package_name, minimum) except VersionError: msg = ('MSMBuilder requires the python package ""%s"", version %s or ' ' later. You have version %s installed. You will need to upgrade.') % (package_name, minimum, v) if recommend_conda: install = ('\nTo install %s, we recommend the conda package manger. See http://conda.pydata.org for info on conda.\n' 'Using conda, you can install it with::\n\n $ conda install %s') % (package_name, package_name) install += '\n\nAlternatively, with pip you can install the package with:\n\n $ pip install %s' % package_name else: install = '\nWith pip you can install the package with:\n\n $ pip install %s' % package_name if msg: banner = ('==' * 40) print('\n'.join([banner, banner, """", msg, install, """", banner, banner])) class mybuildscript(build_scripts): TEMPLATE = ''' from __future__ import print_function import sys print('The MSMBuilder script {basename}.py has been\\nrenamed {basename}.', file=sys.stderr, end=' ') print('You can access it with:\\n\\n $ {basename}\\n\\nor\\n\\n $ msmb {basename}\\n', file=sys.stderr) ''' def copy_scripts(self): exclude = ['msmb'] try: tdir = tempfile.mkdtemp() self.scripts = [] for fn in find_console_scripts(): basename = fn.split(':')[0].split('.')[-1] if basename not in exclude: path = '{}/{}.py'.format(tdir, basename) with open(path, 'w') as f: f.write(self.TEMPLATE.format(basename=basename)) self.scripts.append(path) if PY3: super().copy_scripts() else: build_scripts.copy_scripts(self) finally: shutil.rmtree(tdir) def find_console_scripts(): console_scripts = [] exclude = ['__init__.py'] for fn in glob('scripts/*.py'): dirname, filename = os.path.split(fn) if filename not in exclude: basename, _ = os.path.splitext(filename) console_scripts.append( '{basename} = msmbuilder.scripts.{basename}:entry_point'.format(basename=basename)) return console_scripts # metadata for setup() metadata = { 'name': 'msmbuilder', 'version': VERSION, 'author': __author__, 'author_email': 'msmbuilder-user@stanford.edu', 'license': 'GPL v3.0', 'url': 'https://simtk.org/home/msmbuilder', 'download_url': 'https://simtk.org/home/msmbuilder', 'platforms': [""Linux"", ""Mac OS X""], 'description': DOCLINES[0], 'long_description':""\n"".join(DOCLINES[2:]), 'packages': ['msmbuilder', 'msmbuilder.scripts', 'msmbuilder.project', 'msmbuilder.lumping', 'msmbuilder.metrics', 'msmbuilder.reduce', 'msmbuilder.reference'], 'package_dir': {'msmbuilder': 'MSMBuilder', 'msmbuilder.scripts': 'scripts', 'msmbuilder.reference': 'reference'}, 'package_data': {'msmbuilder.reference': [os.path.relpath(os.path.join(a[0], b), 'reference') for a in os.walk('reference') for b in a[2]]}, 'zip_safe': False, 'entry_points': {'console_scripts': find_console_scripts()}, # CUSTOM HACK TO DYNAMICALLY CREATE STUB SCRIPTS TO DIRECT PEOPLE TO THE NEW ENTRY POINTS # (`Cluster.py` vs. `Cluster`) 'cmdclass': {'build_scripts': mybuildscript}, 'scripts': [''], } # Return the git revision as a string # copied from numpy setup.py def git_version(): def _minimal_ext_cmd(cmd): # construct minimal environment env = {} for k in ['SYSTEMROOT', 'PATH']: v = os.environ.get(k) if v is not None: env[k] = v # LANGUAGE is used on win32 env['LANGUAGE'] = 'C' env['LANG'] = 'C' env['LC_ALL'] = 'C' out = subprocess.Popen(cmd, stdout = subprocess.PIPE, env=env).communicate()[0] return out try: out = _minimal_ext_cmd(['git', 'rev-parse', 'HEAD']) GIT_REVISION = out.strip().decode('ascii') except OSError: GIT_REVISION = ""Unknown"" return GIT_REVISION def write_version_py(filename='MSMBuilder/version.py'): cnt = """""" # THIS FILE IS GENERATED FROM MSMBUILDER SETUP.PY short_version = '%(version)s' version = '%(version)s' full_version = '%(full_version)s' git_revision = '%(git_revision)s' release = %(isrelease)s if not release: version = full_version """""" # Adding the git rev number needs to be done inside write_version_py(), # otherwise the import of numpy.version messes up the build under Python 3. FULLVERSION = VERSION if os.path.exists('.git'): GIT_REVISION = git_version() else: GIT_REVISION = ""Unknown"" if not ISRELEASED: FULLVERSION += '.dev-' + GIT_REVISION[:7] a = open(filename, 'w') try: a.write(cnt % {'version': VERSION, 'full_version' : FULLVERSION, 'git_revision' : GIT_REVISION, 'isrelease': str(ISRELEASED)}) finally: a.close() write_version_py() setup(**metadata) # running these after setup() ensures that they show # at the bottom of the output, since setup() prints # a lot to stdout. helps them not get lost warn_on_version('numpy', '1.6.0') warn_on_version('scipy', '0.11.0') warn_on_version('tables', '2.4.0', package_name='pytables') warn_on_version('fastcluster', '1.1.13') warn_on_version('yaml', package_name='pyyaml') warn_on_version('mdtraj', '0.8.0') ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Tutorial/PlotDihedrals.py",".py","2998","88","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """"""Creates Ramachandran plot from raw dipeptide data and macroscopic MSM."""""" import sys import os import argparse import operator import numpy as np import matplotlib.pyplot as pp from mdtraj.utils.six.moves import reduce import mdtraj as md from mdtraj import io from msmbuilder import Project from mdtraj.utils.six.moves import reduce PSI_INDICES = [6, 8, 14, 16] PHI_INDICES = [4, 6, 8, 14] def main(): parser = argparse.ArgumentParser() parser.add_argument('assignments', default='Macro4/MacroAssignments.h5', help='Path to an assignments file. (default=Macro4/MacroAssignments.h5)') parser.add_argument('--project', default='ProjectInfo.yaml', help='Path to ProjectInfo.yaml file. (default=ProjectInfo.yaml)') args = parser.parse_args() project = Project.load_from(args.project) t = reduce(operator.add, (project.load_traj(i) for i in range(project.n_trajs))) phi_angles = md.compute_dihedrals(t, [PHI_INDICES]) * 180.0 / np.pi psi_angles = md.compute_dihedrals(t, [PSI_INDICES]) * 180.0 / np.pi state_index = np.hstack(io.loadh(args.assignments)['arr_0']) for i in np.unique(state_index): pp.plot(phi_angles[np.where(state_index == i)], psi_angles[np.where(state_index == i)], 'x', label='State %d' % i) pp.title(""Alanine Dipeptide Macrostates"") pp.xlabel(r""$\phi$"") pp.ylabel(r""$\psi$"") annotate() pp.legend(loc=1, labelspacing=0.075, prop={'size': 8.0}, scatterpoints=1, markerscale=0.5, numpoints=1) pp.xlim([-180, 180]) pp.ylim([-180, 180]) pp.show() def annotate(): pp.plot([-180,0],[50,50],'k') pp.plot([-180,0],[-100,-100],'k') pp.plot([0,180], [100,100],'k') pp.plot([0,180], [-50,-50],'k') pp.plot([0,0],[-180,180],'k') pp.plot([-100,-100],[50,180],'k') pp.plot([-100,-100],[-180,-100],'k') pp.annotate(""PPII"",[-30,150],fontsize='x-large') pp.annotate(r""$\beta$"",[-130,150],fontsize='x-large') pp.annotate(r""$\alpha$"",[-100,0],fontsize='x-large') pp.annotate(r""$\alpha_L$"",[100,30],fontsize='x-large') pp.annotate(r""$\gamma$"",[100,-150],fontsize='x-large') if __name__ == '__main__': main() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tools/sphinxbib.py",".py","1780","55","from __future__ import print_function import os import argparse from bibpy import bib def format_author(authors): items = [] for author in authors: if 'given' not in author: author_split = author['family'].split() family = author_split[-1] given_split = author_split[:-1] else: given_split = author['given'].split(' ') family = author['family'] given_initials = given_split[0][0] + '.' if len(given_split) > 1: given_initials += ' ' + (' '.join(given_split[1:])) items.append('%s, %s' % (family, given_initials)) return '; '.join(items) def main(): parser = argparse.ArgumentParser() parser.add_argument('bibtex') parser.add_argument('-v', '--verbose', action='store_true') args = parser.parse_args() with open(args.bibtex) as f: lines = os.linesep.join(l.strip() for l in f) bibobject = bib.Bibparser(lines, verbose=args.verbose) bibobject.parse() entries = sorted(bibobject.records.values(), key=lambda e: e['issued']['literal']) print('Publications') print('============\n') try: for entry in entries: url = entry['URL'] if 'URL' in entry else entry['url'] print('`%s <%s>`_' % (entry['title'], url)) print('~'*80) print() print(format_author(entry['author']), '*%s* **%s**, %s %s' % (entry['journal'], entry['issued']['literal'], entry['volume'], entry['page'])) print() print(' ', entry['abstract']) print() except KeyError as e: raise KeyError('Entry failure during processeing of %s' % entry) if __name__ == '__main__': main() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tools/ci/after_sucess.sh",".sh","677","23","export PATH=$HOME/miniconda/bin:$PATH export PATH=$HOME/miniconda/envs/$python/bin:$PATH if [[ ""$TRAVIS_PULL_REQUEST"" == ""true"" ]]; then echo ""This is a pull request. No deployment will be done.""; exit 0 fi PYVERSION=$(python -c ""import sys; print(sys.version_info[:2])"") if [[ ""$PYVERSION"" != ""(2, 7)"" ]]; then echo ""No deploy on PYVERSION=${PYVERSION}""; exit 0 fi if [[ ""$TRAVIS_BRANCH"" != ""master"" ]]; then echo ""No deployment on BRANCH='$TRAVIS_BRANCH'""; exit 0 fi # Create the docs and push them to S3 # sudo conda install --yes boto pip install -q sphinx boto sphinx_rtd_theme bibpy cd docs/sphinx && make html && cd - python tools/ci/push-docs-to-s3.py ","Shell" "Conformation","msmbuilder/msmbuilder-legacy","tools/ci/push-docs-to-s3.py",".py","826","24","import os import boto from boto.s3.key import Key # The secret key is available as a secure environment variable # on travis-ci to push the build documentation to Amazon S3. AWS_ACCESS_KEY_ID = os.environ['AWS_ACCESS_KEY_ID'] AWS_SECRET_ACCESS_KEY = os.environ['AWS_SECRET_ACCESS_KEY'] BUCKET_NAME = 'msmbuilder.org' bucket_name = AWS_ACCESS_KEY_ID.lower() + '-' + BUCKET_NAME conn = boto.connect_s3(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) bucket = conn.create_bucket(BUCKET_NAME) root = 'docs/sphinx/_build/html' for dirpath, dirnames, filenames in os.walk(root): for filename in filenames: fn = os.path.join(dirpath, filename) print 'Uploading', fn, '...' k = Key(bucket) k.key = os.path.join('legacy', os.path.relpath(fn, root)) k.set_contents_from_filename(fn) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/plot_graph.py",".py","4369","120","# This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """"""Code for visualizing networks (e.g. transition, count, or flux matrices). """""" from __future__ import print_function, division, absolute_import import scipy.sparse import numpy as np import networkx import sys import re import logging logger = logging.getLogger(__name__) def CreateNetwork(Matrix, EqPops, Directed=True, EdgeScale=2, PopCutoff=0.01, EdgeCutoff=0.1, ImageList=None, Labels=None): """"""Creates a NetworkX graph (or DiGraph) object. Inputs: Matrix -- a sparse matrix. EqPops -- state equilibrium populations. Keyword Arguments: Directed -- Is the graph directed? Default: True EdgeScale -- a scale factor for edges. Default: 2 PopCutoff -- hide states with populations lower than this. Default: 0.01 EdgeCutoff -- hide edges with weights lower than this. Default: 0.1 ImageList -- A list of filenames for visualization on each states. Default: None Labels -- A List of labels for display on each state. Default: None Notes: The NetworkX graph can be used for simple visualization (e.g. matplotlib) or export to a GraphViz dotfile. You can optionally add image paths to the graph, which will be recorded in the dotfile for eventual visualization. """""" Matrix=Matrix.tocsr() print(""Loaded an MSM with %d states..."" % Matrix.shape[0]) #These are the desired states. Ind=np.where(EqPops>PopCutoff)[0] if len(Ind) == 0: raise ValueError(""Error! No nodes will be rendered. Try lowering the population cutoff (epsilon)."") # if user specified labels use those, otherwise use Ind if Labels == None: Labels = Ind #Select the desired subset of Matrix Matrix=Matrix[Ind][:,Ind] EqEnergy=-np.log(EqPops[Ind]) # invert thigns so less populated states are smaller than more populated ones maxEqEnergy = EqEnergy.max() EqEnergy = 1 + maxEqEnergy - EqEnergy # add 1 to ensure nothing gets 0 weight # Renormalize stuff to make it more reasonable frm, to, weight = scipy.sparse.find( Matrix ) weight /= weight.max() weight *= EdgeScale n=Matrix.shape[0] if Directed: G=networkx.from_scipy_sparse_matrix(Matrix,create_using=networkx.DiGraph()) else: G=networkx.from_scipy_sparse_matrix(Matrix) logger.info(""Rendering %d nodes..."", n) # Write attributes to G for i in range(n): G.node[i][""width""]=EqEnergy[i]/3 G.node[i][""height""]=EqEnergy[i]/3 G.node[i][""fixedsize""] = True G.node[i][""label""]=Labels[i] for i in range(len(weight)): G[frm[i]][to[i]][""penwidth""]=weight[i]*2 G[frm[i]][to[i]][""arrowsize""]=weight[i]*2 #Save image paths if desired. if ImageList!=None: logger.info(""Found %d images - attempting to include them in the .dot file"", len(ImageList)) ImageList=np.array(ImageList) for Image in ImageList: match = re.findall( '(\d+)', Image ) if len(match) > 0: state = int( match[0] ) if state in Ind: Gind = int(np.where( Ind == state)[0]) G.node[Gind][""image""]=Image logger.info(""Found an image for state: %d"", state) return(G) def PlotNetwork(G,OutputFile=""Graph.dot""): """"""Plot a graph to screen and also save output."""""" try: networkx.draw_graphviz(G) except: logger.error(""could not plot graph to screen. Check X / Matplotlib settings."") networkx.write_dot(G, OutputFile) logger.info(""Wrote: %s"", OutputFile) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/msm_analysis.py",".py","29438","860","# This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA from __future__ import print_function, absolute_import, division from mdtraj.utils.six.moves import xrange import sys import scipy.sparse import scipy.linalg import scipy.sparse.linalg import scipy import numpy as np import multiprocessing import warnings from mdtraj import io from msmbuilder.utils import uneven_zip import logging logger = logging.getLogger(__name__) # Set this value to true (msm_analysis.DisableErrorChecking=True) to ignore # Eigenvector calculation errors. Useful if you need to process disconnected data. DisableErrorChecking = False def get_reversible_eigenvectors(t_matrix, k, populations=None, right=False, dense_cutoff=50, normalized=False, **kwargs): r""""""Find the k largest left eigenvalues and eigenvectors of a reversible row-stochastic matrix, sorted by eigenvalue magnitude Parameters ---------- t_matrix : sparse or dense matrix The row-stochastic transition probability matrix k : int The number of eigenpairs to calculate. The `k` eigenpairs with the highest eigenvalues will be returned. populations : np.ndarray, optional The equilibrium, stationary distribution of t_matrix. If not supplied, it can be re-computed from `t_matrix`. But this substantially increases the runtime of the routine, so if the stationary distribution is known, it's more efficient to supply it. right : bool, optional The default behavior is to compute the *left* eigenvectors of the transition matrix. This option may be invoked to instead compute the *right* eigenvectors. dense_cutoff : int, optional use dense eigensolver if dimensionality is below this normalized : bool, optional normalize the vectors such that .. math:: \phi_i^T \psi_j = \delta_{ij} where :math:`\phi_i` is the :math:`i^{th}` left eigenvector, and :math:`\psi_j` is the :math:`j^{th}` right eigenvector Other Parameters ---------------- **kwargs Additional keyword arguments are passed directly to ``scipy.sparse.linalg.eigsh``. Refer to the scipy documentation for further details. Returns ------- eigenvalues : ndarray 1D array of eigenvalues eigenvectors : ndarray 2D array of eigenvectors Notes ----- - A reversible transition matrix is one that satisifies the detailed balance condition .. math:: \pi_i T_{i,j} = \pi_j T_{j,i} - A reversible transition matrix satisifies a number of special conditions. In particular, it is similar to a symmetric matrix :math:`S_{i, j} = \sqrt{\frac{pi_i}{\pi_j}} T_{i, j} = S_{j, i}`. This property enables a much more robust solution to the eigenvector problem, because of the superior numerical stability of hermetian eigensolvers. See Also -------- get_eigenvectors : computes the eigenpairs of a general row-stochastic matrix, without requiring that the matrix be reversible. scipy.sparse.linalg.eigsh """""" check_dimensions(t_matrix) n = t_matrix.shape[0] if k > n: logger.warning(""You cannot calculate %d eigenvectors from a %d x %d matrix."" % (k, n, n)) k = n logger.warning(""Instead, calculating %d eigenvectors."" % k) if n < dense_cutoff and scipy.sparse.issparse(t_matrix): t_matrix = t_matrix.toarray() elif k >= n - 1 and scipy.sparse.issparse(t_matrix): logger.warning(""ARPACK cannot calculate %d eigenvectors from a %d x %d matrix."" % (k, n, n)) k = n - 2 logger.warning(""Instead, calculating %d eigenvectors."" % k) if populations is None: populations = get_eigenvectors(t_matrix, 1, **kwargs)[1][:, 0] # This should work for BOTH dense and sparse. # Get the left eigenvectors using the sparse hermetian eigensolver # on the symmetrized transition matrix root_pi = populations**(0.5) root_pi_diag = scipy.sparse.diags(root_pi, offsets=0).tocsr() root_pi_diag_inv = scipy.sparse.diags(1.0 / root_pi, offsets=0).tocsr() symtrans = root_pi_diag.dot(scipy.sparse.csr_matrix(t_matrix)).dot(root_pi_diag_inv) # Force temporary conversion to sparse if scipy.sparse.issparse(t_matrix): values, vectors = scipy.sparse.linalg.eigsh(symtrans.T, k=k, which='LA', **kwargs) else: values, vectors = np.linalg.eigh(symtrans.toarray().T) # Reorder the eigenpairs by descending eigenvalue order = np.argsort(-np.real(values)) values = values[order] vectors = vectors[:, order] # the eigenvectors of symtrans are a rotated version of the eigenvectors # of transmat that we want left_vectors = (root_pi * vectors.T).T # normalize the first eigenvector (populations) left_vectors[:, 0] /= np.sum(left_vectors[:, 0]) # normalize the left eigenvectors if normalized: lengths = np.sum(left_vectors * left_vectors / left_vectors[:, 0:1], axis=0, keepdims=True) left_vectors = left_vectors / np.sqrt(lengths) if right: right_vectors = left_vectors / left_vectors[:, 0:1] return np.real(values[0:k]), np.real(right_vectors[:, 0:k]) else: return np.real(values[0:k]), np.real(left_vectors[:, 0:k]) def get_eigenvectors(t_matrix, n_eigs, epsilon=.001, dense_cutoff=50, right=False, tol=1E-30, normalized=False): """"""Get the left eigenvectors of a transition matrix, sorted by eigenvalue magnitude Parameters ---------- t_matrix : sparse or dense matrix transition matrix. if `T` is sparse, the sparse eigensolver will be used n_eigs : int How many eigenvalues to calculate epsilon : float, optional Throw error if `T` is not a stochastic matrix, with tolerance given by `Epsilon` dense_cutoff : int, optional use dense eigensolver if dimensionality is below this right : bool, optional if true, compute the right eigenvectors instead of the left tol : float, optional Convergence criterion for sparse eigenvalue solver. normalized : bool, optional normalize the vectors such that .. math:: \phi_i^T \psi_j = \delta_{ij} where :math:`\phi_i` is the :math`i^{th}` left eigenvector, and :math:`\psi_j` is the :math:`j^{th}` right eigenvector Returns ------- eigenvalues : ndarray 1D array of eigenvalues eigenvectors : ndarray 2D array of eigenvectors Notes ----- - Left eigenvectors satisfy the relation :math:`V \mathbf{T} = \lambda V` - Vectors are returned in columns of matrix. - Too large a value of tol may lead to unstable results. See GitHub issue #174. """""" check_transition(t_matrix, epsilon) check_dimensions(t_matrix) n = t_matrix.shape[0] if n_eigs > n: logger.warning(""You cannot calculate %d Eigenvectors from a %d x %d matrix."" % (n_eigs, n, n)) n_eigs = n logger.warning(""Instead, calculating %d Eigenvectors."" % n_eigs) if n < dense_cutoff and scipy.sparse.issparse(t_matrix): t_matrix = t_matrix.toarray() elif n_eigs >= n - 1 and scipy.sparse.issparse(t_matrix): logger.warning(""ARPACK cannot calculate %d Eigenvectors from a %d x %d matrix."" % (n_eigs, n, n)) n_eigs = n - 2 logger.warning(""Instead, calculating %d Eigenvectors."" % n_eigs) # get the left eigenvectors t_matrix = t_matrix.transpose() if scipy.sparse.issparse(t_matrix): values, vectors = scipy.sparse.linalg.eigs(t_matrix.tocsr(), n_eigs, which=""LR"", maxiter=100000,tol=tol) else: values, vectors = scipy.linalg.eig(t_matrix) order = np.argsort(-np.real(values)) e_lambda = values[order] left_vectors = vectors[:, order] check_for_bad_eigenvalues(e_lambda, cutoff_value=1 - epsilon) # this is bad IMO --TJL # normalize the first eigenvector (populations) left_vectors[:, 0] /= sum(left_vectors[:, 0]) if normalized: lengths = np.sum(left_vectors * left_vectors / left_vectors[:, 0:1], axis=0, keepdims=True) left_vectors = left_vectors / np.sqrt(lengths) if right: right_vectors = left_vectors / left_vectors[:, 0:1] e_vectors = right_vectors else: e_vectors = left_vectors e_lambda = np.real(e_lambda[0: n_eigs]) e_vectors = np.real(e_vectors[:, 0: n_eigs]) return e_lambda, e_vectors def get_implied_timescales(assignments_fn, lag_times, n_implied_times=100, sliding_window=True, trimming=True, symmetrize=None, n_procs=1): """"""Calculate implied timescales in parallel using multiprocessing library. Does not work in interactive mode. Parameters ---------- AssignmentsFn : str Path to Assignments.h5 file on disk LagTimes : list List of lag times to calculate the timescales at NumImpledTimes : int, optional Number of implied timescales to calculate at each lag time Slide : bool, optional Use sliding window Trim : bool, optional Use ergodic trimming Symmetrize : {'MLE', 'Transpose', None} Symmetrization method nProc : int number of processes to use in parallel (multiprocessing Returns ------- formatedLags : ndarray RTM 6/27 I'm not quite sure what the semantics of the output is. It's not trivial and undocummented. See Also -------- MSMLib.mle_reversible_count_matrix : (MLE symmetrization) MSMLib.build_msm get_eigenvectors """""" pool = multiprocessing.Pool(processes=n_procs) # subtle bug possibility; uneven_zip will let strings be iterable, whicj # we dont want inputs = uneven_zip([assignments_fn], lag_times, n_implied_times, sliding_window, trimming, [symmetrize]) result = pool.map_async(get_implied_timescales_helper, inputs) lags = result.get(999999) # reformat formatted_lags = [] for i, (lag_time_array, implied_timescale_array) in enumerate(lags): for j, lag_time in enumerate(lag_time_array): implied_timescale = implied_timescale_array[j] formatted_lags.append([lag_time, implied_timescale]) formatted_lags = np.array(formatted_lags) pool.close() return formatted_lags def get_implied_timescales_helper(args): """"""Helper function to compute implied timescales with multiprocessing Does not work in interactive mode Parameters ---------- assignments_fn : str Path to Assignments.h5 file on disk n_states : int Number of states lag_time : list List of lag times to calculate the timescales at n_implied_times : int, optional Number of implied timescales to calculate at each lag time sliding_window : bool, optional Use sliding window trimming : bool, optional Use ergodic trimming symmetrize : {'MLE', 'Transpose', None} Symmetrization method Returns ------- lagTimes : ndarray vector of lag times impTimes : ndarray vector of implied timescales See Also -------- MSMLib.build_msm get_eigenvectors """""" assignments_fn, lag_time, n_implied_times, sliding_window, trimming, symmetrize = args logger.info(""Calculating implied timescales at lagtime %d"" % lag_time) try: assignments = io.loadh(assignments_fn, 'arr_0') except KeyError: assignments = io.loadh(assignments_fn, 'Data') try: from msmbuilder import MSMLib counts = MSMLib.get_count_matrix_from_assignments(assignments, lag_time=lag_time, sliding_window=sliding_window) rev_counts, t_matrix, populations, mapping = MSMLib.build_msm(counts, symmetrize, trimming) except ValueError as e: logger.critical(e) sys.exit(1) n_eigenvectors = n_implied_times + 1 if symmetrize in ['MLE', 'Transpose']: e_values = get_reversible_eigenvectors(t_matrix, n_eigenvectors, populations=populations)[0] else: e_values = get_eigenvectors(t_matrix, n_eigenvectors, epsilon=1)[0] # Correct for possible change in n_eigenvectors from trimming n_eigenvectors = len(e_values) n_implied_times = n_eigenvectors - 1 # make sure to leave off equilibrium distribution lag_times = lag_time * np.ones((n_implied_times)) imp_times = -lag_times / np.log(e_values[1: n_eigenvectors]) return (lag_times, imp_times) def check_for_bad_eigenvalues(eigenvalues, decimal=5, cutoff_value=0.999999): """"""Ensure that all eigenvalues are less than or equal to one Having multiple eigenvalues of lambda>=1 suggests either non-ergodicity or numerical error. Parameters ---------- Eigenvalues : ndarray 1D array of eigenvalues to check decimal : deprecated (marked 6/27) this doesn't do anything CutoffValue: float, optional Tolerance used Notes ------ Checks that the first eigenvalue is within `CutoffValue` of 1, and that the second eigenvalue is not greater than `CutoffValue` """""" if abs(eigenvalues[0] - 1) > 1 - cutoff_value: warnings.warn((""WARNING: the largest eigenvalue is not 1, "" ""suggesting numerical error. Try using 64 or 128 bit precision."")) if eigenvalues[1] > cutoff_value: warnings.warn((""WARNING: the second largest eigenvalue (x) is close "" "" to 1, suggesting numerical error or nonergodicity. Try using 64 "" ""or 128 bit precision. Your data may also be disconnected, in "" ""which case you cannot simultaneously model both disconnected "" ""components. Try collecting more data or trimming the "" "" disconnected pieces."")) def project_observable_onto_transition_matrix(observable, tprob, num_modes=25): """""" Projects an observable vector onto a probability transition matrix's eigenmodes. The function first decomposes the matrix `tprob` into `num_modes` different eigenvectors, sorted by eigenvalue. Then, it returns the amplitude of the projection of the observable onto each of those eigenmodes. This projection gives an estimate of how strong an experimental signal will be see at each timescale - though the actual experimental response will also be modulated by the populations of states at play. Parameters ---------- observable : array_like, float a one-dimensional array of the values of a given observable for each state in the MSM tprob : matrix the transition probability matrix num_modes : int the number of eigenmodes to calculate (the top ones, sorted by mag.) Returns ------- timescales : array_like, float the timescales of each eigenmode, in units of the lagtime of `tprob` amplitudes : array_like, float the amplitudes of the projection of `observable` onto each mode Notes ----- The stationary mode is always discarded The eigenvalues/vectors are calculated from scratch, so this function may take a little while to run """""" if num_modes + 1 > tprob.shape[0]: logger.warning(""cannot get %d eigenmodes from a rank %d matrix"", num_modes + 1, tprob.shape[0]) logger.warning(""Getting as many modes as possible..."") num_modes = tprob.shape[0] - 1 eigenvalues, eigenvectors = get_eigenvectors(tprob, num_modes + 1, right=True) # discard the stationary eigenmode eigenvalues = np.real(eigenvalues[1:]) eigenvectors = np.real(eigenvectors[:, 1:]) timescales = - 1.0 / np.log(eigenvalues) amplitudes = np.zeros(num_modes) for mode in range(num_modes): amplitudes[mode] = np.dot(observable, eigenvectors[:, mode]) return timescales, amplitudes def sample(transition_matrix, state, steps, traj=None, force_dense=False): """"""Generate a random sequence of states by propogating a transition matrix. Parameters ---------- transition_matrix : sparse or dense matrix A transition matrix State : {int, None, ndarray} Starting state for trajectory. If State is an integer, it will be used as the initial state. If State is None, an initial state will be randomly chosen from an uniform distribution. If State is an array, it represents a probability distribution from which the initial state will be drawn. If a trajectory is specified (see Traj keyword), this variable will be ignored, and the last state of that trajectory will be used. Steps : int How many steps to generate. Traj : list, optional An existing trajectory (python list) can be input; results will be appended to it ForceDense : bool, deprecated Force dense arithmatic. Can speed up results for small models (OBSOLETE). Returns ------- Traj : list Sequence of states as a python list """""" check_transition(transition_matrix) check_dimensions(transition_matrix) n_states = transition_matrix.shape[0] if scipy.sparse.isspmatrix(transition_matrix): transition_matrix = transition_matrix.tocsr() # reserve room for the new trajectory (will be appended to an existing trajectory at the end if necessary) newtraj = [-1] * steps # determine initial state if traj is None or len(traj) == 0: if state is None: state = np.random.randint(n_states) elif isinstance(state, np.ndarray): state = np.where(scipy.random.multinomial(1, state / sum(state)) == 1)[0][0] newtraj[0] = state start = 1 else: state = traj[-1] start = 0 if not state < n_states: raise ValueError(""Intial state is %s, but should be between 0 and %s."" % (state, n_states - 1)) # sample the Markov chain if isinstance(transition_matrix, np.ndarray): for i in xrange(start, steps): p = transition_matrix[state, :] state = np.where(scipy.random.multinomial(1, p) == 1)[0][0] newtraj[i] = state elif isinstance(transition_matrix, scipy.sparse.csr_matrix): if force_dense: # Lutz: this is the old code path that converts the row of transition probabilities to a dense array at each step. # With the optimized handling of sparse matrices below, this can probably be deleted altogether. for i in xrange(start, steps): p = transition_matrix[state, :].toarray().flatten() state = np.where(scipy.random.multinomial(1, p) == 1)[0][0] newtraj[i] = state else: for i in xrange(start, steps): # Lutz: slicing sparse matrices is very slow (compared to slicing ndarrays) # To avoid slicing, use the underlying data structures of the CSR format directly T = transition_matrix vals = T.indices[T.indptr[state]:T.indptr[state + 1]] # the column indices of the non-zero entries are the possible target states p = T.data[T.indptr[state]:T.indptr[state + 1]] # the data values of the non-zero entries are the corresponding probabilities state = vals[np.where(scipy.random.multinomial(1, p) == 1)[0][0]] newtraj[i] = state else: raise RuntimeError(""Unknown matrix type: %s"" % type(T)) # return the new trajectory, or the concatenation of the old trajectory with the new one if traj is None: return newtraj traj.extend(newtraj) return traj def propagate_model(transition_matrix, n_steps, initial_populations, observable_vector=None): """"""Propogate the time evolution of a population vector. Parameters ---------- T : ndarray or sparse matrix A transition matrix NumSteps : int How many timesteps to iterate initial_populations : ndarray The initial population vector observable_vector : ndarray Vector containing the state-wise averaged property of some observable. Can be used to propagate properties such as fraction folded, ensemble average RMSD, etc. Default: None Returns ------- X : ndarray Final population vector, after propagation obslist : list list of floats of length equal to the number of steps, giving the mean value of the observable (dot product of `ObservableVector` and populations) at each timestep See Also -------- sample scipy.sparse.linalg.aslinearoperator """""" check_transition(transition_matrix) if observable_vector == None: check_dimensions(transition_matrix, initial_populations) else: check_dimensions(transition_matrix, initial_populations, observable_vector) X = initial_populations.copy() obslist = [] if scipy.sparse.issparse(transition_matrix): TC = transition_matrix.tocsr() else: TC = transition_matrix Tl = scipy.sparse.linalg.aslinearoperator(TC) for i in xrange(n_steps): X = Tl.rmatvec(X) if observable_vector is not None: obslist.append(sum(observable_vector * X)) return X, obslist def calc_expectation_timeseries(tprob, observable, init_pop=None, timepoints=10 ** 6, n_modes=100, lagtime=15.0): """""" Calculates the expectation value over time for some `observable` in an MSM. Does this by eigenvalue decomposition, according to the eq math :: \langle A \rangle (t) = \sum_{i=0}^N \langle p(0), \psi^L_i \rangle e^{ - \lambda_i t } \langle \psi^R_i, A \rangle Parameters ---------- tprob : matrix The transition probability matrix (of size N) for the MSM. observable : array_like, float A len N array of the values A of the observable for each state. init_pop : array_like, float A len N array of the initial populations of each state. If None is passed, then the function will start from even populations in each state. timepoints : int The number of timepoints to calculate - the final timeseries will be in length LagTime x `timepoints` n_modes : int The number of eigenmodes to include in the calculation. This number will depend on the timescales involved in the relatation of the observable. Returns ------- timeseries : array_like, float A timeseries of the observable over time, in units of the lag time of the transition matrix. """""" # first, perform the eigendecomposition lambd, psi_L = get_eigenvectors(tprob, n_modes, right=False) psi_L = np.real(psi_L) lambd = np.real(lambd) pos_ind = np.where(lambd > 0)[0] lambd = lambd[pos_ind] psi_L = psi_L[:, pos_ind] n_modes = len(lambd) logger.info(""Found %d non-negative eigenvalues"" % n_modes) # normalize eigenvectors pi = psi_L[:, 0] pi /= pi.sum() np.savetxt('calculated_populations.dat', pi) psi_R = np.zeros(psi_L.shape) for i in range(n_modes): psi_L[:, i] /= np.sqrt(np.sum(np.square(psi_L[:, i]) / pi)) psi_R[:, i] = psi_L[:, i] / pi if lagtime: logger.info(""Shortest timescale process included: %s"", -lagtime / np.log(np.min(lambd))) # figure out the initial populations if init_pop == None: init_pop = np.ones(tprob.shape[0]) init_pop /= init_pop.sum() assert np.abs(init_pop.sum() - 1.0) < 0.0001 # generate the timeseries timeseries = np.zeros(timepoints) for i in range(n_modes): front = np.dot(init_pop, psi_R[:, i]) back = np.dot(observable, psi_L[:, i]) mode_decay = front * np.power(lambd[i], np.arange(timepoints)) * back timeseries += np.real(mode_decay) logger.info('The equilibrium value is %f, while the last time point calculated is %f', np.dot(pi, observable), timeseries[-1]) return timeseries def msm_acf(tprob, observable, timepoints, num_modes=10): """""" Calculate an autocorrelation function from an MSM. Rapid calculation of the autocorrelation of an MSM is performed via an eigenmode decomposition. Parameters ---------- tprob : matrix Transition probability matrix observable : ndarray, float Vector representing the observable value for each state timepoints : ndarray, int The timepoints at which to calculate the decay, in units of lag times. num_modes : int (num_modes) The number of eigenmodes to employ. More modes, more accurate, but slower. Returns ------- acf : ndarray, float The autocorrelation function. Notes ----- Use statsmodels.tsa.stattools.acf if you want to calculate an ACF from a raw observable such as an RMSD trace. See Docs/ACF/acf.pdf for a derivation of this calculation. """""" eigenvalues, eigenvectors = get_eigenvectors(tprob, num_modes + 1) num_modes = len(eigenvalues) - 1 populations = eigenvectors[:, 0] D = np.diag(populations ** -1.) # discard the stationary eigenmode eigenvalues = np.real(eigenvalues[1:]) eigenvectors = np.real(eigenvectors[:, 1:]) right_eigenvectors = D.dot(eigenvectors) eigenvector_normalizer = np.diag(right_eigenvectors.T.dot(eigenvectors)) eigenvectors /= eigenvector_normalizer S = eigenvectors.T.dot(observable) # Project observable onto left eigenvectors acf = np.array([(eigenvalues ** t).dot(S**2) for t in timepoints]) acf /= (eigenvalues ** 0.).dot(S**2) # Divide by the ACF at time zero. return acf # ======================================================== # # SOME UTILITY FUNCTIONS FOR CHECKING TRANSITION MATRICES # ======================================================== # def flatten(*args): """"""Return a generator for a flattened form of all arguments"""""" for x in args: if hasattr(x, '__iter__'): for y in flatten(*x): yield y else: yield x def is_transition_matrix(t_matrix, epsilon=.00001): """"""Check for row normalization of a matrix Parameters ---------- t_matrix : densee or sparse matrix epsilon : float, optional threshold for how close the row sums need to be to 1 Returns ------- truth : bool True if the 2-norm of error in the row sums is less than Epsilon. """""" n = t_matrix.shape[0] row_sums = np.array(t_matrix.sum(1)).flatten() if scipy.linalg.norm(row_sums - np.ones(n)) < epsilon: return True return False def are_all_dimensions_same(*args): """"""Are all the supplied arguments the same size Find the shape of every input. Returns ------- truth : boolean True if every matrix and vector is the same size. """""" m = len(args) dim_list = [] for i in range(m): dims = scipy.shape(args[i]) dim_list.append(dims) return len(np.unique(flatten(dim_list))) == 1 def check_transition(t_matrix, epsilon=0.00001): """"""Ensure that matrix is a row normalized stochastic matrix Parameters ---------- t_matrix : dense or sparse matrix epsilon : float, optional Threshold for how close the row sums need to be to one Other Parameters ---------------- DisableErrorChecking : bool If this flag (module scope variable) is set tot True, this function just passes. Raises ------ NormalizationError If T is not a row normalized stochastic matrix See Also -------- check_dimensions : ensures dimensionality is_transition_matrix : does the actual checking """""" if not DisableErrorChecking and not is_transition_matrix(t_matrix, epsilon): logger.critical(t_matrix) logger.critical(""Transition matrix is not a row normalized"" "" stocastic matrix. This is often caused by "" ""either numerical inaccuracies or by having "" ""states with zero counts."") def check_dimensions(*args): """"""Ensure that all the dimensions of the inputs are identical Raises ------ DimensionError If some of the supplied arguments have different dimensions from one another """""" if are_all_dimensions_same(*args) == False: raise RuntimeError(""All dimensions are not the same"") ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/tpt.py",".py","36692","1198","# This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """""" Functions for performing Transition Path Theory calculations. Written and maintained by TJ Lane Contributions from Kyle Beauchamp, Robert McGibbon, Vince Voelz, Christian Schwantes. These are the cannonical references for TPT. Note that TPT is really a specialization of ideas very framiliar to the mathematical study of Markov chains, and there are many books, manuscripts in the mathematical literature that cover the same concepts. References ---------- .. [1] Metzner, P., Schutte, C. & Vanden-Eijnden, E. Transition path theory for Markov jump processes. Multiscale Model. Simul. 7, 1192–1219 (2009). .. [2] Berezhkovskii, A., Hummer, G. & Szabo, A. Reactive flux and folding pathways in network models of coarse-grained protein dynamics. J. Chem. Phys. 130, 205102 (2009). """""" from __future__ import print_function, division, absolute_import from mdtraj.utils.six.moves import xrange import numpy as np import scipy.sparse from msmbuilder import MSMLib from msmbuilder import msm_analysis from msmbuilder.utils import deprecated import logging logger = logging.getLogger(__name__) # turn on debugging printout # logger.setLogLevel(logging.DEBUG) ############################################################################### # Typechecking/Utility Functions # def _ensure_iterable(arg): if not hasattr(arg, '__iter__'): arg = list([int(arg)]) logger.debug(""Passed object was not iterable,"" "" converted it to: %s"" % str(arg)) assert hasattr(arg, '__iter__') return arg def _check_sources_sinks(sources, sinks): sources = _ensure_iterable(sources) sinks = _ensure_iterable(sinks) if np.any(sources == sinks): raise ValueError(""Sets `sources` and `sinks` must be disjoint "" ""to find paths between them"") return sources, sinks ############################################################################### # Path Finding Functions # def find_top_paths(sources, sinks, tprob, num_paths=10, node_wipe=False, net_flux=None): r"""""" Calls the Dijkstra algorithm to find the top 'NumPaths'. Does this recursively by first finding the top flux path, then cutting that path and relaxing to find the second top path. Continues until NumPaths have been found. Parameters ---------- sources : array_like, int The indices of the source states sinks : array_like, int Indices of sink states num_paths : int The number of paths to find Returns ------- Paths : list of lists The nodes transversed in each path Bottlenecks : list of tuples The nodes between which exists the path bottleneck Fluxes : list of floats The flux through each path Optional Parameters ------------------- node_wipe : bool If true, removes the bottleneck-generating node from the graph, instead of just the bottleneck (not recommended, a debugging functionality) net_flux : sparse matrix Matrix of the net flux from `sources` to `sinks`, see function `net_flux`. If not provided, is calculated from scratch. If provided, `tprob` is ignored. To Do ----- -- Add periodic flow check References ---------- .. [1] Dijkstra, E. W. (1959). ""A note on two problems in connexion with graphs"". Numerische Mathematik 1: 269–271. doi:10.1007/BF01386390. """""" # first, do some checking on the input, esp. `sources` and `sinks` # we want to make sure all objects are iterable and the sets are disjoint sources, sinks = _check_sources_sinks(sources, sinks) msm_analysis.check_transition(tprob) # check to see if we get net_flux for free, otherwise calculate it if not net_flux: net_flux = calculate_net_fluxes(sources, sinks, tprob) # initialize objects paths = [] fluxes = [] bottlenecks = [] if scipy.sparse.issparse(net_flux): net_flux = net_flux.tolil() # run the initial Dijkstra pass pi, b = Dijkstra(sources, sinks, net_flux) logger.info(""Path Num | Path | Bottleneck | Flux"") i = 1 done = False while not done: # First find the highest flux pathway (path, (b1, b2), flux) = _backtrack(sinks, b, pi, net_flux) # Add each result to a Paths, Bottlenecks, Fluxes list if flux == 0: logger.info(""Only %d possible pathways found. Stopping backtrack."", i) break paths.append(path) bottlenecks.append((b1, b2)) fluxes.append(flux) logger.info(""%s | %s | %s | %s "", i, path, (b1, b2), flux) # Cut the bottleneck, start relaxing from B side of the cut if node_wipe: net_flux[:, b2] = 0 logger.info(""Wiped node: %s"", b2) else: net_flux[b1, b2] = 0 G = scipy.sparse.find(net_flux) Q = [b2] b, pi, net_flux = _back_relax(b2, b, pi, net_flux) # Then relax the graph and repeat # But only if we still need to if i != num_paths - 1: while len(Q) > 0: w = Q.pop() for v in G[1][np.where(G[0] == w)]: if pi[v] == w: b, pi, net_flux = _back_relax(v, b, pi, net_flux) Q.append(v) Q = sorted(Q, key=lambda v: b[v]) i += 1 if i == num_paths + 1: done = True if flux == 0: logger.info(""Only %d possible pathways found. Stopping backtrack."", i) done = True return paths, bottlenecks, fluxes def Dijkstra(sources, sinks, net_flux): r"""""" A modified Dijkstra algorithm that dynamically computes the cost of all paths from A to B, weighted by NFlux. Parameters ---------- sources : array_like, int The indices of the source states (i.e. for state A in rxn A -> B) sinks : array_like, int Indices of sink states (state B) NFlux : sparse matrix Matrix of the net flux from A to B, see function GetFlux Returns ------- pi : array_like The paths from A->B, pi[i] = node preceeding i b : array_like The flux passing through each node See Also -------- DijkstraTopPaths : child function `DijkstraTopPaths` is probably the function you want to call to find paths through an MSM network. This is a utility function called by `DijkstraTopPaths`, but may be useful in some specific cases References ---------- .. [1] Dijkstra, E. W. (1959). ""A note on two problems in connexion with graphs"". Numerische Mathematik 1: 269–271. doi:10.1007/BF01386390. """""" sources, sinks = _check_sources_sinks(sources, sinks) # initialize data structures if scipy.sparse.issparse(net_flux): net_flux = net_flux.tolil() else: net_flux = scipy.sparse.lil_matrix(net_flux) G = scipy.sparse.find(net_flux) N = net_flux.shape[0] b = np.zeros(N) b[sources] = 1000 pi = np.zeros(N, dtype=int) pi[sources] = -1 U = [] Q = sorted(list(range(N)), key=lambda v: b[v]) for v in sinks: Q.remove(v) # run the Dijkstra algorithm while len(Q) > 0: w = Q.pop() U.append(w) # relax for v in G[1][np.where(G[0] == w)]: if b[v] < min(b[w], net_flux[w, v]): b[v] = min(b[w], net_flux[w, v]) pi[v] = w Q = sorted(Q, key=lambda v: b[v]) logger.info(""Searched %s nodes"", len(U) + len(sinks)) return pi, b def _back_relax(s, b, pi, NFlux): r"""""" Updates a Djikstra calculation once a bottleneck is cut, quickly recalculating only cost of nodes that change due to the cut. Cuts & relaxes the B-side (sink side) of a cut edge (b2) to source from the adjacent node with the most flux flowing to it. If there are no adjacent source nodes, cuts the node out of the graph and relaxes the nodes that were getting fed by b2 (the cut node). Parameters ---------- s : int the node b2 b : array_like the cost function pi : array_like the backtrack array, a list such that pi[i] = source node of node i NFlux : sparse matrix Net flux matrix Returns ------- b : array_like updated cost function pi : array_like updated backtrack array NFlux : sparse matrix net flux matrix See Also -------- DijkstraTopPaths : child function `DijkstraTopPaths` is probably the function you want to call to find paths through an MSM network. This is a utility function called by `DijkstraTopPaths`, but may be useful in some specific cases """""" G = scipy.sparse.find(NFlux) if len(G[0][np.where(G[1] == s)]) > 0: # For all nodes connected upstream to the node `s` in question, # Re-source that node from the best option (lowest cost) one level lower # Notation: j is node one level below, s is the one being considered b[s] = 0 # set the cost to zero for j in G[0][np.where(G[1] == s)]: # for each upstream node if b[s] < min(b[j], NFlux[j, s]): # if that node has a lower cost b[s] = min(b[j], NFlux[j, s]) # then set the cost to that node pi[s] = j # and the source comes from there # if there are no nodes connected to this one, then we need to go one # level up and work there first else: for sprime in G[1][np.where(G[0] == s)]: NFlux[s, sprime] = 0 b, pi, NFlux = _back_relax(sprime, b, pi, NFlux) return b, pi, NFlux def _backtrack(B, b, pi, NFlux): """""" Works backwards to pull out a path from pi, where pi is a list such that pi[i] = source node of node i. Begins at the largest staring incoming flux point in B. Parameters ---------- B : array_like, int Indices of sink states (state B) b : array_like the cost function pi : array_like the backtrack array, a list such that pi[i] = source node of node i NFlux : sparse matrix net flux matrix Returns ------- bestpath : list the list of nodes forming the highest flux path bottleneck : tuple a tupe of nodes, between which is the bottleneck bestflux : float the flux through `bestpath` See Also -------- DijkstraTopPaths : child function `DijkstraTopPaths` is probably the function you want to call to find paths through an MSM network. This is a utility function called by `DijkstraTopPaths`, but may be useful in some specific cases """""" # Select starting location bestflux = 0 for Bnode in B: path = [Bnode] NotDone = True while NotDone: if pi[path[-1]] == -1: break else: path.append(pi[path[-1]]) path.reverse() bottleneck, flux = find_path_bottleneck(path, NFlux) logger.debug('In Backtrack: Flux %s, bestflux %s', flux, bestflux) if flux > bestflux: bestpath = path bestbottleneck = bottleneck bestflux = flux if flux == 0: bestpath = [] bottleneck = (np.nan, np.nan) bestflux = 0 return (bestpath, bestbottleneck, bestflux) def find_path_bottleneck(path, net_flux): """""" Simply finds the bottleneck along a path. This is the point at which the cost function first goes up along the path, backtracking from B to A. Parameters ---------- path : list a list of nodes along the path of interest net_flux : matrix the net flux matrix Returns ------- bottleneck : tuple a tuple of the nodes on either end of the bottleneck flux : float the flux at the bottleneck See Also -------- find_top_paths : child function `find_top_paths` is probably the function you want to call to find paths through an MSM network. This is a utility function called by `find_top_paths`, but may be useful in some specific cases. References ---------- .. [1] Metzner, P., Schutte, C. & Vanden-Eijnden, E. Transition path theory for Markov jump processes. Multiscale Model. Simul. 7, 1192–1219 (2009). .. [2] Berezhkovskii, A., Hummer, G. & Szabo, A. Reactive flux and folding pathways in network models of coarse-grained protein dynamics. J. Chem. Phys. 130, 205102 (2009). """""" if scipy.sparse.issparse(net_flux): net_flux = net_flux.tolil() flux = 100000. # initialize as large value for i in range(len(path) - 1): if net_flux[path[i], path[i + 1]] < flux: flux = net_flux[path[i], path[i + 1]] b1 = path[i] b2 = path[i + 1] return (b1, b2), flux def calculate_fluxes(sources, sinks, tprob, populations=None, committors=None): """""" Compute the transition path theory flux matrix. Parameters ---------- sources : array_like, int The set of unfolded/reactant states. sinks : array_like, int The set of folded/product states. tprob : mm_matrix The transition matrix. Returns ------ fluxes : mm_matrix The flux matrix Optional Parameters ------------------- populations : nd_array, float The equilibrium populations, if not provided is re-calculated committors : nd_array, float The committors associated with `sources`, `sinks`, and `tprob`. If not provided, is calculated from scratch. If provided, `sources` and `sinks` are ignored. References ---------- .. [1] Metzner, P., Schutte, C. & Vanden-Eijnden, E. Transition path theory for Markov jump processes. Multiscale Model. Simul. 7, 1192–1219 (2009). .. [2] Berezhkovskii, A., Hummer, G. & Szabo, A. Reactive flux and folding pathways in network models of coarse-grained protein dynamics. J. Chem. Phys. 130, 205102 (2009). """""" sources, sinks = _check_sources_sinks(sources, sinks) msm_analysis.check_transition(tprob) if scipy.sparse.issparse(tprob): dense = False else: dense = True # check if we got the populations if populations is None: eigens = msm_analysis.get_eigenvectors(tprob, 1) if np.count_nonzero(np.imag(eigens[1][:, 0])) != 0: raise ValueError('First eigenvector has imaginary components') populations = np.real(eigens[1][:, 0]) # check if we got the committors if committors is None: committors = calculate_committors(sources, sinks, tprob) # perform the flux computation Indx, Indy = tprob.nonzero() n = tprob.shape[0] if dense: X = np.zeros((n, n)) Y = np.zeros((n, n)) X[(np.arange(n), np.arange(n))] = populations * (1.0 - committors) Y[(np.arange(n), np.arange(n))] = committors else: X = scipy.sparse.lil_matrix((n, n)) Y = scipy.sparse.lil_matrix((n, n)) X.setdiag(populations * (1.0 - committors)) Y.setdiag(committors) if dense: fluxes = np.dot(np.dot(X, tprob), Y) fluxes[(np.arange(n), np.arange(n))] = np.zeros(n) else: fluxes = (X.tocsr().dot(tprob.tocsr())).dot(Y.tocsr()) # This should be the same as below, but it's a bit messy... #fluxes = np.dot(np.dot(X.tocsr(), tprob.tocsr()), Y.tocsr()) fluxes = fluxes.tolil() fluxes.setdiag(np.zeros(n)) return fluxes def calculate_net_fluxes(sources, sinks, tprob, populations=None, committors=None): """""" Computes the transition path theory net flux matrix. Parameters ---------- sources : array_like, int The set of unfolded/reactant states. sinks : array_like, int The set of folded/product states. tprob : mm_matrix The transition matrix. Returns ------ net_fluxes : mm_matrix The net flux matrix Optional Parameters ------------------- populations : nd_array, float The equilibrium populations, if not provided is re-calculated committors : nd_array, float The committors associated with `sources`, `sinks`, and `tprob`. If not provided, is calculated from scratch. If provided, `sources` and `sinks` are ignored. References ---------- .. [1] Metzner, P., Schutte, C. & Vanden-Eijnden, E. Transition path theory for Markov jump processes. Multiscale Model. Simul. 7, 1192–1219 (2009). .. [2] Berezhkovskii, A., Hummer, G. & Szabo, A. Reactive flux and folding pathways in network models of coarse-grained protein dynamics. J. Chem. Phys. 130, 205102 (2009). """""" sources, sinks = _check_sources_sinks(sources, sinks) msm_analysis.check_transition(tprob) if scipy.sparse.issparse(tprob): dense = False else: dense = True n = tprob.shape[0] flux = calculate_fluxes(sources, sinks, tprob, populations, committors) ind = flux.nonzero() if dense: net_flux = np.zeros((n, n)) else: net_flux = scipy.sparse.lil_matrix((n, n)) for k in range(len(ind[0])): i, j = ind[0][k], ind[1][k] forward = flux[i, j] reverse = flux[j, i] net_flux[i, j] = max(0, forward - reverse) return net_flux ############################################################################### # MFPT & Committor Finding Functions # def calculate_ensemble_mfpt(sources, sinks, tprob, lag_time): """""" Calculates the average 'Folding Time' of an MSM defined by T and a LagTime. The Folding Time is the average of the MFPTs (to F) of all the states in U. Note here 'Folding Time' is defined as the avg MFPT of {U}, to {F}. Consider this carefully. This is probably NOT the experimental folding time! Parameters ---------- sources : array, int indices of the source states sinks : array, int indices of the sink states tprob : matrix transition probability matrix lag_time : float the lag time used to create T (dictates units of the answer) Returns ------- avg : float the average of the MFPTs std : float the standard deviation of the MFPTs References ---------- .. [1] Metzner, P., Schutte, C. & Vanden-Eijnden, E. Transition path theory for Markov jump processes. Multiscale Model. Simul. 7, 1192–1219 (2009). .. [2] Berezhkovskii, A., Hummer, G. & Szabo, A. Reactive flux and folding pathways in network models of coarse-grained protein dynamics. J. Chem. Phys. 130, 205102 (2009). """""" sources, sinks = _check_sources_sinks(sources, sinks) msm_analysis.check_transition(tprob) X = calculate_mfpt(sinks, tprob, lag_time) times = np.zeros(len(sources)) for i in range(len(sources)): times[i] = X[sources[i]] return np.average(times), np.std(times) def calculate_avg_TP_time(sources, sinks, tprob, lag_time): """""" Calculates the Average Transition Path Time for MSM with: T, LagTime. The TPTime is the average of the MFPTs (to F) of all the states immediately adjacent to U, with the U states effectively deleted. Note here 'TP Time' is defined as the avg MFPT of all adjacent states to {U}, to {F}, ignoring {U}. Consider this carefully. Parameters ---------- sources : array, int indices of the unfolded states sinks : array, int indices of the folded states tprob : matrix transition probability matrix lag_time : float the lag time used to create T (dictates units of the answer) Returns ------- avg : float the average of the MFPTs std : float the standard deviation of the MFPTs References ---------- .. [1] Metzner, P., Schutte, C. & Vanden-Eijnden, E. Transition path theory for Markov jump processes. Multiscale Model. Simul. 7, 1192–1219 (2009). .. [2] Berezhkovskii, A., Hummer, G. & Szabo, A. Reactive flux and folding pathways in network models of coarse-grained protein dynamics. J. Chem. Phys. 130, 205102 (2009). """""" sources, sinks = _check_sources_sinks(sources, sinks) msm_analysis.check_transition(tprob) n = tprob.shape[0] if scipy.sparse.issparse(tprob): T = tprob.tolil() P = scipy.sparse.lil_matrix((n, n)) else: P = np.zeros((n, n)) for u in sources: for i in range(n): if i not in sources: P[u, i] = T[u, i] for u in sources: T[u, :] = np.zeros(n) T[:, u] = 0 for i in sources: N = T[i, :].sum() T[i, :] = T[i, :] / N X = calculate_mfpt(sinks, tprob, lag_time) TP = P * X.T TPtimes = [] for time in TP: if time != 0: TPtimes.append(time) return np.average(TPtimes), np.std(TPtimes) def calculate_mfpt(sinks, tprob, lag_time=1.): """""" Gets the Mean First Passage Time (MFPT) for all states to a *set* of sinks. Parameters ---------- sinks : array, int indices of the sink states tprob : matrix transition probability matrix LagTime : float the lag time used to create T (dictates units of the answer) Returns ------- MFPT : array, float MFPT in time units of LagTime, for each state (in order of state index) See Also -------- calculate_all_to_all_mfpt : function A more efficient way to calculate all the MFPTs in a network References ---------- .. [1] Metzner, P., Schutte, C. & Vanden-Eijnden, E. Transition path theory for Markov jump processes. Multiscale Model. Simul. 7, 1192–1219 (2009). .. [2] Berezhkovskii, A., Hummer, G. & Szabo, A. Reactive flux and folding pathways in network models of coarse-grained protein dynamics. J. Chem. Phys. 130, 205102 (2009). """""" sinks = _ensure_iterable(sinks) msm_analysis.check_transition(tprob) n = tprob.shape[0] if scipy.sparse.isspmatrix(tprob): tprob = tprob.tolil() for state in sinks: tprob[state, :] = 0.0 tprob[state, state] = 2.0 if scipy.sparse.isspmatrix(tprob): tprob = tprob - scipy.sparse.eye(n, n) tprob = tprob.tocsr() else: tprob = tprob - np.eye(n) RHS = -1 * np.ones(n) for state in sinks: RHS[state] = 0.0 if scipy.sparse.isspmatrix(tprob): MFPT = lag_time * scipy.sparse.linalg.spsolve(tprob, RHS) else: MFPT = lag_time * np.linalg.solve(tprob, RHS) return MFPT def calculate_all_to_all_mfpt(tprob, populations=None): """""" Calculate the all-states by all-state matrix of mean first passage times. This uses the fundamental matrix formalism, and should be much faster than GetMFPT for calculating many MFPTs. Parameters ---------- tprob : matrix transition probability matrix populations : array_like, float optional argument, the populations of each state. If not supplied, it will be computed from scratch Returns ------- MFPT : array, float MFPT in time units of LagTime, square array for MFPT from i -> j See Also -------- GetMFPT : function for calculating a subset of the MFPTs, with functionality for including a set of sinks References ---------- .. [1] Metzner, P., Schutte, C. & Vanden-Eijnden, E. Transition path theory for Markov jump processes. Multiscale Model. Simul. 7, 1192–1219 (2009). .. [2] Berezhkovskii, A., Hummer, G. & Szabo, A. Reactive flux and folding pathways in network models of coarse-grained protein dynamics. J. Chem. Phys. 130, 205102 (2009). """""" msm_analysis.check_transition(tprob) if scipy.sparse.issparse(tprob): tprob = tprob.toarray() logger.warning('calculate_all_to_all_mfpt does not support sparse linear algebra') if populations is None: eigens = msm_analysis.get_eigenvectors(tprob, 1) if np.count_nonzero(np.imag(eigens[1][:, 0])) != 0: raise ValueError('First eigenvector has imaginary parts') populations = np.real(eigens[1][:, 0]) # ensure that tprob is a transition matrix msm_analysis.check_transition(tprob) num_states = len(populations) if tprob.shape[0] != num_states: raise ValueError(""Shape of tprob and populations vector don't match"") eye = np.transpose(np.matrix(np.ones(num_states))) limiting_matrix = eye * populations #z = scipy.linalg.inv(scipy.sparse.eye(num_states, num_states) - (tprob - limiting_matrix)) z = scipy.linalg.inv(np.eye(num_states) - (tprob - limiting_matrix)) # mfpt[i,j] = z[j,j] - z[i,j] / pi[j] mfpt = -z for j in range(num_states): mfpt[:, j] += z[j, j] mfpt[:, j] /= populations[j] return mfpt def calculate_committors(sources, sinks, tprob): """""" Get the forward committors of the reaction sources -> sinks. Parameters ---------- sources : array_like, int The set of unfolded/reactant states. sinks : array_like, int The set of folded/product states. tprob : mm_matrix The transition matrix. Returns ------- Q : array_like The forward committors for the reaction U -> F. References ---------- .. [1] Metzner, P., Schutte, C. & Vanden-Eijnden, E. Transition path theory for Markov jump processes. Multiscale Model. Simul. 7, 1192–1219 (2009). .. [2] Berezhkovskii, A., Hummer, G. & Szabo, A. Reactive flux and folding pathways in network models of coarse-grained protein dynamics. J. Chem. Phys. 130, 205102 (2009). """""" sources, sinks = _check_sources_sinks(sources, sinks) msm_analysis.check_transition(tprob) if scipy.sparse.issparse(tprob): dense = False tprob = tprob.tolil() else: dense = True # construct the committor problem n = tprob.shape[0] if dense: T = np.eye(n) - tprob else: T = scipy.sparse.eye(n, n, 0, format='lil') - tprob T = T.tolil() for a in sources: T[a, :] = 0.0 # np.zeros(n) T[:, a] = 0.0 T[a, a] = 1.0 for b in sinks: T[b, :] = 0.0 # np.zeros(n) T[:, b] = 0.0 T[b, b] = 1.0 IdB = np.zeros(n) IdB[sinks] = 1.0 if dense: RHS = np.dot(tprob, IdB) else: RHS = tprob.dot(IdB) # This should be the same as below #RHS = tprob * IdB RHS[sources] = 0.0 RHS[sinks] = 1.0 # solve for the committors if dense == False: Q = scipy.sparse.linalg.spsolve(T.tocsr(), RHS) else: Q = np.linalg.solve(T, RHS) epsilon = 0.001 assert np.all(Q <= 1.0 + epsilon) assert np.all(Q >= 0.0 - epsilon) return Q ###################################################################### # Functions for computing hub scores, conditional committors, and # related quantities # def calculate_fraction_visits(tprob, waypoint, source, sink, return_cond_Q=False): """""" Calculate the fraction of times a walker on `tprob` going from `sources` to `sinks` will travel through the set of states `waypoints` en route. Computes the conditional committors q^{ABC^+} and uses them to find the fraction of paths mentioned above. The conditional committors can be Note that in the notation of Dickson et. al. this computes h_c(A,B), with sources = A sinks = B waypoint = C Parameters ---------- tprob : matrix The transition probability matrix waypoint : int The index of the intermediate state sources : nd_array, int or int The indices of the source state(s) sinks : nd_array, int or int The indices of the sink state(s) return_cond_Q : bool Whether or not to return the conditional committors Returns ------- fraction_paths : float The fraction of times a walker going from `sources` -> `sinks` stops by `waypoints` on its way. cond_Q : nd_array, float (optional) Optionally returned (`return_cond_Q`) See Also -------- calculate_hub_score : function Compute the 'hub score', the weighted fraction of visits for an entire network. calculate_all_hub_scores : function Wrapper to compute all the hub scores in a network. Notes ----- Employs dense linear algebra, memory use scales as N^2 cycle use scales as N^3 References ---------- ..[1] Dickson & Brooks (2012), J. Chem. Theory Comput., Article ASAP DOI: 10.1021/ct300537s """""" # do some typechecking - we need to be sure that the lumped sources are in # the second to last row, and the lumped sinks are in the last row # check `tprob` msm_analysis.check_transition(tprob) if type(tprob) != np.ndarray: try: tprob = tprob.todense() except AttributeError as e: raise TypeError('Argument `tprob` must be convertable to a dense' 'numpy array. \n%s' % e) # typecheck for data in [source, sink, waypoint]: if type(data) == int: pass elif hasattr(data, 'len'): if len(data) == 1: data = data[0] else: raise TypeError('Arguments source/sink/waypoint must be an int') if (source == waypoint) or (sink == waypoint) or (sink == source): raise ValueError('source, sink, waypoint must all be disjoint!') N = tprob.shape[0] Q = calculate_committors([source], [sink], tprob) # permute the transition matrix into cannonical form - send waypoint the the # last row, and source + sink to the end after that Bsink_indices = [source, sink, waypoint] perm = np.arange(N) perm = np.delete(perm, Bsink_indices) perm = np.append(perm, Bsink_indices) T = MSMLib.permute_mat(tprob, perm) # extract P, R n = N - len(Bsink_indices) P = T[:n, :n] R = T[:n, n:] # calculate the conditional committors ( B = N*R ), B[i,j] is the prob # state i ends in j, where j runs over the source + sink + waypoint # (waypoint is position -1) B = np.dot(np.linalg.inv(np.eye(n) - P), R) # Not sure if this is sparse or not... # add probs for the sinks, waypoint / b[i] is P( i --> {C & not A, B} ) b = np.append(B[:, -1].flatten(), [0.0] * (len(Bsink_indices) - 1) + [1.0]) cond_Q = b * Q[waypoint] epsilon = 1e-6 # some numerical give, hard-coded assert cond_Q.shape == (N,) assert np.all(cond_Q <= 1.0 + epsilon) assert np.all(cond_Q >= 0.0 - epsilon) assert np.all(cond_Q <= Q[perm] + epsilon) # finally, calculate the fraction of paths h_C(A,B) (eq. 7 in [1]) fraction_paths = np.sum(T[-3, :] * cond_Q) / np.sum(T[-3, :] * Q[perm]) assert fraction_paths <= 1.0 assert fraction_paths >= 0.0 if return_cond_Q: cond_Q = cond_Q[np.argsort(perm)] # put back in orig. order return fraction_paths, cond_Q else: return fraction_paths def calculate_hub_score(tprob, waypoint): """""" Calculate the hub score for the states `waypoint`. The ""hub score"" is a measure of how well traveled a certain state or set of states is in a network. Specifically, it is the fraction of times that a walker visits a state en route from some state A to another state B, averaged over all combinations of A and B. Parameters ---------- tprob : matrix The transition probability matrix waypoints : int The indices of the intermediate state(s) Returns ------- Hc : float The hub score for the state composed of `waypoints` See Also -------- calculate_fraction_visits : function Calculate the fraction of times a state is visited on pathways going from a set of ""sources"" to a set of ""sinks"". calculate_all_hub_scores : function A more efficient way to compute the hub score for every state in a network. Notes ----- Employs dense linear algebra, memory use scales as N^2 cycle use scales as N^5 References ---------- ..[1] Dickson & Brooks (2012), J. Chem. Theory Comput., Article ASAP DOI: 10.1021/ct300537s """""" msm_analysis.check_transition(tprob) # typecheck if type(waypoint) != int: if hasattr(waypoint, '__len__'): if len(waypoint) == 1: waypoint = waypoint[0] else: raise ValueError('Must pass waypoints as int or list/array of ints') else: raise ValueError('Must pass waypoints as int or list/array of ints') # find out which states to include in A, B (i.e. everything but C) N = tprob.shape[0] states_to_include = list(range(N)) states_to_include.remove(waypoint) # calculate the hub score Hc = 0.0 for s1 in states_to_include: for s2 in states_to_include: if (s1 != s2) and (s1 != waypoint) and (s2 != waypoint): Hc += calculate_fraction_visits(tprob, waypoint, s1, s2, return_cond_Q=False) Hc /= ((N - 1) * (N - 2)) return Hc def calculate_all_hub_scores(tprob): """""" Calculate the hub scores for all states in a network defined by `tprob`. The ""hub score"" is a measure of how well traveled a certain state or set of states is in a network. Specifically, it is the fraction of times that a walker visits a state en route from some state A to another state B, averaged over all combinations of A and B. Parameters ---------- tprob : matrix The transition probability matrix Returns ------- Hc_array : nd_array, float The hub score for each state in `tprob` See Also -------- calculate_fraction_visits : function Calculate the fraction of times a state is visited on pathways going from a set of ""sources"" to a set of ""sinks"". calculate_hub_score : function A function that computes just one hub score, can compute the hub score for a set of states. Notes ----- Employs dense linear algebra, memory use scales as N^2 cycle use scales as N^6 References ---------- ..[1] Dickson & Brooks (2012), J. Chem. Theory Comput., Article ASAP DOI: 10.1021/ct300537s """""" N = tprob.shape[0] states = list(range(N)) # calculate the hub score Hc_array = np.zeros(N) # loop over each state and compute it's hub score for i, waypoint in enumerate(states): Hc = 0.0 # now loop over all combinations of sources/sinks and average for s1 in states: if waypoint != s1: for s2 in states: if s1 != s2: if waypoint != s2: Hc += calculate_fraction_visits(tprob, waypoint, s1, s2) # store the hub score in an array Hc_array[i] = Hc / ((N - 1) * (N - 2)) return Hc_array ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/arglib.py",".py","7786","235","from __future__ import print_function, division, absolute_import import sys import os import argparse from msmbuilder.License import LicenseString from msmbuilder.Citation import CiteString from msmbuilder.metrics import parsers as metric_parsers from pprint import pprint import warnings import logging from mdtraj.utils.six import iteritems logger = logging.getLogger(__name__) def _iter_both_cases(string): """"""Iterate over the chars in a strings in both cases >>> [e for e in _iter_both_cases(""string"")] ['s', 'S', 't', 'T', 'r', 'R', 'i', 'I', 'n', 'N', 'g', 'G'] """""" for c in string: yield c yield c.swapcase() def die_if_path_exists(path): if isinstance(path, list): for item in path: die_if_path_exists(item) return directory = os.path.split(path)[0] if len(directory) > 0 and not os.path.exists(directory): logger.info('Creating directory %s', directory) os.makedirs(directory) if os.path.exists(path): name = os.path.split(sys.argv[0])[1] logger.error('%s: Error: %s already exists!. Exiting.', name, path) sys.exit(1) return None def ensure_path_exists(path): name = os.path.split(sys.argv[0])[1] if not os.path.exists(path): logger.error(""%s: Error: Can't find %s"", name, path) sys.exit(1) RESERVED = {'assignments': ('-a', 'Path to assignments file.', 'Data/Assignments.h5', str), 'project': ('-p', 'Path to ProjectInfo file.', 'ProjectInfo.yaml', str), 'tProb': ('-t', 'Path to transition matrix.', 'Data/tProb.mtx', str), 'output_dir': ('-o', 'Location to save results.', 'Data/', str), 'pdb': ('-s', 'Path to PDB structure file.', None, str)} def add_argument(group, dest, help=None, type=None, choices=None, nargs=None, default=None, action=None): """""" Wrapper around arglib.ArgumentParser.add_argument. Gives you a short name directly from your longname """""" if dest in RESERVED: short = RESERVED[dest][0] if help is None: help = RESERVED[dest][1] if default is None: default = RESERVED[dest][2] if type is None: type = RESERVED[dest][3] kwargs = {} if action == 'store_true' or action == 'store_false': type = None if type != None: kwargs['type'] = type if action is not None: kwargs['action'] = action if nargs is not None: kwargs['nargs'] = nargs if choices is not None: kwargs['choices'] = choices if type != None: kwargs['choices'] = [type(c) for c in choices] longn = '--{name}'.format(name=dest) found_short = False for char in _iter_both_cases(dest): if not dest in RESERVED: short = '-%s' % char args = (short, longn) if default is None: kwargs['required'] = True kwargs['help'] = help else: if help is None: helptext = 'Default: {default}'.format(default=default) else: if help[-1] != '.': help += '.' helptext = '{help} Default: {default}'.format(help=help, default=default) kwargs['help'] = helptext kwargs['default'] = default try: group.add_argument(*args, **kwargs) found_short = True break except argparse.ArgumentError: pass if not found_short: raise ValueError('Could not find short name') return dest, type class ArgumentParser(object): ""MSMBuilder specific wrapper around argparse.ArgumentParser"" def __init__(self, *args, **kwargs): """"""Create an ArgumentParser Parameters ---------- description: (str, optional) get_metric: (bool, optional) - Pass true if you want to use the metric parser and get a metric instance returned """""" self.extra_groups = [] self.metric_parser_list = [] self.print_argparse_bug_warning = False if 'description' in kwargs: kwargs['description'] += ('\n' + '-' * 80) kwargs['formatter_class'] = argparse.RawDescriptionHelpFormatter if 'get_metric' in kwargs: # pop gets the value plus removes the entry self.get_metric = bool(kwargs.pop('get_metric')) else: self.get_metric = False self.parser = argparse.ArgumentParser(*args, **kwargs) self.parser.add_argument('-q', '--quiet', dest='quiet', help='Pass this flag to run in quiet mode.', default=False, action='store_true') if self.get_metric: self.metric_parser_list = metric_parsers.add_metric_parsers(self) self.parser.prog = os.path.split(sys.argv[0])[1] self.required = self.parser.add_argument_group(title='required arguments') self.wdefaults = self.parser.add_argument_group(title='arguments with defaults') self.short_strings = set(['-h']) self.name_to_type = {} for v in RESERVED.values(): self.short_strings.add(v[0]) def add_argument_group(self, title): self.extra_groups.append(self.parser.add_argument_group(title=title)) def add_argument(self, dest, help=None, type=None, choices=None, nargs=None, default=None, action=None): if dest in RESERVED and default is None: default = RESERVED[dest][2] if action == 'store_true': default = False elif action == 'store_false': default = True if (nargs in ['+', '*', '?']) and (self.get_metric): self.print_argparse_bug_warning = True if choices: for choice in choices: if not isinstance(choice, str): warnings.warn('arglib bug: choices should all be str') if default is None: group = self.required else: group = self.wdefaults if len(self.extra_groups) > 0: group = self.extra_groups[-1] name, type = add_argument(group, dest, help, type, choices, nargs, default, action) self.name_to_type[name] = type def add_subparsers(self, *args, **kwargs): return self.parser.add_subparsers(*args, **kwargs) def parse_args(self, args=None, namespace=None, print_banner=True): if print_banner: print(LicenseString) print(CiteString) if self.print_argparse_bug_warning: print(""#"" * 80) print(""\n"") warnings.warn('Known bug in argparse regarding subparsers and optional ' 'arguments with nargs=[+*?] (http://bugs.python.org/issue9571)') print(""\n"") print(""#"" * 80) namespace = self.parser.parse_args(args=args, namespace=namespace) if print_banner: pprint(namespace.__dict__) if namespace.quiet: # set the level of the root logger logging.getLogger().setLevel(logging.WARNING) if self.get_metric: # if we want to get the metric, then we have to construct it metric = metric_parsers.construct_metric(namespace) return namespace, metric return namespace def _typecast(self, namespace): """"""Work around for the argparse bug with respect to defaults and FileType not playing together nicely -- http://stackoverflow.com/questions/8236954/specifying-default-filenames-with-argparse-but-not-opening-them-on-help"""""" for name, type in iteritems(self.name_to_type): setattr(namespace, name, type(getattr(namespace, name))) return namespace ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/cfep.py",".py","19701","579",""""""" Code for computing cut-based free energy profiles, and optimal reaction coordinates within that framework. This code employs scipy's weave, so C/OMP compatability is required. Most machines should have this functionality by default. To Do ----- > Choose best search method in `optimize` > Add functionality for saving/loading the state of VariableCoordinate """""" from __future__ import print_function, division, absolute_import import itertools import time import numpy as np import scipy import scipy.optimize import matplotlib.pyplot as plt import mdtraj as md from msmbuilder import MSMLib from msmbuilder import tpt from msmbuilder.msm_analysis import get_eigenvectors TIME = False def contact_reaction_coordinate(trajectory, weights): """""" Computes a residue-contact based reaction coordinate. Specifically, the reaction coordinate is a weighted linear combination of the alpha carbon distances for each residue. Weights can take any value, including negative and zero values. Parameters ---------- trajectory : msmbuilder trajectory The trajectory along which to compute the reaction coordinate value weights : nd_array, float The weights to apply to all the inter-residue (Ca-Ca) distances Returns ------- rc_value : nd_array, float The reaction coordinate value for each snapshot of `trajectory` """""" if TIME: starttime = time.clock() # make an array of all pairwise C-alpha indices C_alpha_pairs = np.array( list(itertools.combinations([a.index for a in t.topology.atoms if a.name == 'CA']))) # calculate the distance between all of those pairs distance_array = md.compute_distances(trajectory, C_alpha_pairs) rc_value = np.sum(distance_array * weights.T, axis=1) if TIME: endtime = time.clock() print(""Time spent in RC eval"", endtime - starttime) return rc_value class CutCoordinate(object): """""" Object containing methods for computing the cut-based free energy profiles of reaction coordinates. Parameters ---------- counts : matrixs A matrix of the transition counts observed in the MSM generators : msmbuilder trajectory The generators (or a trajectory containing an exemplar structure) for each state. reactant : int Index of the state to use to represent the reactant (unfolded) well product : int Index of the state to use to represent the product (folded) well """""" def __init__(self, counts, generators, reactant, product): # store the basic values self.counts = counts self.generators = generators self.reactant = reactant self.product = product self.N = counts.shape[0] self.reaction_coordinate_values = None def _check_coordinate_values(self): """""" Function that checks if we have self.reaction_coordinate_values on hand, and complains if we don't. """""" if self.reaction_coordinate_values == None: raise Exception(""Error: No `reaction_coordinate_values` found. "" ""Either pass in these manually or calculate them "" ""with a class method. See the methods:"" ""\n-- set_coordinate_values"" ""\n-- set_coordinate_as_committors"" ""\n-- set_coordinate_as_eigvector2"") return def set_coordinate_values(self, coordinate_values): """""" Set the reaction coordinate manually, by providing coordinate values that come from some external calculation. Parameters ---------- coordinate_values : nd_array, float The values of the reaction coordinate, evaluated for each state. """""" self.reaction_coordinate_values = coordinate_values self.evaluate_partition_functions() return def set_coordinate_as_committors(self, lag_time=1, symmetrize='transpose'): """""" Set the reaction coordinate to be the committors (pfolds). Employs the reactant, product states provided as the sources, sinks respectively for the committor calculation. Parameters ---------- lag_time : int The MSM lag time to use (in units of frames) in the estimation of the MSM transition probability matrix from the `counts` matrix. symmetrize : str {'mle', 'transpose', 'none'} Which symmetrization method to employ in the estimation of the MSM transition probability matrix from the `counts` matrix. """""" t_matrix = MSMLib.build_msm(self.counts, symmetrize) self.reaction_coordinate_values = tpt.calculate_committors([self.reactant], [self.product], t_matrix) return def set_coordinate_as_eigvector2(self, lag_time=1, symmetrize='transpose'): """""" Set the reaction coordinate to be the second eigenvector of the MSM generated by counts, the provided lag_time, and the provided symmetrization method. Parameters ---------- lag_time : int The MSM lag time to use (in units of frames) in the estimation of the MSM transition probability matrix from the `counts` matrix. symmetrize : str {'mle', 'transpose', 'none'} Which symmetrization method to employ in the estimation of the MSM transition probability matrix from the `counts` matrix. """""" t_matrix = MSMLib.build_msm_from_counts(self.counts, lag_time, symmetrize) v, w = get_eigenvectors(t_matrix, 5) self.reaction_coordinate_values = w[:, 1].flatten() return def reaction_mfpt(self, lag_time=1.0): """""" Calculate the MFPT between the `reactant` and `product` states, as given by the reaction coordinate. Parameters ---------- lag_time : float The units of time for the MSM lag time. Returns ------- mfpt : float The mean first passage time between the `reactant` and `product` """""" if TIME: starttime = time.clock() self._check_coordinate_values() const = lag_time / np.pi A = self.reaction_coordinate_values[self.reactant] B = self.reaction_coordinate_values[self.product] # perform the following integral over the rxn coord numerically # \int_A^B dx ( zh[x] / zc^2[x] ) * \int_A^x dy zh[y] perm = np.argsort(self.reaction_coordinate_values) start = np.where(self.reaction_coordinate_values[perm] == A)[0] end = np.where(self.reaction_coordinate_values[perm] == B)[0] intermediate_states = np.arange(self.N)[perm][start:end] # use weave & OMP to do the integral tau_parallel = 0.0 N = len(intermediate_states) zc = self.zc zh = self.zh rc = self.reaction_coordinate_values import scipy.weave scipy.weave.inline(r"""""" // Loop over all `intermediate_states` to perform the integral // Employ a trapezoid approximation to evaluate the integral Py_BEGIN_ALLOW_THREADS int i, x, y; double secondint, incr, h; #pragma omp parallel for private(x, y, secondint, incr, h) shared(zh, zc, rc) // loop to perform the outer integral for (i = 0; i < N; i++) { x = intermediate_states[i]; // loop to perform the inner/second integral (over dy) secondint = 0; for (y = 0; y < x-1; y++) { h = rc[y+1] - rc[y]; secondint += h * (1.0/2.0) * (zh[y] + zh[y+1]); } // calculate the integral (over dx) h = rc[x+1] - rc[x]; incr = (1.0/2.0) * h * ( ( zh[x+1] / (zc[x+1] * zc[x+1]) ) - ( zh[x] / (zc[x] * zc[x]) ) ) * secondint; #pragma omp critical(tau_update) tau_parallel += incr; } Py_END_ALLOW_THREADS """""", ['tau_parallel', 'N', 'intermediate_states', 'zc', 'zh', 'rc'], extra_link_args=['-lgomp'], extra_compile_args=[""-O3"", ""-fopenmp""]) mfpt = const * tau_parallel if TIME: endtime = time.clock() print(""Time spent in MFPT:"", endtime - starttime) return mfpt def evaluate_partition_functions(self): """""" Computes the partition function of the cut-based free energy profile based on transition network and reaction coordinate. Employs an MSM to do so, thus taking input in the form of a discrete state space and the observed dynamics in that space (assignments). Further, one can provide a ""reaction coordiante"" who's values will be employed to find the min-cut/max-flow coordinate describing dynamics on that space. Generously contributed by Sergei Krivov Optimizations and modifications due to TJL Stores ------ zc : nd_array, float The cut-based free energy profile along the reaction coordinate. The negative log of this function gives the free energy profile along the coordinate. zh : nd_array, float The histogram-based free energy profile. See Also -------- optimize_cut_based_coordinate : function Optimize a flexible reaction coordinate to maximize the free energy barrier along that coordinate. """""" if TIME: starttime = time.clock() self._check_coordinate_values() # permute the counts matrix to order it with the rxn coordinate state_order_along_RC = np.argsort(self.reaction_coordinate_values) perm_counts = MSMLib.permute_mat(self.counts, state_order_along_RC) # set up the three variables for weave -- need to be locals data = perm_counts.data indices = perm_counts.indices indptr = perm_counts.indptr zc = np.zeros(self.N) N = self.N import scipy.weave scipy.weave.inline(r"""""" Py_BEGIN_ALLOW_THREADS int i, j, k; double nij, incr; #pragma omp parallel for private(nij, incr, j, k) shared(N, indptr, indices, data, zc) for (i = 0; i < N; i++) { for (k = indptr[i]; k < indptr[i+1]; k++) { j = indices[k]; if (i == j) { continue; } nij = data[k]; // iterate through all values in the matrix in csr format // i, j are the row and column indices // nij is the entry incr = j < i ? nij : -nij; #pragma omp critical(zc_update) { zc[j] += incr; zc[i] -= incr; } } } Py_END_ALLOW_THREADS """""", ['N', 'data', 'indices', 'indptr', 'zc'], extra_link_args=['-lgomp'], extra_compile_args=[""-O3"", ""-fopenmp""]) zc /= 2.0 # we overcounted in the above - fix that # put stuff back in the original order inv_ordering = np.argsort(state_order_along_RC) zc = zc[inv_ordering] # calculate the histogram-based partition function zh = np.array(self.counts.sum(axis=0)).flatten() self.zc = zc self.zh = zh if TIME: endtime = time.clock() print(""Time spent in zc:"", endtime - starttime) return def rescale_to_natural_coordinate(self): """""" Rescale a cut-based free energy profile along a reaction coordinate such that the diffusion constant is unity for the entire coordinate. Parameters ---------- zc : ndarray, float The cut-based partition function from `calc_cFEP` zh : ndarray, float The histogram-based parition function from `calc_cFEP` rxn_coordinate : ndarray, float The reaction coordinate used. Updates ------- zc, zh <- natural_coordinate : ndarray, float The reaction coordinate values along the rescaled coordinate reaction_coordinate_values <- scaled_z : ndarray, float The partition function value for each point of `natural_coordinate` """""" self._check_coordinate_values() state_order_along_RC = np.argsort(self.reaction_coordinate_values) zc = self.zc[state_order_along_RC] zh = self.zh[state_order_along_RC] scaled_z = np.cumsum(zc) positive_inds = np.where(scaled_z > 0.0) scaled_z = scaled_z[positive_inds] natural_coordinate = np.cumsum(zh[positive_inds] / (scaled_z * np.sqrt(np.pi))) self.zc = natural_coordinate self.zh = natural_coordinate self.reaction_coordinate_values = scaled_z return def plot(self, num_bins=15, filename=None): """""" Plot the current cut-based free energy profile. Can either display this on screen (filename=None), or save to a file if the kwarg `filename` is provided. The plot does a smoothing average over the reaction coordinate. Increasing `bins` makes the average finer, and the resulting coordinate rougher. Fewer `bins` means a coarser, smoother coordinate. Parameters ---------- num_bins : int The number of bins to employ in a sliding average. filename : str The name of the file to save the rendered image to. If None is passed, attempts to display the image on screen. """""" self._check_coordinate_values() perm = np.argsort(self.reaction_coordinate_values) # performing a sliding average h = self.reaction_coordinate_values.max() / float(num_bins) bins = [i * h for i in range(num_bins)] inds = np.digitize(self.reaction_coordinate_values, bins) pops = [np.sum(self.zc[np.where(inds == i)]) for i in range(num_bins)] fig = plt.figure() plt.plot(bins, -1.0 * np.log(pops), lw=2) plt.xlabel('Reaction Coordinate') plt.ylabel('Free Energy Profile (kT)') if not filename: plt.show() else: plt.savefig(filename) print(""Saved reaction coordinate plot to: %s"" % filename) return class VariableCoordinate(CutCoordinate): """""" Class that contains methods for calculating cut-based free energy profiles based on a reaction coordinate mapping that takes variable parameters. Specifically, a reaction coodinate is formally a map from phase space to the reals. Consider such a map that is dependent on some auxillary parameters `alphas`. Then we might hope to optimize that reaction coordinate by wisely choosing those weights. Parameters ---------- rxn_coordinate_function : function This is a function that represents the reaction coordinate. It takes the arguments of an msm trajectory and an array of weights (floats). It should return an array of floats, specifically the reaction coordinate scalar evaluated for each conformation in the trajectory. Graphically: rxn_coordinate_function(msm_traj, weights) --> array( [float, float, ...] ) An example function of this form is provided, for contact-map based reaction coordinates. initial_alphas : nd_array, float An array representing an initial guess at the optimal alphas. counts : matrixs A matrix of the transition counts observed in the MSM generators : msmbuilder trajectory The generators (or a trajectory containing an exemplar structure) for each state. reactant : int Index of the state to use to represent the reactant (unfolded) well product : int Index of the state to use to represent the product (folded) well """""" def __init__(self, rxn_coordinate_function, initial_alphas, counts, generators, reactant, product): CutCoordinate.__init__(self, counts, generators, reactant, product) self.rxn_coordinate_function = rxn_coordinate_function self.rc_alphas = initial_alphas self._evaluate_reaction_coordinate() def _evaluate_reaction_coordinate(self): """""" Evaluates `rxn_coordinate_function` and stores the values obtained in a local variable. """""" self.reaction_coordinate_values = self.rxn_coordinate_function( self.generators, self.rc_alphas) return def optimize(self, maxiter=1000): """""" Compute an optimized reaction coordinate, where optimized means the coordinate the maximizes the barrier between two metastable basins. Parameters ---------- maxiter : int (optional) The maximum number of iterations to run the optimization algorithm for. Note that you can always do a little, check the answer, then come back and optimize more later. Stores ------ optimal_weights : nd_array, float An array of the optimal weights, which maximize the barrier in the cut-based free energy profile. """""" self.i = 1 def objective(weights, generators): """""" returns the negative of the MFPT """""" starttime = time.clock() self._evaluate_reaction_coordinate() self.evaluate_partition_functions() mfpt = self.reaction_mfpt(lag_time=1.0) endtime = time.clock() if TIME: ""Iteration %d, time: %f"" % (self.i, endtime - starttime) self.i += 1 return -1.0 * mfpt optimal_alphas = scipy.optimize.fmin_cg(objective, self.rc_alphas, args=(self.generators,), maxiter=maxiter) self.rc_alphas = optimal_alphas self._evaluate_reaction_coordinate() return def test(): from scipy import io import mdtraj print(""Testing cfep code...."") test_dir = '/Users/TJ/Programs/msmbuilder.sandbox/tjlane/cfep/' generators = mdtraj.load(test_dir + 'Gens.h5') counts = io.mmread(test_dir + 'tCounts.mtx') reactant = 0 # generator w/max RMSD product = 10598 # generator w/min RMSD pfolds = np.loadtxt(test_dir + 'FCommittors.dat') # test the usual coordinate #pfold_cfep = CutCoordinate(counts, generators, reactant, product) # pfold_cfep.set_coordinate_values(pfolds) # pfold_cfep.plot() # pfold_cfep.set_coordinate_as_eigvector2() # print pfold_cfep.reaction_coordinate_values # pfold_cfep.plot() # pfold_cfep.set_coordinate_as_committors() # print pfold_cfep.reaction_coordinate_values # pfold_cfep.plot() # test the Variable Coordinate initial_weights = np.ones((1225, 26104)) contact_cfep = VariableCoordinate(contact_reaction_coordinate, initial_weights, counts, generators, reactant, product) contact_cfep.evaluate_partition_functions() print(contact_cfep.zh) print(contact_cfep.zc) contact_cfep.optimize() print(""Finished optimization"") contact_cfep.plot() return if __name__ == '__main__': test() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/testing.py",".py","6453","206","from __future__ import print_function, division, absolute_import from mdtraj.utils.six import iteritems # methods to support testing import os import re import functools import numpy as np from numpy.testing import (assert_allclose, assert_almost_equal, assert_approx_equal, assert_array_almost_equal, assert_array_almost_equal_nulp, assert_array_equal, assert_array_less, assert_array_max_ulp, assert_equal, assert_raises, assert_string_equal, assert_warns) from nose.tools import ok_, eq_, raises from nose import SkipTest import mdtraj as md from mdtraj import io from pkg_resources import resource_filename __all__ = ['get', 'load', 'eq', 'assert_dict_equal', 'assert_sparse_matrix_equal', 'expected_failure', 'skip', # stuff that was imported from numpy / nose too 'ok_', 'eq_', 'assert_allclose', 'assert_almost_equal', 'assert_approx_equal', 'assert_array_almost_equal', 'assert_array_almost_equal_nulp', 'assert_array_equal', 'assert_array_less', 'assert_array_max_ulp', 'assert_equal', 'assert_raises', 'assert_string_equal', 'assert_warns', 'raises'] def get(name, just_filename=False): """""" Get reference data for testing Parameters ---------- name : string name of the resource, ususally a filename or path just_filename : bool, optional if true, we just return the filename. otherwise we try to load up the data from disk Notes ----- The heuristic basically just looks at the filename extension, but it has a few tricks, like loading AtomIndices ith dtype=np.int """""" # reference is where all the data is stored fn = resource_filename('msmbuilder', os.path.join('reference', name)) if not os.path.exists(fn): raise ValueError('Sorry! %s does not exists. If you just ' 'added it, you\'ll have to re install' % fn) if just_filename: return fn return load(fn) def load(filename): # delay these imports, since this module is loaded in a bunch # of places but not necessarily used import scipy.io from msmbuilder import Project # the filename extension ext = os.path.splitext(filename)[1] # load trajectories if ext != '.h5' and ext in md._FormatRegistry.loaders.keys(): val = md.load(filename) # load flat text files elif 'AtomIndices.dat' in filename: # try loading AtomIndices first, because the default for loadtxt # is to use floats val = np.loadtxt(filename, dtype=np.int) elif ext in ['.dat']: # try loading general .dats with floats val = np.loadtxt(filename) # short circuit opening ProjectInfo elif ('ProjectInfo.yaml' in filename) or ('ProjectInfo.h5' in filename) or (re.search('ProjectInfo.*\.yaml', filename)): val = Project.load_from(filename) # load with serializer files that end with .h5, .hdf or .h5.distances elif ext in ['.h5', '.hdf']: val = io.loadh(filename, deferred=False) elif filename.endswith('.h5.distances'): val = io.loadh(filename, deferred=False) # load matricies elif ext in ['.mtx']: val = scipy.io.mmread(filename) else: raise TypeError(""I could not infer how to load this file. You "" ""can either request load=False, or perhaps add more logic to "" ""the load heuristics in this class: %s"" % filename) return val def eq(o1, o2, decimal=6): from scipy.sparse import isspmatrix assert (type(o1) is type(o2)), 'o1 and o2 not the same type: %s %s' % (type(o1), type(o2)) if isinstance(o1, dict): assert_dict_equal(o1, o2, decimal) elif isspmatrix(o1): assert_sparse_matrix_equal(o1, o2, decimal) elif isinstance(o1, np.ndarray): if o1.dtype.kind == 'f' or o2.dtype.kind == 'f': # compare floats for almost equality assert_array_almost_equal(o1, o2, decimal) else: # compare everything else (ints, bools) for absolute equality assert_array_equal(o1, o2) # probably these are other specialized types # that need a special check? else: eq_(o1, o2) def assert_dict_equal(t1, t2, decimal=6): """""" Assert two dicts are equal. This method should actually work for any dict of numpy arrays/objects """""" # make sure the keys are the same eq_(list(t1.keys()), list(t2.keys())) for key, val in iteritems(t1): # compare numpy arrays using numpy.testing if isinstance(val, np.ndarray): if val.dtype.kind == 'f': # compare floats for almost equality assert_array_almost_equal(val, t2[key], decimal) else: # compare everything else (ints, bools) for absolute equality assert_array_equal(val, t2[key]) else: eq_(val, t2[key]) def assert_sparse_matrix_equal(m1, m2, decimal=6): """"""Assert two scipy.sparse matrices are equal."""""" # delay the import to speed up stuff if this method is unused from scipy.sparse import isspmatrix from numpy.linalg import norm # both are sparse matricies assert isspmatrix(m1) assert isspmatrix(m2) # make sure they have the same format eq_(m1.format, m2.format) # make sure they have the same shape eq_(m1.shape, m2.shape) # even though its called assert_array_almost_equal, it will # work for scalars m1 = m1.tocsr() m2 = m2.tocsr() m1.eliminate_zeros() m2.eliminate_zeros() xi1, yi1 = m1.nonzero() xi2, yi2 = m2.nonzero() assert_array_equal(xi1, xi2) assert_array_equal(yi1, yi2) assert_array_almost_equal(m1.data, m2.data, decimal=decimal) # decorator to mark tests as expected failure def expected_failure(test): @functools.wraps(test) def inner(*args, **kwargs): try: test(*args, **kwargs) except BaseException: raise SkipTest else: raise AssertionError('Failure expected') return inner # decorator to skip tests def skip(rason): def wrap(test): @functools.wraps(test) def inner(*args, **kwargs): raise SkipTest print(""After f(*args)"") return inner return wrap ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/License.py",".py","1494","41","# This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # from msmbuilder.version import version LicenseString=""""""-------------------------------------------------------------------------------- MSMBuilder version %s See file AUTHORS for a list of MSMBuilder contributors. -------------------------------------------------------------------------------- Copyright 2011 Stanford University. MSMBuilder comes with ABSOLUTELY NO WARRANTY. MSMBuilder is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. --------------------------------------------------------------------------------""""""%version ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/__init__.py",".py","1864","58","# This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """"""MSMBuilder: Markov State Models from Molecular Dynamics Simulations. Authors: Kyle A. Beauchamp Gregory R. Bowman Thomas J. Lane Lutz Maibaum Vijay Pande Copyright 2011 Stanford University """""" from __future__ import print_function, division, absolute_import def _setup_logging(): """"""Helper function to set up logger imports without polluting namespace."""""" import sys import logging logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) sh = logging.StreamHandler(sys.stdout) formatter = logging.Formatter(fmt='%(asctime)s - %(message)s', datefmt=""%H:%M:%S"") sh.setFormatter(formatter) logger.addHandler(sh) logger.propagate = False _setup_logging() # list of all the modules (files) that are part of msmbuilder __all__ = [""metrics"", ""msm_analysis"", ""MSMLib"", ""clustering"", ""project"", ""reduce""] from msmbuilder import metrics from msmbuilder import clustering from msmbuilder import msm_analysis from msmbuilder import MSMLib from msmbuilder import project from msmbuilder import reduce from msmbuilder.project import Project ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/fahproject.py",".py","28278","772",""""""" This is a class that contains all of the necessary tools to interact with folding@home projects. Written by: TJ Lane Contributions from Robert McGibbon """""" from __future__ import print_function, division, absolute_import # GLOBAL IMPORTS import os import re import sys import cPickle import time from glob import glob import smtplib from email.mime.text import MIMEText from numpy import argmax import subprocess from subprocess import PIPE from multiprocessing import Pool try: from deap import dtm except: pass from msmbuilder import Trajectory from msmbuilder.metrics import RMSD from msmbuilder.project import Project from msmbuilder.utils import make_methods_pickable, keynat make_methods_pickable() import logging logger = logging.getLogger(__name__) class FahProject(object): """""" A generic class for interacting with Folding@home projects Parameters ---------- pdb : str The pdb file on disk associated with the project. project_number: int The project number assocaited with the project. projectinfo_file : str Name of the project info file. work_server : str Hostname of the work server to interact with. email : str email to forward alerts to """""" def __init__(self, pdb, project_number=1, projectinfo_file=""ProjectInfo.h5"", work_server=None, email=None): # metadata associated with a FAH project self.project_number = project_number self.work_server = work_server self.pdb_topology = pdb self.manager_email = email self.projectinfo_file = projectinfo_file # check that the PDB exists if not os.path.exists(self.pdb): logger.error(""Cannot find %s"", self.pdb) # load in the memory state if os.path.exists( projectinfo_file ): self.load_memory_state( projectinfo_file ) else: self.memory = {} logger.info(""No file: %s found. Generating new memory state."", projectinfo_file) logger.info(""Processing all trajectories, will save progress to: %s"", projectinfo_file) # set the nested classes defined below to be separate namespaces # this should separate concerns and prevent (dangerous) user mistakes self.retrieve = _retrieve(self) self.inject = _inject(self) def restart_server(self): """""" Restarts the workserver, should be called when injecting runs. Checks that the server comes back up without throwing an error - if it doesn't come up OK, sends mail to the project manager. """""" raise NotImplementedError() # restart the server, wait 60s to let it come back up logger.warning(""Restarting server: %s"", self.work_server) stop_cmd = ""/etc/init.d/FAHWorkServer-%s stop"" % self.work_server start_cmd = ""/etc/init.d/FAHWorkServer-%s start"" % self.work_server r = subprocess.call(stop_cmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE) time.sleep(60) r = subprocess.call(stop_cmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE) # check that we came back up OK, if not freak out processname = ""FAHWorkServer-%s"" % self.work_server is_alive = False # guilty until proven innocent for line in os.popen(""ps -a""): if line.find(processname) > 0: is_alive = True if not is_alive: error_msg = """""" FATAL ERROR: msmbuilder.FahProject is reporting a critical issue: Workserver %s did not come back up after restart! Recommend you attend to this immediately."""""" % self.workserver if email: send_error_email(self, error_msg) raise Exception(error_msg) return def send_error_email(self, error_msg): """""" Sends an error message to the registered email. Parameters ---------- error_msg : str The string to include in the email. """""" raise NotImplementedError() if email == None: logger.error(""Cannot send error email - no email provided"") return msg = MIMEText(error_msg) msg['Subject'] = '[msmbuilder.FahProject] FATAL ERROR IN FAHPROJECT' msg['From'] = 'msmbuilder@gmail.com' msg['To'] = self.email # Send the message via our own SMTP server, but don't include the envelope header. logger.error(""Sending error email to: %s"", self.email) s = smtplib.SMTP('smtp.gmail.com') s.sendmail(me, [you], msg.as_string()) s.quit() return def save_memory_state(self): """""" Saves the 'memory state' to disk in a serialized format. Notes ----- When saving, we encode the keys into base16 with a leading 'a', because the HDF5 Serializer doesnt' like '/' characters and is super picky in general See Also -------- load_memory_state """""" project_info = Project.load_from_hdf( projectinfo_file ) project_info[""Memory""] = cPickle.dumps( self.memory ) project_info.save_to_hdf( projectinfo_file, do_file_check=False ) return def load_memory_state(self, projectinfo_file): """""" Loads the 'memory state' from a serialized file on disk Parameters ---------- projectinfo_file : str The file on disk from which to read. Notes ----- When reading the memory state, we have to decode base16, and also remove leading 'a' characters See Also -------- save_memory_state """""" logger.info(""Loading memory state from: %s"", projectinfo_file) project_info = Project.load_from_hdf( projectinfo_file ) self.memory = cPickle.loads( project_info[""Memory""] ) return class _inject(object): """""" Contains all of the methods for directing a FAH project. These functions will change what is on the workserver, modifying files and creating new files to manage sampling. """""" ################################################################# # # The below code is still under development. We are waiting on a # few more things to progress in the FAH WS code API, and also # advances in MSMAccelerator, which will make these methods useful. # -- TJL, Aug. '12 # # un-nest the local namespace from the parent class def __init__(self, outerclass): """""" Initialize the _inject subclass of FahProject. Should not be called by the user! """""" raise NotImplementedError('If youd like to use this functionality, email TJ' ' and send love and affection') self.__dict__.update(outerclass.__dict__) self.send_error_email = outerclass.send_error_email self.restart_server = outerclass.restart_server # if we are on a workserver, if self.work_server != None: self.set_project_basepath() def set_project_basepath(self): """""" Finds and internally stores a FAH Project's path. """""" search = glob(""/home/*/server2/data/SVR*/PROJ%d"" % self.project_number) if len(search) != 1: raise Exception(""Could not find unique FAH project: %d on %s"" % (self.project_number, self.work_server)) else: self.project_basepath = search[0] def new_run(self): """""" Creates a new run in the project directory, and adds that run to the project.xml file. Does not directly reboot the server. """""" # create the new run directory raise NotImplementedError() # add the run to the project.xml def stop_run(self, run): """""" Stops all CLONES in a RUN. Parameters ---------- run : int The run to stop. """""" logger.warning(""Shutting down RUN%d"", run) clone_dirs = glob(run_dir + ""CLONE*"") for clone_dir in clone_dirs: g = re.search('CLONE(\d+)', 'CLONE55') if g: clone = g.group(1) self.stop_clone(run, clone) return def stop_clone(self, run, clone): """""" Stops the specified RUN/CLONE by changing the name of the WU's trr, adding .STOP to the end. Parameters ---------- run : int The run containing the clone to stop. clone : int The clone to stop. """""" clone_dir = os.path.join(self.project_basepath, 'RUN%d/' % run, 'CLONE%d/' % clone) # add .STOP to all dem TRR files trrs = glob( clone_dir + '*.trr' ) if len(trrs) == 0: logger.error(""Could not find any TRRs to stop in %s. Proceeding."", clone_dir) else: for trr in trrs: os.rename(trr, trr+'.STOP') loggger.info(""Stopped: %s"", trr) return class _retrieve(object): """""" Contains all of the functions necessary for getting data from the workserver. Functions are able to navagate the WS directory structure and get trajectories and other information. """""" # un-nest the local namespace from the parent class def __init__(self, outerclass): """""" Initialize the _retrieve subclass of FahProject. Should not be called by the user! """""" self.__dict__.update(outerclass.__dict__) self.save_memory_state = outerclass.save_memory_state def write_all_trajectories(self, input_dir, output_dir, stride, max_rmsd, min_gens, center_conformations, num_proc, input_style, update=False): """""" Convert all of the trajectories in the FAH project in input_dir to h5 trajectory files which will be placed in output dir. If the 'update' flag is set, then will use the memory object to check for previously converted data, and add to it (rather than reconverting everything). This functionality can be more cleanly called through the update_trajectories() method. Parameters ---------- input_dir : str The directory to look for XTC/DCD files in. output_dir : str The place to write the converted h5s stride : int The size of the stride to employ. E.g., if stride = 3, the script keeps every 3rd MD snapshot from the original data. Useful to throw away highly correlated data if snapshots were saved frequently. max_rmsd : float Throw away any data that is further than `max_rmsd` (in nm) from the pdb file associated with the project. This is used as a sanity check to prevent including, e.g. data from a simulation that is blowing up. min_gens : int Discard trajectories with fewer than `min_gens` generations. center_conformations : bool Whether to center the converted (h5) conformations. num_proc : int Number of processors to employ. Note that this function is typically I/O limited, so paralellism is unlikely to yield much gain. input_style : {'FAH', 'FILE'} If you use input_style = 'FAH', this code uses knowledge of the RUN*/CLONE* directory structure to yield all the CLONE directories. If you use input_style = 'FILE', this code uses os.walk() which is A LOT slower because it has to stat every file, but is capable of recursively searching for xtc files to arbitrary depths. update : bool If `True`, then tries to figure out what data has already been converted by reading the ""memory state"" in the provided ProjectInfo file, and only converts new data. If `False`, does a fresh re-convert. Notes ----- Since sometimes a conversion fails, we collect all trajectories at the end and renumber them such that they are contiguously numbered. """""" if update: assert os.path.exists(output_dir) else: try: os.mkdir(output_dir) except OSError: logger.error('Error: The directory %s already exists', output_dir) sys.exit(1) intermediate_filename_root = '_trj' # A placeholder name #dtm does not play nice with OpenMP use_parallel_rmsd = (num_proc != 'use_dtm_instead') jobs = [] for i, clone_dir in enumerate(self.yield_xtc_directories(input_dir, input_style)): job = {'clone_dir' : clone_dir, 'output_dir': output_dir, 'pdb_file': self.pdb_topology, 'trajectory_number': i, 'stride': stride, 'max_rmsd': max_rmsd, 'min_gens': min_gens, 'center_conformations': center_conformations, 'memory_check': update, 'omp_parallel_rmsd': use_parallel_rmsd } jobs.append(job) if len(jobs) == 0: raise RuntimeError('No conversion jobs found!') if num_proc == 'use_dtm_instead': # use DTM mpi parallel map dtm.map(self.write_trajectory_mapper, jobs) elif num_proc > 1: # use multiprocessing pool = Pool(processes=num_proc) pool.map(self.write_trajectory_mapper, jobs) else: # use regular serial execution for j in jobs: self.write_trajectory_mapper(j) # Rename trajectory files such that they have contiguous numbering logger.info(""Finished Generating Trajectories. Renaming them now in contiguous order"") mapping = {} # document the directory changes, allowing us to update memory for i, filename in enumerate( sorted( os.listdir(output_dir), key=keynat) ): path = os.path.join(output_dir, filename) new_path = os.path.join(output_dir, ""trj%d.h5"" % i) os.rename(path, new_path) mapping[path] = new_path # update the memory hash to accound for our renumbering for key in self.memory.keys(): if key not in ['convert_parameters', 'SerializerFilename']: logger.info(""%s --> %s"", self.memory[key][0], mapping[ self.memory[key][0] ]) self.memory[key][0] = mapping[ self.memory[key][0] ] # save the parameters used for this run in the memory file, and write to disk logger.info(""Generating Project File: %s"", self.projectinfo_file) if update: try: os.remove( self.projectinfo_file ) # if we are updating, just start w fresh slate except: pass self.memory['convert_parameters'] = (input_dir, output_dir, stride, max_rmsd, min_gens, center_conformations, num_proc, self.projectinfo_file, input_style ) Project.CreateProjectFromDir( Filename = self.projectinfo_file, TrajFilePath = output_dir, TrajFileBaseName = 'trj', TrajFileType = '.h5', ConfFilename = self.pdb_topology, initial_memory = cPickle.dumps( self.memory ) ) logger.info(""Data converted properly."") return def update_trajectories(self): """""" Using the memory state, updates a trajectory of H5 Trajectory files by scanning a FAH project for new trajectories, and converting those. """""" logger.info(self.memory['convert_parameters']) (input_dir, output_dir, stride, max_rmsd, min_gens, \ center_conformations, num_proc, self.projectinfo_file, input_style ) = self.memory['convert_parameters'] self.write_all_trajectories(input_dir, output_dir, stride, max_rmsd, min_gens, center_conformations, num_proc, input_style, update=True) return def write_trajectory_mapper(self, args): """""" Helper function: Because it is designed to be called via map(), which only supports supplying 1 iterable to the function, this function must formally only take 1 argument. """""" try: clone_dir = args['clone_dir'] output_dir = args['output_dir'] trajectory_number = args['trajectory_number'] stride = args['stride'] max_rmsd = args['max_rmsd'] min_gens = args['min_gens'] center_conformations = args['center_conformations'] memory_check = args['memory_check'] omp_parallel_rmsd = args['omp_parallel_rmsd'] except KeyError as e: logger.critical(""""""One or more required keys (%s) was not suplied in the input argument to create_trajectory()."""""", e) sys.exit(1) self.write_trajectory(clone_dir, output_dir, trajectory_number, stride, max_rmsd, min_gens, center_conformations, memory_check, omp_parallel_rmsd) return def write_trajectory(self, clone_dir, output_dir, trajectory_number, stride, max_rmsd, min_gens, center_conformations, memory_check, omp_parallel_rmsd=True): """""" This function takes in a path to a CLONE and merges all the XTC files it finds into a H5 trajectory: Parameters ---------- clone_dir : str the directory in which the xtc files are found. All of the xtc files in this directory are joined together to make a single trajectory (.h5) output file output_dir : str directory where the outputted files will be placed trajectory_number : int A unique number for this trajectory. This number is used in constructing the filename to write the outputted .h5 trajectory to, and thus must be unique stride: int Subsample by only considering every Nth snapshop. max_rmsd: {int, None} if this value is not None, calculate the RMSD to the pdb_file from each snapshot and reject trajectories which have snapshots with RMSD greated than max_rmsd. If None, no check is performed min_gens : int Discard the trajectories that contain fewer than `min_gens` XTC files. center_conformations : bool center conformations before saving. memory_check : bool if yes, uses the memory dictionary to do an update rather than a complete re-convert. omp_parallel_rmsd : bool If true, use OpenMP accelerated RMSD calculation for max_rmsd check """""" xtc_files = self.list_xtcs_in_dir(clone_dir) # Ensure that we're only joining contiguously numbered xtc files -- starting at 0 -- # into a trajectory. If there are gaps in the xtc files in the directory, we only # want to use the the ones such that they are contiguously numbered i = 0 for i, filename in enumerate(xtc_files): if self.integer_component(filename) != i: logger.error(""Found discontinuity in xtc numbering - check data in %s"", clone_dir) xtc_files = xtc_files[0:i] break # check the memory object to see which xtc files have already been converted, and # exclude those from this conversion if memory_check: if clone_dir in self.memory.keys(): previous_convert_exists = True num_xtcs_converted = self.memory[clone_dir][1] if len(xtc_files) == num_xtcs_converted: # if we have converted everything, logger.info(""Already converted all files in %s, skipping..."", clone_dir) return # just bail out else: xtc_files = xtc_files[num_xtcs_converted:] else: previous_convert_exists = False else: previous_convert_exists = False xtc_file_paths = [os.path.join(clone_dir, f) for f in xtc_files] logger.info(""Processing %d xtc files in clone_dir = %s"", len(xtc_files), clone_dir) if len(xtc_files) <= min_gens: logger.info(""Skipping trajectory in clone_dir = %s"", clone_dir) logger.info(""Too few xtc files (generations)."") return try: # [this should check for and discard overlapping snapshots] trajectory = Trajectory.load_from_xtc(xtc_file_paths, PDBFilename=self.pdb_topology, discard_overlapping_frames=True) except IOError as e: logger.error(""IOError (%s) when processing trajectory in clone_dir = %s"", e, clone_dir) logger.error(""Attempting rescue by disregarding final frame, which is often"") logger.error(""the first/only frame to be corrupted"") if len(xtc_file_paths) == 1: logger.error(""Didn't find any other frames in %s, continuing..."", clone_dir) return try: trajectory = Trajectory.load_from_xtc(xtc_file_paths[0:-1], PDBFilename=self.pdb_topology) except IOError: logger.error(""Unfortunately, the error remained even after ignoring the final frame."") logger.error(""Skipping the trajectory in clone_dir = %s"", clone_dir) return else: logger.error(""Sucessfully recovered from IOError by disregarding final frame."") if max_rmsd is not None: atomindices = [ int(i)-1 for i in trajectory['AtomID'] ] rmsdmetric = RMSD(atomindices, omp_parallel=omp_parallel_rmsd) ppdb = rmsdmetric.prepare_trajectory(Trajectory.load_trajectory_file(self.pdb_topology)) ptraj = rmsdmetric.prepare_trajectory(trajectory) rmsds = rmsdmetric.one_to_all(ppdb, ptraj, 0) if max(rmsds) > max_rmsd: logger.warning(""Snapshot %d RMSD %f > the %f cutoff"" , argmax(rmsds), max(rmsds), max_rmsd) logger.warning(""Dropping trajectory"") return if center_conformations: RMSD.TheoData.centerConformations(trajectory[""XYZList""]) # if we are adding to a previous trajectory, we have to load that traj up and extend it if previous_convert_exists: output_filename = self.memory[clone_dir][0] output_file_path = output_filename logger.info(""Extending: %s"", output_filename) assert os.path.exists( output_filename ) # load the traj and extend it [this should check for and discard overlapping snapshots] Trajectory.append_frames_to_file( output_filename, trajectory['XYZList'][::stride], discard_overlapping_frames=True ) num_xtcs_processed = len(xtc_file_paths) + self.memory[clone_dir][1] # if we are not adding to a traj, then we create a new one else: output_filename = 'trj%s.h5' % trajectory_number output_file_path = os.path.join(output_dir, output_filename) if os.path.exists(output_file_path): logger.info(""The file name %s already exists. Skipping it."", output_file_path) return # stide and discard by snapshot trajectory['XYZList'] = trajectory['XYZList'][::stride] trajectory.save(output_file_path) num_xtcs_processed = len(xtc_file_paths) # log what we did into the memory object self.memory[clone_dir] = [ output_file_path, num_xtcs_processed ] return def yield_xtc_directories(self, input_dir, input_style): """""" This function is an enumerator that yields all of the directories under the input_dir that contain XTCs to be merged into trajectories. If you use input_style = 'FAH', this code uses knowledge of the RUN*/CLONE* directory structure to yield all the CLONE directories. If you use input_style = 'FILE', this code uses os.walk() which is A LOT slower because it has to stat every file, but is capable of recursively searching for xtc files to arbitrary depths. Parameters ---------- input_dir : str The directory to read xtcs from input_style : {'FILE', 'FAH'} Which search strategy to employ. """""" if input_style == 'FAH': input_dir_contents = os.listdir(input_dir) for input_dir_entry in input_dir_contents: run_directory = os.path.join(input_dir, input_dir_entry) if input_dir_entry.startswith(""RUN"") and os.path.isdir(run_directory): #look through each file in the RUN* directory run_directory_contents = os.listdir(run_directory) for run_directory_entry in run_directory_contents: path = os.path.join(run_directory, run_directory_entry) if run_directory_entry.startswith(""CLONE"") and os.path.isdir(path): yield path elif input_dir_entry.startswith(""CLONE"") and os.path.isdir(run_directory): yield os.path.join(input_dir, input_dir_entry) # FAH style is faster, but FILE style is more flexable elif input_style == 'FILE': for (dirpath, dirnames, filenames) in os.walk(input_dir): # if any of the filenames in this directory end in .xtc, then yield this directory def contains_xtcs(filenames): for filename in filenames: #if filename.endswith('.xtc'): # return True #else: return False if contains_xtcs(filenames): yield dirpath else: raise Exception((""""""This function was invoked incorrectly. The only acceptable choices for 'input_style' are 'FILE and 'FAH'. You supplied %s"""""" % input_style)) def list_xtcs_in_dir(self, dir): """""" Find all the xtc files in `dir`. Parameters ---------- dir : str Path of the directory to look in. Returns ------- xtc_files : list List of the xtcs in `dir`. """""" pattern = re.compile('\D+(\d+)[.]xtc') xtc_files = [e for e in os.listdir(dir) if pattern.search(e)] xtc_files.sort(key=self.integer_component) logger.info(xtc_files) return xtc_files def integer_component(self, filename): """""" Extract a the numeric part of the filename for sorting Parameters ---------- filename : str The file name to parse. Returns ------- substr : str The numeric part of the filename for sorting. """""" pattern = re.compile('\D+(\d+)[.]xtc') try: substr = pattern.match(filename).group(1) return int(substr) except: logger.error(""A filename (%s) may not have been sorted correctly"", filename) return 0 ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/MSMLib.py",".py","44169","1241","# This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """"""Classes and functions for working with Transition and Count Matrices. Notes * Assignments typically refer to a numpy array of integers such that Assignments[i,j] gives the state of trajectory i, frame j. * Transition and Count matrices are typically stored in scipy.sparse.csr_matrix format. MSMLib functions generally relate to one of the following * Counting the number of transitions observed in Assignment data--e.g., constructing a Count matrix. * Constructing a transition matrix from a count matrix. * Performing calculations with Assignments, Counts matrices, or transition matrices. .. currentmodule:: msmbuilder.MSMLib .. autosummary:: :toctree: generated/ apply_mapping_to_assignments apply_mapping_to_vector build_msm ergodic_trim ergodic_trim_indices estimate_rate_matrix estimate_transition_matrix get_count_matrix_from_assignments get_counts_from_traj invert_assignments log_likelihood mle_reversible_count_matrix permute_mat renumber_states tarjan trim_states """""" from __future__ import print_function, absolute_import, division from mdtraj.utils.six import iteritems import scipy.sparse import scipy.linalg import scipy import numpy as np import scipy.optimize from collections import defaultdict from msmbuilder.utils import deprecated, check_assignment_array_input from msmbuilder import msm_analysis import logging logger = logging.getLogger(__name__) __all__ = ['apply_mapping_to_assignments', 'apply_mapping_to_vector', 'build_msm', 'ergodic_trim', 'ergodic_trim_indices', 'estimate_rate_matrix', 'estimate_transition_matrix', 'get_count_matrix_from_assignments', 'get_counts_from_traj', 'invert_assignments', 'log_likelihood', 'mle_reversible_count_matrix', 'permute_mat', 'renumber_states', 'tarjan', 'trim_states'] def estimate_rate_matrix(count_matrix, assignments): """"""MLE Rate Matrix given transition counts and *dwell times* Parameters ---------- count_matrix : sparse or dense matrix transition counts assignments : ndarray 2D assignments array used to compute average dwell times Returns ------- K : csr_matrix Rate matrix Notes ----- The *correct* likelihood function to use for estimating the rate matrix when the data is sampled at a discrete frequency is open for debate. This likelihood function doesn't take into account the error in the lifetime estimates from the discrete sampling. Other methods are currently under development (RTM 6/27) See Also -------- estimate_transition_matrix References ---------- .. [1] Buchete NV, Hummer G. ""Coarse master equaions for peptide folding dynamics."" J Phys Chem B 112:6057-6069. """""" # Find the estimated dwell times (need to deal w negative ones) neg_ind = np.where(assignments == -1) n = np.max(assignments.flatten()) + 1 assignments[neg_ind] = n R = np.bincount(assignments.flatten()) R = R[:n] assert count_matrix.shape[0] == R.shape[0] # Most Likely Estimator ( Kij(hat) = Nij / Ri ) if scipy.sparse.isspmatrix(count_matrix): C = scipy.sparse.csr_matrix(count_matrix).asfptype() D = scipy.sparse.dia_matrix((1.0 / R, 0), C.shape).tocsr() K = D * C # if all is sparse is matrix multiply, formerly: D.dot( C ) else: # deprecated due to laziness --TJL raise ValueError(""ERROR! Pass sparse matrix to me"") # Now get the diagonals right. They should be negative row sums row_sums = np.asarray(C.sum(axis=1)).flatten() current = K.diagonal() S = scipy.sparse.dia_matrix(((row_sums + (2.0 * current)), 0), C.shape).tocsr() K = K - S if not K.shape == count_matrix.shape: raise RuntimeError('Bad news bears') # assert K.sum(0).all() == np.zeros(K.shape[0]).all(), K.sum(0).all() return K def estimate_transition_matrix(count_matrix): """""" Simple Maximum Likelihood estimator of transition matrix. Parameters ---------- count_matrix : array or sparse matrix A square matrix of transition counts Returns ------- tProb : array or sparse matrix Most likely transition matrix given `tCount` """""" # 1. Make sure you don't modify tCounts. # 2. Make sure you handle both floats and ints eps = np.finfo(np.float32).tiny if scipy.sparse.isspmatrix(count_matrix): C = scipy.sparse.csr_matrix(count_matrix).asfptype() weights = np.asarray(C.sum(axis=1)).flatten() inv_weights = np.zeros(len(weights)) inv_weights[weights > eps] = 1.0 / weights[weights > eps] D = scipy.sparse.dia_matrix((inv_weights, 0), C.shape).tocsr() tProb = D.dot(C) else: tProb = np.asarray(count_matrix.astype(float)) # astype creates a copy weights = tProb.sum(axis=1) inv_weights = np.zeros(len(weights)) inv_weights[weights > eps] = 1.0 / weights[weights > eps] tProb = tProb * inv_weights.reshape((weights.shape[0], 1)) return tProb def build_msm(counts, symmetrize='MLE', ergodic_trimming=True): """""" Estimates the transition probability matrix from the counts matrix. Parameters ---------- counts : scipy.sparse.csr_matrix the MSM counts matrix symmetrize : {'MLE', 'Transpose', None} symmetrization scheme so that we have reversible counts ergodic_trim : bool (optional) whether or not to trim states to achieve an ergodic model Returns ------- rev_counts : matrix the estimate of the reversible counts t_matrix : matrix the transition probability matrix populations : ndarray, float the equilibrium populations of each state mapping : ndarray, int a mapping from the passed counts matrix to the new counts and transition matrices """""" symmetrize = str(symmetrize).lower() symmetrization_error = ValueError(""Invalid symmetrization scheme "" ""requested: %s. Exiting."" % symmetrize) if symmetrize not in ['mle', 'transpose', 'none']: raise symmetrization_error if ergodic_trimming: counts, mapping = ergodic_trim(counts) else: mapping = np.arange(counts.shape[0]) # Apply a symmetrization scheme if symmetrize == 'mle': if not ergodic_trimming: raise ValueError(""MLE symmetrization requires ergodic trimming."") rev_counts = mle_reversible_count_matrix(counts) elif symmetrize == 'transpose': rev_counts = 0.5 * (counts + counts.transpose()) elif symmetrize == 'none': rev_counts = counts else: raise symmetrization_error t_matrix = estimate_transition_matrix(rev_counts) if symmetrize in ['mle', 'transpose']: populations = np.array(rev_counts.sum(0)).flatten() elif symmetrize == 'none': vectors = msm_analysis.get_eigenvectors(t_matrix, 5)[1] populations = vectors[:, 0] else: raise symmetrization_error populations /= populations.sum() # ensure normalization return rev_counts, t_matrix, populations, mapping def get_count_matrix_from_assignments(assignments, n_states=None, lag_time=1, sliding_window=True): """""" Calculate counts matrix from `assignments`. Parameters ---------- assignments : ndarray A 2d ndarray containing the state assignments. n_states : int, optional Can be automatically determined, unless you want a model with more states than are observed lag_time: int, optional the LagTime with which to estimate the count matrix. Default: 1 sliding_window: bool, optional Use a sliding window. Default: True Returns ------- counts : sparse matrix `Counts[i,j]` stores the number of times in the assignments that a trajectory went from state i to state j in `LagTime` frames Notes ----- assignments are input as iterables over numpy 1-d arrays of integers. For example a 2-d array where assignments[i,j] gives the ith trajectory, jth frame. The beginning and end of each trajectory may be padded with negative ones, which will be ignored. If the number of states is not given explitly, it will be determined as one plus the largest state index of the Assignments. Sliding window yields non-independent samples, but wastes less data. """""" check_assignment_array_input(assignments) if not n_states: # Lutz: a single np.max is not enough, b/c it can't handle a list of 1-d arrays of different lengths n_states = 1 + int(np.max([np.max(a) for a in assignments])) if n_states < 1: raise ValueError() # Lutz: why are we using float for count matrices? C = scipy.sparse.lil_matrix((int(n_states), int(n_states)), dtype='float32') for A in assignments: FirstEntry = np.where(A != -1)[0] # New Code by KAB to skip pre-padded negative ones. # This should solve issues with Tarjan trimming results. if len(FirstEntry) >= 1: FirstEntry = FirstEntry[0] A = A[FirstEntry:] # .tolil() C = C + get_counts_from_traj(A, n_states, lag_time=lag_time, sliding_window=sliding_window) return C def get_counts_from_traj(states, n_states=None, lag_time=1, sliding_window=True): """"""Computes the transition count matrix for a sequence of states (single trajectory). Parameters ---------- states : array A one-dimensional array of integers representing the sequence of states. These integers must be in the range [0, n_states] n_states : int The total number of states. If not specified, the largest integer in the states array plus one will be used. lag_time : int, optional The time delay over which transitions are counted sliding_window : bool, optional Use sliding window Returns ------- C : sparse matrix of integers The computed transition count matrix """""" check_assignment_array_input(states, ndim=1) if not n_states: n_states = np.max(states) + 1 if sliding_window: from_states = states[: -lag_time: 1] to_states = states[lag_time:: 1] else: from_states = states[: -lag_time: lag_time] to_states = states[lag_time:: lag_time] assert from_states.shape == to_states.shape transitions = np.row_stack((from_states, to_states)) counts = np.ones(transitions.shape[1], dtype=int) try: C = scipy.sparse.coo_matrix((counts, transitions), shape=(n_states, n_states)) except ValueError: # Lutz: if we arrive here, there was probably a state with index -1 # we try to fix it by ignoring transitions in and out of those states # (we set both the count and the indices for those transitions to 0) mask = transitions < 0 counts[mask[0, :] | mask[1, :]] = 0 transitions[mask] = 0 C = scipy.sparse.coo_matrix((counts, transitions), shape=(n_states, n_states)) return C def apply_mapping_to_assignments(assignments, mapping): """"""Remap the states in an assignments file according to a mapping. Parameters ---------- assignments : ndarray Standard 2D assignments array mapping : ndarray 1D numpy array of length equal to the number of states in Assignments. Mapping[a] = b means that the frames currently in state a will be mapped to state b Returns ------- NewAssignments : ndarray Notes ----- This function is useful after performing PCCA or Ergodic Trimming. Also, the state -1 is treated specially -- it always stays -1 and is not remapped. """""" check_assignment_array_input(assignments) NewMapping = mapping.copy() # Make a special state for things that get deleted by Ergodic Trimming. NewMapping[np.where(mapping == -1)] = mapping.max() + 1 NegativeOneStates = np.where(assignments == -1) assignments[:] = NewMapping[assignments] WhereEliminatedStates = np.where(assignments == (mapping.max() + 1)) # These are the dangling 'tails' of trajectories (with no actual data) that we denote state -1. assignments[NegativeOneStates] = -1 # These states have typically been ""deleted"" by the ergodic trimming # algorithm. Can be at beginning or end of trajectory. assignments[WhereEliminatedStates] = -1 def invert_assignments(assignments): """"""Invert an assignments array -- that is, produce a mapping from state -> traj/frame Parameters ---------- assignments : np.ndarray 2D array of MSMBuilder assignments Returns ------- inverse_mapping : collections.defaultdict Mapping from state -> traj,frame, such that inverse_mapping[s] gives the conformations assigned to state s. Notes ----- The assignments array may have -1's, which are simply placeholders we do not add these to the inverted assignments. Therefore, doing the following will raise a KeyError: >>> inv_assignments = MSMLib.invert_assignments(assignments) >>> print inv_assignments[-1] KeyError: -1 """""" check_assignment_array_input(assignments) inverse_mapping = defaultdict(lambda: ([], [])) non_neg_inds = np.array(np.where(assignments != -1)).T # we do not care about -1's for (i, j) in non_neg_inds: inverse_mapping[assignments[i, j]][0].append(i) inverse_mapping[assignments[i, j]][1].append(j) # convert from lists to numpy arrays for key, (trajs, frames) in iteritems(inverse_mapping): inverse_mapping[key] = (np.array(trajs), np.array(frames)) return inverse_mapping def apply_mapping_to_vector(vector, mapping): """""" Remap an observable vector after ergodic trimming RTM 6/27: I don't think this function is really doing what it should. It does a reordering, but when the mapping is a many->one, don't you really want to average things together or something? TJL 7/1: That's true. I wrote this with only the ergodic trimming in mind, it needs to be updated if it's going to work w/PCCA as well... Parameters ---------- vector : ndarray 1D. Some observable value associated with each states Mapping : ndarray 1D numpy array of length equal to the number of states in Assignments. Mapping[a] = b means that the frames currently in state a are now assigned to state b, and thus their observable should be too Returns ------- new_vector : ndarray mapped observable values Notes ----- The state -1 is treated specially -- it always stays -1 and is not remapped. """""" new_vector = vector[np.where(mapping != -1)[0]] logger.info(""Mapping %d elements --> %d"", len(vector), len(new_vector)) return new_vector def renumber_states(assignments): """"""Renumber states to be consecutive integers (0, 1, ... , n), performs this transformation in place. Parameters ---------- assignments : ndarray 2D array of msmbuilder assignments Returns ------- mapping : ndarray, int A mapping from the old numbering scheme to the new, such that mapping[new] = old Notes ----- Useful if some states have 0 counts. """""" check_assignment_array_input(assignments) unique = list(np.unique(assignments)) if unique[0] == -1: minus_one = np.where(assignments == -1) unique.pop(0) else: minus_one = [] inverse_mapping = invert_assignments(assignments) for i, x in enumerate(unique): assignments[inverse_mapping[x]] = i assignments[minus_one] = -1 mapping = np.array(unique, dtype=int) return mapping @deprecated(scipy.sparse.csgraph.connected_components, '2.8') def tarjan(graph): """"""Find the strongly connected components in a graph using Tarjan's algorithm. Parameters ---------- graph : scipy.sparse.csr_matrix mapping from node names to lists of successor nodes. Returns ------- components : list list of the strongly connected components Notes ----- Code based on ActiveState code by Josiah Carlson (New BSD license). Most users will want to call the ErgodicTrim() function rather than directly calling Tarjan(). See Also -------- ErgodicTrim """""" n_states = graph.shape[0] # Keeping track of recursion state info by node Nodes = np.arange(n_states) NodeNums = [None for i in range(n_states)] NodeRoots = np.arange(n_states) NodeVisited = [False for i in range(n_states)] NodeHidden = [False for i in range(n_states)] NodeInComponent = [None for i in range(n_states)] stack = [] components = [] nodes_visit_order = [] graph.next_visit_num = 0 def visit(v): ""Mark a state as visited"" call_stack = [(1, v, graph.getrow(v).nonzero()[1], None)] while call_stack: tovisit, v, iterator, w = call_stack.pop() if tovisit: NodeVisited[v] = True nodes_visit_order.append(v) NodeNums[v] = graph.next_visit_num graph.next_visit_num += 1 stack.append(v) if w and not NodeInComponent[v]: NodeRoots[v] = nodes_visit_order[min(NodeNums[NodeRoots[v]], NodeNums[NodeRoots[w]])] cont = 0 for w in iterator: if not NodeVisited[w]: cont = 1 call_stack.append((0, v, iterator, w)) call_stack.append((1, w, graph.getrow(w).nonzero()[1], None)) break if not NodeInComponent[w]: NodeRoots[v] = nodes_visit_order[min(NodeNums[NodeRoots[v]], NodeNums[NodeRoots[w]])] if cont: continue if NodeRoots[v] == v: c = [] while 1: w = stack.pop() NodeInComponent[w] = c c.append(w) if w == v: break components.append(c) # the ""main"" routine for v in Nodes: if not NodeVisited[v]: visit(v) # extract SCC info for n in Nodes: if NodeInComponent[n] and len(NodeInComponent[n]) > 1: # part of SCC NodeHidden[n] = False else: # either not in a component, or singleton case NodeHidden[n] = True return(components) def ergodic_trim(counts, assignments=None): """"""Use Tarjan's Algorithm to find maximal strongly connected subgraph. Parameters ---------- counts : sparse matrix (csr is best) transition counts assignments : ndarray, optional Optionally map assignments to the new states, nulling out disconnected regions. Returns ---- trimmed_counts : lil sparse matrix transition counts after ergodic trimming mapping : ndarray mapping[i] = j maps from untrimmed state index i to trimmed state index j, or mapping[i] = -1 if state i was trimmed Notes ----- The component with maximum number of counts is selected See Also -------- Tarjan """""" states_to_trim = ergodic_trim_indices(counts) trimmed_counts = trim_states(states_to_trim, counts, assignments=assignments) # Hacky way to calculate the mapping of saved / discarded states. mapping = np.array([np.arange(counts.shape[0])]) # Need 2D shape for renumber_states. mapping[:, states_to_trim] = -1 renumber_states(mapping) # renumbers into contiguous order, in-place mapping = mapping[0] # Unpack the 2D array into a 1D array. return trimmed_counts, mapping def ergodic_trim_indices(counts): """""" Finds the indices of the largest strongly connected subgraph implied by the transitions in `counts`. Parameters ---------- counts : matrix The MSM counts matrix Returns ------- states_to_trim : ndarray, int A list of the state indices that should be trimmed to obtain the See Also -------- trim_states : func """""" n_components, component_assignments = scipy.sparse.csgraph.connected_components(counts, connection=""strong"") populations_symmetrized = np.array(counts.sum(0)).flatten() component_pops = np.array([populations_symmetrized[component_assignments == i].sum() for i in range(n_components)]) which_component = component_pops.argmax() logger.info(""Selected component %d with population %f"", which_component, component_pops[which_component] / component_pops.sum()) states_to_trim = np.arange(counts.shape[0])[component_assignments != which_component] return states_to_trim def trim_states(states_to_trim, counts, assignments=None): """""" Performs the necessary operations to reduce an MSM to a subset of the original states -- effectively trimming those states out. Parameters ---------- states_to_trim : ndarray, int OR list of ints A list of indices of the states to trim counts : matrix A counts matrix assignments : ndarray, int (optional) An assignments array Returns ------- trimmed_counts : matrix The trimmed counts matrix trimmed_assignments : ndarray (if assignments are provided) The assignements, with values for ""trimmed"" states set to ""-1"", which is read as an empty value by MSMBuilder """""" # Trim the counts matrix by simply deleting the appropriate rows & columns. # Switching to lil format makes it easy to delete rows directly -- # maybe not most efficient, but easy to understand (and shouldn't be # a bottleneck) counts = counts.tolil() ndel = len(states_to_trim) # delete rows counts.rows = np.delete(counts.rows, states_to_trim) counts.data = np.delete(counts.data, states_to_trim) counts._shape = (counts._shape[0] - ndel, counts._shape[1]) # delete cols counts = counts.T counts.rows = np.delete(counts.rows, states_to_trim) counts.data = np.delete(counts.data, states_to_trim) counts._shape = (counts._shape[0] - ndel, counts._shape[1]) counts = counts.T if assignments is not None: # Use the ORIGINAL number of states! Re bug #300 mapping = np.arange(counts.shape[0] + ndel) mapping[states_to_trim] = -1 # renumber_states requires rank 2 input, not rank 1. Re bug #300 mapping = np.array([mapping]) renumber_states(mapping) # renumbers into contiguous order, in-place mapping = mapping[0] # Unpack the 2D array into a 1D array. Re bug #300 trimmed_assignments = assignments.copy() apply_mapping_to_assignments(trimmed_assignments, mapping) # in-place return counts, trimmed_assignments else: return counts def log_likelihood(count_matrix, transition_matrix): """"""log of the likelihood of an observed count matrix given a transition matrix Parameters ---------- count_matrix : ndarray or sparse matrix Transition count matrix. transition_matrix : ndarray or sparse matrix Transition probability matrix. Returns ------- loglikelihood : float The natural log of the likelihood, computed as :math:`\sum_{ij} C_{ij} \log(P_{ij})` """""" if isinstance(transition_matrix, np.ndarray) and isinstance(count_matrix, np.ndarray): # make sure that both count_matrix and transition_matrix are arrays count_matrix = np.asarray(count_matrix) # (not dense matrices), so we can use element-wise multiplication transition_matrix = np.asarray(transition_matrix) mask = count_matrix > 0 return np.sum(np.log(transition_matrix[mask]) * count_matrix[mask]) else: # make sure both count_matrix and transition_matrix are sparse CSR matrices if not scipy.sparse.isspmatrix(count_matrix): count_matrix = scipy.sparse.csr_matrix(count_matrix) else: count_matrix = count_matrix.tocsr() if not scipy.sparse.isspmatrix(transition_matrix): transition_matrix = scipy.sparse.csr_matrix(transition_matrix) else: transition_matrix = transition_matrix.tocsr() row, col = count_matrix.nonzero() return np.sum(np.log(np.asarray(transition_matrix[row, col])) * np.asarray(count_matrix[row, col])) # Lutz's MLE code works but has occasional convergence issues. We use # this code as a reference to unit test our more recent MLE code. def __mle_reversible_count_matrix_lutz__(count_matrix, prior=0.0, initial_guess=None): """"""Calculates the maximum-likelihood symmetric count matrix for a givnen observed count matrix. This function uses a Newton conjugate-gradient algorithm to maximize the likelihood of a reversible transition probability matrix. Parameters ---------- count_matrix : array or sparse matrix Transition count matrix. prior : float If not zero, add this value to the count matrix for every transition that has occured in either direction. initial_guess : array or sparse matrix Initial guess for the symmetric count matrix uses as starting point for likelihood maximization. If None, the naive symmetrized guess 0.5*(C+C.T) is used. Returns ------- reversible_counts : array or sparse matrix Symmetric count matrix. If C is sparse then the returned matrix is also sparse, and dense otherwise. """""" C = count_matrix def negativeLogLikelihoodFromCountEstimatesSparse(Xupdata, row, col, N, C): """"""Calculates the negative log likelihood that a symmetric count matrix X gave rise to an observed transition count matrix C, as well as the gradient d -log L / d X_ij."""""" assert np.alltrue(Xupdata > 0) Xup = scipy.sparse.csr_matrix( (Xupdata, (row, col)), shape=(N, N)) # Xup is the upper triagonal (inluding the main diagonal) of the symmetric count matrix # X is the complete symmetric count matrix X = Xup + Xup.T - scipy.sparse.spdiags(Xup.diagonal(), 0, Xup.shape[0], Xup.shape[1]) # Xs is the array of row sums of X: Xs_i = sum_j X_ij Xs = np.array(X.sum(axis=1)).ravel() XsInv = scipy.sparse.spdiags(1.0 / Xs, 0, len(Xs), len(Xs)) # P is now the matrix P_ij = X_ij / sum_j X_ij P = (XsInv * X).tocsr() logP = scipy.sparse.csr_matrix((np.log(P.data), P.indices, P.indptr)) # logL is the log of the likelihood: sum_ij C_ij log(X_ij / Xs_i) logL = np.sum(C.multiply(logP).data) # Cs is the array of row sums of C: Cs_i = sum_j C_ij Cs = np.array(C.sum(axis=1)).ravel() # remember the postitions of the non-zero elements of X srow, scol = X.nonzero() Udata = np.array( (C[srow, scol] / X[srow, scol]) - (Cs[srow] / Xs[srow])).ravel() # calculate the derivative: d(log L)/dX_ij = C_ij/X_ij - Cs_i/Xs_i # U is the matrix U_ij = d(log L) / dX_ij U = scipy.sparse.csr_matrix((Udata, (srow, scol)), shape=(N, N)) # so far, we have assumed that all the partial derivatives wrt. X_ij are independent # however, the degrees of freedom are only X_ij for i <= j # for i != j, the total change in log L is d(log L)/dX_ij + d(log L)/dX_ji gradient = (U + U.T - scipy.sparse.spdiags(U.diagonal(), 0, U.shape[0], U.shape[1])).tocsr() # now we have to convert the non-zero elements of the upper triangle into the # same 1-d array structure that was used for Xupdata gradient = np.array(gradient[row, col]).reshape(-1) # print ""max g:"", np.max(gradient), ""min g:"", np.min(gradient), ""|g|^2"", # (gradient*gradient).sum(), ""g * X"", (gradient*Xupdata).sum() return -logL, -gradient # current implementation only for sparse matrices # if given a dense matrix, sparsify it, and turn the result back to a dense array if not scipy.sparse.isspmatrix(C): return __mle_reversible_count_matrix_lutz__(scipy.sparse.csr_matrix(C), prior=prior, initial_guess=initial_guess).toarray() N = C.shape[0] if not C.shape[1] == N: raise ValueError(""Count matrix is not square, but has shape %s"" % C.shape) C = C.tocsr() C.eliminate_zeros() # add prior if necessary if (prior is not None) and (prior != 0): PriorMatrix = (C + C.transpose()).tocsr() PriorMatrix.data *= 0. PriorMatrix.data += prior C = C + PriorMatrix logger.warning(""Added prior value of %f to count matrix"", prior) # initial guess for symmetric count matrix if initial_guess is None: X0 = 0.5 * (C + C.T) else: # this guarantees that the initial guess is indeed symmetric (and sparse) X0 = scipy.sparse.csr_matrix(0.5 * (initial_guess + initial_guess.T)) initialLogLikelihood = log_likelihood(C, estimate_transition_matrix(X0)) # due to symmetry, we degrees of freedom for minimization are only the # elments in the upper triangle of the matrix X (incl. main diagonal) X0up = scipy.sparse.triu(X0).tocoo() row = X0up.row col = X0up.col # the variables used during minimization are those X_ij (i <= j) for which either C_ij or C_ji is greater than zero # those X_ij can be arbitrariliy small, but they must be positive # the function minimizer requires an inclusive bound, so we use some very small number instead of zero # (without loss of generality, b/c we can always multiply all X_ij by some large number without changing the likelihood) lower_bound = 1.E-10 bounds = [[lower_bound, np.inf]] * len(X0up.data) # Here comes the main loop # In principle, we would have to run the function minimizer only once. But in practice, minimization may fail # if the gradient term becomes too large, or minimization is slow if the gradient is too small. # Every so often, we therefore rescale the parameters X_ij so that the gradient is of resonable magnitude # (which does not affect the likelihood). This empirical procedure includes two parameters: the rescaling # frequency and the target value. In principles, these choices should not # affect the outcome of the maximization. rescale_every = 500 rescale_target = 1. Xupdata = X0up.data maximizationrun = 1 totalnumberoffunctionevaluations = 0 negative_logL, negative_gradient = negativeLogLikelihoodFromCountEstimatesSparse( Xupdata, row, col, N, C) logger.info(""Log-Likelihood of intial guess for reversible transition "" ""probability matrix: %s"", -negative_logL) while maximizationrun <= 1000: # rescale the X_ij so that the magnitude of the gradient is 1 gtg = (negative_gradient * negative_gradient).sum() scalefactor = np.sqrt(gtg / rescale_target) Xupdata[:] *= scalefactor # now run the minimizer Xupdata, nfeval, rc = scipy.optimize.fmin_tnc(negativeLogLikelihoodFromCountEstimatesSparse, Xupdata, args=(row, col, N, C), bounds=bounds, approx_grad=False, maxfun=rescale_every, disp=0, xtol=1E-20) totalnumberoffunctionevaluations += nfeval negative_logL, negative_gradient = negativeLogLikelihoodFromCountEstimatesSparse( Xupdata, row, col, N, C) logger.info(""Log-Likelihood after %s function evaluations; %s "", totalnumberoffunctionevaluations, -negative_logL) if rc in (0, 1, 2): break # Converged elif rc in (3, 4): pass # Not converged, keep going else: raise RuntimeError(""Likelihood maximization caused internal error (code %s): %s"" % ( rc, scipy.optimize.tnc.RCSTRINGS[rc])) maximizationrun += 1 else: logger.error(""maximum could not be obtained."") logger.info(""Result of last maximization run (run %s): %s"", str( maximizationrun), scipy.optimize.tnc.RCSTRINGS[rc]) Xup = scipy.sparse.coo_matrix((Xupdata, (row, col)), shape=(N, N)) # reconstruct full symmetric matrix from upper triangle part X = Xup + Xup.T - scipy.sparse.spdiags(Xup.diagonal(), 0, Xup.shape[0], Xup.shape[1]) finalLogLikelihood = log_likelihood(C, estimate_transition_matrix(X)) logger.info( ""Log-Likelihood of final reversible transition probability matrix: %s"", finalLogLikelihood) logger.info(""Likelihood ratio: %s"", np.exp(finalLogLikelihood - initialLogLikelihood)) # some basic consistency checks if not np.alltrue(np.isfinite(X.data)): raise RuntimeError(""The obtained symmetrized count matrix is not finite."") if not np.alltrue(X.data > 0): raise RuntimeError( ""The obtained symmetrized count matrix is not strictly positive for all observed transitions, the smallest element is %s"" % str(np.min(X.data))) # normalize X to have correct total number of counts X /= X.sum() X *= C.sum() return X def permute_mat(A, permutation): """""" Permutes the indices of a transition probability matrix. This functions simply switches the lables of `A` rows and columns from [0, 1, 2, ...] to `permutation`. Parameters ---------- tprob : matrix permutation: ndarray, int The permutation array, a list of unique indices that Returns ------- permuted_A : matrix The permuted matrix """""" if scipy.sparse.issparse(A): sparse = True else: sparse = False if sparse: Pi = scipy.sparse.lil_matrix(A.shape) for i in range(A.shape[0]): Pi[i, permutation[i]] = 1.0 # send i -> correct place permuted_A = Pi * A * Pi.T else: Pi = np.zeros(A.shape) for i in range(A.shape[0]): Pi[i, permutation[i]] = 1.0 # send i -> correct place permuted_A = np.dot(Pi, np.dot(A, Pi.T)) return permuted_A def mle_reversible_count_matrix(count_matrix): """"""Maximum likelihood estimate for a reversible count matrix Parameters ---------- counts : scipy.sparse.csr_matrix sparse matrix of transition counts (raw, not symmetrized) Returns ------- X : scipy.sparse.csr_matrix Returns the MLE reversible (symmetric) counts matrix Notes ----- This function can be used to find the maximum likelihood reversible count matrix. See Docs/notes/mle_notes.pdf for details on the math used during these calculations. """""" mle = __Reversible_MLE_Estimator__(count_matrix) return mle.optimize() # This class is hidden: you should use the helper function instead. class __Reversible_MLE_Estimator__(): def __init__(self, counts): """"""Construct class to maximize likelihood of reversible count matrix. Parameters ---------- counts : scipy.sparse.csr_matrix sparse matrix of transition counts (raw, not symmetrized) Notes ----- This object can be used to find the maximum likelihood reversible count matrix. See Docs/notes/mle_notes.pdf for details on the math used during these calculations. This class is hidden: you should use the helper function instead. """""" c = counts.asformat(""csr"").asfptype() c.eliminate_zeros() self.counts = c self.row_sums = np.array(c.sum(1)).flatten() # sym_counts is a sparse matrix with the symmetrized counts--e.g. the # ""full"" symmetric matrix. sym_i and sym_j are the nonzero indices of # sym_counts self.sym_counts = c + c.transpose() self.sym_row_indices, self.sym_col_indices = self.sym_counts.nonzero() self.sym_upper_ind = np.where(self.sym_row_indices < self.sym_col_indices)[0] self.sym_lower_ind = np.where(self.sym_row_indices >= self.sym_col_indices)[0] # This will be used to calculate the log likelihood. Avoids repeated # copying of sparse matrices. self.temporary_sym_counts = self.sym_counts.copy() # partial_counts is a sparse matrix with the lower triangle (including # diagonal) of the symmetrized counts self.partial_counts = self.sym_counts.copy() self.partial_counts.data[self.sym_upper_ind] = 0. self.partial_counts.eliminate_zeros() self.partial_row_indices, self.partial_col_indices = self.partial_counts.nonzero() self.partial_diag_indices = np.where( self.partial_row_indices == self.partial_col_indices)[0] self.construct_upper_mapping() self.stencil = self.partial_counts.copy() self.stencil.data[:] = 1. self.sym_diag_indices = np.where(self.sym_row_indices == self.sym_col_indices)[0] def construct_upper_mapping(self): """"""Construct a mapping (self.partial_upper_mapping) that maps elements from the data vector to the full sparse symmetric matrix. Notes ----- Use the following mappings to go between the data vector (log_vector) and the full sparse symmetric matrix (X): X.data[self.sym_lower_ind] = np.exp(log_vector) X.data[self.sym_upper_ind] = np.exp(log_vector)[self.partial_upper_mapping] """""" partial_ij_to_data = {} for k, i in enumerate(self.partial_row_indices): j = self.partial_col_indices[k] partial_ij_to_data[i, j] = k self.partial_upper_mapping = np.zeros(len(self.sym_upper_ind), 'int') for k0, k in enumerate(self.sym_upper_ind): i0, j0 = self.sym_row_indices[k], self.sym_col_indices[k] k1 = partial_ij_to_data[j0, i0] self.partial_upper_mapping[k0] = k1 def log_vector_to_matrix(self, log_vector): """"""Construct sparse matrix from vector of parameters. Parameters ---------- log_vector: np.ndarray log_vector contains the log of all nonzero matrix entries on the lower triangle (including the diagonal) """""" x = self.temporary_sym_counts x.data[self.sym_lower_ind] = np.exp(log_vector) x.data[self.sym_upper_ind] = np.exp(log_vector)[self.partial_upper_mapping] return x def flatten_matrix(self, counts): """"""Extract lower triangle from an arbitrary sparse CSR matrix. Parameters ---------- counts : scipy.sparse.csr_matrix Returns ------- data : np.ndarray The nonzero entries on the lower triangle (including diagonal) """""" counts = self.stencil.multiply(counts) counts = counts + self.stencil data = counts.data - 1. return data def matrix_to_log_vector(self, counts): """"""Construct vector of parameters from sparse matrix Parameters ---------- counts : scipy.sparse.csr_matrix C must be symmetric. Returns ------- data : np.ndarray The log of all nonzero entries on the lower triangle (including diagonal). """""" data = self.flatten_matrix(counts) return np.log(data) def log_likelihood(self, log_vector): """"""Calculate log likelihood of log_vector given the observed counts Parameters ---------- log_vector : np.ndarray log_vector contains the log of all nonzero matrix entries Notes ----- The counts used are those input during construction of this class. This calculation is based on Eqn. 4 in Docs/notes/mle_notes.pdf """""" f = (log_vector * self.partial_counts.data).sum() f -= (log_vector * self.partial_counts.data)[self.partial_diag_indices].sum() * 0.5 r = self.log_vector_to_matrix(log_vector) q = np.array(r.sum(0)).flatten() f -= np.log(q).dot(self.row_sums) return f def dlog_likelihood(self, log_vector): """"""Log likelihood gradient at log_vector given the observed counts Parameters ---------- log_vector : np.ndarray log_vector contains the log of all nonzero matrix entries Returns ------- grad : np.ndarray grad is the derivative of the log likelihood with respect to log_vector Notes ----- The counts used are those input during construction of this class. This calculation is based on Eqn. 5 in Docs/notes/mle_notes.pdf """""" grad = 0.0 * log_vector grad += self.partial_counts.data grad[self.partial_diag_indices] -= 0.5 * self.partial_counts.data[self.partial_diag_indices] current_count_matrix = self.log_vector_to_matrix(log_vector) current_row_sums = np.array(current_count_matrix.sum(1)).flatten() v = self.row_sums / current_row_sums D = scipy.sparse.dia_matrix((v, 0), shape=current_count_matrix.shape) grad -= self.flatten_matrix(D.dot(current_count_matrix) + current_count_matrix.dot(D)) grad += self.flatten_matrix(D.multiply(current_count_matrix)) return grad def optimize(self): """"""Maximize the log_likelihood to find the MLE reversible counts. Returns ------- X : scipy.sparse.csr_matrix Returns the MLE reversible (symmetric) counts matrix Notes ----- This algorithm uses the symmetrized counts as an initial guess. """""" log_vector = 1.0 * np.log(self.partial_counts.data) f = lambda x: -1 * self.log_likelihood(x) df = lambda x: -1 * self.dlog_likelihood(x) initial_log_likelihood = -1 * f(log_vector) parms, final_log_likelihood, info_dict = scipy.optimize.fmin_l_bfgs_b( f, log_vector, df, disp=0, factr=0.001, m=26) # m is the number of variable metric correcitons. m=26 seems to give ~15% speedup X = self.log_vector_to_matrix(parms) X *= (self.counts.sum() / X.sum()) final_log_likelihood *= -1 logger.info(""BFGS likelihood maximization terminated after %d function calls. Initial and final log likelihoods: %f, %f."" % (info_dict[""funcalls""], initial_log_likelihood, final_log_likelihood)) if info_dict[""warnflag""] != 0: logger.warning(""Abnormal termination of BFGS likelihood maximization. Error code %d"" % info_dict[""warnflag""]) return X ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/utils.py",".py","10220","335","from __future__ import print_function, division, absolute_import import numpy as np import re import types import warnings import functools import collections from mdtraj.utils.six import PY3 from mdtraj.utils.six.moves import copyreg, xrange if PY3: from itertools import filterfalse as ifilterfalse else: from itertools import ifilterfalse warnings.simplefilter('always') def uneven_zip(*args): '''Zip the arguments together like the builtin function, except that when one argument runs out (because its shorter), you keep filling it in with its last value i.e. uneven_zip([1,2,3], 'a', [10,11]) = [[1, 'a', 10], [2, 'a', 11], [3, 'a', 11]] ''' num_args = len(args) args = list(args) for i in xrange(num_args): if not hasattr(args[i], '__len__'): args[i] = (args[i],) lengths = [len(arg) for arg in args] def get(i): result = [None] * num_args for j in range(num_args): try: result[j] = args[j][i] except: result[j] = args[j][lengths[j] - 1] return result zipped = [get(i) for i in range(max(lengths))] return zipped def format_block(block): '''Format the given block of text, trimming leading/trailing empty lines and any leading whitespace that is common to all lines. The purpose is to let us list a code block as a multiline, triple-quoted Python string, taking care of indentation concerns.''' # separate block into lines lines = str(block).split('\n') # remove leading/trailing empty lines while lines and not lines[0]: del lines[0] while lines and not lines[-1]: del lines[-1] # look at first line to see how much indentation to trim ws = re.match(r'\s*', lines[0]).group(0) if ws: lines = [x.replace(ws, '', 1) for x in lines] # remove leading/trailing blank lines (after leading ws removal) # we do this again in case there were pure-whitespace lines while lines and not lines[0]: del lines[0] while lines and not lines[-1]: del lines[-1] return '\n'.join(lines) + '\n' def keynat(string): '''A natural sort helper function for sort() and sorted() without using regular expression. >>> items = ('Z', 'a', '10', '1', '9') >>> sorted(items) ['1', '10', '9', 'Z', 'a'] >>> sorted(items, key=keynat) ['1', '9', '10', 'Z', 'a'] ''' r = [] for c in string: try: c = int(c) try: r[-1] = r[-1] * 10 + c except: r.append(c) except: r.append(c) return r def _pickle_method(method): func_name = method.__func.__name__ obj = method.__self__ cls = method.__self__.__class__ return _unpickle_method, (func_name, obj, cls) def _unpickle_method(func_name, obj, cls): for cls in cls.mro(): try: func = cls.__dict__[func_name] except KeyError: pass else: break return func.__get__(obj, cls) def make_methods_pickable(): ""Run this at the top of a script to register pickable methods"" copyreg.pickle(types.MethodType, _pickle_method, _unpickle_method) def deprecated(replacement=None, removal_version=None): """"""A decorator which can be used to mark functions as deprecated. replacement is a callable that will be called with the same args as the decorated function. Code adapted from http://code.activestate.com/recipes/577819-deprecated-decorator/, MIT license >>> @deprecated() ... def foo(x): ... return x ... >>> ret = foo(1) DeprecationWarning: foo is deprecated >>> ret 1 >>> >>> >>> def newfun(x): ... return 0 ... >>> @deprecated(newfun) ... def foo(x): ... return x ... >>> ret = foo(1) DeprecationWarning: foo is deprecated; use newfun instead >>> ret 0 >>> """""" def outer(oldfun): def inner(*args, **kwargs): msg = ""%s is deprecated use %s instead. "" % (oldfun.__name__, replacement.__name__) if removal_version is not None: msg += '%s will be removed in version %s' % (oldfun.__name__, removal_version) warnings.warn(msg, DeprecationWarning, stacklevel=2) return replacement(*args, **kwargs) return inner return outer def future_warning(func): '''This is a decorator which can be used to mark functions as to-be deprecated. It will result in a warning being emitted when the function is used.''' @functools.wraps(func) def new_func(*args, **kwargs): warnings.warn_explicit( ""Call to future function {}."".format(func.__name__), category=FutureWarning, filename=func.__code__.co_filename, lineno=func.__code__.co_firstlineno + 1 ) return func(*args, **kwargs) return new_func def highlight(text, color='Red', bold=False): """"""Return a highlighted string using color or bold. @param[in] text The string that the printout is based upon. This function will return the highlighted string. @param[in] color String or number corresponding to the color. 1 red\n 2 green\n 3 yellow\n 4 blue\n 5 magenta\n 6 cyan\n 7 white @param[in] bold Whether to use bold print """""" colordict = {'red': 1, 'green': 2, 'yellow': 3, 'blue': 4, 'magenta': 5, 'cyan': 6, 'white': 7} if color.lower() in colordict: color = colordict[color.lower()] elif color in ['1', '2', '3', '4', '5', '6', '7']: color = int(color) elif color in range(1, 8): pass else: raise ValueError( 'Invalid argument given for color (use integer 1-7 or case-insensitive word: red, green, yellow, blue, magenta, cyan, or white)') return ""\x1b[%s9%im"" % (bold and ""1;"" or """", color) + text + ""\x1b[0m"" # http://code.activestate.com/recipes/498245-lru-and-lfu-cache-decorators/ class Counter(dict): 'Mapping where default values are zero' def __missing__(self, key): return 0 def lru_cache(maxsize=100): '''Least-recently-used cache decorator. Arguments to the cached function must be hashable. Cache performance statistics stored in f.hits and f.misses. Clear the cache with f.clear(). http://en.wikipedia.org/wiki/Cache_algorithms#Least_Recently_Used ''' maxqueue = maxsize * 10 def decorating_function(user_function, len=len, iter=iter, tuple=tuple, sorted=sorted, KeyError=KeyError): cache = {} # mapping of args to results queue = collections.deque() # order that keys have been used refcount = Counter() # times each key is in the queue sentinel = object() # marker for looping around the queue kwd_mark = object() # separate positional and keyword args # lookup optimizations (ugly but fast) queue_append, queue_popleft = queue.append, queue.popleft queue_appendleft, queue_pop = queue.appendleft, queue.pop @functools.wraps(user_function) def wrapper(*args, **kwds): # cache key records both positional and keyword args key = args if kwds: key += (kwd_mark,) + tuple(sorted(kwds.items())) # record recent use of this key queue_append(key) refcount[key] += 1 # get cache entry or compute if not found try: result = cache[key] wrapper.hits += 1 except KeyError: result = user_function(*args, **kwds) cache[key] = result wrapper.misses += 1 # purge least recently used cache entry if len(cache) > maxsize: key = queue_popleft() refcount[key] -= 1 while refcount[key]: key = queue_popleft() refcount[key] -= 1 del cache[key], refcount[key] # periodically compact the queue by eliminating duplicate keys # while preserving order of most recent access if len(queue) > maxqueue: refcount.clear() queue_appendleft(sentinel) for key in ifilterfalse(refcount.__contains__, iter(queue_pop, sentinel)): queue_appendleft(key) refcount[key] = 1 return result def clear(): cache.clear() queue.clear() refcount.clear() wrapper.hits = wrapper.misses = 0 wrapper.hits = wrapper.misses = 0 wrapper.clear = clear return wrapper return decorating_function def check_assignment_array_input(assignments, check_ndarray=True, check_integer=True, ndim=2): """"""Check if input is an appropriate data type for assignments. Parameters ---------- assignments : ndarray Assignment data whose format will be checked. check_ndarray : bool, optional Default True; set False to skip checking for ndarray type check_integer : bool, optional Default True; set False to skip checking for integer dtype ndim : int, optional Default is 2, which is the correct value for an assignment array. Notes ----- Checks if type is Numpy array, if dtype is int-like, and if ndim is ndim (2 by default). """""" if check_ndarray and not isinstance(assignments, np.ndarray): raise TypeError(""Input assignments must be numpy array type."") if check_integer and assignments.dtype.kind != ""i"": raise TypeError(""Input assignments must be integer type."") if assignments.ndim != ndim: raise TypeError(""Input assignments must have ndim = %d; found %d."" % (ndim, assignments.ndim)) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/assigning.py",".py","9840","243","from __future__ import print_function, absolute_import, division from mdtraj.utils.six.moves import xrange import os import mdtraj as md import numpy as np import tables import warnings from mdtraj import io import logging logger = logging.getLogger(__name__) def _setup_containers(project, assignments_fn, distances_fn): """""" Setup the files on disk (Assignments.h5 and Assignments.h5.distances) that results will be sent to. Check to ensure that if they exist (and contain partial results), the containers are not corrupted Parameters ---------- project : msmbuilder.Project The msmbuilder project file. Only the n_trajs and traj_lengths are actully used. assignments_fn : string distances_fn : string Returns ------- f_assignments : tables.File pytables handle to the assignments file, open in 'append' mode f_distances : tables.File pytables handle to the assignments file, open in 'append' mode """""" def save_container(filename, dtype): io.saveh(filename, arr_0=-1 * np.ones((project.n_trajs, np.max(project.traj_lengths)), dtype=dtype), completed_trajs=np.zeros((project.n_trajs), dtype=np.bool)) def check_container(filename): with warnings.catch_warnings(): warnings.simplefilter('ignore') fh = tables.openFile(filename, 'r') if fh.root.arr_0.shape != (project.n_trajs, np.max(project.traj_lengths)): raise ValueError('Shape error 1') if fh.root.completed_trajs.shape != (project.n_trajs,): raise ValueError('Shape error 2') fh.close() # save assignments container if (not os.path.exists(assignments_fn)) \ and (not os.path.exists(distances_fn)): save_container(assignments_fn, np.int) save_container(distances_fn, np.float32) elif os.path.exists(assignments_fn) and os.path.exists(distances_fn): check_container(assignments_fn) check_container(distances_fn) else: raise ValueError(""You're missing one of the containers"") # append mode is read and write with warnings.catch_warnings(): warnings.simplefilter('ignore') f_assignments = tables.openFile(assignments_fn, mode='a') f_distances = tables.openFile(distances_fn, mode='a') return f_assignments, f_distances def assign_in_memory(metric, generators, project, atom_indices_to_load=None): """""" Assign every frame to its closest generator This code does everything in memory, and does not checkpoint. It also does not save any results to disk. Parameters ---------- metric : msmbuilder.metrics.AbstractDistanceMetric A distance metric used to define ""closest"" project : msmbuilder.Project Used to load the trajectories generators : msmbuilder.Trajectory A trajectory containing the structures of all of the cluster centers atom_indices_to_load : {None, list} The indices of the atoms to load for each trajectory chunk. Note that this method is responsible for loading up atoms from the project, but does NOT load up the generators. Those are passed in as a trajectory object (above). So if the generators are already subsampled to a restricted set of atom indices, but the trajectories on disk are NOT, you'll need to pass in a set of indices here to resolve the difference. See Also -------- assign_with_checkpoint """""" n_trajs, max_traj_length = project.n_trajs, np.max(project.traj_lengths) assignments = -1 * np.ones((n_trajs, max_traj_length), dtype='int') distances = -1 * np.ones((n_trajs, max_traj_length), dtype='float32') pgens = metric.prepare_trajectory(generators) for i in xrange(n_trajs): traj = project.load_traj(i, atom_indices=atom_indices_to_load) if traj['XYZList'].shape[1] != generators['XYZList'].shape[1]: raise ValueError('Number of atoms in generators does not match ' 'traj we\'re trying to assign! Maybe check atom indices?') ptraj = metric.prepare_trajectory(traj) for j in xrange(len(traj)): d = metric.one_to_all(ptraj, pgens, j) assignments[i, j] = np.argmin(d) distances[i, j] = d[assignments[i, j]] return assignments, distances def assign_with_checkpoint(metric, project, generators, assignments_path, distances_path, chunk_size=10000, atom_indices_to_load=None): """""" Assign every frame to its closest generator The results will be checkpointed along the way, trajectory by trajectory. If the process is killed, it should be able to roughly pick up where it left off. Parameters ---------- metric : msmbuilder.metrics.AbstractDistanceMetric A distance metric used to define ""closest"" project : msmbuilder.Project Used to load the trajectories generators : msmbuilder.Trajectory A trajectory containing the structures of all of the cluster centers assignments_path : str Path to a file that contains/will contain the assignments, as a 2D array of integers in hdf5 format distances_path : str Path to a file that contains/will contain the assignments, as a 2D array of integers in hdf5 format chunk_size : int The number of frames to load and process per step. The optimal number here depends on your system memory -- it should probably be roughly the number of frames you can fit in memory at any one time. Note, this is only important if your trajectories are long, as the effective chunk_size is really `min(traj_length, chunk_size)` atom_indices_to_load : {None, list} The indices of the atoms to load for each trajectory chunk. Note that this method is responsible for loading up atoms from the project, but does NOT load up the generators. Those are passed in as a trajectory object (above). So if the generators are already subsampled to a restricted set of atom indices, but the trajectories on disk are NOT, you'll need to pass in a set of indices here to resolve the difference. See Also -------- assign_in_memory """""" pgens = metric.prepare_trajectory(generators) # setup the file handles fh_a, fh_d = _setup_containers(project, assignments_path, distances_path) for i in xrange(project.n_trajs): if fh_a.root.completed_trajs[i] and fh_d.root.completed_trajs[i]: logger.info('Skipping trajectory %s -- already assigned', i) continue if fh_a.root.completed_trajs[i] or fh_d.root.completed_trajs[i]: logger.warn(""Re-assigning trajectory even though some data is"" "" available..."") fh_a.root.completed_trajs[i] = False fh_d.root.completed_trajs[i] = False logger.info('Assigning trajectory %s', i) # pointer to the position in the total trajectory where # the current chunk starts, so we know where in the Assignments # array to put each batch of data start_index = 0 filename = project.traj_filename(i) chunkiter = md.iterload(filename, chunk=chunk_size, atom_indices=atom_indices_to_load) for tchunk in chunkiter: if tchunk.n_atoms != generators.n_atoms: msg = (""Number of atoms in generators does not match "" ""traj we're trying to assign! Maybe check atom indices?"") raise ValueError(msg) ptchunk = metric.prepare_trajectory(tchunk) this_length = len(ptchunk) distances = np.empty(this_length, dtype=np.float32) assignments = np.empty(this_length, dtype=np.int) for j in xrange(this_length): d = metric.one_to_all(ptchunk, pgens, j) ind = np.argmin(d) assignments[j] = ind distances[j] = d[ind] end_index = start_index + this_length fh_a.root.arr_0[i, start_index:end_index] = assignments fh_d.root.arr_0[i, start_index:end_index] = distances # i'm not sure exactly what the optimal flush frequency is fh_a.flush() fh_d.flush() start_index = end_index # we're going to keep duplicates of this record -- i.e. writing # it to both files # completed chunks are not checkpointed -- only completed trajectories # this means that if the process dies after completing 10/20 of the # chunks in trajectory i -- those chunks are going to have to be recomputed # (put trajectory i-1 is saved) # this could be changed, but the implementation is a little tricky -- you # have to watch out for the fact that the person might call this function # with chunk_size=N, let it run for a while, kill it, and then call it # again with chunk_size != N. Dealing with that appropriately is tricky # since the chunks wont line up in the two cases fh_a.root.completed_trajs[i] = True fh_d.root.completed_trajs[i] = True fh_a.close() fh_d.close() def streaming_assign_with_checkpoint(metric, project, generators, assignments_path, distances_path, checkpoint=1, chunk_size=10000, atom_indices_to_load=None): warnings.warn((""assign_with_checkpoint now uses the steaming engine "" ""-- this function is deprecated""), DeprecationWarning) assign_with_checkpoint(metric, project, generators, assignments_path, distances_path, chunk_size, atom_indices_to_load) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/clustering.py",".py","49464","1263","from __future__ import print_function, division, absolute_import from mdtraj.utils.six import PY2 from mdtraj.utils.six.moves import xrange import sys import types import random import numpy as np try: import fastcluster except ImportError: pass import scipy.cluster.hierarchy import mdtraj as md from msmbuilder import metrics from mdtraj import io from msmbuilder.utils import uneven_zip from multiprocessing import Pool try: from deap import dtm # has parallel map() implementation via mpi except: pass import logging logger = logging.getLogger(__name__) ##################################################################### # # # Begin Helper Functions # # # ##################################################################### def concatenate_trajectories(trajectories): """"""Concatenate a list of trajectories into a single long trajectory Parameters ---------- trajectories : list list of mdtraj.Trajectory object Returns ------- concat_traj : mdtraj.Trajectory """""" assert len(trajectories) > 0, 'Please supply a list of trajectories' concat_traj = trajectories[0] for i in xrange(1, len(trajectories)): # Use mdtraj operator overloading concat_traj += trajectories[i] return concat_traj def concatenate_prep_trajectories(prep_trajectories, metric): """"""Concatenate a list of prepared trajectories and create a single prepared_trajectory. This is non-trivial because the RMSD and LPRMSD prepared trajectories are not np.ndarrays ... Parameters ---------- prep_trajectories : list list of prepared trajectories metric : msmbuilder.metrics.AbstractDistance metric subclass instance metric used to prepare the trajectories. Needed for RMSD and LPRMSD since concatenation requires recreating the prepared trajectory Returns ------- ptraj : prepared_trajectory prepared trajectory instance, like that returned from metric.prepare_trajectory """""" if isinstance(prep_trajectories[0], np.ndarray): ptraj = np.concatenate(prep_trajectories) elif isinstance(prep_trajectories[0], RMSD.TheoData): xyz = np.concatenate([p.XYZData[:, :, :p.NumAtoms] for p in prep_trajectories]) xyz = xyz.transpose((0, 2, 1)) ptraj = metric.TheoData(xyz) else: raise Exception(""unrecognized prepared trajectory."" ""NOTE: LPRMSD currently unsupported. Email schwancr@stanford.edu"") return ptraj def unconcatenate_trajectory(trajectory, lengths): """"""Take a single trajectory that was created by concatenating seperate trajectories and unconcenatenate it, returning the original trajectories. You have to supply the lengths of the original trajectories. Parameters ---------- trajectory : mdtraj.Trajectory Long trajectory to be split lengths : array_like list of lengths to split the long trajectory into Returns ------- A list of trajectories """""" return split(trajectory, lengths) def split(longlist, lengths): """"""Split a long list into segments Parameters ---------- longlist : array_like Long trajectory to be split lengths : array_like list of lengths to split the long list into Returns ------- A list of lists """""" if not sum(lengths) == len(longlist): raise Exception('sum(lengths)=%s, len(longlist)=%s' % (sum(lengths), len(longlist))) def func(x): length, cumlength = x return longlist[cumlength - length: cumlength] output = [func(elem) for elem in zip(lengths, np.cumsum(lengths))] return output def stochastic_subsample(trajectories, shrink_multiple): """"""Randomly subsample from a trajectory Given a list of trajectories, return a single trajectory shrink_multiple times smaller than the total number of frames in trajectories taken by random sampling of frames from trajectories Parameters ---------- trajectories : list of mdtraj.Trajectory list of trajectories to sample from shrink_multiple : int fraction to shrint by Note that this method will modify the trajectory objects that you pass in @CHECK is the note above actually true? """""" shrink_multiple = int(shrink_multiple) if shrink_multiple < 1: raise ValueError('Shrink multiple should be an integer greater ' 'than 1. You supplied %s' % shrink_multiple) elif shrink_multiple == 1: # if isinstance(trajectories, Trajectory): # return trajectories # return concatenate_trajectories(trajectories) return trajectories if isinstance(trajectories, md.Trajectory): traj = trajectories length = traj.n_frames new_length = int(length / shrink_multiple) if new_length <= 0: return None indices = np.array(random.sample(np.arange(length), new_length)) new_traj = traj[indices, :, :] return new_traj else: # assume we have a list of trajectories # check that all trajectories have the same number of atoms num_atoms = np.array([traj.n_atoms for traj in trajectories]) if not np.all(num_atoms == num_atoms[0]): raise Exception('Not all same # atoms') # shrink each trajectory subsampled = [stochastic_subsample(traj, shrink_multiple) for traj in trajectories] # filter out failures subsampled = [a for a in subsampled if a is not None] return concatenate_trajectories(subsampled) def deterministic_subsample(trajectories, stride, start=0): """"""Given a list of trajectories, return a single trajectory shrink_multiple times smaller than the total number of frames in trajectories by taking every ""stride""th frame, starting from ""start"" Note that this method will modify the trajectory objects that you pass in Parameters ---------- trajectories : list of mdtraj.Trajectory trajectories to subsample from stride : int freq to subsample at start : int first frame to pick Returns ------- trajectory : mdtraj.trajectory shortened trajectory """""" stride = int(stride) if stride < 1: raise ValueError('stride should be an integer greater than 1. You supplied %s' % stride) elif stride == 1: # if isinstance(trajectories, Trajectory): # return trajectories # return concatenate_trajectories(trajectories) return trajectories if isinstance(trajectories, Trajectory): traj = trajectories traj = traj[start::stride] return traj else: # assume we have a list of trajectories # check that all trajectories have the same number of atoms num_atoms = np.array([traj.n_atoms for traj in trajectories]) if not np.all(num_atoms == num_atoms[0]): raise Exception('Not all same # atoms') # shrink each trajectory strided = [deterministic_subsample(traj, stride, start) for traj in trajectories] return concatenate_trajectories(strided) def p_norm(data, p=2): """"""p_norm of an ndarray with XYZ coordinates Parameters ---------- data : ndarray XYZ coordinates. TODO: Shape? p : {int, ""max""}, optional power of p_norm Returns ------- value : float the answer """""" if p == ""max"": return data.max() else: p = float(p) n = float(data.shape[0]) return ((data ** p).sum() / n) ** (1.0 / p) ##################################################################### # # # End Helper Functions # # Begin Clustering Function # # # ##################################################################### def _assign(metric, ptraj, generator_indices): """"""Assign the frames in ptraj to the centers with indices *generator_indices* Parameters ---------- metric : msmbuilder.metrics.AbstractDistanceMetric A metric capable of handling `ptraj` ptraj : prepared trajectory ptraj return by the action of the preceding metric on a msmbuilder trajectory generator_indices : array_like indices (with respect to ptraj) of the frames to be considered the cluster centers. Returns ------- assignments : ndarray `assignments[i] = j` means that the `i`th frame in ptraj is assigned to `ptraj[j]` distances : ndarray `distances[i] = j` means that the distance (according to `metric`) from `ptraj[i]` to `ptraj[assignments[i]]` is `j` """""" assignments = np.zeros(len(ptraj), dtype='int') distances = np.inf * np.ones(len(ptraj), dtype='float32') for m in generator_indices: d = metric.one_to_all(ptraj, ptraj, m) closer = np.where(d < distances)[0] distances[closer] = d[closer] assignments[closer] = m return assignments, distances def _kcenters(metric, ptraj, k=None, distance_cutoff=None, seed=0, verbose=True): """"""Run kcenters clustering algorithm. Terminates either when `k` clusters have been identified, or when every data is clustered better than `distance_cutoff`. Parameters ---------- metric : msmbuilder.metrics.AbstractDistanceMetric A metric capable of handling `ptraj` ptraj : prepared trajectory ptraj return by the action of the preceding metric on a msmbuilder trajectory k : {int, None} number of desired clusters, or None distance_cutoff : {float, None} Stop identifying new clusters once the distance of every data to its cluster center falls below this value. Supply either this or `k` seed : int, optional index of the frame to use as the first cluster center verbose : bool, optional print as each new generator is found Returns ------- generator_indices : ndarray indices (with respect to ptraj) of the frames to be considered cluster centers assignments : ndarray the cluster center to which each frame is assigned to (1D) distances : ndarray distance from each of the frames to the cluster center it was assigned to See Also -------- KCenters : wrapper around this implementation that provides more convenience Notes ------ the assignments are numbered with respect to the position in ptraj of the generator, not the position in generator_indices. That is, assignments[10] = 1020 means that the 10th simulation frame is assigned to the 1020th simulation frame, not to the 1020th generator. References ---------- .. [1] Beauchamp, MSMBuilder2 """""" if k is None and distance_cutoff is None: raise ValueError(""I need some cutoff criterion! both k and "" ""distance_cutoff can't both be none"") if k is None and distance_cutoff <= 0: raise ValueError(""With k=None you need to supply a legit distance_cutoff"") if distance_cutoff is None: # set it below anything that can ever be reached distance_cutoff = -1 if k is None: k = sys.maxsize distance_list = np.inf * np.ones(len(ptraj), dtype=np.float32) assignments = -1 * np.ones(len(ptraj), dtype=np.int32) generator_indices = [] for i in xrange(k): new_ind = seed if i == 0 else np.argmax(distance_list) if k == sys.maxsize: logger.info(""K-centers: Finding generator %i. Will finish when % .4f drops below % .4f"", i, distance_list[new_ind], distance_cutoff) else: logger.info(""K-centers: Finding generator %i"", i) if distance_list[new_ind] < distance_cutoff: break new_distance_list = metric.one_to_all(ptraj, ptraj, new_ind) updated_indices = np.where(new_distance_list < distance_list)[0] distance_list[updated_indices] = new_distance_list[updated_indices] assignments[updated_indices] = new_ind generator_indices.append(new_ind) if verbose: logger.info('KCenters found %d generators', i + 1) return np.array(generator_indices), assignments, distance_list def _clarans(metric, ptraj, k, num_local_minima, max_neighbors, local_swap=True, initial_medoids='kcenters', initial_assignments=None, initial_distance=None, verbose=True): """"""Run the CLARANS clustering algorithm on the frames in a trajectory Reference --------- .. [1] Ng, R.T, Jan, Jiawei, 'CLARANS: A Method For Clustering Objects For Spatial Data Mining', IEEE Trans. on Knowledge and Data Engineering, vol. 14 no.5 pp. 1003-1016 Sep/Oct 2002 http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=1033770 Parameters ---------- metric : msmbuilder.metrics.AbstractDistanceMetric A metric capable of handling `ptraj` ptraj : prepared trajectory ptraj return by the action of the preceding metric on a msmbuilder trajectory k : int number of desired clusters num_local_minima : int number of local minima in the set of all possible clusterings to identify. Execution time will scale linearly with this parameter. The best of these local minima will be returned. max_neighbors : int number of rejected swaps in a row necessary to declare a proposed clustering a local minima local_swap : bool, optional If true, proposed swaps will be between a medoid and a data point currently assigned to that medoid. If false, the data point for the proposed swap is selected randomly. initial_medoids : {'kcenters', 'random', ndarray}, optional If 'kcenters', run kcenters clustering first to get the initial medoids, and then run the swaps to improve it. If 'random', select the medoids at random. Otherwise, initial_medoids should be a numpy array of the indices of the medoids. initial_assignments : {None, ndarray}, optional If None, initial_assignments will be computed based on the initial_medoids. If you pass in your own initial_medoids, you can also pass in initial_assignments to avoid recomputing them. initial_distances : {None, ndarray}, optional If None, initial_distances will be computed based on the initial_medoids. If you pass in your own initial_medoids, you can also pass in initial_distances to avoid recomputing them. verbose : bool, optional Print information about the swaps being attempted Returns ------- generator_indices : ndarray indices (with respect to ptraj) of the frames to be considered cluster centers assignments : ndarray the cluster center to which each frame is assigned to (1D) distances : ndarray distance from each of the frames to the cluster center it was assigned to """""" num_frames = len(ptraj) if initial_medoids == 'kcenters': initial_medoids, initial_assignments, initial_distance = _kcenters(metric, ptraj, k) elif initial_medoids == 'random': initial_medoids = np.random.permutation(np.arange(num_frames))[0:k] initial_assignments, initial_distance = _assign(metric, ptraj, initial_medoids) else: if not isinstance(initial_medoids, np.ndarray): raise ValueError('Initial medoids should be a numpy array') if initial_assignments is None or initial_distance is None: initial_assignments, initial_distance = _assign(metric, ptraj, initial_medoids) if not len(initial_assignments) == num_frames: raise ValueError('Initial assignments is not the same length as ptraj') if not len(initial_distance) == num_frames: raise ValueError('Initial distance is not the same length as ptraj') if not k == len(initial_medoids): raise ValueError('Initial medoids not the same length as k') initial_pmedoids = ptraj[initial_medoids] initial_cost = np.sum(initial_distance) min_cost = initial_cost # these iterations could be parallelized for i in xrange(num_local_minima): logger.info('%s of %s local minima', i, num_local_minima) # the cannonical clarans approach is to initialize the medoids that you # start from randomly, but instead we use the kcenters medoids. medoids = initial_medoids pmedoids = initial_pmedoids assignments = initial_assignments distance_to_current = initial_distance current_cost = initial_cost optimal_medoids = initial_medoids optimal_assignments = initial_assignments optimal_distances = initial_distance # loop over neighbors j = 0 while j < max_neighbors: medoid_i = np.random.randint(k) old_medoid = medoids[medoid_i] if local_swap is False: trial_medoid = np.random.randint(num_frames) else: trial_medoid = random.choice(np.where(assignments == medoids[medoid_i])[0]) new_medoids = medoids.copy() new_medoids[medoid_i] = trial_medoid pmedoids = ptraj[new_medoids] if type(pmedoids) == np.ndarray: pmedoids = pmedoids.copy() new_distances = distance_to_current.copy() new_assignments = assignments.copy() logger.info('swapping %s for %s...', old_medoid, trial_medoid) distance_to_trial = metric.one_to_all(ptraj, ptraj, trial_medoid) assigned_to_trial = np.where(distance_to_trial < distance_to_current)[0] new_assignments[assigned_to_trial] = trial_medoid new_distances[assigned_to_trial] = distance_to_trial[assigned_to_trial] ambiguous = np.where((new_assignments == old_medoid) & \ (distance_to_trial >= distance_to_current))[0] for l in ambiguous: if len(ptraj) <= l: logger.error(len(ptraj)) logger.error(l) logger.error(ptraj.dtype) logger.error(l.dtype) d = metric.one_to_all(ptraj, pmedoids, l) argmin = np.argmin(d) new_assignments[l] = new_medoids[argmin] new_distances[l] = d[argmin] new_cost = np.sum(new_distances) if new_cost < current_cost: logger.info('Accept') medoids = new_medoids assignments = new_assignments distance_to_current = new_distances current_cost = new_cost j = 0 else: j += 1 logger.info('Reject') if current_cost < min_cost: min_cost = current_cost optimal_medoids = medoids.copy() optimal_assignments = assignments.copy() optimal_distances = distance_to_current.copy() return optimal_medoids, optimal_assignments, optimal_distances def _clarans_helper(args): return _clarans(*args) def _hybrid_kmedoids(metric, ptraj, k=None, distance_cutoff=None, num_iters=10, local_swap=True, norm_exponent=2.0, too_close_cutoff=0.0001, ignore_max_objective=False, initial_medoids='kcenters', initial_assignments=None, initial_distance=None): """"""Run the hybrid kmedoids clustering algorithm to cluster a trajectory References ---------- .. [1] Beauchamp, K. MSMBuilder2 Parameters ---------- metric : msmbuilder.metrics.AbstractDistanceMetric A metric capable of handling `ptraj` ptraj : prepared trajectory ptraj return by the action of the preceding metric on a msmbuilder trajectory k : int number of desired clusters num_iters : int number of swaps to attempt per medoid local_swap : boolean, optional If true, proposed swaps will be between a medoid and a data point currently assigned to that medoid. If false, the data point for the proposed swap is selected randomly. norm_exponent : float, optional exponent to use in pnorm of the distance to generate objective function too_close_cutoff : float, optional Summarily reject proposed swaps if the distance of the medoid to the trial medoid is less than thus value ignore_max_objective : boolean, optional Ignore changes to the distance of the worst classified point, and only reject or accept swaps based on changes to the p norm of all the data points. initial_medoids : {'kcenters', ndarray} If 'kcenters', run kcenters clustering first to get the initial medoids, and then run the swaps to improve it. If 'random', select the medoids at random. Otherwise, initial_medoids should be a numpy array of the indices of the medoids. initial_assignments : {None, ndarray}, optional If None, initial_assignments will be computed based on the initial_medoids. If you pass in your own initial_medoids, you can also pass in initial_assignments to avoid recomputing them. initial_distances : {None, ndarray}, optional If None, initial_distances will be computed based on the initial_medoids. If you pass in your own initial_medoids, you can also pass in initial_distances to avoid recomputing them. """""" if k is None and distance_cutoff is None: raise ValueError(""I need some cutoff criterion! both k and distance_cutoff can't both be none"") if k is None and distance_cutoff <= 0: raise ValueError(""With k=None you need to supply a legit distance_cutoff"") if distance_cutoff is None: # set it below anything that can ever be reached distance_cutoff = -1 num_frames = len(ptraj) if initial_medoids == 'kcenters': initial_medoids, initial_assignments, initial_distance = _kcenters(metric, ptraj, k, distance_cutoff) elif initial_medoids == 'random': if k is None: raise ValueError('You need to supply the number of clusters, k, you want') initial_medoids = np.random.permutation(np.arange(num_frames))[0:k] initial_assignments, initial_distance = _assign(metric, ptraj, initial_medoids) else: if not isinstance(initial_medoids, np.ndarray): raise ValueError('Initial medoids should be a numpy array') if initial_assignments is None or initial_distance is None: initial_assignments, initial_distance = _assign(metric, ptraj, initial_medoids) assignments = initial_assignments distance_to_current = initial_distance medoids = initial_medoids pgens = ptraj[medoids] k = len(initial_medoids) obj_func = p_norm(distance_to_current, p=norm_exponent) max_norm = p_norm(distance_to_current, p='max') if not np.all(np.unique(medoids) == np.sort(medoids)): raise ValueError('Initial medoids must be distinct') if not np.all(np.unique(assignments) == sorted(medoids)): raise ValueError('Initial assignments dont match initial medoids') for iteration in xrange(num_iters): for medoid_i in xrange(k): if not np.all(np.unique(assignments) == sorted(medoids)): raise ValueError('Loop invariant lost') if local_swap is False: trial_medoid = np.random.randint(num_frames) else: trial_medoid = random.choice(np.where(assignments == medoids[medoid_i])[0]) old_medoid = medoids[medoid_i] if old_medoid == trial_medoid: continue new_medoids = medoids.copy() new_medoids[medoid_i] = trial_medoid pmedoids = ptraj[new_medoids] new_distances = distance_to_current.copy() new_assignments = assignments.copy() logger.info('Sweep %d, swapping medoid %d (conf %d) for conf %d...', iteration, medoid_i, old_medoid, trial_medoid) distance_to_trial = metric.one_to_all(ptraj, ptraj, trial_medoid) if not np.all(np.isfinite(distance_to_trial)): raise ValueError('distance metric returned nonfinite distances') if distance_to_trial[old_medoid] < too_close_cutoff: logger.info('Too close') continue assigned_to_trial = np.where(distance_to_trial < distance_to_current)[0] new_assignments[assigned_to_trial] = trial_medoid new_distances[assigned_to_trial] = distance_to_trial[assigned_to_trial] ambiguous = np.where((new_assignments == old_medoid) & \ (distance_to_trial >= distance_to_current))[0] for l in ambiguous: d = metric.one_to_all(ptraj, pmedoids, l) if not np.all(np.isfinite(d)): raise ValueError('distance metric returned nonfinite distances') argmin = np.argmin(d) new_assignments[l] = new_medoids[argmin] new_distances[l] = d[argmin] new_obj_func = p_norm(new_distances, p=norm_exponent) new_max_norm = p_norm(new_distances, p='max') if new_obj_func < obj_func and (new_max_norm <= max_norm or ignore_max_objective is True): logger.info(""Accept. New f = %f, Old f = %f"", new_obj_func, obj_func) medoids = new_medoids assignments = new_assignments distance_to_current = new_distances obj_func = new_obj_func max_norm = new_max_norm else: logger.info(""Reject. New f = %f, Old f = %f"", new_obj_func, obj_func) return medoids, assignments, distance_to_current ##################################################################### # # # End Clustering Functions # # Begin Clustering Classes # # # ##################################################################### class Hierarchical(object): allowable_methods = ['single', 'complete', 'average', 'weighted', 'centroid', 'median', 'ward'] def __init__(self, metric, trajectories, method='single', precomputed_values=None): """"""Initialize a hierarchical clusterer using the supplied distance metric and method. Method should be one of the fastcluster linkage methods, namely 'single', 'complete', 'average', 'weighted', 'centroid', 'median', or 'ward'. Parameters ---------- metric : msmbuilder.metrics.AbstractDistanceMetric A metric capable of handling `ptraj` trajectory : Trajectory list of Trajectorys data to cluster method : {'single', 'complete', 'average', 'weighted', 'centroid', 'median', 'ward'} precomputed_values : used internally to implement load_from_disk() Notes ----- This is implemenred with the fastcluster library, which can be downloaded from CRAN http://cran.r-project.org/web/packages/fastcluster/ """""" if precomputed_values is not None: precomputed_z_matrix, traj_lengths = precomputed_values if isinstance(precomputed_z_matrix, np.ndarray) and precomputed_z_matrix.shape[1] == 4: self.Z = precomputed_z_matrix self.traj_lengths = traj_lengths return else: raise Exception('Something is wrong') if not isinstance(metric, metrics.AbstractDistanceMetric): raise TypeError('%s is not an abstract distance metric' % metric) if not method in self.allowable_methods: raise ValueError(""%s not in %s"" % (method, str(self.allowable_methods))) if isinstance(trajectories, md.Trajectory): trajectories = [trajectories] elif isinstance(trajectories, types.GeneratorType): trajectories = list(trajectories) self.traj_lengths = np.array([len(t) for t in trajectories]) # self.ptrajs = [self.metric.prepare_trajectory(traj) for traj in self.trajectories] logger.info('Preparing...') flat_trajectory = concatenate_trajectories(trajectories) pflat_trajectory = metric.prepare_trajectory(flat_trajectory) logger.info('Getting all to all pairwise distance matrix...') dmat = metric.all_pairwise(pflat_trajectory) logger.info('Done with all2all') self.Z = fastcluster.linkage(dmat, method=method, preserve_input=False) logger.info('Got Z matrix') # self.Z = scipy.cluster.hierarchy.linkage(dmat, method=method) def _oneD_assignments(self, k=None, cutoff_distance=None): """"""Assign the frames into clusters. Either supply k, the number of clusters desired, or cutoff_distance, a max diameteric of each cluster Parameters ---------- k : int, optional number of clusters desired cutoff_distance : float, optional max diameter of each cluster, as a cutoff Returns ------- assignments_1d : ndarray 1D array with the assignments of the flattened trajectory (internal). See Also -------- Hierarchical.get_assignments """""" # note that we subtract 1 from the results given by fcluster since # they start with 1-based numbering, but we want the lowest index cluster # to be number 0 if k is not None and cutoff_distance is not None: raise Exception('You cant supply both a k and cutoff distance') elif k is not None: return scipy.cluster.hierarchy.fcluster(self.Z, k, criterion='maxclust') - 1 elif cutoff_distance is not None: return scipy.cluster.hierarchy.fcluster(self.Z, cutoff_distance, criterion='distance') - 1 else: raise Exception('You need to supply either k or a cutoff distance') def get_assignments(self, k=None, cutoff_distance=None): """"""Assign the frames into clusters. Either supply k, the number of clusters desired, or cutoff_distance, a max diameteric of each cluster Parameters ---------- k : int, optional number of clusters desired cutoff_distance : float, optional max diameter of each cluster, as a cutoff Returns ------- assignments : ndarray 2D array of shape num_trajs x length of longest traj. Padded with -1s at the end if not all trajectories are the same length """""" assgn_list = split(self._oneD_assignments(k, cutoff_distance), self.traj_lengths) output = -1 * np.ones((len(self.traj_lengths), max(self.traj_lengths)), dtype='int') for i, traj_assign in enumerate(assgn_list): output[i][0:len(traj_assign)] = traj_assign return output def save_to_disk(self, filename): """"""Save this clusterer to disk. This is useful because computing the Z-matrix (done in __init__) is the most expensive part, and assigning is cheap Parameters ---------- filename : str location to save to Raises ------ Exception if something already exists at `filename` """""" io.saveh(filename, z_matrix=self.Z, traj_lengths=self.traj_lengths) @classmethod def load_from_disk(cls, filename): """"""Load up a clusterer from disk This is useful because computing the Z-matrix (done in __init__) is the most expensive part, and assigning is cheap Parameters ---------- filename : str location to save to Raises ------ TODO: Probablt raises something if filename doesn't exist? """""" data = io.loadh(filename, deferred=False) Z, traj_lengths = data['z_matrix'], data['traj_lengths'] # Next two lines are a hack to fix Serializer bug. KAB if np.rank(traj_lengths) == 0: traj_lengths = [traj_lengths] return cls(None, None, precomputed_values=(Z, traj_lengths)) class BaseFlatClusterer(object): """""" (Abstract) base class / mixin that Clusterers can extend. Provides convenience functions for the user. To implement a clusterer using this base class, subclass it and define your init method to do the clustering you want, and then set self._generator_indices, self._assignments, and self._distances with the result. For convenience (and to enable some of its functionality), let BaseFlatCluster prepare the trajectories for you by calling BaseFlatClusterer's __init__ method and then using the prepared, concatenated trajectory self.ptraj for your clustering. """""" def __init__(self, metric, trajectories=None, prep_trajectories=None): if not isinstance(metric, metrics.AbstractDistanceMetric): raise TypeError('%s is not an AbstractDistanceMetric' % metric) # if we got a single trajectory instead a list of trajectories, make it a # list if not trajectories is None: if isinstance(trajectories, md.Trajectory): trajectories = [trajectories] elif isinstance(trajectories, types.GeneratorType): trajectories = list(trajectories) self._concatenated = concatenate_trajectories(trajectories) if prep_trajectories is None: self.ptraj = metric.prepare_trajectory(self._concatenated) self._traj_lengths = [len(traj) for traj in trajectories] if not prep_trajectories is None: # If they also provide trajectories # that's fine, but we will use the prep_trajectories if isinstance(prep_trajectories, np.ndarray) or \ isinstance(prep_trajectories[0], np.ndarray): prep_trajectories = np.array(prep_trajectories) if len(prep_trajectories.shape) == 2: prep_trajectories = [prep_trajectories] else: # 3D means a list of prep_trajectories was input prep_trajectories = list(prep_trajectories) if trajectories is None: self._traj_lengths = [len(ptraj) for ptraj in prep_trajectories] self._concatenated = None self.ptraj = concatenate_prep_trajectories(prep_trajectories, metric) if trajectories is None and prep_trajectories is None: raise Exception(""must provide at least one of trajectories and prep_trajectories"") self._metric = metric self.num_frames = sum(self._traj_lengths) # All the actual Clusterer objects that subclass this base class # need to calculate these three parameters and store them here # self._generator_indices[i] = j means that the jth frame of self.ptraj is # considered a generator. self._assignments[i] = j should indicate that # self.ptraj[j] is the coordinates of the the cluster center corresponding to i # and self._distances[i] = f should indicate that the distance from self.ptraj[i] # to self.ptraj[self._assignments[i]] is f. self._generator_indices = 'abstract' self._assignments = 'abstract' self._distances = 'abstract' def _ensure_generators_computed(self): if self._generator_indices == 'abstract': raise Exception('Your subclass of BaseFlatClusterer is implemented wrong and didnt compute self._generator_indicies.') def _ensure_assignments_and_distances_computed(self): if self._assignments == 'abstract' or self._distances == 'abstract': self._assignments, self._distances = _assign(self._metric, self.ptraj, self._generator_indices) def get_assignments(self): """"""Assign the trajectories you passed into the constructor based on generators that have been identified Returns ------- assignments : ndarray 2D array of assignments where k = assignments[i,j] means that the jth frame in the ith trajectory is assigned to the center whose coordinates are in the kth frame of the trajectory in get_generators_as_traj() """""" self._ensure_generators_computed() self._ensure_assignments_and_distances_computed() twoD = split(self._assignments, self._traj_lengths) # the numbers in self._assignments are indices with respect to self.ptraj, # but we want indices with respect to the number in the trajectory of generators # returned by get_generators_as_traj() ptraj_index_to_gens_traj_index = np.zeros(self.num_frames) for i, g in enumerate(self._generator_indices): ptraj_index_to_gens_traj_index[g] = i # put twoD into a rectangular array output = -1 * np.ones((len(self._traj_lengths), max(self._traj_lengths)), dtype=np.int32) for i, traj_assign in enumerate(twoD): output[i, 0:len(traj_assign)] = ptraj_index_to_gens_traj_index[traj_assign] return output def get_distances(self): """"""Extract the distance from each frame to its assigned cluster kcenter Returns ------- distances : ndarray 2D array of size num_trajs x length of longest traj, such that distances[i,j] gives the distance from the ith trajectorys jth frame to its assigned cluster center """""" self._ensure_generators_computed() self._ensure_assignments_and_distances_computed() twoD = split(self._distances, self._traj_lengths) # put twoD into a rectangular array output = -1 * np.ones((len(self._traj_lengths), max(self._traj_lengths)), dtype='float32') for i, traj_distances in enumerate(twoD): output[i][0:len(traj_distances)] = traj_distances return output def get_generators_as_traj(self): """"""Get a trajectory containing the generators Returns ------- traj or ptraj : msmbuilder.Trajectory or np.ndarray a trajectory object where each frame is one of the generators/medoids identified. If trajectories was not originally provided, then will only return the prepared generators """""" self._ensure_generators_computed() if self._concatenated is None: output = self.ptraj[self._generator_indices] else: output = self._concatenated[self._generator_indices] return output def get_generator_indices(self): """"""Get the generator indices corresponding to frames in self.ptraj. Returns ------- gen_inds : np.ndarray generator indices corresponding to the generators in self.ptraj """""" return self._generator_indices class KCenters(BaseFlatClusterer): def __init__(self, metric, trajectories=None, prep_trajectories=None, k=None, distance_cutoff=None, seed=0): """"""Run kcenters clustering algorithm. Terminates either when `k` clusters have been identified, or when every data is clustered better than `distance_cutoff`. Parameters ---------- metric : msmbuilder.metrics.AbstractDistanceMetric A metric capable of handling `ptraj` trajectory : Trajectory or list of msmbuilder.Trajectory data to cluster k : {int, None} number of desired clusters, or None distance_cutoff : {float, None} Stop identifying new clusters once the distance of every data to its cluster center falls below this value. Supply either this or `k` seed : int, optional index of the frame to use as the first cluster center See Also -------- _kcenters : implementation References ---------- .. [1] Beauchamp, MSMBuilder2 """""" s = super(KCenters, self) if PY2 else super() s.__init__(metric, trajectories, prep_trajectories) gi, asgn, dl = _kcenters(metric, self.ptraj, k, distance_cutoff, seed) # note that the assignments here are with respect to the numbering # in the trajectory -- they are not contiguous. Using the get_assignments() # method defined on the superclass (BaseFlatClusterer) will convert them # back into the contiguous numbering scheme (with respect to position in the # self._generator_indices). self._generator_indices = gi self._assignments = asgn self._distances = dl class Clarans(BaseFlatClusterer): def __init__(self, metric, trajectories=None, prep_trajectories=None, k=None, num_local_minima=10, max_neighbors=20, local_swap=False): """"""Run the CLARANS clustering algorithm on the frames in a trajectory Reference --------- .. [1] Ng, R.T, Jan, Jiawei, 'CLARANS: A Method For Clustering Objects For Spatial Data Mining', IEEE Trans. on Knowledge and Data Engineering, vol. 14 no.5 pp. 1003-1016 Sep/Oct 2002 http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=1033770 Parameters ---------- metric : msmbuilder.metrics.AbstractDistanceMetric A metric capable of handling `ptraj` trajectory : Trajectory or list of msmbuilder.Trajectory data to cluster k : int number of desired clusters num_local_minima : int number of local minima in the set of all possible clusterings to identify. Execution time will scale linearly with this parameter. The best of these local minima will be returned. max_neighbors : int number of rejected swaps in a row necessary to declare a proposed clustering a local minima local_swap : bool, optional If true, proposed swaps will be between a medoid and a data point currently assigned to that medoid. If false, the data point for the proposed swap is selected randomly. See Also -------- _kcenters : implementation SubsampledClarans : random subsampling version (faster) """""" s = super(Clarans, self) if PY2 else super() s.__init__(metric, trajectories, prep_trajectories) medoids, assignments, distances = _clarans(metric, self.ptraj, k, num_local_minima, max_neighbors, local_swap, initial_medoids='kcenters') self._generator_indices = medoids self._assignments = assignments self._distances = distances class SubsampledClarans(BaseFlatClusterer): def __init__(self, metric, trajectories=None, prep_trajectories=None, k=None, num_samples=None, shrink_multiple=None, num_local_minima=10, max_neighbors=20, local_swap=False, parallel=None): """""" Run the CLARANS algorithm (see the Clarans class for more description) on multiple subsamples of the data drawn randomly. Parameters ---------- metric : msmbuilder.metrics.AbstractDistanceMetric A metric capable of handling `ptraj` trajectories : Trajectory or list of msmbuilder.Trajectory data to cluster prep_trajectories : np.ndarray or None prepared trajectories instead of msmbuilder.Trajectory k : int number of desired clusters num_samples : int number of random subsamples to draw shrink_multiple : int Each of the subsamples drawn will be of size equal to the total number of frames divided by this number num_local_minima : int, optional number of local minima in the set of all possible clusterings to identify. Execution time will scale linearly with this parameter. The best of these local minima will be returned. max_neighbors : int, optional number of rejected swaps in a row necessary to declare a proposed clustering a local minima local_swap : bool, optional If true, proposed swaps will be between a medoid and a data point currently assigned to that medoid. If false, the data point for the proposed swap is selected randomly parallel : {None, 'multiprocessing', 'dtm} Which parallelization library to use. Each of the random subsamples are run independently """""" s = super(SubsampledClarans, self) if PY2 else super() s.__init__(metric, trajectories, prep_trajectories) if parallel is None: mymap = map elif parallel == 'multiprocessing': mymap = Pool().map elif parallel == 'dtm': mymap = dtm.map else: raise ValueError('Unrecognized parallelization') # function that returns a list of random indices gen_sub_indices = lambda: np.array(random.sample(np.arange(self.num_frames), self.num_frames / shrink_multiple)) # gen_sub_indices = lambda: np.arange(self.num_frames) sub_indices = [gen_sub_indices() for i in range(num_samples)] ptrajs = [self.ptraj[sub_indices[i]] for i in range(num_samples)] clarans_args = uneven_zip(metric, ptrajs, k, num_local_minima, max_neighbors, local_swap, ['kcenters'], None, None, False) results = mymap(_clarans_helper, clarans_args) medoids_list, assignments_list, distances_list = list(zip(*results)) best_i = np.argmin([np.sum(d) for d in distances_list]) # print 'best i', best_i # print 'best medoids (relative to subindices)', medoids_list[best_i] # print 'sub indices', sub_indices[best_i] # print 'best_medoids', sub_indices[best_i][medoids_list[best_i]] self._generator_indices = sub_indices[best_i][medoids_list[best_i]] class HybridKMedoids(BaseFlatClusterer): def __init__(self, metric, trajectories=None, prep_trajectories=None, k=None, distance_cutoff=None, local_num_iters=10, global_num_iters=0, norm_exponent=2.0, too_close_cutoff=.0001, ignore_max_objective=False): """"""Run the hybrid kmedoids clustering algorithm on a set of trajectories Parameters ---------- metric : msmbuilder.metrics.AbstractDistanceMetric A metric capable of handling `ptraj` trajectory : Trajectory or list of msmbuilder.Trajectory data to cluster k : int number of desired clusters num_iters : int number of swaps to attempt per medoid local_swap : boolean, optional If true, proposed swaps will be between a medoid and a data point currently assigned to that medoid. If false, the data point for the proposed swap is selected randomly. norm_exponent : float, optional exponent to use in pnorm of the distance to generate objective function too_close_cutoff : float, optional Summarily reject proposed swaps if the distance of the medoid to the trial medoid is less than thus value ignore_max_objective : boolean, optional Ignore changes to the distance of the worst classified point, and only reject or accept swaps based on changes to the p norm of all the data points. References ---------- .. [1] Beauchamp, K, et. al. MSMBuilder2 See Also -------- KCenters : faster, less accurate Clarans : slightly more clever termination criterion """""" s = super(HybridKMedoids, self) if PY2 else super() s.__init__(metric, trajectories, prep_trajectories) medoids, assignments, distances = _hybrid_kmedoids( metric, self.ptraj, k, distance_cutoff, local_num_iters, True, norm_exponent, too_close_cutoff, ignore_max_objective, initial_medoids='kcenters') if global_num_iters != 0: medoids, assignments, distances = _hybrid_kmedoids( metric, self.ptraj, k, distance_cutoff, global_num_iters, False, norm_exponent, too_close_cutoff, ignore_max_objective, medoids, assignments, distances) self._generator_indices = medoids self._assignments = assignments self._distances = distances ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/SCRE.py",".py","6038","256","from __future__ import print_function, division, absolute_import import numpy as np import scipy import scipy.linalg import scipy.optimize import scipy.stats def GetFormat(): """"""Construct a generator to enumerate colors for plotting. Returns ------- ColorList[i] : string Color string """""" ColorList = [ ""#99CC00"", ""#003300"", ""#00CC99"", ""#0000FF"", ""#6600FF"", ""#CC0000"", ""#FF9900"", ""#FFFF99"", ""#000000"", ""#CCCCCC"" ] i = 0 while True: i = (i + 1) % len(ColorList) yield ColorList[i] color_generator = GetFormat() def FixEntry(mapping, parameters, populations, K0, i, j, Val): """"""Constrain an entry in a rate matrix. Parameters ---------- mapping : list List of (i,j) indices that have already been constrained. parameters : list List of rate matrix elements K[i,j]. populations : ndarray Equilibrium populations i : int j : int Val : float Constrain the value K[i,j] = Val. Notes ----- Also constrains the transpose entry by detailed balance. Removes the entry from the lists of free variables (mapping, parameters). """""" Ind = mapping.index([i, j]) mapping.pop(Ind) parameters.pop(Ind) K0[i, j] = Val K0[j, i] = Val * populations[i] / populations[j] def LogLikelihood(C, T): """"""Calculate the likelihood of a transition matrix given counts C. Parameters ---------- C : ndarray Count matrix T : ndarray Transition matrix Returns ---------- f : float log likelihood of T given C """""" f = np.sum(C * np.log(T)) return f def ConvertTIntoK(T0): """"""Convert a transition matrix into a rate matrix. Parameters ---------- T0 : ndarray Initial transition matrix Returns ---------- K : ndarray rate matrix Notes ---------- For best results, use a transition matrix with short lagtime. This follows because one can show that T = exp(K t) ~ I +K t + ... """""" if type(T0) != np.ndarray: raise Exception(""Error, T0 must be a numpy array"") D = T0.diagonal() K = T0 - np.diag(D) D2 = K.sum(1) K = K - np.diag(D2) return(K) def ConstructRateFromParams(parameters, mapping, populations, K0): """"""Construct a rate matrix from a flat array of parameters. Parameters ---------- parameters : list Flat list of parameters mapping : list Mapping from flat indices to (2d) array indices. populations : ndarray stationary populations of model K0 : ndarray Initial rate matrix. Returns ---------- K : ndarray rate matrix Notes ---------- The returned matrix K is such that K[mapping.T[0],mapping.T[1]] = abs(parameters) """""" parameters = np.array(parameters) mapping = np.array(mapping) K = K0.copy() if len(mapping) > 0: K[mapping.T[0], mapping.T[1]] = abs(parameters) X2 = abs(parameters) * populations[mapping.T[0]] / populations[mapping.T[1]] K[mapping.T[1], mapping.T[0]] = X2 K -= np.diag(K.sum(1)) return K def get_parameter_mapping(K): """"""Get a mapping from 1D to 2D indices. Parameters ---------- K : ndarray Rate matrix. Returns ---------- mapping : list List of nonzero (i,j) elements such that i > j. parameters : list List of values of K[i,j] at locations in mapping. """""" mapping = [] parameters = [] NumStates = K.shape[0] for i in range(NumStates): for j in range(NumStates): if i > j and K[i, j] != 0: mapping.append([i, j]) parameters.append(K[i, j]) return mapping, parameters def MaximizeRateLikelihood(parameters, mapping, populations, C, K0): """"""Maximize the likelihood of a rate matrix given assignment data. Parameters ---------- parameters : list List of values of K[i,j] at locations in mapping. mapping : list List of nonzero (i,j) elements such that i > j. C : ndarray Array of observed counts K0 : ndarray Initial rate matrix. Returns ---------- ans : ndarray Final rate matrix. """""" def obj(parameters): K = ConstructRateFromParams(parameters, mapping, populations, K0) T = scipy.linalg.matfuncs.expm(K) f = LogLikelihood(C, T) return -1 * f def callback(parameters): pass ans = scipy.optimize.fmin(obj, parameters, full_output=True, xtol=1E-10, ftol=1E-10, maxfun=100000, maxiter=100000, callback=callback)[0] ans = abs(ans) return ans def PlotRates(KList, LagTimeList, counts_list, Tau=1): """"""Plot the intermediate SCRE output to evaluate convergence. Parameters ---------- KList : list List of MLE rate matrices as function of lagtime. LagTimeList : list List of lagtimes. counts_list : ndarray List of observed count arrays at function of lagtime. Tau : int, optional The time unit associated with spacings between lagtimes. """""" import matplotlib KList = np.array(KList) NumStates = KList.shape[-1] TauList = Tau / KList counts_list = np.array(counts_list) for i in range(NumStates): for j in range(NumStates): if i > j and KList[0, i, j] > 0: matplotlib.pyplot.errorbar(Tau * LagTimeList, TauList[:, i, j], fmt=next(color_generator), yerr=TauList[:, i, j] / np.sqrt(counts_list[:, i]), label=""%d-%d"" % (i, j)) #matplotlib.pyplot.plot(Tau*LagTimeList,TauList[:,i,j],color_generator.next(),label=""%d-%d""%(i,j)) matplotlib.pyplot.yscale('log') matplotlib.pyplot.legend(loc=0) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/Citation.py",".py","622","19","""""""Literature References for MSMBuilder. """""" CiteString="""""" Please cite the following references: GR Bowman, X Huang, and VS Pande. Methods 2009. Using generalized ensemble simulations and Markov state models to identify conformational states. KA Beauchamp, GR Bowman, TJ Lane, L Maibaum, IS Haque, VS Pande. JCTC 2011. MSMBuilder2: Modeling Conformational Dynamics at the Picosecond to Millisecond Timescale IS Haque, KA Beauchamp, VS Pande. In preparation. A Fast 3 x N Matrix Multiply Routine for Calculation of Protein RMSD. --------------------------------------------------------------------------------"""""" ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/drift.py",".py","6192","173",""""""" Compute the drift in trajectories under different distance metrics using new distance_metrics.py code """""" from __future__ import print_function, division, absolute_import import numpy as np def _drift_single_trajectory(metric, trajectory, tau): """""" Compute the drift in your desired metric between all pairs of conformations in the supplied trajectory which are seperated by tau frames. Parameters ---------- metric : msmbuilder.metrics.AbstractDistanceMetric The distance metric to compute distances with trajectory : msmbuilder.Trajectory The trajectory to compute the distances tau : {int, np.ndarray} tau can be either a positive integer or an array of positive integers. If tau is an integer, the return value is a 1D array of length equal to the length of the trajectory minus tau containing the pairwise distance of all conformations in trajectory seperated by tau frames. If tau is an array of integers of length n, the return value is a 2D array with n rows and a number of columns equal to the length of the trajectory minus min(tau). The ith row of the returned array contains the pairwise distance of all of the conformations in the supplied trajectory separated by tau[i] frames. The final i entries in row i will be padded with -1s to ensure that the output 2D arrau is rectangular. Returns ------- distances : np.ndarray 1D or 2D array of the drifts, depending on whether tau is a single number or an array """""" # make sure tau is a 1D numpy array of positive ints, or make it into one tau = __typecheck_tau(tau) # if not isinstance(metric, AbstractDistanceMetric): # raise TypeError('metric must be an instance of AbstractDistanceMetric. you supplied a %s' % metric) traj_length = trajectory['XYZList'].shape[0] ptraj = metric.prepare_trajectory(trajectory) distances = -1 * np.ones((len(tau), traj_length - np.min(tau))) for i in xrange(traj_length - np.min(tau)): comp_indices = [elem for elem in tau + i if elem < traj_length] d = metric.one_to_many(ptraj, ptraj, i, comp_indices) # these distances are the ith column distances[0:len(comp_indices), i] = d # if there was only 1 element in tau, reshape output so its 1D # if distances.shape == (1, traj_length - np.min(tau)): # distances = np.reshape(distances, traj_length - np.min(tau)) return distances def drift(metric, trajectories, taus): if 'XYZList' in trajectories: trajectories = [trajectories] if isinstance(taus, int): taus = [taus] output = [np.array([])] * len(taus) for trajectory in trajectories: d = _drift_single_trajectory(metric, trajectory, taus) for i in range(len(taus)): #length_i = d.shape[1] - (taus[i] - np.min(taus)) selected_d = np.ma.masked_less(d[i, :], 0) selected_d = np.ma.compressed(selected_d) output[i] = np.hstack((output[i], selected_d)) return output def square_drift(metric, trajectories, tau): output = drift(metric, trajectories, tau) for i, row in enumerate(output): output[i] = row ** 2 return output def get_epsilon_neighborhoods(metric, ptraj, tau): output = [] N = len(ptraj) for i in xrange(N): if i < tau: output.append(metric.one_to_many(ptraj, ptraj, i, [i + tau])[0]) elif i >= N - tau: output.append(metric.one_to_many(ptraj, ptraj, i, [i - tau])[0]) else: output.append(metric.one_to_many(ptraj, ptraj, i, [i - tau, i + tau]).max()) return output def hitting_time(metric, trajectory, epsilon): """""" For each frame in trajectories, determine the time it takes to go more than epsilon distance from where it started. Returns: a masked array of integers of length equal to the length of the trajectory. The masked values correspond to frames for which the hitting time could not be determined (maybe the trajectory wasn't long enough so it never left the epsilon-ball) """""" traj_length = len(trajectory) ptraj = metric.prepare_trajectory(trajectory) window_length = 8 output = -1 * np.ones(len(trajectory), dtype=np.int) for i in xrange(traj_length): found = False mult = 1 start = i + 1 while not found: forward_window = np.arange(start, start + window_length * mult) forward_window = forward_window[np.where(forward_window < traj_length)] if len(forward_window) == 0: break # print forward_window d = metric.one_to_many(ptraj, ptraj, i, forward_window) where = np.where(d > epsilon)[0] found = len(where) != 0 if not found: start += window_length * mult mult *= 2 if found: first = np.min(where) output[i] = forward_window[first] - i # print d[first - 1], d[first] # xprint i, first, forward_window # print i # print forward_window[np.min(where)] # print d[np.min(where)] # return np.ma.masked_equal(output, -1) return output def __typecheck_tau(tau): """"""make sure tau is a 1D numpy array of positive ints, or make it into one if possible unambiguously"""""" if isinstance(tau, int): if tau < 0: raise TypeError('Tau cannot be negative') tau = np.array([tau]) else: tau = np.array(tau) if not len(tau.shape) == 1: raise TypeError('Tau must be a 1D array or an int. You supplied %s' % tau) # ensure positive if not np.all(tau == np.abs(tau)): raise TypeError('Taus must be all positive.') # ensure ints if not np.all(tau == np.array(tau, dtype='int')): raise TypeError('Taus must be all integers.') return tau ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/metrics/projection.py",".py","4136","112","from __future__ import print_function, division, absolute_import from mdtraj.utils.six import PY2 import abc import re import numpy as np import warnings from mdtraj import io from msmbuilder.metrics.baseclasses import AbstractDistanceMetric, Vectorized import inspect class RedDimPNorm(Vectorized, AbstractDistanceMetric): """""" This is a class for using a reduced dimensionality representation for the trajectory data. A transformation matrix must be generated by some other method """""" def __init__(self, proj_obj, abs_min=None, num_vecs=None, expl_var=None, which=None, metric='euclidean', p=2): """""" Parameters: ----------- proj_obj: object object that has at least a method called project that has a call signature like: OBJECT.project(trajectory=None, prep_trajectory=None, which=None) # trajectory is an instance of msmbuilder.Trajectory # prep_trajectory is a prepared msmbuilder.Trajectory (np.ndarray) # which is a np.ndarray of which eigenvectors to use additionally, there needs to be an attribute called 'vals' that holds the eigenvalues used to determine which vectors to project onto abs_min: float, optional keep all eigenvectors with eigenvalues greater than num_vecs: int, optional number of vectors to use (sorted by decreasing eigenvalue) expl_var: float, optional keep vectors (from highest eigenvalue) such that the sum of the kept eigenvalues divided by the sum of all the eigenvalues is greater than which: np.ndarray, optional indices of eigenvectors to use (sorted by decreasing eigenvalue) metric: str, optional metric to use in reduced space. See Vectorized for choices (default: euclidean) p : int, optional Exponent for the p-norm (default: 2) Remarks: -------- Only one of abs_min, num_vecs, expl_var, and which is necessary. If more than one is provided, then the one that will be used is which ever is given in this order: (which, num_vecs, abs_min, expl_var) """""" self.proj_obj = proj_obj if not hasattr(self.proj_obj, 'project'): raise Exception(""proj_obj must have a method called 'project'"") project_args = inspect.getargspec(self.proj_obj.project) if not ('trajectory' in project_args.args or 'prep_trajectory' in project_args.args or 'which' in project_args.args): raise Exception(""proj_obj.project must take all of trajectory, "" ""prep_trajectory, and which"") self._set_which(abs_min=abs_min, num_vecs=num_vecs, expl_var=expl_var, which=which) s = super(RedDimPNorm, self) if PY2 else super() s.__init__(metric, p) def _set_which(self, abs_min=None, num_vecs=None, expl_var=None, which=None): """""" set which eigenvectors will be selected. """""" if not which is None: self.which = np.array(which).flatten().astype(int) elif not num_vecs is None: self.which = np.arange(num_vecs) elif not abs_min is None: self.which = np.where(self.proj_obj.vals > abs_min)[0] elif not expl_var is None: tot_sum = self.proj_obj.vals.sum() if tot_sum <= 1e-8: raise Exception( ""total sum of eigenvalues is almost zero (or negative): %f"" % tot_sum) self.which = np.where(np.cumsum(self.proj_obj.vals) / tot_sum < expl_var)[0] else: raise Exception(""must pass one of (abs_min, num_vecs, which, or expl_var)"") def prepare_trajectory(self, trajectory): """""" prepare_trajectory """""" proj_trajectory = self.proj_obj.project(trajectory=trajectory, which=self.which) return proj_trajectory ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/metrics/hybrid.py",".py","11167","313","from __future__ import print_function, division, absolute_import from mdtraj.utils.six import PY2 from .baseclasses import Vectorized, AbstractDistanceMetric import numpy as np import logging logger = logging.getLogger(__name__) from .baseclasses import AbstractDistanceMetric class Hybrid(AbstractDistanceMetric): ""A linear combination of other distance metrics"" class HybridPreparedTrajectory(object): """"""Container to to hold the prepared trajectory. This container needs to support slice notation in a way that kind of passes through the indices to the 2nd dimension. So if you have a HybridPreparedTrajectory with 3 bases metrics, and you do metric[0:100], it needs to return a HybridPrepareTrajectory with the same three base metrics, but with each of the base prepared trajectories sliced 0:100. We don't want to slice out base_metrics and thus have metric[0] return only one of the three prepared_trajectories in its full length."""""" def __init__(self, *args): self.num_base = len(args) self.length = len(args[0]) if not np.all((len(arg) == self.length for arg in args)): raise ValueError(""Must all be equal length"") self.datas = args def __getitem__(self, key): if isinstance(key, int): key = slice(key, key + 1) return Hybrid.HybridPreparedTrajectory(*(d[key] for d in self.datas)) def __len__(self): return self.length def __setitem__(self, key, value): try: if self.num_base != value.num_base: raise ValueError(""Must be prepared over the same metrics"") except: raise ValueError(""I can only set in something which is also "" ""a HybridPreparedTrajectory"") for i in xrange(self.num_base): self.datas[i][key] = value.datas[i] def __init__(self, base_metrics, weights): """"""Create a hybrid linear combinatiin distance metric Parameters ---------- base_metrics : list of distance metric objects weights : list of floats list of scalars of equal length to `base_metrics` -- each base metric will be multiplied by that scalar when they get summed. """""" self.base_metrics = base_metrics self.weights = weights self.num = len(self.base_metrics) if not len(self.weights) == self.num: raise ValueError() def prepare_trajectory(self, trajectory): """"""Preprocess trajectory for use with this metric Parameters ---------- trajectory : mdtraj.Trajectory Trajectory to prepare Returns ------- prepared_trajectory : array_like The prepared trajectory is a special array like object called HybridPreparedTrajectory which is designed to pass through the slicing correctly so that if you ask for prepared_trajectory[5] you get the appropriate 5th frames dihedral angles, RMSD, etc (depending what base metrics you used) """""" prepared = (m.prepare_trajectory(trajectory) for m in self.base_metrics) return self.HybridPreparedTrajectory(*prepared) def one_to_many(self, prepared_traj1, prepared_traj2, index1, indices2): """"""Calculate a vector of distances from one frame of the first trajectory to many frames of the second trajectory The distances calculated are from the `index1`th frame of `prepared_traj1` to the frames in `prepared_traj2` with indices `indices2` Parameters ---------- prepared_traj1 : ndarray First prepared trajectory prepared_traj2 : ndarray Second prepared trajectory index1 : int index in `prepared_trajectory` indices2 : ndarray list of indices in `prepared_traj2` to calculate the distances to Returns ------- Vector of distances of length len(indices2) """""" distances = None for i in range(self.num): d = self.base_metrics[i].one_to_many( prepared_traj1.datas[i], prepared_traj2.datas[i], index1, indices2) if distances is None: distances = self.weights[i] * d else: distances += self.weights[i] * d return distances def one_to_all(self, prepared_traj1, prepared_traj2, index1): """"""Calculate the vector of distances from the index1th frame of prepared_traj1 to all of the frames in prepared_traj2. Parameters ---------- prepared_traj1 : prepared_trajectory First prepared trajectory prepared_traj2 : prepared_trajectory Second prepared trajectory index1 : int index in `prepared_trajectory` Returns ------- distances : ndarray vector of distances of length len(prepared_traj2) Notes ----- Although this might seem to be a special case of one_to_many(), it can often be implemented in a much more optimized way because it doesn't require construction of the indices2 array and array slicing in python is kindof slow. """""" distances = None for i in range(self.num): d = self.base_metrics[i].one_to_all( prepared_traj1.datas[i], prepared_traj2.datas[i], index1) if distances is None: distances = self.weights[i] * d else: distances += self.weights[i] * d return distances def all_pairwise(self, prepared_traj): """"""Calculate condensed distance metric of all pairwise distances See `scipy.spatial.distance.squareform` for information on how to convert the condensed distance matrix to a redundant square matrix Parameters ---------- prepared_traj : array_like Prepared trajectory Returns ------- Y : ndarray A 1D array containing the distance from each frame to each other frame See Also -------- fast_pdist scipy.spatial.distance.squareform """""" distances = None for i in range(self.num): d = self.base_metrics[i].all_pairwise(prepared_traj.datas[i]) distances = self.weights[i] * \ d if distances is None else distances + self.weights[i] * d return distances class HybridPNorm(Hybrid): """"""A p-norm combination of other distance metrics. With p=2 for instance, this gives you the root mean square combination of the base metrics"""""" def __init__(self, base_metrics, weights, p=2): """"""Initialize the HybridPNorm distance metric. Parameters ---------- base_metrics : list of distance metric objects weights : list of floats list of scalars of equal length to `base_metrics` -- each base metric will be multiplied by that scalar. p : float p should be a scalar, greater than 0, which will be the exponent. If p=2, all the base metrics will be squared, then summed, then the square root will be taken. If p=3, the base metrics will be cubed, summed and cube rooted, etc. """""" self.p = float(p) s = super(HybridPNorm, self) if PY2 else super() s.__init__(base_metrics, weights) def one_to_many(self, prepared_traj1, prepared_traj2, index1, indices2): """"""Calculate a vector of distances from one frame of the first trajectory to many frames of the second trajectory The distances calculated are from the `index1`th frame of `prepared_traj1` to the frames in `prepared_traj2` with indices `indices2` Parameters ---------- prepared_traj1 : ndarray First prepared trajectory prepared_traj2 : ndarray Second prepared trajectory index1 : int index in `prepared_trajectory` indices2 : ndarray list of indices in `prepared_traj2` to calculate the distances to Returns ------- Vector of distances of length len(indices2) """""" distances = None for i in range(self.num): d = self.base_metrics[i].one_to_many( prepared_traj1.datas[i], prepared_traj2.datas[i], index1, indices2) if distances is None: distances = (self.weights[i] * d) ** self.p else: distances += (self.weights[i] * d) ** self.p return distances ** (1.0 / self.p) def one_to_all(self, prepared_traj1, prepared_traj2, index1): """"""Calculate the vector of distances from the index1th frame of prepared_traj1 to all of the frames in prepared_traj2. Parameters ---------- prepared_traj1 : prepared_trajectory First prepared trajectory prepared_traj2 : prepared_trajectory Second prepared trajectory index1 : int index in `prepared_trajectory` Returns ------- distances : ndarray vector of distances of length len(prepared_traj2) Notes ----- Although this might seem to be a special case of one_to_many(), it can often be implemented in a much more optimized way because it doesn't require construction of the indices2 array and array slicing in python is kindof slow. """""" distances = None for i in range(self.num): d = self.base_metrics[i].one_to_all( prepared_traj1.datas[i], prepared_traj2.datas[i], index1) if distances is None: distances = (self.weights[i] * d) ** self.p else: distances += (self.weights[i] * d) ** self.p return distances ** (1.0 / self.p) def all_pairwise(self, prepared_traj): """"""Calculate condensed distance metric of all pairwise distances See `scipy.spatial.distance.squareform` for information on how to convert the condensed distance matrix to a redundant square matrix Parameters ---------- prepared_traj : array_like Prepared trajectory Returns ------- Y : ndarray A 1D array containing the distance from each frame to each other frame See Also -------- fast_pdist scipy.spatial.distance.squareform """""" distances = None for i in range(self.num): d = self.base_metrics[i].all_pairwise(prepared_traj.datas[i]) d = (self.weights[i] * d) ** self.p distances = d if distances is None else distances + (self.weights[i] * d) logger.info('got %s', i) return distances ** (1.0 / self.p) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/metrics/__init__.py",".py","1092","22",""""""" This should be documented better somewhere, because it will cause cryptic errors if you don't do it. Whatever data structure you return from prepare_trajectory() needs to support slice sytax. If you return an array or something, then this is no problem, but if you create your own object to hold the data that prepare_trajectory() returns, you need to add a __getitem__(), __setitem__() and __len__() methods. See the RMSD.TheoData object for an example. Also, if you're not familiar with this side of python these docs (http://docs.python.org/reference/datamodel.html#emulating-container-types) are pretty good. Only __getitem__, __setitem__ and __len__ are necessary. """""" from __future__ import print_function, division, absolute_import from .baseclasses import AbstractDistanceMetric from .baseclasses import Vectorized from .rmsd import RMSD from .dihedral import Dihedral from .contact import BooleanContact, AtomPairs, ContinuousContact from .projection import RedDimPNorm from .hybrid import Hybrid, HybridPNorm from .projection import RedDimPNorm from .positions import Positions ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/metrics/contact.py",".py","10375","229","from __future__ import print_function, absolute_import, division from mdtraj.utils.six import PY2 import numpy as np import itertools from numbers import Number import mdtraj as md from .baseclasses import Vectorized, AbstractDistanceMetric class ContinuousContact(Vectorized, AbstractDistanceMetric): """"""Distance metric for calculating distances between frames based on the pairwise distances between residues. Here each frame is represented as a vector of the distances between pairs of residues. """""" allowable_scipy_metrics = ['braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation', 'cosine', 'euclidean', 'minkowski', 'sqeuclidean', 'seuclidean', 'mahalanobis'] def __init__(self, metric='euclidean', p=2, contacts='all', scheme='closest-heavy', V=None, VI=None): """"""Create a distance calculator based on the distances between pairs of atoms in a sturcture -- like the contact map except without casting to boolean. Parameters ---------- metric : {'braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation', 'cosine', 'euclidean', 'minkowski', 'sqeuclidean'} distance metric to equip the space with p : int exponent for p-norm, used only for `metric='minkowski'` contacts : {ndarray, 'all'} contacts can be an n by 2 array, where each row is a pair of integers giving the indices of 2 residues whose distance you care about. Alternatively, contacts can be the string 'all'. This is a shortcut for supplying a contacts list that includes all (N-2 * N-3) / 2 pairs of residues which are more than 2 residues apart. scheme: {'CA', 'closest', 'closest-heavy'} scheme can be 'CA', 'closest', or 'closest-heavy' and gives the sense in which the 'distance between two residues' is computed. If scheme is 'CA', then we'll use the cartesian distance between the residues' C-alpha atoms as their distance for the purpose of calculating whether or not they have exceeded the cutoff. If scheme is 'closest', we'll use the distance between the closest pair of atoms where one belongs to residue i and to residue j. If scheme is 'closest-heavy', we'll use the distance between the closest pair of non-hydrogen atoms where one belongs to reside i and one to residue j. """""" s = super(ContinuousContact, self) if PY2 else super() s.__init__(metric, p, V, VI) self.contacts = contacts scheme = scheme.lower() if not scheme in ['ca', 'closest', 'closest-heavy']: raise ValueError('Unrecognized scheme') self.scheme = scheme def __repr__(self): try: contacts_repr = repr(self.contacts.tolist()) except: contacts_repr = repr(self.contacts) return 'metrics.ContinuousContact(metric=%s, p=%s, contacts=%s, scheme=%s)' % (self.metric, self.p, contacts_repr, self.scheme) def prepare_trajectory(self, trajectory): """"""Prepare a trajectory for distance calculations based on the contact map. Each frame in the trajectory will be represented by a vector where each entries represents the distance between two residues in the structure. Depending on what contacts you pick to use, this can be a 'native biased' picture or not. Paramters --------- trajectory : mdtraj.Trajectory The trajectory to prepare Returns ------- pairwise_distances : ndarray 1D array of various residue-residue distances """""" # the result of md.compute_contacts is a tuple, where the distances are # returned in the first element, and a list of contacts calculated are # returned in the second element return md.compute_contacts(trajectory, self.contacts, self.scheme)[0] class BooleanContact(Vectorized, AbstractDistanceMetric): """"""Distance metric for calculating distances between frames based on their contact maps. Here each frame is represented as a vector of booleans representing whether the distance between pairs of residues is less than a cutoff. """""" allowable_scipy_metrics = ['dice', 'kulsinki', 'matching', 'rogerstanimoto', 'russellrao', 'sokalmichener', 'sokalsneath', 'yule'] def __init__(self, metric='matching', contacts='all', cutoff=0.5, scheme='closest-heavy'): """""" Create a distance metric that will measure the distance between frames based on differences in their contact maps. Paramters --------- metric : {'dice', 'kulsinki', 'matching', 'rogerstanimoto', russellrao', 'sokalmichener', 'sokalsneath', 'yule'} You should probably use matching. Then the distance between two frames is just the number of elements in their contact map that are the same. See the scipy.spatial.distance documentation for details. contacts : {ndarray, 'all'} contacts can be an n by 2 array, where each row is a pair of integers giving the indices of 2 residues which form a native contact. Each conformation is then represnted by a vector of booleans representing whether or not that contact is present in the conformation. The distance metric acts on two conformations and compares their vectors of booleans. Alternatively, contacts can be the string 'all'. This is a shortcut for supplying a contacts list that includes all (N-2 * N-3) / 2 pairs of residues which are more than 2 residues apart. cutoff : {float, ndarray} cutoff can be either a positive float representing the cutoff distance between two residues which constitues them being 'in contact' vs 'not in contact'. It is measured in the same distance units that your trajectory's XYZ data is in (probably nanometers). Alternatively, cutoff can be an array of length equal to the number of rows in the contacts array, specifying a different cutoff for each contact. That is, cutoff[i] should contain the cutoff for the contact in contact[i]. scheme : {'CA', 'closest', 'closest-heavy'} scheme can be 'CA', 'closest', or 'closest-heavy' and gives the sense in which the 'distance between two residues' is computed. If scheme is 'CA', then we'll use the cartesian distance between the residues' C-alpha atoms as their distance for the purpose of calculating whether or not they have exceeded the cutoff. If scheme is 'closest', we'll use the distance between the closest pair of atoms where one belongs to residue i and to residue j. If scheme is 'closest-heavy', we'll use the distance between the closest pair of non-hydrogen atoms where one belongs to reside i and one to residue j."""""" super(BooleanContact, self).__init__(metric) self.contacts = contacts if isinstance(cutoff, Number): self.cutoff = cutoff else: self.cutoff = np.array(cutoff).flatten() scheme = scheme.lower() if not scheme in ['ca', 'closest', 'closest-heavy']: raise ValueError('Unrecognized scheme') self.scheme = scheme def __repr__(self): try: contacts_repr = repr(self.contacts.tolist()) except: contacts_repr = repr(self.contacts) try: cutoff_repr = repr(self.cutoff.tolist()) except: cutoff_repr = repr(self.cutoff) return 'metrics.BooleanContact(metric=%s, p=%s, contacts=%s, cutoff=%s, scheme=%s)' % (self.metric, self.p, contacts_repr, cutoff_repr, self.scheme) def prepare_trajectory(self, trajectory): """"""Prepare a trajectory for distance calculations based on the contact map. Paramters --------- trajectory : mdtraj.Trajectory The trajectory to prepare Returns ------- pairwise_distances : ndarray 1D array of various residue-residue distances, casted to boolean """""" ccm = ContinuousContact(contacts=self.contacts, scheme=self.scheme) contact_d = ccm.prepare_trajectory(trajectory) if not isinstance(self.cutoff, Number): # contact_d has frames in rows and contacts in columns if not len(self.cutoff) == contact_d.shape[1]: raise ValueError('cutoff must be a number or match the length of contacts') # contact = np.zeros_like(contact_d).astype(bool) # for i in xrange(contact_d.shape[0]): # contact[i, :] = contact_d[i, :] < self.cutoff contact = contact_d < self.cutoff return contact class AtomPairs(Vectorized, AbstractDistanceMetric): """"""Concrete distance metric that monitors the distance between certain pairs of atoms (as opposed to certain pairs of residues as ContinuousContact does)"""""" allowable_scipy_metrics = ['braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation', 'cosine', 'euclidean', 'minkowski', 'sqeuclidean', 'seuclidean', 'mahalanobis'] def __init__(self, metric='cityblock', p=1, atom_pairs=None, V=None, VI=None): """""" Atom pairs should be a N x 2 array of the N pairs of atoms whose distance you want to monitor"""""" super(AtomPairs, self).__init__(metric, p, V=V, VI=VI) try: atom_pairs = np.array(atom_pairs, dtype=int) n, m = atom_pairs.shape if not m == 2: raise ValueError() except (ValueError, TypeError): raise ValueError('Atom pairs must be an n x 2 array of pairs of atoms') self.atom_pairs = np.int32(atom_pairs) def prepare_trajectory(self, trajectory): return md.compute_distances(trajectory, self.atom_pairs) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/metrics/dihedral.py",".py","5761","138","from __future__ import print_function, absolute_import, division from mdtraj.utils.six import PY2 import logging logger = logging.getLogger(__name__) import numpy as np from mdtraj.geometry import dihedral as _dihedralcalc from .baseclasses import Vectorized, AbstractDistanceMetric class Dihedral(Vectorized, AbstractDistanceMetric): """"""Distance metric for calculating distances between frames based on their projection in dihedral space."""""" allowable_scipy_metrics = ['braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation', 'cosine', 'euclidean', 'minkowski', 'sqeuclidean', 'seuclidean', 'mahalanobis', 'sqmahalanobis'] def __init__(self, metric='euclidean', p=2, angles='phi/psi', userfilename='DihedralIndices.dat', V=None, VI=None, indices=None): """"""Create a distance metric to act on torison angles Parameters ---------- metric : {'braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation', 'cosine', 'euclidean', 'minkowski', 'sqeuclidean', 'seuclidean', 'mahalanobis', 'sqmahalanobis'} Distance metric to equip the vector space with. angles : {'phi', 'psi', 'chi', 'omega', 'psi/psi', etc... OR 'user' } A slash separated list of strings specifying the types of angles to compute per residue. The choices are 'phi', 'psi', 'chi', and 'omega', or any combination thereof. If angles = 'user', indices are taken from the userfilename userfilename: string, optional filename used for angles=user. Default is 'DihderalIndices.dat' p : int, optional p-norm order, used for metric='minkowski' V : ndarray, optional variances, used for metric='seuclidean' VI : ndarray, optional inverse covariance matrix, used for metric='mahalanobi' indices : ndarray, optional N x 4 numpy array of indices to be considered as dihedral angles. If provided, this overrrides the angles argument. The semantics of the array are that each row, indices[i], is an array of length 4 giving (in order) the indices of 4 atoms that together form a dihedral you want to monitor. See Also -------- fast_cdist fast_pdist scipy.spatial.distance """""" s = super(Dihedral, self) if PY2 else super() s.__init__(metric, p, V, VI) self.angles = angles self.userfilename = userfilename self.indices = indices if indices is not None: if not isinstance(indices, np.ndarray): raise ValueError('indices must be a numpy array') if not indices.ndim == 2: raise ValueError('indices must be 2D') if not indices.dtype == np.int: raise ValueError('indices must contain ints') if not indices.shape[1] == 4: raise ValueError('indices must be N x 4') logger.warning('OVERRIDING angles=%s and using custom indices instead', angles) def __repr__(self): ""String representation of the object"" return 'metrics.Dihedral(metric=%s, p=%s, angles=%s)' % (self.metric, self.p, self.angles) def prepare_trajectory(self, trajectory): """"""Prepare the dihedral angle representation of a trajectory, suitable for distance calculations. Parameters ---------- trajectory : mdtraj.Trajectory An MDTraj trajectory to prepare Returns ------- projected_angles : ndarray A 2D array of dimension len(trajectory) x (2*number of dihedral angles per frame), such that in each row, the first half of the entries contain the cosine of the dihedral angles and the later dihedral angles contain the sine of the dihedral angles. This transform is necessary so that distance calculations preserve the periodic symmetry. """""" traj_length = trajectory.n_frames if self.angles == 'user': indices = self.read_dihedral_indices(self.userfilename) dihedrals = _dihedralcalc.compute_dihedrals(trajectory, indices) else: if self.indices is None: f = lambda e: getattr(_dihedralcalc, 'compute_%s' % e) dihedrals = np.hstack(f(e)(trajectory)[1] for e in self.angles.split('/')) else: dihedrals = _dihedralcalc.compute_dihedrals(trajectory, self.indices) # these dihedrals go between -pi and pi but obviously because of the # periodicity, when we take distances we want the distance between -179 # and +179 to be very close, so we need to do a little transform num_dihedrals = dihedrals.shape[1] transformed = np.empty((traj_length, 2 * num_dihedrals)) transformed[:, 0:num_dihedrals] = np.cos(dihedrals) transformed[:, num_dihedrals:2 * num_dihedrals] = np.sin(dihedrals) return np.double(transformed) def read_dihedral_indices(self, filename): """"""Read in a flat text file of dihedral indices, and return the indices as an array. Parameters ---------- filename : string The filename containing user-defined dihedral indices. Expected format is N lines of 4 space-separated indices i j k l Returns ------- indices : ndarray A 2D array of (number of dihedral angles) x 4 """""" from scipy import loadtxt indices = loadtxt(filename) return indices ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/metrics/positions.py",".py","4231","109","from __future__ import print_function, absolute_import, division from mdtraj.utils.six import PY2 import logging logger = logging.getLogger(__name__) import mdtraj as md import numpy as np try: import lprmsd except: RuntimeError( ""Unable to import lprmsd. See msmbuilder/Extras/lprmsd for directions on installing"") from .baseclasses import Vectorized, AbstractDistanceMetric class Positions(Vectorized, AbstractDistanceMetric): """""" This metric will calculate distances based on some vector norm while doing only a single alignment to a target structure. This is NOT the RMSD since the structures are not pair-wise aligned, they are aligned to a single structure at the beginning. """""" allowable_scipy_metrics = ['braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation', 'cosine', 'euclidean', 'minkowski', 'sqeuclidean', 'seuclidean', 'mahalanobis'] def __init__(self, target, align_indices=None, atom_indices=None, metric='euclidean', p=2): """"""Create a distance metric to act on absolute atom positions Parameters ---------- target : mdtraj.Trajectory structure to align each conformation to align_indices : np.ndarray or None atom indices to use in the alignment step atom_indices : np.ndarray or None atom indices to use when calculating distances metric : {'braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation', 'cosine', 'euclidean', 'minkowski', 'sqeuclidean', 'seuclidean', 'mahalanobis', 'sqmahalanobis'} Distance metric to equip the vector space with. or any combination thereof p : int, optional p-norm order, used for metric='minkowski' """""" s = super(Positions, self) if PY2 else super() s.__init__(metric, p) if not isinstance(target, md.Trajectory): raise ValueError(""target must be mdtraj.Trajectory instance"") if isinstance(align_indices, list) or isinstance(align_indices, np.ndarray): self.align_indices = np.array(align_indices).astype(int).flatten() else: self.align_indices = None if isinstance(atom_indices, list) or isinstance(atom_indices, np.ndarray): self.atom_indices = np.array(atom_indices).astype(int).flatten() else: self.atom_indices = None self.lprmsd = lprmsd.LPRMSD(atomindices=self.atom_indices, altindices=self.align_indices) self.target = target self.prep_target = self.lprmsd.prepare_trajectory(self.target) def prepare_trajectory(self, trajectory, return_dist=False): """""" Prepare a trajectory by first aligning it to the target with LPRMSD then returning a reshaped array corresponding to the correct atom positions flattened into a vector Parameters: ----------- trajectory : mdtraj.Trajectory instance trajectory to prepare return_dist : bool, optional this will align the frames in trajectory to self.target, if you want the aligned distances, then pass return_dist=True Returns ------- prep_trajectory : np.ndarray prepared trajectory aligned_distances : np.ndarray only returned if return_dist==True. Distance to the target after alignment for each frame in trajectory """""" # TODO: This method hasn't been updated yet (2013-11-22 mph) lp_prep_trajectory = self.lprmsd.prepare_trajectory(trajectory) aligned_distances, prep_trajectory = self.lprmsd._compute_one_to_all( self.prep_target, lp_prep_trajectory, 0, b_xyzout=True) if not self.atom_indices is None: prep_trajectory = prep_trajectory[:, self.atom_indices] prep_trajectory = np.reshape(prep_trajectory, (prep_trajectory.shape[0], -1)) if return_dist: return prep_trajectory, aligned_distances else: return prep_trajectory ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/metrics/rmsd.py",".py","5554","157","from __future__ import print_function, absolute_import, division from mdtraj.utils.six.moves import xrange import warnings import numpy as np from collections import namedtuple import mdtraj as md from .baseclasses import AbstractDistanceMetric class RMSD(AbstractDistanceMetric): """""" Compute distance between frames using the Room Mean Square Deviation over a specifiable set of atoms using the Theobald QCP algorithm References ---------- .. [1] Theobald, D. L. Acta. Crystallogr., Sect. A 2005, 61, 478-480. """""" def __init__(self, atomindices=None, omp_parallel=True): """"""Initalize an RMSD calculator Parameters ---------- atomindices : array_like, optional List of the indices of the atoms that you want to use for the RMSD calculation. For example, if your trajectory contains the coordinates of all the atoms, but you only want to compute the RMSD on the C-alpha atoms, then you can supply a reduced set of atom_indices. If unsupplied, all of the atoms will be used. omp_parallel : bool, optional Use OpenMP parallelized C code under the hood to take advantage of multicore architectures. If you're using another parallelization scheme (e.g. MPI), you might consider turning off this flag. Notes ----- You can also control the degree of parallelism with the OMP_NUM_THREADS envirnoment variable """""" self.atomindices = atomindices self.omp_parallel = omp_parallel def __repr__(self): try: val = 'metrics.RMSD(atom_indices=%s, omp_parallel=%s)' % ( repr(list(self.atomindices)), self.omp_parallel) except: val = 'metrics.RMSD(atom_indices=%s, omp_parallel=%s)' % ( self.atomindices, self.omp_parallel) return val def prepare_trajectory(self, trajectory): """"""Prepare the trajectory for RMSD calculation. Preprocessing includes extracting the relevant atoms, centering the frames, and computing the G matrix. Parameters ---------- trajectory : mdtraj.Trajectory Molecular dynamics trajectory Returns ------- theodata : array_like A msmbuilder.metrics.TheoData object, which contains some preprocessed calculations for the RMSD calculation """""" if self.atomindices is not None: if trajectory.topology is not None: topology = trajectory.topology.copy() else: topology = None t = md.Trajectory(xyz=trajectory.xyz.copy(), topology=topology) t.restrict_atoms(self.atomindices) else: t = trajectory t.center_coordinates() return t def one_to_many(self, prepared_traj1, prepared_traj2, index1, indices2): """"""Calculate a vector of distances from one frame of the first trajectory to many frames of the second trajectory The distances calculated are from the `index1`th frame of `prepared_traj1` to the frames in `prepared_traj2` with indices `indices2` Parameters ---------- prepared_traj1 : rmsd.TheoData First prepared trajectory prepared_traj2 : rmsd.TheoData Second prepared trajectory index1 : int index in `prepared_trajectory` indices2 : ndarray list of indices in `prepared_traj2` to calculate the distances to Returns ------- Vector of distances of length len(indices2) Notes ----- If the omp_parallel optional argument is True, we use shared-memory parallelization in C to do this faster. Using omp_parallel = False is advised if indices2 is a short list and you are paralellizing your algorithm (say via mpi) at a different level. """""" return md.rmsd(prepared_traj1, prepared_traj2, index1, parallel=self.omp_parallel, precentered=True)[indices2] def one_to_all(self, prepared_traj1, prepared_traj2, index1): """"""Calculate a vector of distances from one frame of the first trajectory to all of the frames in the second trajectory The distances calculated are from the `index1`th frame of `prepared_traj1` to the frames in `prepared_traj2` Parameters ---------- prepared_traj1 : rmsd.TheoData First prepared trajectory prepared_traj2 : rmsd.TheoData Second prepared trajectory index1 : int index in `prepared_trajectory` Returns ------- Vector of distances of length len(prepared_traj2) Notes ----- If the omp_parallel optional argument is True, we use shared-memory parallelization in C to do this faster. """""" return md.rmsd(prepared_traj2, prepared_traj1, index1, parallel=self.omp_parallel, precentered=True) def _square_all_pairwise(self, prepared_traj): """"""Reference implementation of all_pairwise"""""" warnings.warn( 'This is HORRIBLY inefficient. This operation really needs to be done directly in C') output = np.empty((prepared_traj.n_frames, prepared_traj.n_frames)) for i in xrange(prepared_traj.n_frames): output[i] = self.one_to_all(prepared_traj, prepared_traj, i) return output ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/metrics/baseclasses.py",".py","12699","345","from __future__ import print_function, division, absolute_import from mdtraj.utils.six import with_metaclass import abc import re import numpy as np import warnings from scipy.spatial.distance import cdist, pdist class AbstractDistanceMetric(with_metaclass(abc.ABCMeta, object)): """"""Abstract base class for distance metrics. All distance metrics should inherit from this abstract class. Provides a niave implementation of all_pairwise and one_to_many in terms of the abstract method one_to_all, which may be overridden by subclasses. """""" @abc.abstractmethod def prepare_trajectory(self, trajectory): """"""Prepare trajectory on a format that is more conventient to take distances on. Parameters ---------- trajecory : msmbuilder.Trajectory Trajectory to prepare Returns ------- prepared_traj : array-like the exact form of the prepared_traj is subclass specific, but it should support fancy indexing Notes ----- For RMSD, this is going to mean making word-aligned padded arrays (TheoData) suitable for faste calculation, for dihedral-space distances means computing the dihedral angles, etc."""""" return @abc.abstractmethod def one_to_all(self, prepared_traj1, prepared_traj2, index1): """"""Calculate the vector of distances from the index1th frame of prepared_traj1 to all of the frames in prepared_traj2. Parameters ---------- prepared_traj1 : prepared_trajectory First prepared trajectory prepared_traj2 : prepared_trajectory Second prepared trajectory index1 : int index in `prepared_trajectory` Returns ------- distances : ndarray vector of distances of length len(prepared_traj2) Notes ----- Although this might seem to be a special case of one_to_many(), it can often be implemented in a much more optimized way because it doesn't require construction of the indices2 array and array slicing in python is kindof slow. """""" return def one_to_many(self, prepared_traj1, prepared_traj2, index1, indices2): """"""Calculate the a vector of distances from the index1th frame of prepared_traj1 to all of the indices2 frames of prepared_traj2. Parameters ---------- prepared_traj1 : prepared_trajectory First prepared trajectory prepared_traj2 : prepared_trajectory Second prepared trajectory index1 : int index in `prepared_trajectory` indices2 : ndarray list of indices in `prepared_traj2` to calculate the distances to Returns ------- Vector of distances of length len(indices2) Notes ----- A subclass should be able to provide a more efficient implementation of this """""" return self.one_to_all(prepared_traj1, prepared_traj2[indices2], index1) def all_pairwise(self, prepared_traj): """"""Calculate condensed distance metric of all pairwise distances See `scipy.spatial.distance.squareform` for information on how to convert the condensed distance matrix to a redundant square matrix Parameters ---------- prepared_traj : array_like Prepared trajectory Returns ------- Y : ndarray A 1D array containing the distance from each frame to each other frame See Also -------- fast_pdist scipy.spatial.distance.squareform """""" traj_length = len(prepared_traj) output = -1 * np.ones(traj_length * (traj_length - 1) / 2) p = 0 for i in range(traj_length): cmp_indices = np.arange(i + 1, traj_length) output[p: p + len(cmp_indices)] = self.one_to_many(prepared_traj, prepared_traj, i, cmp_indices) p += len(cmp_indices) return output class Vectorized(AbstractDistanceMetric): """"""Represent MSM frames as vectors in some arbitrary vector space, and then use standard vector space metrics. Some examples of this might be extracting the contact map or dihedral angles. In order to be a full featured DistanceMetric, a subclass of Vectorized implements its own prepared_trajectory() method, Vectorized provides the remainder. allowable_scipy_metrics gives the list of metrics which your client can use. If the vector space that you're projecting your trajectory onto is just a space of boolean vectors, then you probably don't want to allow eulcidean distance for instances. default_scipy_metric is the metric that will be used by your default metric if the user leaves the 'metric' field blank/unspecified. default_scipy_p is the default value of 'p' that will be used if left unspecified. the value 'p' is ONLY used for the minkowski (pnorm) metric, so otherwise the scipy.spatial.distance code ignores it anyways. See http://docs.scipy.org/doc/scipy/reference/spatial.distance.html for a description of all the distance metrics and how they work. """""" allowable_scipy_metrics = ['braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation', 'cosine', 'euclidean', 'minkowski', 'sqeuclidean', 'dice', 'kulsinki', 'matching', 'rogerstanimoto', 'russellrao', 'sokalmichener', 'sokalsneath', 'yule', 'seuclidean', 'mahalanobis', 'sqmahalanobis'] def __init__(self, metric='euclidean', p=2, V=None, VI=None): """"""Create a Vectorized metric Parameters ---------- metric : {'braycurtis', 'canberra', 'chebyshev', 'cityblock', 'correlation', 'cosine', 'euclidean', 'minkowski', 'sqeuclidean','dice', 'kulsinki', 'matching', 'rogerstanimoto', 'russellrao', 'sokalmichener', 'sokalsneath', 'yule', 'seuclidean', 'mahalanobis', 'sqmahalanobis'} Distance metric to equip the vector space with. See http://docs.scipy.org/doc/scipy/reference/spatial.distance.html for details p : int, optional p-norm order, used for metric='minkowski' V : ndarray, optional variances, used for metric='seuclidean' VI : ndarray, optional inverse covariance matrix, used for metric='mahalanobis' """""" self._validate_scipy_metric(metric) self.metric = metric self.p = p self.V = V self.VI = VI if self.metric == 'seuclidean' and V is None: raise ValueError('To use seuclidean, you need to supply V') if self.metric in ['mahalanobis', 'sqmahalanobis'] and VI is None: raise ValueError('To used mahalanobis or sqmahalanobis, you need to supply VI') def _validate_scipy_metric(self, metric): """"""Ensure that ""metric"" is an ""allowable"" metric (in allowable_scipy_metrics)"""""" if not metric in self.allowable_scipy_metrics: raise TypeError('%s is an unrecognize metric. ""metric"" must be one of %s' % (metric, str(self.allowable_scipy_metrics))) def one_to_many(self, prepared_traj1, prepared_traj2, index1, indices2): """"""Calculate a vector of distances from one frame of the first trajectory to many frames of the second trajectory The distances calculated are from the `index1`th frame of `prepared_traj1` to the frames in `prepared_traj2` with indices `indices2` Parameters ---------- prepared_traj1 : ndarray First prepared trajectory prepared_traj2 : ndarray Second prepared trajectory index1 : int index in `prepared_trajectory` indices2 : ndarray list of indices in `prepared_traj2` to calculate the distances to Returns ------- distances : ndarray Vector of distances of length len(indices2) """""" if not isinstance(index1, int): raise TypeError('index1 must be of type int.') out = cdist(prepared_traj2[indices2], prepared_traj1[[index1]], metric=self.metric, p=self.p, V=self.V, VI=self.VI) return out[:, 0] def one_to_all(self, prepared_traj1, prepared_traj2, index1): """"""Measure the distance from one frame to every frame in a trajectory The distances calculated are from the `index1`th frame of `prepared_traj1` to all the frames in `prepared_traj2` with indices `indices2`. Although this is similar to one_to_many, it can often be computed faster Parameters ---------- prepared_traj1 : ndarray First prepared trajectory prepared_traj2 : ndarray Second prepared trajectory index1 : int index in `prepared_trajectory` Returns ------- distances : ndarray A vector of distances of length len(prepared_traj2)"""""" if not isinstance(index1, int): raise TypeError('index1 must be of type int.') out2 = cdist(prepared_traj2, prepared_traj1[[index1]], metric=self.metric, p=self.p, V=self.V, VI=self.VI) return out2[:, 0] def many_to_many(self, prepared_traj1, prepared_traj2, indices1, indices2): """"""Get a matrix of distances from each frame in a set to each other frame in a second set. Calculate a MATRIX of distances from the frames in prepared_traj1 with indices `indices1` to the frames in prepared_traj2 with indices `indices2`, using supplied metric. Parameters ---------- prepared_traj1 : ndarray First prepared trajectory prepared_traj2 : ndarray Second prepared trajectory indices1 : array_like list of indices in `prepared_traj1` to calculate the distances from indices2 : array_like list of indices in `prepared_traj2` to calculate the distances to Returns ------- distances : ndarray A 2D array of shape len(indices1) * len(indices2)"""""" out = cdist(prepared_traj1[indices1], prepared_traj2[indices2], metric=self.metric, p=self.p, V=self.V, VI=self.VI) return out def all_to_all(self, prepared_traj1, prepared_traj2): """"""Get a matrix of distances from all frames in one traj to all frames in another Parameters ---------- prepared_traj1 : ndarray First prepared trajectory prepared_traj2 : ndarray Second prepared trajectory Returns ------- distances : ndarray A 2D array of shape len(preprared_traj1) * len(preprared_traj2)"""""" if prepared_traj1 is prepared_traj2: warnings.warn('runtime', re.sub(""\s+"", "" "", """"""it's not recommended to use this method to calculate the full pairwise distance matrix for one trajectory to itself (as you're doing). Use all_pairwise, which will be more efficient if you reall need the results as a 2D matrix (why?) then you can always use scipy.spatial.distance.squareform() on the output of all_pairwise()"""""".replace('\n', ' '))) out = cdist(prepared_traj1, prepared_traj2, metric=self.metric, p=self.p, V=self.V, VI=self.VI) return out def all_pairwise(self, prepared_traj): """"""Calculate a condense"" distance matrix of all the pairwise distances between each frame with each other frame in prepared_traj The condensed distance matrix can be converted to the redundant square form if desired Parameters ---------- prepared_traj1 : ndarray Prepared trajectory Returns ------- distances : ndarray 1D vector of length len(pairwise_traj) choose 2 where the i*jth entry contains the distance between prepared_traj[i] and prepared_traj[j] See Also -------- scipy.spatial.distance.pdist scipy.spatial.distance.squareform """""" out = pdist(prepared_traj, metric=self.metric, p=self.p, V=self.V, VI=self.VI) return out ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/metrics/parsers.py",".py","13078","245","from __future__ import print_function, division, absolute_import import sys import os import pickle import numpy as np import mdtraj as md import itertools from pkg_resources import iter_entry_points from msmbuilder.reduce import tICA from msmbuilder.metrics import (RMSD, Dihedral, BooleanContact, AtomPairs, ContinuousContact, AbstractDistanceMetric, Vectorized, RedDimPNorm, Positions) def add_argument(group, *args, **kwargs): if 'default' in kwargs: d = 'Default: {d}'.format(d=kwargs['default']) if 'help' in kwargs: kwargs['help'] += ' {d}'.format(d=d) else: kwargs['help'] = d group.add_argument(*args, **kwargs) ################################################################################ def locate_metric_plugins(name): if not name in ['add_metric_parser', 'construct_metric', 'metric_class']: raise ValueError() eps = iter_entry_points(group='msmbuilder.metrics', name=name) return [ep.load() for ep in eps] def add_metric_parsers(parser): metric_parser_list = [] metric_subparser = parser.add_subparsers(dest='metric', description='Available metrics to use.') #metrics_parsers = parser.add_subparsers(description='Available metrics to use.',dest='metric') rmsd = metric_subparser.add_parser('rmsd', description='''RMSD: Root mean square deviation over a set of user defined atoms (typically backbone heavy atoms or alpha carbons). To evaluate the distance between two structures, first they are rotated and translated with respect to one another to achieve maximum coincidence. This code is executed in parallel on multiple cores (but not multiple boxes) using OMP.''') add_argument(rmsd, '-a', dest='rmsd_atom_indices', help='Atom indices to use in RMSD calculation. Pass ""all"" to use all atoms.', default='AtomIndices.dat') metric_parser_list.append(rmsd) dihedral = metric_subparser.add_parser('dihedral', description='''DIHEDRAL: For each frame in the simulation data, we extract the torsion angles for the class of angles that you request (phi/psi is recommended, but chi angles are available as well). Each frame is then reprented by a vector containing the sin and cosine of these dihedral angles. The distances between frames are computed by taking distances between these vectors in R^n. The euclidean distance is recommended, but other distance metrics are available (cityblock, etc). This code is executed in parallel on multiple cores (but not multiple boxes) using OMP. ''') add_argument(dihedral, '-a', dest='dihedral_angles', default='phi/psi', help='which dihedrals. Choose from phi, psi, chi (to choose multiple, seperate them with a slash), or user') add_argument(dihedral, '-f', dest='dihedral_userfilename', default='DihedralIndices.dat', help='filename for dihedral indices, N lines of 4 space-separated indices (otherwise ignored)') add_argument(dihedral, '-p', dest='dihedral_p', default=2, help='p used for metric=minkowski (otherwise ignored)') add_argument(dihedral, '-m', dest='dihedral_metric', default='euclidean', help='which distance metric', choices=Dihedral.allowable_scipy_metrics) metric_parser_list.append(dihedral) contact = metric_subparser.add_parser('contact', description='''CONTACT: For each frame in the simulation data, we extract the contact map (presence or absense of ""contacts"") between residues. Each frame is then represented as a boolean valued vector containing information between the presence or absense of certain contacts. The contact vector can either include all possible pairwise contacts, only the native contacts, or any other set of pairs of residues. The distance with which two residues must be within to classify as ""in contact"" is also settable, and can dependend on the contact (e.g. 5 angstroms from some pairs, 10 angstroms for other pairs). Furthermore, the sense in which the distance between two residues is computed can be either specified as ""CA"", ""closest"", or ""closest-heavy"", which will respectively compute (""CA"") the distance between the residues' alpha carbons, (""closest""), the closest distance between any pair of atoms i and j such that i belongs to one residue and j to the other residue, (""closest-heavy""), or the closest distance between any pair of NON-HYDROGEN atoms i and j such that i belongs to one residue and j to the other residue. This code is executed in parallel on multiple cores (but not multiple boxes) using OMP.''') add_argument(contact, '-c', dest='contact_which', default='all', help='Path to file containing 2D array of the contacts you want, or the string ""all"".') add_argument(contact, '-C', dest='contact_cutoff', default=0.5, help='Cutoff distance in nanometers. If you pass -1, then the contact ""map"" will be a matrix of residue-residue distances. Passing a number greater than 0 means the residue-residue distance matrix will be converted to a boolean matrix, one if the distance is less than the specified cutoff') add_argument(contact, '-f', dest='contact_cutoff_file', help='File containing residue specific cutoff distances (supercedes the scalar cutoff distance if present).', default=None) add_argument(contact, '-s', dest='contact_scheme', default='closest-heavy', help='contact scheme.', choices=['CA', 'closest', 'closest-heavy']) metric_parser_list.append(contact) atompairs = metric_subparser.add_parser('atompairs', description='''ATOMPAIRS: For each frame, we represent the conformation as a vector of particular atom-atom distances. Then the distance between frames is calculated using a specified norm on these vectors. This code is executed in parallel (but not multiple boxes) using OMP.''') add_argument(atompairs, '-a', dest='atompairs_which', help='path to file with 2D array of which atompairs to use.', default='AtomPairs.dat') add_argument(atompairs, '-p', dest='atompairs_p', default=2, help='p used for metric=minkowski (otherwise ignored)') add_argument(atompairs, '-m', dest='atompairs_metric', default='euclidean', help='which distance metric', choices=AtomPairs.allowable_scipy_metrics) metric_parser_list.append(atompairs) positions = metric_subparser.add_parser('positions', description=""""""POSITIONS: For each frame we represent the conformation as a vector of atom positions, where the atoms have been aligned to a target structure."""""") add_argument(positions, '-t', dest='target', help='target structure (PDB) to align structures to.') add_argument(positions, '-a', dest='pos_atom_indices', help='atom indices to include in the distances.') add_argument(positions, '-i', dest='align_indices', help='atom indices to use when aligning to target.') add_argument(positions, '-p', dest='positions_p', default=2, help='p used for metric=minkowski (otherwise ignored)') add_argument(positions, '-m', dest='positions_metric', default='euclidean', help='which distance metric', choices=Positions.allowable_scipy_metrics) metric_parser_list.append(positions) tica = metric_subparser.add_parser( 'tica', description=''' tICA: This metric is based on a variation of PCA which looks for the slowest d.o.f. in the simulation data. See (Schwantes, C.R., Pande, V.S. JCTC 2013, 9 (4), 2000-09.) for more details. In addition to these options, you must provide an additional metric you used to prepare the trajectories in the training step.''') add_argument(tica, '-p', dest='p', help='p value for p-norm') add_argument(tica, '-m', dest='projected_metric', help='metric to use in the projected space', choices=Vectorized.allowable_scipy_metrics, default='euclidean') add_argument(tica, '-f', dest='tica_fn', help='tICA Object which was prepared by tICA_train.py') add_argument(tica, '-n', dest='num_vecs', type=int, help='Choose the top <-n> eigenvectors based on their eigenvalues') metric_parser_list.append(tica) picklemetric = metric_subparser.add_parser('custom', description=""""""CUSTOM: Use a custom distance metric. This requires defining your metric and saving it to a file using the pickle format, which can be done fron an interactive shell. This is an EXPERT FEATURE, and requires significant knowledge of the source code's architecture to pull off."""""") add_argument(picklemetric, '-i', dest='picklemetric_input', required=True, help=""Path to pickle file for the metric"") metric_parser_list.append(picklemetric) for add_parser in locate_metric_plugins('add_metric_parser'): plugin_metric_parser = add_parser(metric_subparser, add_argument) metric_parser_list.append(plugin_metric_parser) return metric_parser_list ################################################################################ def construct_metric(args): metric_name = args.metric if metric_name == 'rmsd': if args.rmsd_atom_indices != 'all': atom_indices = np.loadtxt(args.rmsd_atom_indices, np.int) else: atom_indices = None metric = RMSD(atom_indices) # , omp_parallel=args.rmsd_omp_parallel) elif metric_name == 'dihedral': metric = Dihedral(metric=args.dihedral_metric, p=args.dihedral_p, angles=args.dihedral_angles, userfilename=args.dihedral_userfilename) elif metric_name == 'contact': if args.contact_which != 'all': contact_which = np.loadtxt(args.contact_which, np.int) else: contact_which = 'all' if args.contact_cutoff_file != None: contact_cutoff = np.loadtxt(args.contact_cutoff_file, np.float) elif args.contact_cutoff != None: contact_cutoff = float(args.contact_cutoff) else: contact_cutoff = None if contact_cutoff != None and contact_cutoff < 0: metric = ContinuousContact(contacts=contact_which, scheme=args.contact_scheme) else: metric = BooleanContact(contacts=contact_which, cutoff=contact_cutoff, scheme=args.contact_scheme) elif metric_name == 'atompairs': if args.atompairs_which != None: pairs = np.loadtxt(args.atompairs_which, np.int) else: pairs = None metric = AtomPairs(metric=args.atompairs_metric, p=args.atompairs_p, atom_pairs=pairs) elif metric_name == 'positions': target = md.load(args.target) if args.pos_atom_indices != None: atom_indices = np.loadtxt(args.pos_atom_indices, np.int) else: atom_indices = None if args.align_indices != None: align_indices = np.loadtxt(args.align_indices, np.int) else: align_indices = None metric = Positions(target, atom_indices=atom_indices, align_indices=align_indices, metric=args.positions_metric, p=args.positions_p) elif metric_name == ""tica"": tica_obj = tICA.load(args.tica_fn) metric = RedDimPNorm(tica_obj, num_vecs=args.num_vecs, metric=args.projected_metric, p=args.p) elif metric_name == 'custom': with open(args.picklemetric_input) as f: metric = pickle.load(f) print('#' * 80) print('Loaded custom metric:') print(metric) print('#' * 80) else: # apply the constructor on args and take the first non-none element # note that using these itertools constructs, we'll only actual # execute the constructor until the match is achieved metrics = [c(args) for c in locate_metric_plugins('construct_metric')] try: metric = next(itertools.dropwhile(lambda c: not c, metrics)) except StopIteration: # This means that none of the plugins acceptedthe metric raise RuntimeError( ""Bad metric. Could not be constructed by any built-in or plugin metric. Perhaps you have a poorly written plugin?"") if not isinstance(metric, AbstractDistanceMetric): return ValueError(""%s is not a AbstractDistanceMetric"" % metric) return metric ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/reduce/tICA.py",".py","14203","431","from __future__ import print_function, division, absolute_import import numpy as np import scipy.linalg from time import time import logging from mdtraj import io from mdtraj.utils.six.moves import cPickle from msmbuilder.metrics import Vectorized from msmbuilder.reduce import AbstractDimReduction logger = logging.getLogger(__name__) class tICA(AbstractDimReduction): """""" tICA is a class for calculating the matrices required to do time-structure based independent component analysis (tICA). It can be used to calculate both the time-lag correlation matrix and covariance matrix. The advantage it has is that you can calculate the matrix for a large dataset by ""training"" smaller pieces of the dataset at a time. Notes ----- It can be shown that the time-lag correlation matrix is the same as: C = E[Outer(X[t], X[t+lag])] - Outer(E[X[t]], E[X[t+lag]]) Because of this it is possible to calculate running sums corresponding to variables A, B, D: A = E[X[t]] B = E[X[t+lag]] D = E[Outer(X[t], X[t+lag])] Then at the end we can calculate C: C = D - Outer(A, B) Finally we can get a symmetrized C' from our estimate of C, for example by adding the transpose: C' = (C + C^T) / 2 There is, in fact, an MLE estimator for ech matrix C, and S: S = E[Outer(X[t], X[t])] The MLE estimators are: \mu = 1 / (2(N - lag)) \sum_{t=1}^{N - lag} X[t] + X[t + lag] C = 1 / (2(N - lag)) * \sum_{t=1}^{N - lag} Outer(X[t] - \mu, X[t + lag] - \mu) + Outer(X[t + lag] - \mu, X[t] - \mu) S = 1 / (2(N - lag)) * \sum_{t=1}^{N - lag} Outer(X[t] - \mu, X[t] - \mu) + Outer(X[t + lag] - \mu, X[t + lag] - \mu) """""" def __init__(self, lag, calc_cov_mat=True, prep_metric=None, size=None): """""" Create an empty tICA object. To add data to the object, use the train method. Parameters ---------- lag: int The lag to use in calculating the time-lag correlation matrix. If zero, then only the covariance matrix is calculated calc_cov_mat: bool, optional if lag > 0, then will also calculate the covariance matrix prep_metric: msmbuilder.metrics.Vectorized subclass instance, optional metric to use to prepare trajectories. If not specified, then you must pass prepared trajectories to the train method, via the kwarg ""prep_trajectory"" size: int, optional the size is the number of coordinates for the vector representation of the protein. If None, then the first trained vector will be used to initialize it. Notes ----- To load an already constructed tICA object, use `tICA.load()`. """""" self.corrs = None self.sum_t = None self.sum_t_dt = None # The above containers hold a running sum that is used to # calculate the time-lag correlation matrix as well as the # covariance matrix self.corrs_lag0 = None # needed for calculating the covariance # matrix self.sum_all = None self.trained_frames = 0 self.total_frames = 0 # Track how many frames we've trained self.lag = int(lag) if self.lag < 0: raise Exception(""lag must be non-negative."") elif self.lag == 0: # If we have lag=0 then we don't need to # calculate the covariance matrix twice self.calc_cov_mat = False else: self.calc_cov_mat = calc_cov_mat if prep_metric is None: self.prep_metric = None logger.warn(""no metric specified, you must pass prepared"" "" trajectories to the train and project methods"") else: if not isinstance(prep_metric, Vectorized): raise Exception(""prep_metric must be an instance of a "" ""subclass of msmbuilder.metrics.Vectorized"") self.prep_metric = prep_metric self.size = size if not self.size is None: self.initialize(size) # containers for the solutions: self.timelag_corr_mat = None self.cov_mat = None self.vals = None self.vecs = None self._sorted = False def initialize(self, size): """""" initialize the containers for the calculation Parameters ---------- size : int The size of the square matrix will be (size, size) """""" self.size = size self.corrs = np.zeros((size, size), dtype=float) self.sum_t = np.zeros(size, dtype=float) self.sum_t_dt = np.zeros(size, dtype=float) self.sum_all = np.zeros(size, dtype=float) if self.calc_cov_mat: self.corrs_lag0_t = np.zeros((size, size), dtype=float) self.corrs_lag0_t_dt = np.zeros((size, size), dtype=float) def train(self, trajectory=None, prep_trajectory=None): """""" add a trajectory to the calculation Parameters: ----------- trajectory: msmbuilder.Trajectory, optional trajectory object prep_trajectory: np.ndarray, optional prepared trajectory object Remarks: -------- must input one of trajectory or prep_trajectory (if both are given, then prep_trajectory is used.) """""" if not prep_trajectory is None: data_vector = prep_trajectory elif not trajectory is None: data_vector = self.prep_metric.prepare_trajectory(trajectory) else: raise Exception(""need to input one of trajectory or prep_trajectory"") a = time() # For debugging we are tracking the time each step takes if self.size is None: # then we haven't started yet, so set up the containers self.initialize(size=data_vector.shape[1]) if data_vector.shape[1] != self.size: raise Exception(""Input vector is not the right size. axis=1 should "" ""be length %d. Vector has shape %s"" % (self.size, str(data_vector.shape))) if data_vector.shape[0] <= self.lag: logger.warn(""Data vector is too short (%d) "" ""for this lag (%d)"", data_vector.shape[0], self.lag) return b = time() if self.lag != 0: self.corrs += data_vector[:-self.lag].T.dot(data_vector[self.lag:]) self.sum_t += data_vector[:-self.lag].sum(axis=0) self.sum_t_dt += data_vector[self.lag:].sum(axis=0) else: self.corrs += data_vector.T.dot(data_vector) self.sum_t += data_vector.sum(axis=0) self.sum_t_dt += data_vector.sum(axis=0) if self.calc_cov_mat: self.corrs_lag0_t += data_vector[:-self.lag].T.dot(data_vector[:-self.lag]) self.corrs_lag0_t_dt += data_vector[self.lag:].T.dot(data_vector[self.lag:]) self.sum_all += data_vector.sum(axis=0) self.total_frames += data_vector.shape[0] self.trained_frames += data_vector.shape[0] - self.lag # this accounts for us having finite trajectories, so we really are # only calculating expectation values over N - \Delta t total samples c = time() logger.debug(""Setup: %f, Corrs: %f"" % (b - a, c - b)) # Probably should just get rid of this.. def get_current_estimate(self): """"""Calculate the current estimate of the time-lag correlation matrix and the covariance matrix (if asked for). These estimates come from an MLE argument assuming that the data {X_t, X_t+dt} are distributed as a multivariate normal. Of course, this assumption is not very true, but this is merely one way to enforce that the timelag correlation matrix is symmetric. The MLE has nice properties, as well, such as the eigenvalues that result from solving the tICA equation are always bounded between -1 and 1, which is not the case when one merely symmetrizes the timelag correlation matrix while estimating the covariance matrix and mean in the usual manner. See Shukla, D et. al. In Preparation for details, or email Christian Schwantes (schwancr@stanford.edu). """""" two_N = 2. * float(self.trained_frames) # ^^ denominator in all of these expressions... mle_mean = (self.sum_t + self.sum_t_dt) / two_N outer_means = np.outer(mle_mean, mle_mean) time_lag_corr = (self.corrs + self.corrs.T) / two_N timelag_corr_mat = time_lag_corr - outer_means self.timelag_corr_mat = timelag_corr_mat if self.calc_cov_mat: cov_mat = (self.corrs_lag0_t + self.corrs_lag0_t_dt) / two_N cov_mat -= np.outer(mle_mean, mle_mean) self.cov_mat = cov_mat return timelag_corr_mat, cov_mat return timelag_corr_mat def _sort(self): """""" sort the eigenvectors by their eigenvalues. """""" if self.vals is None: self.solve() ind = np.argsort(self.vals)[::-1] # in order of decreasing value self.vals = self.vals[ind] self.vecs = self.vecs[:, ind] self._sorted = True def solve(self, pca_cutoff=0): """""" Solve the eigenvalue problem. We can translate into the PCA space and remove directions that have zero variance. If there are directions with zero variance, then the tICA eigenvalues will be complex or greater than one. Parameters: ----------- pca_cutoff : float, optional pca_cutoff to throw out PCs with variance less than this cutoff. Default is zero, but you should really check your covariance matrix to see if you need this. """""" if self.timelag_corr_mat is None or self.cov_mat is None: self.get_current_estimate() # should really add check if we're just doing PCA, but I # don't know why anyone would use this class to do PCA... # maybe I should just remove that ability... if pca_cutoff <= 0: lhs = self.timelag_corr_mat rhs = self.cov_mat else: pca_vals, pca_vecs = np.linalg.eigh(self.cov_mat) good_ind = np.where(pca_vals > pca_cutoff)[0] pca_vals = pca_vals[good_ind] pca_vecs = pca_vecs[:, good_ind] lhs = pca_vecs.T.dot(self.timelag_corr_mat).dot(pca_vecs) rhs = pca_vecs.T.dot(self.cov_mat).dot(pca_vecs) vals, vecs = scipy.linalg.eig(lhs, b=rhs) if pca_cutoff <= 0: self.vals = vals self.vecs = vecs else: self.vals = vals self.vecs = pca_vecs.dot(vecs) if np.abs(self.vals.imag).max() > 1E-10: logger.warn(""you have non-real eigenvalues. This usually means "" ""you need to throw out some coordinates by doing tICA "" ""in PCA space."") else: self.vals = self.vals.real if np.abs(self.vecs.imag).max() > 1E-10: logger.warn(""you have non-real eigenvector entries..."") else: self.vecs = self.vecs.real self._sort() def project(self, trajectory=None, prep_trajectory=None, which=None): """""" project a trajectory (or prepared trajectory) onto a subset of the tICA eigenvectors. Parameters: ----------- trajectory : mdtraj.Trajectory, optional trajectory object (can also pass a prepared trajectory instead) prep_trajectory : np.ndarray, optional prepared trajectory which : np.ndarray which eigenvectors to project onto Returns: -------- proj_trajectory : np.ndarray projected trajectory (n_points, n_tICs) """""" if not self._sorted: self._sort() if prep_trajectory is None: if trajectory is None: raise Exception(""must pass one of trajectory or prep_trajectory"") prep_trajectory = self.prep_metric.prepare_trajectory(trajectory) if which is None: raise Exception(""must pass 'which' to indicate which tICs to project onto"") which = np.array(which).flatten().astype(int) proj_trajectory = prep_trajectory.dot(self.vecs[:, which]) return proj_trajectory def save(self, output): """""" save the results to file Parameters: ----------- output : str output filename (.h5) """""" # Serialize metric used to calculate tICA input. metric_string = cPickle.dumps(self.prep_metric) io.saveh(output, timelag_corr_mat=self.timelag_corr_mat, cov_mat=self.cov_mat, lag=np.array([self.lag]), vals=self.vals, vecs=self.vecs, metric_string=np.array([metric_string])) @classmethod def load(cls, tica_fn): """""" load a tICA solution to use in projecting data. Parameters: ----------- tica_fn : str filename pointing to tICA solutions """""" # the only variables we need to save are the two matrices # and the eigenvectors / values as well as the lag time logger.warn(""NOTE: You can only use the tICA solution, you will "" ""not be able to continue adding data"") f = io.loadh(tica_fn) metric = cPickle.loads(f[""metric_string""][0]) tica_obj = cls(f['lag'][0], prep_metric=metric) # lag entry is an array... with a single item tica_obj.timelag_corr_mat = f['timelag_corr_mat'] tica_obj.cov_mat = f['cov_mat'] tica_obj.vals = f['vals'] tica_obj.vecs = f['vecs'] tica_obj._sort() return tica_obj ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/reduce/__init__.py",".py","135","5","from __future__ import print_function, absolute_import, division from .baseclasses import AbstractDimReduction from .tICA import tICA ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/reduce/baseclasses.py",".py","898","35","import abc from mdtraj.utils.six import with_metaclass class AbstractDimReduction(with_metaclass(abc.ABCMeta, object)): """""" abstract class for defining dimensionality reduction techniques. Any subclass of this class can be used with the RedDimPNorm distance metric """""" @abc.abstractmethod def project(self, trajectory=None, prep_trajectory=None, which=None): """""" this method should take at least three kwargs: Parameters: ----------- trajectory: mdtraj.Trajectory instance, optional prep_trajectory: prepared msmbuilder.Trajectory instance, optional prepared trajectory which: np.ndarray which vectors to use to project onto Returns: -------- proj_trajectory: np.ndarray projected trajectory (n_frames, len(which)) """""" return ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/lumping/__init__.py",".py","121","5","from __future__ import print_function, absolute_import, division from .pcca import PCCA from .pcca_plus import PCCAPlus ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/lumping/pcca.py",".py","2857","76","from __future__ import print_function, absolute_import, division import numpy as np from .lumper import EigenvectorLumper import logging logger = logging.getLogger(__name__) class PCCA(EigenvectorLumper): def __init__(self, T, num_macrostates, tolerance=1E-5, flux_cutoff=None): """"""Create a lumped model using the PCCA algorithm. 1. Iterate over the eigenvectors, starting with the slowest. 2. Calculate the spread of that eigenvector within each existing macrostate. 3. Pick the macrostate with the largest eigenvector spread. 4. Split the macrostate based on the sign of the eigenvector. Parameters ---------- T : csr sparse matrix A transition matrix num_macrostates : int The desired number of states. tolerance : float, optional Specifies the numerical cutoff to use when splitting states based on sign. flux_cutoff : float, optional If enabled, discard eigenvectors with flux below this value. Returns ------- microstate_mapping : ndarray mapping from the Microstate indices to the Macrostate indices Notes ------- To construct a Macrostate MSM, you then need to map your Assignment data to the new states (e.g. MSMLib.apply_mapping_to_assignments). References ---------- .. [1] Deuflhard P, et al. ""Identification of almost invariant aggregates in reversible nearly uncoupled markov chains,"" Linear Algebra Appl., vol 315 pp 39-59, 2000. """""" EigenvectorLumper.__init__(self, T, num_macrostates, flux_cutoff=None) self.lump(tolerance=tolerance) def lump(self, tolerance): """"""Do the PCCA lumping. Notes ------- 1. Iterate over the eigenvectors, starting with the slowest. 2. Calculate the spread of that eigenvector within each existing macrostate. 3. Pick the macrostate with the largest eigenvector spread. 4. Split the macrostate based on the sign of the eigenvector. """""" right_eigenvectors = self.right_eigenvectors[:, 1:] # Extract non-perron eigenvectors microstate_mapping = np.zeros(self.num_microstates, 'int') # Function to calculate the spread of a single eigenvector. spread = lambda x: x.max() - x.min() for i in range(self.num_macrostates - 1): # Thus, if we want 2 states, we split once. v = right_eigenvectors[:, i] all_spreads = np.array([spread(v[microstate_mapping == k]) for k in range(i + 1)]) state_to_split = np.argmax(all_spreads) microstate_mapping[(microstate_mapping == state_to_split) & (v >= tolerance)] = i + 1 self.microstate_mapping = microstate_mapping ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/lumping/lumper.py",".py","1538","46","from __future__ import print_function, absolute_import, division import numpy as np from msmbuilder import msm_analysis from msmbuilder.lumping import utils import logging logger = logging.getLogger(__name__) class Lumper(): # Not sure what the most general lumper would look like, so fill in later. pass class EigenvectorLumper(Lumper): def __init__(self, T, num_macrostates, flux_cutoff=None): """"""Base class for PCCA and PCCA+. Parameters ---------- T : csr sparse matrix Transition matrix num_macrostates : int Desired number of macrostates flux_cutoff : float, optional Can be set to discard low-flux eigenvectors. """""" self.T = T self.num_macrostates = num_macrostates self.eigenvalues, self.left_eigenvectors = msm_analysis.get_eigenvectors(T, self.num_macrostates) utils.normalize_left_eigenvectors(self.left_eigenvectors) if flux_cutoff != None: self.eigenvalues, self.left_eigenvectors = utils.trim_eigenvectors_by_flux( self.eigenvalues, self.left_eigenvectors, flux_cutoff) self.num_macrostates = len(self.eigenvalues) self.populations = self.left_eigenvectors[:, 0] self.num_microstates = len(self.populations) # Construct properly normalized right eigenvectors self.right_eigenvectors = utils.construct_right_eigenvectors( self.left_eigenvectors, self.populations, self.num_macrostates) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/lumping/utils.py",".py","3104","96","from __future__ import print_function, absolute_import, division from mdtraj.utils.six.moves import xrange import numpy as np from numpy import dot import logging logger = logging.getLogger(__name__) def construct_right_eigenvectors(left_eigenvectors, populations, num_macrostates): """"""Calculate normalized right eigenvectors from left eigenvectors and populations."""""" right_eigenvectors = left_eigenvectors.copy() for i in range(num_macrostates): right_eigenvectors[:, i] /= populations right_eigenvectors[:, i] *= np.sign(right_eigenvectors[0, i]) right_eigenvectors[:, i] /= np.sqrt(dot(right_eigenvectors[:, i] * populations, right_eigenvectors[:, i])) return right_eigenvectors def normalize_left_eigenvectors(left_eigenvectors): """"""Normalize the left eigenvectors Normalization condition is = 1 Parameters ---------- left_eigenvectors : ndarray The left eigenvectors, as a two-dimensional array where the kth eigenvectors is left_eigenvectors[:,k] Notes ----- Acts inplace. Assumes that left_eigenvectors[:,0] is the equilibrium vector and that detailed balance holds. """""" populations = left_eigenvectors[:, 0] populations /= populations.sum() for k in xrange(1, left_eigenvectors.shape[-1]): x = left_eigenvectors[:, k] x /= abs(np.dot(x / populations, x)) ** .5 def trim_eigenvectors_by_flux(eigenvalues, left_eigenvectors, flux_cutoff): """"""Trim eigenvectors that have low equilibrium flux. Parameters ---------- lam : nadarray Eigenvalues of transition matrix. vl : ndarray Left eigenvectors of transition matrix. flux_cutoff : float Discard eigenvectors with fluxes below this value. Notes ----- Assuming that the left eigenvectors are properly pi-normalized, the equilibrium flux contribution of each eigenvector :math:`v` is given by :math:`\sum_i v_i^2` Returns ------- lam : ndarray Eigenvalues after discarding low-flux eigenvectors. vl : ndarray Left eigenvectors after discarding low-flux eigenvectors. """""" normalize_left_eigenvectors(left_eigenvectors) N = len(eigenvalues) flux_list = np.array([(left_eigenvectors[:, i] ** 2).sum() for i in range(N)]) flux_list /= flux_list[0] flux_list[0] = flux_list.max() KeepInd = np.where(flux_list >= flux_cutoff)[0] logger.info(""Implied timescales (UNITLESS)"") logger.info(-1 / np.log(eigenvalues)) logger.info(""Flux"") logger.info(flux_list) logger.info(""Keeping %d eigenvectors after flux cutoff %f"", len(KeepInd), flux_cutoff) eigenvalues = eigenvalues[KeepInd] left_eigenvectors = left_eigenvectors[:, KeepInd] flux_list = flux_list[KeepInd] logger.info(""After Flux calculation, Implied timescales (UNITLESS):"") logger.info(-1 / np.log(eigenvalues)) logger.info(""After Flux calculation, fluxes."") logger.info(flux_list) return eigenvalues, left_eigenvectors ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/lumping/pcca_plus.py",".py","15059","515","from __future__ import print_function, absolute_import, division import numpy as np from numpy import dot, diag inv = np.linalg.inv norm = np.linalg.norm tr = np.trace import scipy.optimize from .lumper import EigenvectorLumper import logging logger = logging.getLogger(__name__) def metastability(alpha, T, right_eigenvectors, square_map, pi): """"""Return the metastability PCCA+ objective function. Parameters ---------- alpha : ndarray Parameters of objective function (e.g. flattened A) T : csr sparse matrix Transition matrix right_eigenvectors : ndarray The right eigenvectors. square_map : ndarray Mapping from square indices (i,j) to flat indices (k). pi : ndarray Equilibrium Populations of transition matrix. Returns ------- obj : float The objective function Notes ------- metastability: try to make metastable fuzzy state decomposition. Defined in ref. [2]. """""" num_micro, num_eigen = right_eigenvectors.shape A, chi, mapping = calculate_fuzzy_chi(alpha, square_map, right_eigenvectors) # If current point is infeasible or leads to degenerate lumping. if len(np.unique(mapping)) != right_eigenvectors.shape[1] or has_constraint_violation(A, right_eigenvectors): return -1.0 * np.inf obj = 0.0 for i in range(num_eigen): # Calculate metastabilty of the lumped model. Eqn 4.20 in LAA. obj += np.dot(T.dot(chi[:, i]), pi * chi[:, i]) / np.dot(chi[:, i], pi) return obj def crisp_metastability(alpha, T, right_eigenvectors, square_map, pi): """"""Return the crisp_metastability PCCA+ objective function. Parameters ---------- alpha : ndarray Parameters of objective function (e.g. flattened A) T : csr sparse matrix Transition matrix right_eigenvectors : ndarray The right eigenvectors. square_map : ndarray Mapping from square indices (i,j) to flat indices (k). pi : ndarray Equilibrium Populations of transition matrix. Returns ------- obj : float The objective function Notes ------- crisp_metastability: try to make the resulting crisp msm metastable. This is the recommended choice. This is the metastability (trace) of a transition matrix computed by forcing a crisp (non-fuzzy) microstate mapping. Defined in ref. [2]. """""" num_micro, num_eigen = right_eigenvectors.shape A, chi_fuzzy, mapping = calculate_fuzzy_chi(alpha, square_map, right_eigenvectors) chi = 0.0 * chi_fuzzy # Make the membership matrix ""crisp"" chi[np.arange(num_micro), mapping] = 1. # If current point is infeasible or leads to degenerate lumping. if len(np.unique(mapping)) != right_eigenvectors.shape[1] or has_constraint_violation(A, right_eigenvectors): return -1.0 * np.inf obj = 0.0 for i in range(num_eigen): # Calculate metastabilty of the lumped model. Eqn 4.20 in LAA. obj += np.dot(T.dot(chi[:, i]), pi * chi[:, i]) / np.dot(chi[:, i], pi) return obj def crispness(alpha, T, right_eigenvectors, square_map, pi): """"""Return the crispness PCCA+ objective function. Parameters ---------- alpha : ndarray Parameters of objective function (e.g. flattened A) T : csr sparse matrix Transition matrix right_eigenvectors : ndarray The right eigenvectors. square_map : ndarray Mapping from square indices (i,j) to flat indices (k). pi : ndarray Equilibrium Populations of transition matrix. Returns ------- obj : float The objective function Notes ------- Tries to make crisp state decompostion. This function is defined in [3]. """""" A, chi, mapping = calculate_fuzzy_chi(alpha, square_map, right_eigenvectors) # If current point is infeasible or leads to degenerate lumping. if len(np.unique(mapping)) != right_eigenvectors.shape[1] or has_constraint_violation(A, right_eigenvectors): return -1.0 * np.inf obj = tr(dot(diag(1. / A[0]), dot(A.transpose(), A))) return obj class PCCAPlus(EigenvectorLumper): def __init__(self, T, num_macrostates, objective_function=""crisp_metastability"", flux_cutoff=None, do_minimization=True): """"""Perform PCCA+ lumping and return PCCA+ object. Parameters ---------- T : csr sparse matrix Transition matrix num_macrostates : int desired (maximum) number of macrostates flux_cutoff : float, optional If desired, discard eigenvectors with flux below this value. do_minimization : bool, optional If False, skip the optimization of the transformation matrix. In general, minimization is recommended. objective_function: {'crisp_metastablility', 'metastability', 'metastability'} Possible objective functions. See objective for details. Notes ----- PCCA+ is used to construct a ""lumped"" state decomposition. First, The eigenvalues and eigenvectors are computed for a transition matrix. An optimization problem is then used to estimate a mapping from microstates to macrostates. For each microstate i, microstate_mapping[i] is chosen as the macrostate with the largest membership (chi) value. The membership matrix chi is given by chi = dot(vr,A). The transformation matrix A is the output of a constrained optimization problem. You have three choices for objective function: crispness, metastability, or crisp_metastability Our implementation of PCCA+ REQUIRES DETAILED BALANCE. Here are some key quantities that will be saved as member variables: A : ndarray The transformation matrix. chi : ndarray The membership matrix vr : ndarray The right eigenvectors. microstate_mapping : ndarray Mapping from microstates to macrostates. References ---------- .. [1] Deuflhard P, Weber, M., ""Robust perron cluster analysis in conformation dynamics,"" Linear Algebra Appl., vol 398 pp 161-184 2005. .. [2] Kube S, Weber M. ""A coarse graining method for the identification of transition rates between molecular conformations,"" J. Chem. Phys., vol 126 pp 24103-024113, 2007. .. [3] Kube S., ""Statistical Error Estimation and Grid-free Hierarchical Refinement in Conformation Dynamics,"" Doctoral Thesis. 2008 .. [4] Deuflhard P, et al. ""Identification of almost invariant aggregates in reversible nearly uncoupled markov chains,"" Linear Algebra Appl., vol 315 pp 39-59, 2000. See Also -------- PCCA """""" if objective_function == ""crispness"": self.objective_function = crispness elif objective_function == ""metastability"": self.objective_function = metastability elif objective_function == ""crisp_metastability"": self.objective_function = crisp_metastability else: possible_objective_functions = [""crispness"", ""crisp_metastability"", ""metastability""] raise Exception(""objective_function must be one of "", possible_objective_functions) EigenvectorLumper.__init__(self, T, num_macrostates, flux_cutoff=flux_cutoff) self.lump(do_minimization=do_minimization) def lump(self, do_minimization=True): """"""Perform PCCA+ algorithm by optimizing transformation matrix A. Creates the following member variables: ------- A : ndarray The transformation matrix. chi : ndarray The membership matrix microstate_mapping : ndarray Mapping from microstates to macrostates. """""" index = index_search(self.right_eigenvectors) # compute transformation matrix A as initial guess for local optimization # (maybe not feasible) A = self.right_eigenvectors[index, :] A = inv(A) A = fill_A(A, self.right_eigenvectors) if do_minimization == True: logger.warning(""Minimizing PCCA+ objective function."") A = self.optimize_A(A) else: logger.warning(""Skipping Minimization"") A = fill_A(A, self.right_eigenvectors) chi = dot(self.right_eigenvectors, A) microstate_mapping = np.argmax(chi, 1) self.A, self.chi, self.microstate_mapping = A, chi, microstate_mapping def optimize_A(self, A): """"""Find optimal transformation matrix A by minimization. Parameters ---------- A : ndarray The transformation matrix A. Returns ------- A : ndarray The transformation matrix. """""" flat_map, square_map = get_maps(A) alpha = to_flat(1.0 * A, flat_map) obj = lambda x: -1 * \ self.objective_function( x, self.T, self.right_eigenvectors, square_map, self.populations) self.obj = obj self.alpha = alpha.copy() logger.info(""Initial value of objective function: f = %f"", obj(alpha)) alpha = scipy.optimize.anneal( obj, alpha, lower=0.0, maxiter=1, schedule=""boltzmann"", dwell=1000, feps=1E-3, boltzmann=2.0, T0=1.0)[0] alpha = scipy.optimize.fmin( obj, alpha, full_output=True, xtol=1E-4, ftol=1E-4, maxfun=5000, maxiter=100000)[0] logger.info(""Final value: f = %f"" % (obj(alpha))) if np.isneginf(obj(alpha)): raise ValueError(""Error: minimization has not located a feasible point."") A = to_square(alpha, square_map) return A def get_maps(A): """"""Get mappings from the square array A to the flat vector of parameters alpha. Helper function for PCCA+ optimization. Parameters ---------- A : ndarray The transformation matrix A. Returns ------- flat_map : ndarray Mapping from flat indices (k) to square (i,j) indices. square map : ndarray Mapping from square indices (i,j) to flat indices (k). """""" N = A.shape[0] flat_map = [] for i in range(1, N): for j in range(1, N): flat_map.append([i, j]) flat_map = np.array(flat_map) square_map = np.zeros(A.shape, 'int') for k in range((N - 1) ** 2): i, j = flat_map[k] square_map[i, j] = k return flat_map, square_map def to_flat(A, flat_map): """"""Convert a square matrix A to a flat array alpha. Parameters ---------- A : ndarray The transformation matrix A flat_map : ndarray Mapping from flat indices (k) to square (i,j) indices. Returns ------- FlatenedA : ndarray flattened version of A """""" return A[flat_map[:, 0], flat_map[:, 1]] def to_square(alpha, square_map): """"""Convert a flat array alpha to a square array A. Parameters ---------- alpha : ndarray An array of (n-1)^2 parameters used as optimization parameters. alpha is a minimal, flat representation of A. square_map : ndarray Mapping from square indices (i,j) to flat indices (k). Returns ------- SquareA : ndarray Square version of alpha """""" return alpha[square_map] def has_constraint_violation(A, right_eigenvectors, epsilon=1E-8): """"""Check for constraint violations in transformation matrix. Parameters ---------- A : ndarray The transformation matrix. right_eigenvectors : ndarray The right eigenvectors. epsilon : float, optional Tolerance of constraint violation. Returns ------- truth : bool Whether or not the violation exists Notes ------- Checks constraints using Eqn 4.25 in [1]. References ---------- .. [1] Deuflhard P, Weber, M., ""Robust perron cluster analysis in conformation dynamics,"" Linear Algebra Appl., vol 398 pp 161-184 2005. """""" lhs = 1 - A[0, 1:].sum() rhs = dot(right_eigenvectors[:, 1:], A[1:, 0]) rhs = -1 * rhs.min() if abs(lhs - rhs) > epsilon: return True else: return False def index_search(right_eigenvectors): """"""Find simplex structure in eigenvectors to begin PCCA+. Parameters ---------- right_eigenvectors : ndarray Right eigenvectors of transition matrix Returns ------- index : ndarray Indices of simplex """""" num_micro, num_eigen = right_eigenvectors.shape index = np.zeros(num_eigen, 'int') # first vertex: row with largest norm index[0] = np.argmax([norm(right_eigenvectors[i]) for i in range(num_micro)]) ortho_sys = right_eigenvectors - np.outer(np.ones(num_micro), right_eigenvectors[index[0]]) for j in range(1, num_eigen): temp = ortho_sys[index[j - 1]].copy() for l in range(num_micro): ortho_sys[l] -= temp * dot(ortho_sys[l], temp) dist_list = np.array([norm(ortho_sys[l]) for l in range(num_micro)]) index[j] = np.argmax(dist_list) ortho_sys /= dist_list.max() return index def fill_A(A, right_eigenvectors): """"""Construct feasible initial guess for transformation matrix A. Parameters ---------- A : ndarray Possibly non-feasible transformation matrix. right_eigenvectors : ndarray Right eigenvectors of transition matrix Returns ------- A : ndarray Feasible transformation matrix. """""" num_micro, num_eigen = right_eigenvectors.shape A = A.copy() # compute 1st column of A by row sum condition A[1:, 0] = -1 * A[1:, 1:].sum(1) # compute 1st row of A by maximum condition A[0] = -1 * dot(right_eigenvectors[:, 1:].real, A[1:]).min(0) # rescale A to be in the feasible set A /= A[0].sum() return A def calculate_fuzzy_chi(alpha, square_map, right_eigenvectors): """"""Calculate the membership matrix (chi) from parameters alpha. Parameters ---------- alpha : ndarray Parameters of objective function (e.g. flattened A) square_map : ndarray Mapping from square indices (i,j) to flat indices (k). right_eigenvectors : ndarray The right eigenvectors. Returns ------- A : ndarray The transformation matrix A chi_fuzzy : ndarray The (fuzzy) membership matrix. mapping: ndarray The mapping from microstates to macrostates. """""" A = to_square(alpha, square_map) # Convert parameter vector into matrix A A = fill_A(A, right_eigenvectors) # Make A feasible. chi_fuzzy = np.dot(right_eigenvectors, A) # Calculate the fuzzy membership matrix. mapping = np.argmax(chi_fuzzy, 1) # Calculate the microstate mapping. return A, chi_fuzzy, mapping ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/project/project.py",".py","18240","445","# This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA from __future__ import print_function, absolute_import, division from mdtraj.utils.six.moves import xrange from mdtraj.utils.six import string_types import os import numpy as np import yaml # if CLoader/CDumper are available (i.e. user has libyaml installed) # then use them since they are much faster. try: from yaml import CLoader as Loader from yaml import CDumper as Dumper except ImportError: from yaml import Loader from yaml import Dumper from msmbuilder import MSMLib import mdtraj as md from mdtraj import io import logging logger = logging.getLogger(__name__) class Project(object): @property def conf_filename(self): """"""Filename of the project topology (PDB)"""""" return os.path.normpath(os.path.join(self._project_dir, self._conf_filename)) @property def n_trajs(self): """"""Number of trajectories in the project"""""" return len(self._valid_traj_indices) @property def traj_lengths(self): """"""Length of each of the trajectories, in frames"""""" return self._traj_lengths[self._valid_traj_indices] def __eq__(self, other): '''Is this project equal to another''' if not isinstance(other, Project): return False return os.path.basename(self._conf_filename) == os.path.basename(other._conf_filename) and \ np.all(self._traj_lengths == other._traj_lengths) and \ np.all(np.array([os.path.basename(e) for e in self._traj_paths]) == np.array([os.path.basename(e) for e in other._traj_paths])) and \ np.all(self._traj_errors == other._traj_errors) # np.all(self._traj_converted_from == other._traj_converted_from) def __init__(self, records, validate=False, project_dir='.'): """"""Create a project from a set of records Parameters ---------- records : dict The data, either constructed or loaded from disk. If you provide insufficient data, we an error will be thrown. validate : bool, optional If true, some checks for consistency are done project_dir : string Base directory for the project. Filenames in the records dict are assumed to be given relative to this directory Notes ----- This method is generally used internally. To load projects from disk, use `Project.load_from` `records` should be a dict with 'conf_filename`, 'traj_lengths`, `traj_paths`, `traj_converted_from` and `traj_errors` keys. The first should be a path on disk, relative to `project_dir` giving the pdb for the project. the others should be arrays or lists with one entry per trajectory in the project. See Also -------- load_from : to load from disk """""" self._conf_filename = records['conf_filename'] self._traj_lengths = np.array(records['traj_lengths']) self._traj_paths = np.array([os.path.relpath(p) for p in records['traj_paths']]) self._traj_converted_from = list(records['traj_converted_from']) self._traj_errors = np.array(records['traj_errors']) self._project_dir = os.path.abspath(project_dir) # make sure lengths are all consistent if not len(self._traj_lengths) == len(self._traj_paths) == \ len(self._traj_converted_from) == len(self._traj_errors): raise ValueError(""Inconsistent records: traj fields not all the same length"") # set the length field self._valid_traj_indices = np.arange(len(self._traj_lengths)) # if there are errors if np.any(self._traj_errors): self._valid_traj_indices = np.array([i for i, e in enumerate(self._traj_errors) if e is None], dtype=int) n_errors = len([e for e in self._traj_errors if e is not None]) logger.error('Errors detected in conversion: %d trajectories', n_errors) errors = np.setdiff1d(np.arange(len(self._traj_errors)), self._valid_traj_indices) logger.error('The trajectories in error are numbers %s. If this project was ' 'loaded from a yaml file, check the file for details' % errors) # now _valid_traj_indicies gives the indices of the trajectories # without errors, so that when someone asks for self.traj_filename(i) # they'll get self._traj_paths[self._valid_traj_indices[i]] if validate: self._validate() def __repr__(self): ""Return a string representation of the project"" return 'Project<(%d trajectories, from %s to %s topology: %s)>' % (self.n_trajs, self.traj_filename(0), self.traj_filename(self.n_trajs - 1), self.conf_filename) @classmethod def load_from(cls, filename): """""" Load project from disk Parameters ---------- filename : string filename_or_file can be a path to a legacy .h5 or current .yaml file. Returns ------- project : the loaded project object """""" rootdir = os.path.abspath(os.path.dirname(filename)) if filename.endswith('.yaml'): with open(filename) as f: ondisk = yaml.load(f, Loader=Loader) records = {'conf_filename': ondisk['conf_filename'], 'traj_lengths': [], 'traj_paths': [], 'traj_converted_from': [], 'traj_errors': []} for trj in ondisk['trajs']: records['traj_lengths'].append(trj['length']) records['traj_paths'].append(trj['path']) records['traj_errors'].append(trj['errors']) records['traj_converted_from'].append(trj['converted_from']) elif filename.endswith('.h5'): ondisk = io.loadh(filename, deferred=False) n_trajs = len(ondisk['TrajLengths']) records = {'conf_filename': str(ondisk['ConfFilename'][0]), 'traj_lengths': ondisk['TrajLengths'], 'traj_paths': [], 'traj_converted_from': [[None]] * n_trajs, 'traj_errors': [None] * n_trajs} for i in xrange(n_trajs): # this is the convention used in the hdf project format to get the traj paths path = os.path.join(ondisk['TrajFilePath'][0], ondisk['TrajFileBaseName'][0] + str(i) + ondisk['TrajFileType'][0]) records['traj_paths'].append(path) else: raise ValueError('Sorry, I can only open files in .yaml' ' or .h5 format: %s' % filename) return cls(records, validate=False, project_dir=rootdir) def save(self, filename_or_file): if isinstance(filename_or_file, string_types): if not filename_or_file.endswith('.yaml'): filename_or_file += '.yaml' dirname = os.path.abspath(os.path.dirname(filename_or_file)) if not os.path.exists(dirname): logger.info(""Creating directory: %s"" % dirname) os.makedirs(dirname) handle = open(filename_or_file, 'w') own_fid = True elif isinstance(filename_or_file, file): dirname = os.path.abspath(os.path.dirname(filename_or_file.name)) handle = filename_or_file own_fid = False # somewhat complicated logic if the directory you're # saving in is different than the directory this # project references its paths from # the point is that the when the file lists paths, those # paths are going to be interpreted as being with respect to # the directory that the file is in. So when the Project file # is being resaved (but the Trajectorys are not being moved) # then the paths need to change to compensate relative = os.path.relpath(self._project_dir, os.path.dirname(filename_or_file)) records = {'trajs': []} records['conf_filename'] = os.path.join(relative, self._conf_filename) traj_paths = [os.path.join(relative, path) for path in self._traj_paths] for i in xrange(len(traj_paths)): # yaml doesn't like numpy types, so we have to sanitize them records['trajs'].append({'id': i, 'path': str(traj_paths[i]), 'converted_from': list(self._traj_converted_from[i]), 'length': int(self._traj_lengths[i]), 'errors': self._traj_errors[i]}) yaml.dump(records, handle, Dumper=Dumper) if own_fid: handle.close() return filename_or_file def get_random_confs_from_states(self, assignments, states, num_confs, replacement=True, random=np.random): """""" Get random conformations from a particular state (or states) in assignments. Parameters ---------- assignments : np.ndarray 2D array storing the assignments for a particular MSM states : int or 1d array_like state index (or indices) to load random conformations from num_confs : int or 1d array_like number of conformations to get from state. The shape should be the same as the states argument replacement : bool, optional whether to sample with replacement or not (default: True) random : np.random.RandomState, optional use a particular RandomState for generating the random samples. this is only useful if you want to get the same samples, i.e. when debugging something. Returns ------- random_confs : msmbuilder.Trajectory or list of msmbuilder.Trajectory objects If states is a list, then the output is a list, otherwise a single trajectory is returned Trajectory object containing random conformations from the specified state """""" def randomize(state_counts, size=1, replacement=True, random=np.random): """""" This is a helper function for selecting random conformations. It will select many samples from a discrete, uniform distribution over: .. math:: \{i\}_{i=1}^{\textnormal{state_counts}} If replacement==True, then random.randint will be used, otherwise random.permutation will be used. Parameters ---------- state_counts : int number of conformations in the state size : int, optional number of samples to draw (size kwarg in np.random.randint) default: 1 replacement : bool, optional if True, then we sample with replacement, otherwise we use a permutation random : np.random.RandomState, optional if you want this to behave deterministically then pass a particular random state, otherwise we will use np.random. Returns ------- result : np.ndarray 1d array with samples from the given distribution Raises ------ ValueError: if size > state_counts and replacement is False, then it is not possible to sample that many conformations without replacement """""" assert state_counts > 0 if replacement: result = random.randint(0, state_counts, size=size) else: if size > state_counts: raise ValueError(""Asked for %d conformations from a state "" ""with only %d conformations."" % (size, state_counts)) else: result = random.permutation(np.arange(state_counts))[:size] return result if isinstance(states, int): states = np.array([states]) states = np.array(states).flatten() # if num_confs is just a number, map it to # each state given in states if isinstance(num_confs, int): num_confs = np.array([num_confs] * len(states)) num_confs = np.array(num_confs).flatten() # if num_confs is length-1, then map that value to each # state in states if len(num_confs) == 1: num_confs = np.array(list(num_confs) * len(states)) if len(num_confs) != len(states): raise Exception(""num_confs must be the same size as num_states"") inv_assignments = MSMLib.invert_assignments(assignments) state_counts = np.bincount(assignments[np.where(assignments != -1)]) random_confs = [] for n, state in zip(num_confs, states): logger.debug(""Working on %s"", state) if state_counts[state] == 0: raise ValueError('No conformations to sample from state %d! It contains ' 'no assigned conformations.' % state) random_conf_inds = randomize(state_counts[state], size=n, replacement=replacement, random=random) traj_inds, frame_inds = inv_assignments[state] random_confs.append(self.load_frame(traj_inds[random_conf_inds], frame_inds[random_conf_inds])) return random_confs def load_traj(self, trj_index, stride=1, atom_indices=None): ""Load the a trajectory from disk"" filename = self.traj_filename(trj_index) return md.load(filename, stride=stride, atom_indices=atom_indices, discard_overlapping_frames=True) def load_chunked_traj(self, trj_index, chunk_size=50000, stride=1, atom_indices=None): return md.iterload(self.traj_filename(trj_index), chunk=chunk_size, stride=stride, atom_indices=atom_indices) # does anything use this function? def load_frame(self, traj_index, frame_index): """"""Load one or more specified frames. Parameters ---------- traj_index : int, [int] Index or indices of the trajectories to pull from frame_index : int, [int] Index or indices of the frames to pull from Returns ------- traj : msmbuilder.Trajectory A trajectory object containing the requested frame(s). """""" if np.isscalar(traj_index): traj_index = np.array([traj_index]) if np.isscalar(frame_index): frame_index = np.array([frame_index]) traj_index = np.array(traj_index) frame_index = np.array(frame_index) if not (traj_index.ndim == 1 and np.all(traj_index.shape == frame_index.shape)): raise ValueError('traj_index and frame_index must be 1D and have the same length') conf = self.load_conf() xyzlist = [] for i, j in zip(traj_index, frame_index): if j >= self.traj_lengths[i]: raise ValueError('traj %d too short (%d) to contain a frame %d' % (i, self.traj_lengths[i], j)) xyzlist.append(md.load_frame(self.traj_filename(i), j).xyz) conf.xyz = np.concatenate(xyzlist) conf.time = [1 for _ in xyzlist] conf.unitcell_vectors = None return conf def load_conf(self): ""Load the PDB associated with this project from disk"" return md.load(self.conf_filename) def traj_filename(self, traj_index): ""Get the filename of one of the trajs on disk"" path = self._traj_paths[self._valid_traj_indices[traj_index]] return os.path.normpath(os.path.join(self._project_dir, path)) def _validate(self): ""Run some checks to ensure that this project is consistent"" if not os.path.exists(self.conf_filename): raise ValueError('conf does not exist: %s' % self.conf_filename) for i in xrange(self.n_trajs): if not os.path.exists(self.traj_filename(i)): raise ValueError(""%s does not exist"" % self.traj_filename(i)) lengths, atoms = self._eval_traj_shapes() if not np.all(self.traj_lengths == lengths): raise ValueError('Trajs length don\'t match what\'s on disk') # make sure all trajs have the same number of atoms # note that it is possible that there are no valid trajectories, so atoms # could be empty if len(atoms) > 0 and not np.all(atoms == atoms[0]): raise ValueError('Not all trajs have the same number of atoms') def empty_traj(self): traj = self.load_conf() traj.xyz = np.empty((0, traj.n_atoms, 3)) return traj def _eval_traj_shapes(self): lengths = np.zeros(self.n_trajs) n_atoms = np.zeros(self.n_trajs) for i in xrange(self.n_trajs): filename = self.traj_filename(i) with md.open(filename) as f: lengths[i] = len(f) n_atoms[i] = md.load_frame(filename, 0).n_atoms return lengths, n_atoms ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/project/validators.py",".py","5779","157",""""""" As the trajectories are being converted from their native format to MSMBuilder's format (lh5), all of the registeted validtors will be run against each trajectory. Validators should be callables like functions or classes with a __call__ method that check a trajectory. They are free to modify a trajectory as well, since it is passed by reference to the validator. If a validator detects a problem with a trajectory, it should raise a ValidationError -- that is, an error which subclasses msmbuilder.project.validators.ValidationError. When the ProjectBuilder detects a ValidationError, the error will be recorded in the project file, but the execution will procdede as normal and the trajectory will still be saved to disk. It will just be marked specially as ""in error"". In the current Project implementation, trajectories that are ""in error"" will be ignored -- when using project.load_traj(), only the ""valid"" trajectories will be returned, and project.n_trajs will only count the valid trajectories. """""" from __future__ import print_function, absolute_import, division from mdtraj.utils.six import string_types, PY2 import numpy as np from msmbuilder.metrics import RMSD import mdtraj as md class ValidationError(Exception): ""All validation errors should subclass me"" pass class ExplosionError(ValidationError): ""I get thrown by validators that check for explosion"" pass class TooLittleDataError(ValidationError): """""" Gets called when a trajectory has too little data to be modelled """""" pass # All of the validators must be callables. they should raise a ValidationError # when they fail, or else return None class ExplosionValidator(object): def __init__(self, structure_or_filename, metric, max_distance): """"""Create an explosion validator Checks the distance from every frame to a structure and watches for things that are too far away Parameters ---------- structure_or_filename : {msmbuilder.Trajectory, str} The structure to measure distances to, either as a trajectory (the first frame is the only one that counts) or a path to a trajectory on disk that can be loaded metric : msmbuilder distance metric Metric by which you want to measure distance max_distance : float The threshold distance, above which a ValidationError will be thrown """""" if isinstance(structure_or_filename, md.Trajectory): conf = structure_or_filename elif isinstance(structure_or_filename, string_types): conf = md.load(structure_or_filename) self.max_distance = max_distance self.metric = metric self._pconf = self.metric.prepare_trajectory(conf) def __call__(self, traj): ptraj = self.metric.prepare_trajectory(traj) distances = self.metric.one_to_all(self._pconf, ptraj, 0) if np.any(distances > self.max_distance): i = np.where(distances > self.max_distance)[0][0] # just get the first d = distances[i] raise ExplosionError('d(conf, frame[%d])=%f; greater than %s; metric=%s' % (i, d, self.max_distance, self.metric)) class RMSDExplosionValidator(ExplosionValidator): """"""Validator that checks for explosion by measuring the RMSD of every frame to a PDB and watching for values which are too high"""""" def __init__(self, structure_or_filename, max_rmsd, atom_indices=None): """"""Create an RMSD validator Parameters ---------- structure_or_filename : {msmbuilder.Trajectory, str} The structure to measure distances to, either as a trajectory (the first frame is the only one that counts) or a path to a trajectory on disk that can be loaded max_rmsd : float The threshold rmsd atom_indices : np.array [ndim=1, dtype=int] The indices over which you want to measure RMSD """""" metric = RMSD(atom_indices) if PY2: super(RMSDExplosionValidator, self).__init__(structure_or_filename, metric, max_rmsd) else: super().__init__(structure_or_filename, metric, max_rmsd) class MinLengthValidator(object): def __init__(self, min_length, length_in_time_units=False): """""" A validator that discards trajectories with two little data. Useful for excluding trajectories that might be far too short to lend any kind of significance to an MSM. Parameters ---------- min_length : float The minimum length cutoff (default in units of frames, see below). Trajectories shorter than this length will be discarded. length_in_time_units : bool If set to true, will try to read length in real time, not frames. Uses time ripped from the XTC files. """""" self.min_length = min_length self.length_in_time_units = length_in_time_units def __call__(self, traj): if self.length_in_time_units: # traj.dt here needs the timestep if len(traj) * traj.dt < self.min_length: raise NotImplementedError() raise TooLittleDataError('trajectory shorter than requested cutoff: %f' % self.min_length) else: # traj.dt here needs the timestep if len(traj) < self.min_length: raise TooLittleDataError('trajectory shorter than requested cutoff: %f' % self.min_length) class TrajCenterer(object): def __call__(self, traj): traj.center_coordinates() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/project/__init__.py",".py","150","5","from __future__ import print_function, absolute_import, division from .project import Project from .builder import ProjectBuilder, FahProjectBuilder ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/project/builder.py",".py","19586","496","from __future__ import print_function, absolute_import, division import os import re import logging from glob import glob from msmbuilder.utils import keynat import numpy as np import mdtraj as md from .project import Project from .validators import ValidationError logger = logging.getLogger(__name__) class ProjectBuilder(object): def __init__(self, input_traj_dir, input_traj_ext, conf_filename, stride=1, project=None, validators=[], output_traj_dir='Trajectories', output_traj_ext='.h5', output_traj_basename='trj', atom_indices=None): """""" Build an MSMBuilder project from a set of trajectories Parameters ---------- input_traj_dir : str Root directory of the trajectory hierarchy. The trajectories should actually be in input_traj_dir//{files}. input_traj_ext : {'.xtc', '.dcd', '', any mdtraj format} Trajectory file format conf_filename : str path to a pdb this will be used to load xtc's and other trajectories stride : int, optional Stride the input data at this frequency validators : list, optional list of validators project : msmbuilder.Project or None project instance that we are updating output_traj_dir : str, optional output directory to save trajectories output_traj_ext : str, optional output extension for trajectories output_traj_basename : str, optional output trajectory basename atom_indices : np.ndarray Select only these atom indices when loading trajectories and PDBs (Zero-based index). If None, selected all atoms. This also will cause a new PDB to be written with name conf_filename.subset.pdb Attributes ---------- project : msmbuilder.Project the built project Examples -------- >>> pb = ProjectBuilder('XTC', '.xtc', 'native.pdb') >>> pb.project.save('ProjectInfo.yaml') """""" format_reg = md.formats.registry._FormatRegistry valid_ext = list(format_reg.fileobjects.keys()) if input_traj_ext not in valid_ext + ['']: raise ValueError(""Unsupported format"") self.atom_indices = atom_indices self.input_traj_dir = input_traj_dir.strip() self.input_traj_ext = input_traj_ext.strip() if len(self.input_traj_ext) != 0 and self.input_traj_ext[0] != '.': self.input_traj_ext = '.%s' % self.input_traj_ext self.conf_filename = conf_filename.strip() # If not using atom_indices, we work exclusively with the original conf_filename if self.atom_indices is None: self.conf_filename_final = self.conf_filename else: # If we are selecting atom subsets, we need to generate # a new PDB file with the desired atoms, which will be called # conf_filename.subset.pdb filename_pieces = list(os.path.splitext(self.conf_filename)) filename_pieces.insert(-1, "".subset"") self.conf_filename_final = """".join(filename_pieces) subset_conf = md.load(self.conf_filename, atom_indices=atom_indices) subset_conf.save(self.conf_filename_final) self.conf = md.load(self.conf_filename) self.output_traj_ext = output_traj_ext.strip() if self.output_traj_ext[0] != '.': self.output_traj_ext = '.%s' % self.output_traj_ext self.project = project if self.project is None: self.output_traj_basename = output_traj_basename.strip() self.output_traj_dir = output_traj_dir.strip() else: logger.info(""using project data to determine trajectory basename/location/extension"") self.output_traj_dir = os.path.relpath(os.path.dirname(self.project.traj_filename(0))) trj_name = os.path.basename(self.project._traj_paths[0]) match_obj = re.search('(\w+)\d+\.%s$' % self.output_traj_ext[1:], trj_name) if match_obj: self.output_traj_basename = match_obj.group(1) else: logger.warning(""could not parse %s, defaulting to traj basename 'trj'"", trj_name) self.output_traj_basename = 'trj' self.stride = int(stride) self.project_updated = False # Keep track of when we've updated everything # setup containers for all of the metadata self.traj_lengths = [] self.traj_errors = [] self.traj_converted_from = [] self.traj_paths = [] self._validators = [] for e in validators: self.add_validator(e) self._check_out_dir() def _validate_traj(self, traj): """""" Run the registered validators on the trajectory Parameters ---------- traj : mdtraj.Trajectory Raises ------ validation_error On failure """""" for validator in self._validators: validator(traj) def add_validator(self, validator): """""" Add a validator to the project builder Parameters ---------- validator : callable Notes ----- As the trajectories are being converted from their native format to MSMBuilder's format (lh5), all of the registeted validtors will be run against each trajectory. Validators should be callables like functions or classes with a __call__ method that check a trajectory. They are free to modify a trajectory as well, since it is passed by reference to the validator. If a validator detects a problem with a trajectory, it should raise a ValidationError -- that is, an error which subclasses msmbuilder.project.validators.ValidationError. When the ProjectBuilder detects a ValidationError, the error will be recorded in the project file, but the execution will procede as normal and the trajectory will still be saved to disk. It will just be marked specially as ""in error"". In the current Project implementation, trajectories that are ""in error"" will be ignored -- when using project.load_traj(), only the ""valid"" trajectories will be returned, and project.n_trajs will only count the valid trajectories. """""" if not hasattr(validator, '__call__'): raise TypeError('Validator must be callable: %s' % validator) self._validators.append(validator) def get_project(self): """""" Retreive the project that was built. This can also be done with self.project Examples -------- >>> pb = ProjectBuilder('XTC', '.xtc', 'native.pdb') >>> pb.convert() >>> pb.project == pb.get_project() True """""" if not self.project_updated: self.convert() return self.project def _check_out_dir(self): ""Create self.output_traj_dir, or throw an error if it already exists"" if not os.path.exists(self.output_traj_dir): os.makedirs(self.output_traj_dir) elif self.project is None: raise IOError('%s already exists' % self.output_traj_dir) else: # project exists so we are supposed to be updating the # trajectories pass def _load_new_files(self, file_list, traj_loc): """""" load a new trajectory specified by a list of input files. """""" num_files = len(file_list) try: traj, n_loaded = self._load_traj(file_list) traj = traj[::self.stride] except RuntimeError as e: # traj_errors.append(e) logger.warning('Could not convert %d files from %s (%s)', num_files, traj_loc, e) else: if self.project is None: next_ind = len(self.traj_lengths) else: next_ind = len(self.traj_lengths) + len(self.project._traj_lengths) out_fn = os.path.join(self.output_traj_dir, (self.output_traj_basename + str(next_ind) + self.output_traj_ext)) traj.save(out_fn) self.traj_lengths.append(traj.n_frames) self.traj_paths.append(out_fn) self.traj_converted_from.append(file_list[:n_loaded]) error = None try: self._validate_traj(traj) logger.info(""%s (%d files), length %d, converted to %s"", traj_loc, n_loaded, self.traj_lengths[-1], out_fn) except ValidationError as e: error = e logger.error(""%s (%d files), length %d, converted to %s with error '%s'"", traj_loc, num_files, self.traj_lengths[-1], out_fn, e) self.traj_errors.append(error) def _update_traj(self, old_ind, file_list, traj_loc): """""" update a trajectory that we already had in the old project. """""" # This trajectory has been seen before, and so we need to # either extend it or skip it # This procedure would ideally be done using EArrays and we # use pyTables to actually extend the trajectory. Currently, # the XYZList is a CArray, and so at some point we have to load # the old array into memory, which is not the most efficient # way to do this... old_locs = self.project._traj_converted_from[old_ind] old_num_files = len(old_locs) num_files = len(file_list) if old_num_files == len(file_list): # Just assume if it is the same number of files then they are the # same. We should change this eventually logger.info(""%s no change, did nothing for %s"", traj_loc, self.project._traj_paths[old_ind]) elif old_num_files < len(file_list): # Need to update the trajectory try: extended_traj, n_loaded = self._load_traj(file_list[old_num_files:]) except RuntimeError as e: logger.warning('Could not convert: %s (%s)', file_list[old_num_files:], e) else: # assume that the first are the same # ^^^ This should be modified, but I want to get it working first traj = self.project.load_traj(old_ind) # remove the redundant first frame if it is actually redundant if np.abs(traj.xyz[-1] - extended_traj.xyz[0]).sum() < 1E-8: extended_traj = extended_traj[1:] traj.xyz = np.concatenate((traj.xyz, extended_traj.xyz)) traj.save(self.project._traj_paths[old_ind]) # This does what we want it to do, because msmbuilder.io.saveh # deletes keys that exist already. However, this could be made more # efficient by only updating the XYZList node since it's the # only thing that changes new_traj_locs = np.concatenate((old_locs, file_list[old_num_files:old_num_files + n_loaded])) self.project._traj_converted_from[old_ind] = list(new_traj_locs) self.project._traj_lengths[old_ind] = traj.n_frames # _errors updated later, saved to the same place, so traj_filename is the same try: self._validate_traj(traj) logger.info(""%s (%d files), length %d, UPDATED %s"", traj_loc, num_files, self.project._traj_lengths[old_ind], self.project._traj_paths[old_ind]) except ValidationError as e: error = e logger.info(""%s (%d files), length %d, UPDATED %s"", traj_loc, num_files, self.project._traj_lengths[old_ind], self.project._traj_paths[old_ind]) if self.project._traj_errors[old_ind] is None: self.project._traj_errors[old_ind] = error elif isinstance(self.project._traj_errors[old_ind], list): self.project._traj_errors[old_ind].append(error) else: self.project._traj_errors[old_ind] = [self.project._traj_errors[old_ind], error] else: logger.warn('Fewer frames found than currently have. Skipping. (%s)' % traj_loc) def convert(self): """""" Main method for this class. Convert all of the trajectories into h5 format and save them to self.output_traj_dir. Returns ------- project : msmbuilder.project The project object, summarizing the conversion """""" if not self.project is None: old_traj_locs = ['/'.join([d for d in os.path.relpath(file_list[0]).split('/') if not d in ['.', '..']][:-1]) for file_list in self.project._traj_converted_from] # ^^^ haha, @rmcgibbo, is this acceptable? # basically we want to turn something like: # ../../PROJXXXX/RUN0/CLONE195/frame0.xtc # into: # PROJXXXX/RUN0/CLONE195 # and we use this label to see if we've already included the # trajectory in the old project else: old_traj_locs = [] old_traj_locs = np.array(old_traj_locs) num_trajs_added = 0 if self.project is None: num_orig_trajs = 0 else: num_orig_trajs = len(self.project._traj_paths) for file_list in self._input_trajs(): traj_loc = '/'.join([d for d in os.path.relpath(file_list[0]).split('/') if not d in ['.', '..']][:-1]) num_files = len(file_list) if not traj_loc in old_traj_locs: self._load_new_files(file_list, traj_loc) else: old_ind = np.where(old_traj_locs == traj_loc)[0][0] self._update_traj(old_ind, file_list, traj_loc) if len(self.traj_paths) == 0 and self.project is None: os.rmdir(self.output_traj_dir) raise RuntimeError('No conversion jobs found!') if not self.project is None: self.traj_lengths = list(self.project._traj_lengths) + self.traj_lengths self.traj_paths = list(self.project._traj_paths) + self.traj_paths self.traj_errors = list(self.project._traj_errors) + self.traj_errors self.traj_converted_from = list(self.project._traj_converted_from) + self.traj_converted_from self.traj_converted_from = [[str(i) for i in l] for l in self.traj_converted_from] self.project = Project({'conf_filename': self.conf_filename_final, 'traj_lengths': self.traj_lengths, 'traj_paths': self.traj_paths, 'traj_errors': self.traj_errors, 'traj_converted_from': self.traj_converted_from}) self.updated_project = True def _input_trajs(self): logger.warning(""WARNING: Sorting trajectory files by numerical values in their names."") logger.warning(""Ensure that numbering is as intended."") traj_dirs = glob(os.path.join(self.input_traj_dir, ""*"")) traj_dirs.sort(key=keynat) logger.info(""Found %s traj dirs"", len(traj_dirs)) for traj_dir in traj_dirs: to_add = glob(traj_dir + '/*' + self.input_traj_ext) to_add.sort(key=keynat) if to_add: yield to_add def _load_traj(self, file_list): """""" Load a set of xtc or dcd files as a single trajectory Note that the ordering of `file_list` is relevant, as the trajectories are catted together. Returns ------- traj : mdtraj.Trajectory """""" traj = md.load(file_list, discard_overlapping_frames=True, top=self.conf, atom_indices=self.atom_indices) # return the number of files loaded, which in this case is all or # nothing, since an error is raised if the Trajectory.load_from_ # doesn't work return traj, len(file_list) class FahProjectBuilder(ProjectBuilder): """""" Build a project using the classic FAH-style directory setup. E.g. looks for data of the form -- RUNs ---- CLONEs ------ frame0.xtc, frame1.xtc .... Contains a little more forgiving code than the standard ProjectBuilder, specifically if a certain CLONE will not load, then we try to load again excluding the last frame (which is often a FAH crash). This helps out quite a bit. Parameters ---------- input_traj_dir : str Root directory of the trajectory hierarchy. The trajectories should actually be in input_traj_dir//{files}. input_traj_ext : {'.xtc', '.dcd'} Trajectory file format conf_filename : str Path to a pdb Additional Parameters --------------------- stride : int Stride the input data at this frequency validators : [msmbuilder.project.Validator] Attributes ---------- project : msmbuilder.Project the built project Examples -------- >>> pb = ProjectBuilder('XTC', '.xtc', 'native.pdb') >>> pb.project.save('ProjectInfo.yaml') """""" def _input_trajs(self): run_dirs = glob(os.path.join(self.input_traj_dir, ""RUN*"")) run_dirs.sort(key=keynat) logger.info(""Found %d RUN dirs"", len(run_dirs)) for run_dir in run_dirs: clone_dirs = glob(os.path.join(run_dir, ""CLONE*"")) clone_dirs.sort(key=keynat) logger.info(""%s: Found %d CLONE dirs"", run_dir, len(clone_dirs)) for clone_dir in clone_dirs: to_add = glob(clone_dir + '/*' + self.input_traj_ext) to_add.sort(key=keynat) if to_add: yield to_add def _load_traj(self, file_list): traj = None try: traj, n_loaded = super(FahProjectBuilder, self)._load_traj(file_list) except (RuntimeError, IOError) as e: if hasattr(e, ""errno"") and e.errno == 2: # Then the pdb filename doesn't exist raise e corrupted_files = True n_corrupted = 1 logger.error(""Some files appear to be corrupted"") while corrupted_files: logger.error(""Trying to recover by discarding the %d-th-to-last file"", n_corrupted) if len(file_list[:-n_corrupted]) == 0: traj = None break try: traj, n_loaded = super(FahProjectBuilder, self)._load_traj( file_list[:-n_corrupted]) except IOError: n_corrupted += 1 else: logger.error(""That seemed to work"") corrupted_files = False if traj is None: raise RuntimeError(""Corrupted frames in %s, recovery impossible"" % file_list) return traj, n_loaded ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/project/reference_data.py",".py","2920","91","# This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA from __future__ import print_function, absolute_import, division import os import numpy as np import mdtraj as md from mdtraj.utils.six import iteritems import logging logger = logging.getLogger(__name__) def randomize_coordinates(template_traj, traj_len): """"""Randomize the coordinates in an input trajectory. Parameters ---------- template_traj : mdtraj.Trajectory template_traj will be the template for randomly generated coordinate data. template_traj WILL BE MODIFIED inplace. traj_len : int This is the length of each trajectory (generator) to be generated. """""" template_traj.xyz = np.random.normal(size=(traj_len, template_traj.n_atoms, 3)) template_traj.time = np.arange(traj_len) class FAHReferenceData(object): """"""Generate a test case for FAH project building. Parameters ---------- traj : mdtraj.Trajectory traj will be the template for randomly generated coordinate data. traj WILL BE MODIFIED inplace. path : path where generated FAH-style project will be placed run_clone_gen : dict ""run_clone_gen[run, clone] = gen"" means that `gen` trajectories will be generated for that run, clone pair. traj_len : int This is the length of each trajectory (generator) to be generated. Notes ----- This will generate a directory with the following structure [%s/RUN%d/CLONE%d/frame%d.xtc % (path, run, clone, k)] where (run, clone) are the keys of run_clone_gen and k is in range(run_clone_gen[run, clone]. """""" def __init__(self, traj, path, run_clone_gen, traj_len): try: os.mkdir(path + ""/"") except OSError: pass for (run, clone), num_gens in iteritems(run_clone_gen): try: os.mkdir(path + ""/RUN%d/"" % run) except OSError: pass os.mkdir(path + ""/RUN%d/CLONE%d"" % (run, clone)) for gen in range(num_gens): randomize_coordinates(traj, traj_len) traj.save(path + ""/RUN%d/CLONE%d/frame%d.xtc"" % (run, clone, gen)) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","MSMBuilder/project/utils.py",".py","2403","71","from __future__ import print_function, absolute_import, division import os import logging from msmbuilder.utils import keynat import tables import mdtraj as md from .project import Project logger = logging.getLogger(__name__) def get_project_object(traj_directory, conf_filename, out_filename=None): """""" This function constructs a msmbuilder.Project object given a directory of trajectories saved as .lh5's. Note that this is only really necessary when a script like ConvertDataToLHDF.py converts the data but fails to write out the ProjectInfo.yaml file. This function can also be used to combine two projects by copying and renaming the trajectories in a new folder. Though, it's probably more efficient to just do some bash stuff to cat the ProjectInfo.yaml's together and rename the trajectories. Inputs: ------- 1) traj_directory : directory to find the trajectories 2) conf_filename : file to find the conformation 3) out_filename [ None ] : if None, then this function does not save the project file, but if given, the function will save the project file and also return the object Outputs: ------- project : msmbuilder.Project object corresponding to your project. """""" # relative to the traj_directory traj_paths = sorted(os.listdir(traj_directory), key=keynat) # relative to current directory traj_paths = [os.path.join(traj_directory, filename) for filename in traj_paths] traj_lengths = [] for traj_filename in traj_paths: # Get the length of each trajectory logger.info(traj_filename) if traj_filename.split('.')[-1] in ['hdf', 'h5', 'lh5']: with tables.openFile(traj_filename) as f: traj_lengths.append(f.root.coordinates.shape[0]) else: traj_lengths.append(md.load(traj_filename).n_frames) project = Project({'conf_filename': conf_filename, 'traj_lengths': traj_lengths, 'traj_paths': traj_paths, 'traj_errors': [None] * len(traj_paths), 'traj_converted_from': [[None]] * len(traj_paths)}) if out_filename is None: return project else: project.save(out_filename) logger.info('Saved project file to %s', out_filename) return project ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/TPTdiagrams/KyleGeneratePNG.py",".py","1059","45","import __main__ import sys, time, os import pymol pymol.finish_launching() if not os.path.exists(OutDir): os.mkdir(OutDir) GetFilename=lambda i,j: PDBDir+""State%d-%d.pdb""%(i,j) GetName=lambda i,j: ""State%d-%d""%(i,j) time.sleep(.1) pymol.cmd.load(NativeFilename, ""native"") pymol.cmd.util.chainbow(""native"") for i in range(NumStates): for j in range(NumConfs): print(GetName(i,j)) pymol.cmd.load(GetFilename(i,j), GetName(i,j)) pymol.cmd.util.chainbow(GetName(i,j)) pymol.cmd.fit(GetName(i,j),""native"") pymol.cmd.zoom() pymol.cmd.hide(""lines"") pymol.cmd.show(""cartoon"") #disable all objects from viewing pymol.cmd.disable(""all"") for i in range(NumStates): for j in range(NumConfs): #enable all of state i pymol.cmd.enable(GetName(i,j)) time.sleep(.1) print(""ray"") pymol.cmd.ray(600,600) print(""done"") time.sleep(.1) pymol.cmd.png(OutDir+""State%d.png""%i) time.sleep(.1) for j in range(NumConfs): pymol.cmd.disable(GetName(i,j)) pymol.cmd.quit() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/TPTdiagrams/GenerateTPTgraph.py",".py","2187","38","from msmbuilder import arglib from msmbuilder import plot_graph import numpy as np from scipy import io, sparse import sys import glob def run(Matrix, EqPops, ImageDir, Directed=False, EdgeScale=1, PopCutoff=0.01, EdgeCutoff=0.0, OutputFile='Graph.dot'): if ImageDir != 'none': pngs = glob.glob(ImageDir+'/*.png') else: pngs = None G = plot_graph.CreateNetwork(Matrix,EqPops,Directed=Directed,EdgeScale=EdgeScale,PopCutoff=PopCutoff,EdgeCutoff=EdgeCutoff,ImageList=pngs) plot_graph.PlotNetwork(G,OutputFile=OutputFile) if __name__ == ""__main__"": parser = arglib.ArgumentParser(description="""""" Draws a representation of your MSM and draws a graph corresponding to it. This graph is written as a .dot file, which can be read by many common graph utilities. Read in MSM info as a counts, transition, or net flux matrix. Note: You need networkx and either Graphviz & PyGraphviz or pydot to get this utility working. To get the graph the way you want it to look, you might want to open up this script and play with some default parameters (EdgeScale=1, PopCutoff=0.01, EdgeCutoff=0.1) in the run() function.\n\n"""""") parser.add_argument('tmat', description='Name of the matric to represent as a graph. Can be counts, transition, or net flux matrix. Should be in .mtx format') parser.add_argument('populations', description='Populations file', default='Populations.dat') parser.add_argument('directed', description='Make the graph directed (if, e.g., a net flux matrix)', action='store_true', default=False) parser.add_argument('input', description=""Directory containing node impages generated by 'RenderStateImages.py' that will be associated with the graph (optional)"", default='none') parser.add_argument('output', description='Name of the dot file to write.', default='Graph.dot') parser.add_argument('epsilon', description='Cutoff for merging SL states.', default=0.1, type=float) args = parser.parse_args() print args matrix = io.mmread(args.tmat) populations = np.loadtxt(args.populations, dtype=float) run(matrix, populations, args.input, Directed=args.directed, OutputFile=args.output, PopCutoff=args.epsilon) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/TPTdiagrams/RenderStateImages.py",".py","3424","108",""""""" Reads in a 'PDBs' directory generated by SavePDBs.py and generates some images that represent the conformations of molecules in each state. THIS SCRIPT IS RUN FROM *WITHIN* PYMOL. While an external interface is possible and desirable, it requires a specific install of PyMol on some systems. This should be much more general. Note that you probably want to play around with the parameters in the RenderImage() function to get things looking right. Example workflow to get some pretty images: (1) Save PBSs from states that you care about using SavePDBs.py (choose many confs, they become nice backgrounds) (2) Open PyMol (3) Run, in the command line: > run GenerateStateFigure.py > gen_state_fig , , where ""aligned pdb"" is a PDB file of your molecule that is appropriately aligned for visual effect. All structures will get aligned to this structure by an RMSD minimization calculation, but this aligned/reference structure will not appear in the final image. """""" #import Trajectory import sys import os import re import glob from pymol import cmd def RenderImage(files, index, reference, OutDir): """"""This function issues commands to pymol. Alter these commands to change what the final output looks like. Note that 'reference' is a reference structure that allows you to align everything to that structure"""""" cmd.do('reinitialize') cmd.do('set_color lblue= [0.86 , 1.00 , 1.00]') for i,f in enumerate(files): cmd.load(f, 'Structure%d'%i) cmd.load(f, 'Overlay') cmd.load(reference, 'Reference') cmd.hide('all') cmd.do('dss') cmd.do('bg white') cmd.do('show cartoon, Overlay') cmd.fit('Overlay', 'Reference') cmd.fit('Structure0', 'Reference') for i in range(len(files)): cmd.do('show cartoon, Structure%d'%i) cmd.fit('Structure%d'%i, 'Structure0') cmd.do('color lblue, Structure%d'%i) cmd.do('set cartoon_transparency, 0.5, Structure%d'%i) cmd.do('spectrum count, rainbow, Overlay') cmd.do('translate [0,0,10], Overlay') cmd.do('ray') cmd.do('png %s/State%d'% (OutDir, index)) return def run(InDir, RefStruct, OutDir): # Check output paths if os.path.exists(OutDir): print ""Error: Directory %s already exists! Exiting."" % OutDir sys.exit(1) os.mkdir(OutDir) print ""Created %s and wrote png files there"" % OutDir # Parse directory ref_path = os.path.abspath(RefStruct) print ""Looking in %s"" % InDir states=[] files = glob.glob(InDir+""/State*-*.pdb"") for f in files: state = int( re.findall(""State(\d+)-\d+.pdb"", f)[0] ) if state not in states: states.append(state) for state in states: pdbs=glob.glob(InDir+'/State%d-*.pdb'%state) RenderImage(pdbs, state, ref_path, OutDir) print ""Finished rendering all images."" return print """"""\nReads in a 'PDBs' directory generated by SavePDBs.py and generates a png figure representing each state in each cluster. Also takes a reference structure, which should be manually aligned and saved in some appealing conformation. All saved figures will be aligned to this reference strucutre. NOTE: This script can be VERY RESOURCE INTENSIVE since it has to ray-trace many images usage syntax: 'gen_state_fig , , '"""""" cmd.extend('gen_state_fig', run) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/setup.py",".py","904","26","import os, sys import numpy from glob import glob from setuptools import setup, Extension _lprmsd = Extension('_lprmsd', sources = glob('src/*.c'), extra_compile_args = [""-std=c99"",""-O2"", ""-msse2"",""-msse3"",""-Wno-unused"",""-fopenmp"",""-m64""], # If you are 32-bit you should remove the -m64 flag extra_link_args = ['-lblas', '-lpthread', '-lm', '-lgomp'], include_dirs = [numpy.get_include(), os.path.join(numpy.get_include(), 'numpy')]) setup(name='msmbuilder.metrics.lprmsd', version='1.2', py_modules = ['lprmsd'], ext_modules = [_lprmsd], scripts=glob('scripts/*.py'), zip_safe=False, entry_points="""""" [msmbuilder.metrics] metric_class=lprmsd:LPRMSD add_metric_parser=lprmsd:add_metric_parser construct_metric=lprmsd:construct_metric """""") ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/lprmsd.py",".py","13612","324",""""""" Modified version of RMSD distance metric that does the following: 1) Returns the RMSD, rotation matrices, and aligned conformations 2) Permutes selected atomic indices. 3) Perform the alignment again. Sniffy """""" from msmbuilder.metrics import AbstractDistanceMetric from msmbuilder.metrics import RMSD import _lprmsd import mdtraj as md import numpy as np import itertools from scipy import optimize import copy import logging logger = logging.getLogger('LPRMSD') PT = {'H' : 1.0079, 'He' : 4.0026, 'Li' : 6.941, 'Be' : 9.0122, 'B' : 10.811, 'C' : 12.0107, 'N' : 14.0067, 'O' : 15.9994, 'F' : 18.9984, 'Ne' : 20.1797, 'Na' : 22.9897, 'Mg' : 24.305, 'Al' : 26.9815, 'Si' : 28.0855, 'P' : 30.9738, 'S' : 32.065, 'Cl' : 35.453, 'Ar' : 39.948, 'K' : 39.0983, 'Ca' : 40.078, 'Sc' : 44.9559, 'Ti' : 47.867, 'V' : 50.9415, 'Cr' : 51.9961, 'Mn' : 54.938, 'Fe' : 55.845, 'Co' : 58.9332, 'Ni' : 58.6934, 'Cu' : 63.546, 'Zn' : 65.39, 'Ga' : 69.723, 'Ge' : 72.64, 'As' : 74.9216, 'Se' : 78.96, 'Br' : 79.904, 'Kr' : 83.8, 'Rb' : 85.4678, 'Sr' : 87.62, 'Y' : 88.9059, 'Zr' : 91.224, 'Nb' : 92.9064, 'Mo' : 95.94, 'Tc' : 98, 'Ru' : 101.07, 'Rh' : 102.9055, 'Pd' : 106.42, 'Ag' : 107.8682, 'Cd' : 112.411, 'In' : 114.818, 'Sn' : 118.71, 'Sb' : 121.76, 'Te' : 127.6, 'I' : 126.9045, 'Xe' : 131.293, 'Cs' : 132.9055, 'Ba' : 137.327, 'La' : 138.9055, 'Ce' : 140.116, 'Pr' : 140.9077, 'Nd' : 144.24, 'Pm' : 145, 'Sm' : 150.36, 'Eu' : 151.964, 'Gd' : 157.25, 'Tb' : 158.9253, 'Dy' : 162.5, 'Ho' : 164.9303, 'Er' : 167.259, 'Tm' : 168.9342, 'Yb' : 173.04, 'Lu' : 174.967, 'Hf' : 178.49, 'Ta' : 180.9479, 'W' : 183.84, 'Re' : 186.207, 'Os' : 190.23, 'Ir' : 192.217, 'Pt' : 195.078, 'Au' : 196.9665, 'Hg' : 200.59, 'Tl' : 204.3833, 'Pb' : 207.2, 'Bi' : 208.9804, 'Po' : 209, 'At' : 210, 'Rn' : 222, 'Fr' : 223, 'Ra' : 226, 'Ac' : 227, 'Th' : 232.0381, 'Pa' : 231.0359, 'U' : 238.0289, 'Np' : 237, 'Pu' : 244, 'Am' : 243, 'Cm' : 247, 'Bk' : 247, 'Cf' : 251, 'Es' : 252, 'Fm' : 257, 'Md' : 258, 'No' : 259, 'Lr' : 262, 'Rf' : 261, 'Db' : 262, 'Sg' : 266, 'Bh' : 264, 'Hs' : 277, 'Mt' : 268 } def ReadPermFile(fnm): LL = [] L = [] K = [] fopen = open(fnm).readlines() for ln, line in enumerate(fopen): s = line.strip() if '--' not in s: L.append(int(s)) if (ln != 0 and '--' in s) or (ln == len(fopen) - 1): LL.append(np.array(L)) if len(s.split()) > 1: try: K.append(int(s.split()[1])) except: logger.error(""The syntax of this line is incorrect: %s"", line) else: K.append(len(L)) L = [] else: continue return (LL, K) class LPTraj(dict): def __init__(self, S, atomindices=None, permuteindices=None): super(LPTraj, self).__init__() self['XYZList'] = S.xyz aidx = list(atomindices) if atomindices != None else [] pidx = list(itertools.chain(*permuteindices)) if permuteindices != None else [] if atomindices == None: self.TD = RMSD.TheoData(S.xyz) else: self.TD = RMSD.TheoData(S.xyz[:, np.array(aidx)]) def __getitem__(self, key): if isinstance(key, int) or isinstance(key, slice) or isinstance(key, np.ndarray): if isinstance(key, int): key = [key] newtraj = copy.copy(self) newtraj['XYZList'] = self['XYZList'][key] newtraj.TD = self.TD[key] return newtraj return super(LPTraj, self).__getitem__(key) def EulerMatrix(T1, T2, T3): DMat = np.mat(np.zeros((3, 3), dtype=float)) DMat[0, 0] = np.cos(T1) DMat[0, 1] = np.sin(T1) DMat[1, 0] = -np.sin(T1) DMat[1, 1] = np.cos(T1) DMat[2, 2] = 1 CMat = np.mat(np.zeros((3, 3), dtype=float)) CMat[0, 0] = 1 CMat[1, 1] = np.cos(T2) CMat[1, 2] = np.sin(T2) CMat[2, 1] = -np.sin(T2) CMat[2, 2] = np.cos(T2) BMat = np.mat(np.zeros((3, 3), dtype=float)) BMat[0, 0] = np.cos(T3) BMat[0, 1] = np.sin(T3) BMat[1, 0] = -np.sin(T3) BMat[1, 1] = np.cos(T3) BMat[2, 2] = 1 EMat = BMat * CMat * DMat return np.mat(EMat) def AlignToMoments(elem, xyz1, xyz2=None): """"""Pre-aligns molecules to 'moment of inertia'. If xyz2 is passed in, it will assume that xyz1 is already aligned to the moment of inertia, and it simply does 180-degree rotations to make sure nothing is inverted."""""" xyz = xyz1 if xyz2 == None else xyz2 I = np.zeros((3, 3)) for ei, xi in zip(elem, xyz): I += PT[ei] * (np.dot(xi, xi) * np.eye(3) - np.outer(xi, xi)) A, B = np.linalg.eig(I) # Sort eigenvectors by eigenvalue BB = B[:, np.argsort(A)] determ = np.linalg.det(BB) Thresh = 1e-3 if np.abs(determ - 1.0) > Thresh: if np.abs(determ + 1.0) > Thresh: logger.error(""AHOOGA, determinant is % .3f"", determ) BB[:, 2] *= -1 xyzr = np.array(np.mat(BB).T * np.mat(xyz).T).T.copy() if xyz2 != None: xyzrr = AlignToDensity(elem, xyz1, xyzr, binary=True) return xyzrr else: return xyzr def ComputeOverlap(theta, elem, xyz1, xyz2): """""" Computes an 'overlap' between two molecules based on some fictitious density. Good for fine-tuning alignment but gets stuck in local minima. """""" xyz2R = np.array(EulerMatrix(theta[0], theta[1], theta[2]) * np.mat(xyz2.T)).T Obj = 0.0 for i in set(elem): for j in np.where(elem == i)[0]: for k in np.where(elem == i)[0]: dx = xyz1[j] - xyz2R[k] dx2 = np.dot(dx, dx) Obj -= np.exp(-0.5 * dx2) return Obj def AlignToDensity(elem, xyz1, xyz2, binary=False): """""" Pre-aligns molecules to some density. I don't really like this, but I have to start with some alignment and a grid scan just plain sucks. This function can be called by AlignToMoments to get rid of inversion problems """""" t0 = np.array([0, 0, 0]) if binary: t1 = optimize.brute(ComputeOverlap, ((0, np.pi), (0, np.pi), (0, np.pi)), args=(elem, xyz1, xyz2), Ns=2, finish=optimize.fmin_bfgs) else: t1 = optimize.brute(ComputeOverlap, ((0, 2 * np.pi), (0, 2 * np.pi), (0, 2 * np.pi)), args=(elem, xyz1, xyz2), Ns=6, finish=optimize.fmin_bfgs) xyz2R = (np.array(EulerMatrix(t1[0], t1[1], t1[2]) * np.mat(xyz2.T)).T).copy() return xyz2R class LPRMSD(AbstractDistanceMetric): def __init__(self, atomindices=None, permuteindices=None, altindices=None, moments=False, gridmesh=0, debug=False): self.atomindices = atomindices self.altindices = altindices if permuteindices != None: self.permuteindices = permuteindices[0] self.permutekeep = permuteindices[1] else: self.permuteindices = None self.permutekeep = None self.grid = None self.moments = moments self.debug = debug if gridmesh > 0: # Generate a list of Euler angles self.grid = list(itertools.product(*[list(np.arange(0, 2 * np.pi, 2 * np.pi / gridmesh)) for i in range(gridmesh)])) def _compute_one_to_all(self, pt1, pt2, index1, b_xyzout=False): #=========================================# # Required information # #=========================================# # Two prepared trajectories # A list of lists of permutable indices # A list of nonpermutable indices (aka the AtomIndices) # Boolean of whether to do the grid scan if self.atomindices == None and self.permuteindices == None: self.atomindices = np.arange(pt2['XYZList'].shape[1]) Usage = 0 pi_flat = np.array([]) pi_lens = np.array([]) pi_keep = np.array([]) alt_idx = np.array([]) id_idx = np.array([]) if self.atomindices != None: Usage += 1000 id_idx = np.array(self.atomindices) if self.permuteindices != None: Usage += 100 pi_flat = np.array(list(itertools.chain(*self.permuteindices))) pi_lens = np.array([len(i) for i in self.permuteindices]) pi_keep = np.array(self.permutekeep) if self.altindices != None: Usage += 10 alt_idx = np.array(self.altindices) if b_xyzout : Usage += 1 XYZOut = pt2['XYZList'].transpose(0, 2, 1).copy().astype('float32') XYZRef = pt1['XYZList'].transpose(0, 2, 1)[index1].copy().astype('float32') RotOut = np.zeros(len(pt2) * 9, dtype='float32') RMSDOut = _lprmsd.LPRMSD_Multipurpose(Usage, self.debug, pt1.TD.NumAtoms, pt1.TD.NumAtomsWithPadding, pt1.TD.NumAtomsWithPadding, pt2.TD.XYZData, pt1.TD.XYZData[index1], pt2.TD.G, pt1.TD.G[index1], id_idx, pi_flat, pi_lens, pi_keep, alt_idx, RotOut, XYZOut, XYZRef) if b_xyzout: return RMSDOut, XYZOut.transpose(0, 2, 1) else: return RMSDOut def one_to_all_aligned(self, prepared_traj1, prepared_traj2, index1): """""" Inputs: Two trajectories (Unlike RMSD, this takes in raw trajectory files) Calculate a vector of distances from the index1th frame of prepared_traj1 to all the frames in prepared_traj2. This always uses OMP parallelization. If you really don't want OMP paralellization (why not?), then you can modify the C code yourself. Returns: a vector of distances of length len(indices2)"""""" return self._compute_one_to_all(prepared_traj1, prepared_traj2, index1, b_xyzout=True) def prepare_trajectory(self, trajectory): """""" Copies the trajectory and optionally performs pre-alignment using moments of inertia. """""" T1 = LPTraj(trajectory, self.atomindices, self.permuteindices) if self.moments: xyz1 = trajectory.xyz[0] xyz1 -= xyz1.mean(0) # TODO: Change this to mdtraj. # Should I construct a list of atom names or try to be fancy # and use a pandas dataframe xyz1 = AlignToMoments(trajectory['AtomNames'], xyz1) for index2, xyz2 in enumerate(trajectory['XYZList']): xyz2 -= xyz2.mean(0) xyz2 = AlignToMoments(trajectory['AtomNames'], xyz1, xyz2) T1['XYZList'][index2] = xyz2 else: for index, xyz in enumerate(trajectory.xyz): if not self.atomindices is None: xsel = xyz[np.array(self.atomindices), :] else: xsel = xyz xyz -= xsel.mean(0) T1['XYZList'][index] = xyz.copy() return T1 def one_to_all(self, prepared_traj1, prepared_traj2, index1): """""" Inputs: Two trajectories (Unlike RMSD, this takes in raw trajectory files) Calculate a vector of distances from the index1th frame of prepared_traj1 to all the frames in prepared_traj2. This always uses OMP parallelization. If you really don't want OMP paralellization (why not?), then you can modify the C code yourself. Returns: a vector of distances of length len(indices2)"""""" return self._compute_one_to_all(prepared_traj1, prepared_traj2, index1, b_xyzout=False) def add_metric_parser(parsergroup, add_argument): lprmsd = parsergroup.add_parser('lprmsd', description='''LPRMSD: RMSD with the ability to to handle permutation-invariant atoms. Solves the assignment problem using a linear programming solution (LP). Can handle aligning on some atoms and computing the RMSD on other atoms.:''') add_argument(lprmsd, '-a', dest='lprmsd_atom_indices', help='Regular atom indices. Pass ""all"" to use all atoms.', default='AtomIndices.dat') add_argument(lprmsd, '-l', dest='lprmsd_alt_indices', default=None, help='''Optional alternate atom indices for RMSD. If you want to align the trajectories using one set of atom indices but then compute the distance using a different set of indices, use this option. If supplied, the regular atom_indices will be used for the alignment and these indices for the distance calculation''') add_argument(lprmsd, '-P', dest='lprmsd_permute_atoms', default=None, help='''Atom labels to be permuted. Sets of indistinguishable atoms that can be permuted to minimize the RMSD. On disk this should be stored as a list of newline separated indices with a ""--"" separating the sets of indices if there are more than one set of indistinguishable atoms. Use ""-- (integer)"" to include a subset in the RMSD (to avoid undesirable boundary effects.)''') return lprmsd def construct_metric(args): if args.metric != 'lprmsd': return None if args.lprmsd_atom_indices != 'all': atom_inds = np.loadtxt(args.lprmsd_atom_indices, dtype=np.int) else: atom_inds = None if args.lprmsd_permute_atoms is not None: permute_inds = ReadPermFile(args.lprmsd_permute_atoms) else: permute_inds = None if args.lprmsd_alt_indices is not None: alt_inds = np.loadtxt(args.lprmsd_alt_indices, np.int) else: alt_inds = None return LPRMSD(atom_inds, permute_inds, alt_inds) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/src/apc.c",".c","8512","373","/* SOLUTION OF THE LINEAR MIN-SUM ASSIGNMENT PROBLEM. HUNGARIAN METHOD. COMPLEXITY O(n^3). October 2008: - Original FORTRAN code translated in C LANGUAGE by Andrea Tramontani Andrea Tramontani DEIS, University of Bologna Viale Risorgimento, 2 40136 - Bologna (Italy) - All the data are assumed to be integral */ #include #include #include ""apc.h"" void init(int n,int *a,int *f,int *u,int *v,int *fb,int *p,int INF,int *m_p); void path(int n,int *a,int *f,int *u,int *v,int *fb,int *rc,int *pi,int *lr,int *uc,int INF,int ii,int *jj_p); void incr(int *f,int *fb,int *rc,int j); /* SOLUTION OF THE LINEAR MIN-SUM ASSIGNMENT PROBLEM. HUNGARIAN METHOD. COMPLEXITY O(n^3). MEANING OF THE INPUT PARAMETERS: n = NUMBER OF ROWS AND COLUMNS OF THE COST MATRIX. a[i][j] = COST OF THE ASSIGNMENT OF ROW i TO COLUMN j . INF = A VERY LARGE INTEGER VALUE, SETTED BY THE USER ACCORDING TO THE CHARACTERISTICS OF THE USED MACHINE. INF IS THE ONLY MACHINE-DEPENDENT CONSTANT USED AND IT MUST BE STRICTLY GREATER THAN THE MAXIMUM ASSIGNMENT COST (E.G., INF MUST BE STRICTLY GREATER THAN THE MAXIMUM VALUE OF THE COST MATRIX a). ON RETURN, THE INPUT PARAMETERS ARE UNCHANGED. MEANING OF THE OUTPUT PARAMETERS: f[i] = COLUMN ASSIGNED TO ROW i . z_p = COST OF THE OPTIMAL ASSIGNMENT = = a[0][f[0]] + a[1][f[1]] + ... + a[n-1][f[n-1]] . RETURN VALUE: 0, IF THE PROBLEM HAS BEEN SOLVED AND THE OUTPUT PARAMETERS HAVE BEEN PROPERLY SETTED -1, IF THE PROBLEM HAS NOT BEEN SOLVED DUE TO A MEMORY ISSUE (NOT ENOUGH AVAILABLE MEMORY) ALL THE PARAMETERS ARE INTEGERS. VECTOR f MUST BE DIMENSIONED AT LEAST AT n , MATRIX a AT LEAST AT (n,n) . THE CODE IS BASED ON THE HUNGARIAN METHOD AS DESCRIBED BY LAWLER (COMBINATORIAL OPTIMIZATION : NETWORKS AND MATROIDS, HOLT, RINEHART AND WINSTON, NEW YORK, 1976). THE ALGORITHMIC PASCAL-LIKE DESCRIPTION OF THE CODE IS GIVEN IN G.CARPANETO, S.MARTELLO AND P.TOTH, ALGORITHMS AND CODES FOR THE ASSIGNMENT PROBLEM, ANNALS OF OPERATIONS RESEARCH XX, 1988. SUBROUTINE APC DETERMINES THE INITIAL DUAL AND PARTIAL PRIMAL SOLUTIONS AND THEN SEARCHES FOR AUGMENTING PATHS UNTIL ALL ROWS AND COLUMNS ARE ASSIGNED. MEANING OF THE MAIN INTERNAL VARIABLES: fb[j] = ROW ASSIGNED TO COLUMN j . m = NUMBER OF INITIAL ASSIGNMENTS. u[i] = DUAL VARIABLE ASSOCIATED WITH ROW i . v[j] = DUAL VARIABLE ASSOCIATED WITH COLUMN j . APC NEEDS THE FOLLOWING SUBROUTINES: incr init path QUESTIONS AND COMMENTS SHOULD BE DIRECTED TO G. CARPANETO, S.MARTELLO AND P.TOTH DIPARTIMENTO DI ELETTRONICA, INFORMATICA E SISTEMISTICA UNIVERSITA' DI BOLOGNA, VIALE RISORGIMENTO 2 40136 BOLOGNA (ITALY) THIS WORK WAS SUPPORTED BY C.N.R. , ITALY. */ int apc(int n,int *a,int INF,int *z_p,int *f) { int i,j,k,m,*u,*v,*fb,*rc,*pi,*lr,*uc; /* Memory allocation All the memory required by the method and by the subroutines is here allocated If not enough memory is available, the method returns -1 */ u=(int*)malloc(n*sizeof(int)); if(u==NULL) { return -1; } v=(int*)malloc(n*sizeof(int)); if(v==NULL) { free(u); return -1; } fb=(int*)malloc(n*sizeof(int)); if(fb==NULL) { free(u); free(v); return -1; } rc=(int*)malloc(n*sizeof(int)); if(rc==NULL) { free(u); free(v); free(fb); return -1; } pi=(int*)malloc(n*sizeof(int)); if(pi==NULL) { free(u); free(v); free(fb); free(rc); return -1; } lr=(int*)malloc(n*sizeof(int)); if(lr==NULL) { free(u); free(v); free(fb); free(rc); free(pi); return -1; } uc=(int*)malloc(n*sizeof(int)); if(uc==NULL) { free(u); free(v); free(fb); free(rc); free(pi); free(lr); return -1; } //SEARCH FOR THE INITIAL DUAL AND PARTIAL PRIMAL SOLUTIONS. init(n,a,f,u,v,fb,rc,INF,&m); //SOLUTION OF THE REDUCED PROBLEM. if(m!=n) { for(i=0;i=0); }//incr() /* SEARCH FOR THE INITIAL DUAL AND PARTIAL PRIMAL SOLUTIONS. p[i] = FIRST UNSCANNED COLUMN OF ROW i . */ void init(int n,int *a,int *f,int *u,int *v,int *fb,int *p,int INF,int *m_p) { int i,j,jmin,k,kk,r,min,m,ia,skip; //PHASE 1 . m = 0; for(k=0;k=0) ) { min=ia; j=k; } } u[i]=min; jmin=j; if(fb[j]>=0) { skip=0; for(j=jmin;j pi[j]) min=pi[j]; } for(l=0;l #include #include ""cblas.h"" #include ""cblas_f77.h"" #define XerblaStrLen 6 #define XerblaStrLen1 7 #ifdef F77_CHAR void F77_xerbla(F77_CHAR F77_srname, void *vinfo) #else void F77_xerbla(char *srname, void *vinfo) #endif { #ifdef F77_CHAR char *srname; #endif char rout[] = {'c','b','l','a','s','_','\0','\0','\0','\0','\0','\0','\0'}; #ifdef F77_INT F77_INT *info=vinfo; F77_INT i; #else int *info=vinfo; int i; #endif extern int CBLAS_CallFromC; #ifdef F77_CHAR srname = F2C_STR(F77_srname, XerblaStrLen); #endif if (CBLAS_CallFromC) { for(i=0; i != XerblaStrLen; i++) rout[i+6] = tolower(srname[i]); rout[XerblaStrLen+6] = '\0'; cblas_xerbla(*info+1,rout,""""); } else { fprintf(stderr, ""Parameter %d to routine %s was incorrect\n"", *info, srname); } } ","C" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/src/cblas_xerbla.c",".c","1666","68","#include #include #include #include #include ""cblas.h"" #include ""cblas_f77.h"" void cblas_xerbla(int info, const char *rout, const char *form, ...) { extern RowMajorStrg; va_list argptr; va_start(argptr, form); if (RowMajorStrg) { if (strstr(rout,""gemm"") != 0) { if (info == 5 ) info = 4; else if (info == 4 ) info = 5; else if (info == 11) info = 9; else if (info == 9 ) info = 11; } else if (strstr(rout,""symm"") != 0 || strstr(rout,""hemm"") != 0) { if (info == 5 ) info = 4; else if (info == 4 ) info = 5; } else if (strstr(rout,""trmm"") != 0 || strstr(rout,""trsm"") != 0) { if (info == 7 ) info = 6; else if (info == 6 ) info = 7; } else if (strstr(rout,""gemv"") != 0) { if (info == 4) info = 3; else if (info == 3) info = 4; } else if (strstr(rout,""gbmv"") != 0) { if (info == 4) info = 3; else if (info == 3) info = 4; else if (info == 6) info = 5; else if (info == 5) info = 6; } else if (strstr(rout,""ger"") != 0) { if (info == 3) info = 2; else if (info == 2) info = 3; else if (info == 8) info = 6; else if (info == 6) info = 8; } else if ( (strstr(rout,""her2"") != 0 || strstr(rout,""hpr2"") != 0) && strstr(rout,""her2k"") == 0 ) { if (info == 8) info = 6; else if (info == 6) info = 8; } } if (info) fprintf(stderr, ""Parameter %d to routine %s was incorrect\n"", info, rout); vfprintf(stderr, form, argptr); va_end(argptr); if (info && !info) F77_xerbla("""", &info); /* Force link of our F77 error handler */ exit(-1); } ","C" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/src/theobald_rmsd.c",".c","14965","513","// This file is part of MSMBuilder. // // Copyright 2011 Stanford University // // MSMBuilder is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // //============================================================================================= // Calculation of RMSD by a the quaternion-based characteristic polynomial (QCP) algorithm of Theobald [1]. // // [1] Theobald DL. Rapid calculation of RMSDs using a quaternion-based characteristic polynomial. // Acta Cryst., A61:478, 2005. doi:10.1107/50108767305015266 // // Written by John D. Chodera , Dill lab, UCSF, 2006. // Contributions in 2010 from: // Kyle Beauchamp(kyleb@stanford.edu) // Peter Kasson (kasson@stanford.edu) // Kai Kohlhoff (kohlhoff@stanford.edu) // Imran Haque (ihaque@cs.stanford.edu) //============================================================================================= #include #include ""theobald_rmsd.h"" #include ""qcprot.h"" #include #include #ifdef __SSE3__ #include #endif #ifndef max #define max( a, b ) ( ((a) > (b)) ? (a) : (b) ) #endif /*------------------------------------------------------------------------------ * The quartic and cubic functions are taken from: * FILE: quartic.c * * AUTHOR: Jonathan Zrake, NYU CCPP: zrake@nyu.edu * Adapted from the nvwa code by Weiqun Zhang * Modified by KAB 2011 * GPLv2 / LGPL exemption from Jonathan Zrake, Aug. 2, 2011 * Original code from http://code.google.com/p/python-mhd/ *------------------------------------------------------------------------------ */ int quartic_equation_solve_exact(double *r1, double *r2, double *r3, double *r4, int *nr12, int *nr34,double d0,double d1,double d2, double d3, double d4) { double a3 = d3/d4; double a2 = d2/d4; double a1 = d1/d4; double a0 = d0/d4; double au2 = -a2; double au1 = (a1*a3 - 4.0*a0) ; double au0 = 4.0*a0*a2 - a1*a1 - a0*a3*a3; double x1, x2, x3; int nr = solve_cubic_equation(1.0, au2, au1, au0, &x1, &x2, &x3); double u1; if (nr==1) u1 = x1; else u1 = (x1>x3) ? x1 : x3; double R2 = 0.25*a3*a3 + u1 - a2; double R = (R2>0.0) ? sqrt(R2) : 0.0; double D2, E2; if (R != 0.0) { double foo1 = 0.75*a3*a3 - R2 - 2.0*a2; double foo2 = 0.25*(4.0*a3*a2 - 8.0*a1 - a3*a3*a3) / R; D2 = foo1 + foo2; E2 = foo1 - foo2; } else { double foo1 = 0.75*a3*a3 - 2.0*a2; double foo2 = 2.0 * sqrt(u1*u1 - 4.0*a0); D2 = foo1 + foo2; E2 = foo1 - foo2; } if (D2 >= 0.0) { double D = sqrt(D2); *r1 = -0.25*a3 + 0.5*R - 0.5*D; *r2 = -0.25*a3 + 0.5*R + 0.5*D; *nr12 = 2; } else { *r1 = *r2 = -0.25*a3 + 0.5*R; *nr12 = 0; } if (E2 >= 0.0) { double E = sqrt(E2); *r3 = -0.25*a3 - 0.5*R - 0.5*E; *r4 = -0.25*a3 - 0.5*R + 0.5*E; *nr34 = 2; } else { *r3 = *r4 = -0.25*a3 - 0.5*R; *nr34 = 0; } return *nr12 + *nr34; } int solve_cubic_equation(double c3, double c2, double c1, double c0, double *x1, double *x2, double *x3) { double a2 = c2/c3; double a1 = c1/c3; double a0 = c0/c3; double q = a1/3.0 - a2*a2/9.0; double r = (a1*a2 - 3.0*a0)/6.0 - a2*a2*a2 / 27.0; double delta = q*q*q + r*r; if (delta>0.0) { double s1 = r + sqrt(delta); s1 = (s1>=0.0) ? pow(s1,1./3.) : -pow(-s1,1./3.); double s2 = r - sqrt(delta); s2 = (s2>=0.0) ? pow(s2,1./3.) : -pow(-s2,1./3.); *x1 = (s1+s2) - a2/3.0; *x2 = *x3 = -0.5 * (s1+s2) - a2/3.0; return 1; } else if (delta < 0.0) { double theta = acos(r/sqrt(-q*q*q)) / 3.0; double costh = cos(theta); double sinth = sin(theta); double sq = sqrt(-q); *x1 = 2.0*sq*costh - a2/3.0; *x2 = -sq*costh - a2/3.0 - sqrt(3.) * sq * sinth; *x3 = -sq*costh - a2/3.0 + sqrt(3.) * sq * sinth; return 3; } else { double s = (r>=0.0) ? pow(r,1./3.) : -pow(-r,1./3.); *x1 = 2.0*s - a2/3.0; *x2 = *x3 = -s - a2/3.0; return 3; } } float DirectSolve(float lambda, float C_0, float C_1, float C_2) { double result; double r1,r2,r3,r4; int nr1,nr2; quartic_equation_solve_exact(&r1,&r2,&r3,&r4,&nr1,&nr2,(double )C_0,(double)C_1,(double)C_2,0.0,1.0); result=max(r1,r2); result=max(result,r3); result=max(result,r4); return(result); } float NewtonSolve(float lambda, float C_0, float C_1, float C_2) { unsigned int maxits = 500; float tolerance = 1.0e-6f; float lambda_old,lambda2; float a,b; for (int i = 0; i < maxits; i++) { lambda_old = lambda; lambda2 = lambda_old * lambda_old; b = (lambda2 + C_2) * lambda_old; a = b + C_1; lambda = lambda_old - (a * lambda_old + C_0) / (2.0f * lambda2 * lambda_old + b + a); if (fabsf(lambda - lambda_old) < fabsf(tolerance * lambda)) break; } if (fabsf(lambda - lambda_old) >= fabsf(100*tolerance * lambda)) { printf(""RMSD Warning: No convergence after %d iterations: Lambda,Lambda0,Diff,Allowed = %f, %f, %f, %f \n"",maxits,lambda, lambda_old, fabsf(lambda - lambda_old), fabsf(tolerance * lambda) ); } return(lambda); } float rmsd2FromMandG(const float M[9],const float G_x,const float G_y,const int numAtoms) { // DEV: still too many glob mem accesses, can reduce this const int m = 3; float k00 = M[0+0*m ] + M[1+1*m] + M[2+2*m]; // [0, 0] float k01 = M[1+2*m ] - M[2+1*m]; // [0, 1] float k02 = M[2+0*m ] - M[0+2*m]; // [0, 2] float k03 = M[0+1*m ] - M[1+0*m]; // [0, 3] float k11 = M[0+0*m ] - M[1+1*m] - M[2+2*m]; // [1, 1] float k12 = M[0+1*m ] + M[1+0*m]; // [1, 2] float k13 = M[2+0*m ] + M[0+2*m]; // [1, 3] float k22 = -M[0+0*m ] + M[1+1*m] - M[2+2*m]; // [2, 2] float k23 = M[1+2*m ] + M[2+1*m]; // [2, 3] float k33 = -M[0+0*m ] - M[1+1*m] + M[2+2*m]; // [3, 3] // float C_4 = 1.0, C_3 = 0.0; float detM = 0.0f, detK = 0.0f; float C_2, C_1, C_0; float lambda = (G_x + G_y) / 2.0f; float rmsd2,ls_rmsd2; C_2 = 0.0f; for (int i = 0; i < m * m; i++) { C_2 += M[i] * M[i]; } C_2 *= -2.0f; // get determinante M // could use rule of Sarrus, but better: // computationally more efficient with Laplace expansion detM = M[0] * (M[4] * M[8] - M[5] * M[7]) + M[3] * (M[7] * M[2] - M[8] * M[1]) + M[6] * (M[1] * M[5] - M[2] * M[4]); detK = k01*k01*k23*k23 - k22*k33*k01*k01 + 2*k33*k01*k02*k12 - 2*k01*k02*k13*k23 - 2*k01*k03*k12*k23 + 2*k22*k01*k03*k13 + k02*k02*k13*k13 - k11*k33*k02*k02 - 2*k02*k03*k12*k13 + 2*k11*k02*k03*k23 + k03*k03*k12*k12 - k11*k22*k03*k03 - k00*k33*k12*k12 + 2*k00*k12*k13*k23 - k00*k22*k13*k13 - k00*k11*k23*k23 + k00*k11*k22*k33; C_1 = -8.0f * detM; C_0 = detK; lambda=DirectSolve(lambda, C_0,C_1,C_2); rmsd2 = (G_x + G_y - 2.0f * lambda) / numAtoms; ls_rmsd2 = 0.0f; if (rmsd2 > 0.0f) ls_rmsd2 = rmsd2; return ls_rmsd2; } real ls_rmsd2_aligned_T_g(const int nrealatoms, const int npaddedatoms, const int rowstride, const float* aT, const float* bT, const real G_a, const real G_b, float *msd, int NeedMat, double *rot) { /* Structure setup for this function: * * structures are stored axis major, possibly with extra padding to ensure you * meet two constraints: * - the number of elements in a row must be a multiple of 4 * - the first element in each row must be aligned to a 16 byte boundary * * note that if you meet the second condition for the first row, and meet the * first condition, the alignment will automatically be satisfied for every row. * * the layout in memory for a structure of 7 atoms would look like this: * * x0 x1 x2 x3 x4 x5 x6 0 * y0 y1 y2 y3 y4 y5 y6 0 * z0 z1 z2 z3 z4 z5 z6 0 * * if your structure has a number of atoms that is not a multiple of 4, you must * pad it out to a multiple of 4 using zeros (using anything other than zero will * make the calculation go wrong). * * arguments: * nrealatoms: the *actual* number of atoms in the structure * * npaddedatoms: the number of atoms in the structure including padding atoms; * should equal nrealatoms rounded up to the next multiple of 4 * * rowstride: the offset in elements between rows in the arrays. will prob * be equal to npaddedatoms, but you might use something else if * (for example) you were subsetting the structure * * aT: pointer to start of first structure (A). should be aligned to * a 16-byte boundary * * bT: pointer to start of second structure (B). should be aligned to * a 16-byte boundary * * G_a: trace of A'A * * G_b: trace of B'B */ int nIndex; // Will have 3 garbage elements at the end float M[12] __attribute__ ((aligned (16))); const float* aTx = aT; const float* aTy = aT+rowstride; const float* aTz = aT+2*rowstride; const float* bTx = bT; const float* bTy = bT+rowstride; const float* bTz = bT+2*rowstride; // npaddedatoms must be a multiple of 4 int niters = npaddedatoms >> 2; __m128 xx,xy,xz,yx,yy,yz,zx,zy,zz; __m128 ax,ay,az,b; __m128 t0,t1,t2; // Prologue xx = _mm_xor_ps(xx,xx); xy = _mm_xor_ps(xy,xy); xz = _mm_xor_ps(xz,xz); yx = _mm_xor_ps(yx,yx); yy = _mm_xor_ps(yy,yy); yz = _mm_xor_ps(yz,yz); zx = _mm_xor_ps(zx,zx); zy = _mm_xor_ps(zy,zy); zz = _mm_xor_ps(zz,zz); for (int k = 0; k < niters; k++) { ax = _mm_load_ps(aTx); ay = _mm_load_ps(aTy); az = _mm_load_ps(aTz); b = _mm_load_ps(bTx); t0 = ax; t1 = ay; t2 = az; t0 = _mm_mul_ps(t0,b); t1 = _mm_mul_ps(t1,b); t2 = _mm_mul_ps(t2,b); xx = _mm_add_ps(xx,t0); yx = _mm_add_ps(yx,t1); zx = _mm_add_ps(zx,t2); b = _mm_load_ps(bTy); t0 = ax; t1 = ay; t2 = az; t0 = _mm_mul_ps(t0,b); t1 = _mm_mul_ps(t1,b); t2 = _mm_mul_ps(t2,b); xy = _mm_add_ps(xy,t0); yy = _mm_add_ps(yy,t1); zy = _mm_add_ps(zy,t2); b = _mm_load_ps(bTz); ax = _mm_mul_ps(ax,b); ay = _mm_mul_ps(ay,b); az = _mm_mul_ps(az,b); xz = _mm_add_ps(xz,ax); yz = _mm_add_ps(yz,ay); zz = _mm_add_ps(zz,az); aTx += 4; aTy += 4; aTz += 4; bTx += 4; bTy += 4; bTz += 4; } // Epilogue - reduce 4 wide vectors to one wide /*xmm07 = xx0 xx1 xx2 xx3 xmm08 = xy0 xy1 xy2 xy3 xmm09 = xz0 xz1 xz2 xz3 xmm10 = yx0 yx1 yx2 yx3 xmm11 = yy0 yy1 yy2 yy3 xmm12 = yz0 yz1 yz2 yz3 xmm13 = zx0 zx1 zx2 zx3 xmm14 = zy0 zy1 zy2 zy3 xmm15 = zz0 zz1 zz2 zz3 haddps xmm07 xmm08 xmm07 = xx0+1 xx2+3 xy0+1 xy2+3 haddps xmm09 xmm10 xmm09 = xz0+1 xz2+3 yx0+1 yx2+3 haddps xmm11 xmm12 xmm11 = yy0+1 yy2+3 yz0+1 yz2+3 haddps xmm13 xmm14 xmm13 = zx0+1 zx2+3 zy0+1 zy2+3 haddps xmm15 xmm14 xmm15 = zz0+1 zz2+3 zy0+1 zy2+3 haddps xmm07 xmm09 xmm07 = xx0123 xy0123 xz0123 yx0123 haddps xmm11 xmm13 xmm11 = yy0123 yz0123 zx0123 zy0123 haddps xmm15 xmm09 xmm15 = zz0123 zy0123 xz0123 yx0123*/ #ifdef __SSE3__ xx = _mm_hadd_ps(xx,xy); xz = _mm_hadd_ps(xz,yx); yy = _mm_hadd_ps(yy,yz); zx = _mm_hadd_ps(zx,zy); zz = _mm_hadd_ps(zz,zy); xx = _mm_hadd_ps(xx,xz); yy = _mm_hadd_ps(yy,zx); zz = _mm_hadd_ps(zz,xz); #else // Emulate horizontal adds using UNPCKLPS/UNPCKHPS t0 = xx; t1 = xx; t0 = _mm_unpacklo_ps(t0,xz); // = xx0 xz0 xx1 xz1 t1 = _mm_unpackhi_ps(t1,xz); // = xx2 xz2 xx3 xz3 t0 = _mm_add_ps(t0,t1); // = xx02 xz02 xx13 xz13 t1 = xy; t2 = xy; t1 = _mm_unpacklo_ps(t1,yx); // = xy0 yx0 xy1 yx1 t2 = _mm_unpackhi_ps(t2,yx); // = xy2 yx2 xy3 yx3 t1 = _mm_add_ps(t1,t2); // = xy02 yx02 xy13 yx13 xx = t0; xx = _mm_unpacklo_ps(xx,t1); // = xx02 xy02 xz02 yx02 t0 = _mm_unpackhi_ps(t0,t1); // = xx13 xy13 xz13 yx13 xx = _mm_add_ps(xx,t0); // = xx0123 xy0123 xz0123 yx0123 t0 = yy; t1 = yy; t0 = _mm_unpacklo_ps(t0,zx); // = yy0 zx0 yy1 zx1 t1 = _mm_unpackhi_ps(t1,zx); // = yy2 zx2 yy3 zx3 t0 = _mm_add_ps(t0,t1); // = yy02 zx02 yy13 zx13 t1 = yz; t2 = yz; t1 = _mm_unpacklo_ps(t1,zy); // = yz0 zy0 yz1 zy1 t2 = _mm_unpackhi_ps(t2,zy); // = yz2 zy2 yz3 zy3 t1 = _mm_add_ps(t1,t2); // = yz02 zy02 yz13 zy13 yy = t0; yy = _mm_unpacklo_ps(yy,t1); // = yy02 yz02 zx02 zy02 t0 = _mm_unpackhi_ps(t0,t1); // = yy13 yz13 zx13 zy13 yy = _mm_add_ps(yy,t0); // = yy0123 yz0123 zx0123 zy0123 t1 = _mm_movehl_ps(t1,zz); // = zz2 zz3 - - zz = _mm_add_ps(zz,t1); // = zz02 zz13 - - t1 = _mm_shuffle_ps(zz,zz,_MM_SHUFFLE(1,1,1,1)); // = zz13 zz13 zz13 zz13 zz = _mm_add_ps(zz,t1); // = zz0123 zz1133 - - #endif _mm_store_ps(M , xx); _mm_store_ps(M+4, yy); _mm_store_ps(M+8, zz); if (NeedMat) { double E0 = (G_a+G_b)/2; double M1[9]; double msd_d; for (int k=0; k<9; k++) { M1[k] = M[k]; } int success = FastCalcRMSDAndRotation(rot, M1, &msd_d, E0, nrealatoms, -1); *(msd) = msd_d; } else { *(msd) = rmsd2FromMandG(M,G_a,G_b,nrealatoms); } return 0; } ","C" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/src/cblas_f77.h",".h","29066","703","/* * cblas_f77.h * Written by Keita Teranishi * * Updated by Jeff Horner * Merged cblas_f77.h and cblas_fortran_header.h */ #ifndef CBLAS_F77_H #define CBLAS_f77_H #ifdef __cplusplus extern ""C"" { #endif #ifdef CRAY #include #define F77_CHAR _fcd #define C2F_CHAR(a) ( _cptofcd( (a), 1 ) ) #define C2F_STR(a, i) ( _cptofcd( (a), (i) ) ) #define F77_STRLEN(a) (_fcdlen) #endif #ifdef WeirdNEC #define F77_INT long #endif #ifdef F77_CHAR #define FCHAR F77_CHAR #else #define FCHAR char * #endif #ifdef F77_INT #define FINT const F77_INT * #define FINT2 F77_INT * #else #define FINT const int * #define FINT2 int * #endif #define ADD_ #if defined(ADD_) /* * Level 1 BLAS */ #define F77_xerbla xerbla_ #define F77_srotg srotg_ #define F77_srotmg srotmg_ #define F77_srot srot_ #define F77_srotm srotm_ #define F77_drotg drotg_ #define F77_drotmg drotmg_ #define F77_drot drot_ #define F77_drotm drotm_ #define F77_sswap sswap_ #define F77_scopy scopy_ #define F77_saxpy saxpy_ #define F77_isamax_sub isamaxsub_ #define F77_dswap dswap_ #define F77_dcopy dcopy_ #define F77_daxpy daxpy_ #define F77_idamax_sub idamaxsub_ #define F77_cswap cswap_ #define F77_ccopy ccopy_ #define F77_caxpy caxpy_ #define F77_icamax_sub icamaxsub_ #define F77_zswap zswap_ #define F77_zcopy zcopy_ #define F77_zaxpy zaxpy_ #define F77_izamax_sub izamaxsub_ #define F77_sdot_sub sdotsub_ #define F77_ddot_sub ddotsub_ #define F77_dsdot_sub dsdotsub_ #define F77_sscal sscal_ #define F77_dscal dscal_ #define F77_cscal cscal_ #define F77_zscal zscal_ #define F77_csscal csscal_ #define F77_zdscal zdscal_ #define F77_cdotu_sub cdotusub_ #define F77_cdotc_sub cdotcsub_ #define F77_zdotu_sub zdotusub_ #define F77_zdotc_sub zdotcsub_ #define F77_snrm2_sub snrm2sub_ #define F77_sasum_sub sasumsub_ #define F77_dnrm2_sub dnrm2sub_ #define F77_dasum_sub dasumsub_ #define F77_scnrm2_sub scnrm2sub_ #define F77_scasum_sub scasumsub_ #define F77_dznrm2_sub dznrm2sub_ #define F77_dzasum_sub dzasumsub_ #define F77_sdsdot_sub sdsdotsub_ /* * Level 2 BLAS */ #define F77_ssymv ssymv_ #define F77_ssbmv ssbmv_ #define F77_sspmv sspmv_ #define F77_sger sger_ #define F77_ssyr ssyr_ #define F77_sspr sspr_ #define F77_ssyr2 ssyr2_ #define F77_sspr2 sspr2_ #define F77_dsymv dsymv_ #define F77_dsbmv dsbmv_ #define F77_dspmv dspmv_ #define F77_dger dger_ #define F77_dsyr dsyr_ #define F77_dspr dspr_ #define F77_dsyr2 dsyr2_ #define F77_dspr2 dspr2_ #define F77_chemv chemv_ #define F77_chbmv chbmv_ #define F77_chpmv chpmv_ #define F77_cgeru cgeru_ #define F77_cgerc cgerc_ #define F77_cher cher_ #define F77_chpr chpr_ #define F77_cher2 cher2_ #define F77_chpr2 chpr2_ #define F77_zhemv zhemv_ #define F77_zhbmv zhbmv_ #define F77_zhpmv zhpmv_ #define F77_zgeru zgeru_ #define F77_zgerc zgerc_ #define F77_zher zher_ #define F77_zhpr zhpr_ #define F77_zher2 zher2_ #define F77_zhpr2 zhpr2_ #define F77_sgemv sgemv_ #define F77_sgbmv sgbmv_ #define F77_strmv strmv_ #define F77_stbmv stbmv_ #define F77_stpmv stpmv_ #define F77_strsv strsv_ #define F77_stbsv stbsv_ #define F77_stpsv stpsv_ #define F77_dgemv dgemv_ #define F77_dgbmv dgbmv_ #define F77_dtrmv dtrmv_ #define F77_dtbmv dtbmv_ #define F77_dtpmv dtpmv_ #define F77_dtrsv dtrsv_ #define F77_dtbsv dtbsv_ #define F77_dtpsv dtpsv_ #define F77_cgemv cgemv_ #define F77_cgbmv cgbmv_ #define F77_ctrmv ctrmv_ #define F77_ctbmv ctbmv_ #define F77_ctpmv ctpmv_ #define F77_ctrsv ctrsv_ #define F77_ctbsv ctbsv_ #define F77_ctpsv ctpsv_ #define F77_zgemv zgemv_ #define F77_zgbmv zgbmv_ #define F77_ztrmv ztrmv_ #define F77_ztbmv ztbmv_ #define F77_ztpmv ztpmv_ #define F77_ztrsv ztrsv_ #define F77_ztbsv ztbsv_ #define F77_ztpsv ztpsv_ /* * Level 3 BLAS */ #define F77_chemm chemm_ #define F77_cherk cherk_ #define F77_cher2k cher2k_ #define F77_zhemm zhemm_ #define F77_zherk zherk_ #define F77_zher2k zher2k_ #define F77_sgemm sgemm_ #define F77_ssymm ssymm_ #define F77_ssyrk ssyrk_ #define F77_ssyr2k ssyr2k_ #define F77_strmm strmm_ #define F77_strsm strsm_ #define F77_dgemm dgemm_ #define F77_dsymm dsymm_ #define F77_dsyrk dsyrk_ #define F77_dsyr2k dsyr2k_ #define F77_dtrmm dtrmm_ #define F77_dtrsm dtrsm_ #define F77_cgemm cgemm_ #define F77_csymm csymm_ #define F77_csyrk csyrk_ #define F77_csyr2k csyr2k_ #define F77_ctrmm ctrmm_ #define F77_ctrsm ctrsm_ #define F77_zgemm zgemm_ #define F77_zsymm zsymm_ #define F77_zsyrk zsyrk_ #define F77_zsyr2k zsyr2k_ #define F77_ztrmm ztrmm_ #define F77_ztrsm ztrsm_ #elif defined(UPCASE) /* * Level 1 BLAS */ #define F77_xerbla XERBLA #define F77_srotg SROTG #define F77_srotmg SROTMG #define F77_srot SROT #define F77_srotm SROTM #define F77_drotg DROTG #define F77_drotmg DROTMG #define F77_drot DROT #define F77_drotm DROTM #define F77_sswap SSWAP #define F77_scopy SCOPY #define F77_saxpy SAXPY #define F77_isamax_sub ISAMAXSUB #define F77_dswap DSWAP #define F77_dcopy DCOPY #define F77_daxpy DAXPY #define F77_idamax_sub IDAMAXSUB #define F77_cswap CSWAP #define F77_ccopy CCOPY #define F77_caxpy CAXPY #define F77_icamax_sub ICAMAXSUB #define F77_zswap ZSWAP #define F77_zcopy ZCOPY #define F77_zaxpy ZAXPY #define F77_izamax_sub IZAMAXSUB #define F77_sdot_sub SDOTSUB #define F77_ddot_sub DDOTSUB #define F77_dsdot_sub DSDOTSUB #define F77_sscal SSCAL #define F77_dscal DSCAL #define F77_cscal CSCAL #define F77_zscal ZSCAL #define F77_csscal CSSCAL #define F77_zdscal ZDSCAL #define F77_cdotu_sub CDOTUSUB #define F77_cdotc_sub CDOTCSUB #define F77_zdotu_sub ZDOTUSUB #define F77_zdotc_sub ZDOTCSUB #define F77_snrm2_sub SNRM2SUB #define F77_sasum_sub SASUMSUB #define F77_dnrm2_sub DNRM2SUB #define F77_dasum_sub DASUMSUB #define F77_scnrm2_sub SCNRM2SUB #define F77_scasum_sub SCASUMSUB #define F77_dznrm2_sub DZNRM2SUB #define F77_dzasum_sub DZASUMSUB #define F77_sdsdot_sub SDSDOTSUB /* * Level 2 BLAS */ #define F77_ssymv SSYMV #define F77_ssbmv SSBMV #define F77_sspmv SSPMV #define F77_sger SGER #define F77_ssyr SSYR #define F77_sspr SSPR #define F77_ssyr2 SSYR2 #define F77_sspr2 SSPR2 #define F77_dsymv DSYMV #define F77_dsbmv DSBMV #define F77_dspmv DSPMV #define F77_dger DGER #define F77_dsyr DSYR #define F77_dspr DSPR #define F77_dsyr2 DSYR2 #define F77_dspr2 DSPR2 #define F77_chemv CHEMV #define F77_chbmv CHBMV #define F77_chpmv CHPMV #define F77_cgeru CGERU #define F77_cgerc CGERC #define F77_cher CHER #define F77_chpr CHPR #define F77_cher2 CHER2 #define F77_chpr2 CHPR2 #define F77_zhemv ZHEMV #define F77_zhbmv ZHBMV #define F77_zhpmv ZHPMV #define F77_zgeru ZGERU #define F77_zgerc ZGERC #define F77_zher ZHER #define F77_zhpr ZHPR #define F77_zher2 ZHER2 #define F77_zhpr2 ZHPR2 #define F77_sgemv SGEMV #define F77_sgbmv SGBMV #define F77_strmv STRMV #define F77_stbmv STBMV #define F77_stpmv STPMV #define F77_strsv STRSV #define F77_stbsv STBSV #define F77_stpsv STPSV #define F77_dgemv DGEMV #define F77_dgbmv DGBMV #define F77_dtrmv DTRMV #define F77_dtbmv DTBMV #define F77_dtpmv DTPMV #define F77_dtrsv DTRSV #define F77_dtbsv DTBSV #define F77_dtpsv DTPSV #define F77_cgemv CGEMV #define F77_cgbmv CGBMV #define F77_ctrmv CTRMV #define F77_ctbmv CTBMV #define F77_ctpmv CTPMV #define F77_ctrsv CTRSV #define F77_ctbsv CTBSV #define F77_ctpsv CTPSV #define F77_zgemv ZGEMV #define F77_zgbmv ZGBMV #define F77_ztrmv ZTRMV #define F77_ztbmv ZTBMV #define F77_ztpmv ZTPMV #define F77_ztrsv ZTRSV #define F77_ztbsv ZTBSV #define F77_ztpsv ZTPSV /* * Level 3 BLAS */ #define F77_chemm CHEMM #define F77_cherk CHERK #define F77_cher2k CHER2K #define F77_zhemm ZHEMM #define F77_zherk ZHERK #define F77_zher2k ZHER2K #define F77_sgemm SGEMM #define F77_ssymm SSYMM #define F77_ssyrk SSYRK #define F77_ssyr2k SSYR2K #define F77_strmm STRMM #define F77_strsm STRSM #define F77_dgemm DGEMM #define F77_dsymm DSYMM #define F77_dsyrk DSYRK #define F77_dsyr2k DSYR2K #define F77_dtrmm DTRMM #define F77_dtrsm DTRSM #define F77_cgemm CGEMM #define F77_csymm CSYMM #define F77_csyrk CSYRK #define F77_csyr2k CSYR2K #define F77_ctrmm CTRMM #define F77_ctrsm CTRSM #define F77_zgemm ZGEMM #define F77_zsymm ZSYMM #define F77_zsyrk ZSYRK #define F77_zsyr2k ZSYR2K #define F77_ztrmm ZTRMM #define F77_ztrsm ZTRSM #elif defined(NOCHANGE) /* * Level 1 BLAS */ #define F77_xerbla xerbla #define F77_srotg srotg #define F77_srotmg srotmg #define F77_srot srot #define F77_srotm srotm #define F77_drotg drotg #define F77_drotmg drotmg #define F77_drot drot #define F77_drotm drotm #define F77_sswap sswap #define F77_scopy scopy #define F77_saxpy saxpy #define F77_isamax_sub isamaxsub #define F77_dswap dswap #define F77_dcopy dcopy #define F77_daxpy daxpy #define F77_idamax_sub idamaxsub #define F77_cswap cswap #define F77_ccopy ccopy #define F77_caxpy caxpy #define F77_icamax_sub icamaxsub #define F77_zswap zswap #define F77_zcopy zcopy #define F77_zaxpy zaxpy #define F77_izamax_sub izamaxsub #define F77_sdot_sub sdotsub #define F77_ddot_sub ddotsub #define F77_dsdot_sub dsdotsub #define F77_sscal sscal #define F77_dscal dscal #define F77_cscal cscal #define F77_zscal zscal #define F77_csscal csscal #define F77_zdscal zdscal #define F77_cdotu_sub cdotusub #define F77_cdotc_sub cdotcsub #define F77_zdotu_sub zdotusub #define F77_zdotc_sub zdotcsub #define F77_snrm2_sub snrm2sub #define F77_sasum_sub sasumsub #define F77_dnrm2_sub dnrm2sub #define F77_dasum_sub dasumsub #define F77_scnrm2_sub scnrm2sub #define F77_scasum_sub scasumsub #define F77_dznrm2_sub dznrm2sub #define F77_dzasum_sub dzasumsub #define F77_sdsdot_sub sdsdotsub /* * Level 2 BLAS */ #define F77_ssymv ssymv #define F77_ssbmv ssbmv #define F77_sspmv sspmv #define F77_sger sger #define F77_ssyr ssyr #define F77_sspr sspr #define F77_ssyr2 ssyr2 #define F77_sspr2 sspr2 #define F77_dsymv dsymv #define F77_dsbmv dsbmv #define F77_dspmv dspmv #define F77_dger dger #define F77_dsyr dsyr #define F77_dspr dspr #define F77_dsyr2 dsyr2 #define F77_dspr2 dspr2 #define F77_chemv chemv #define F77_chbmv chbmv #define F77_chpmv chpmv #define F77_cgeru cgeru #define F77_cgerc cgerc #define F77_cher cher #define F77_chpr chpr #define F77_cher2 cher2 #define F77_chpr2 chpr2 #define F77_zhemv zhemv #define F77_zhbmv zhbmv #define F77_zhpmv zhpmv #define F77_zgeru zgeru #define F77_zgerc zgerc #define F77_zher zher #define F77_zhpr zhpr #define F77_zher2 zher2 #define F77_zhpr2 zhpr2 #define F77_sgemv sgemv #define F77_sgbmv sgbmv #define F77_strmv strmv #define F77_stbmv stbmv #define F77_stpmv stpmv #define F77_strsv strsv #define F77_stbsv stbsv #define F77_stpsv stpsv #define F77_dgemv dgemv #define F77_dgbmv dgbmv #define F77_dtrmv dtrmv #define F77_dtbmv dtbmv #define F77_dtpmv dtpmv #define F77_dtrsv dtrsv #define F77_dtbsv dtbsv #define F77_dtpsv dtpsv #define F77_cgemv cgemv #define F77_cgbmv cgbmv #define F77_ctrmv ctrmv #define F77_ctbmv ctbmv #define F77_ctpmv ctpmv #define F77_ctrsv ctrsv #define F77_ctbsv ctbsv #define F77_ctpsv ctpsv #define F77_zgemv zgemv #define F77_zgbmv zgbmv #define F77_ztrmv ztrmv #define F77_ztbmv ztbmv #define F77_ztpmv ztpmv #define F77_ztrsv ztrsv #define F77_ztbsv ztbsv #define F77_ztpsv ztpsv /* * Level 3 BLAS */ #define F77_chemm chemm #define F77_cherk cherk #define F77_cher2k cher2k #define F77_zhemm zhemm #define F77_zherk zherk #define F77_zher2k zher2k #define F77_sgemm sgemm #define F77_ssymm ssymm #define F77_ssyrk ssyrk #define F77_ssyr2k ssyr2k #define F77_strmm strmm #define F77_strsm strsm #define F77_dgemm dgemm #define F77_dsymm dsymm #define F77_dsyrk dsyrk #define F77_dsyr2k dsyr2k #define F77_dtrmm dtrmm #define F77_dtrsm dtrsm #define F77_cgemm cgemm #define F77_csymm csymm #define F77_csyrk csyrk #define F77_csyr2k csyr2k #define F77_ctrmm ctrmm #define F77_ctrsm ctrsm #define F77_zgemm zgemm #define F77_zsymm zsymm #define F77_zsyrk zsyrk #define F77_zsyr2k zsyr2k #define F77_ztrmm ztrmm #define F77_ztrsm ztrsm #endif void F77_xerbla(FCHAR, void *); /* * Level 1 Fortran Prototypes */ /* Single Precision */ void F77_srot(FINT, float *, FINT, float *, FINT, const float *, const float *); void F77_srotg(float *,float *,float *,float *); void F77_srotm( FINT, float *, FINT, float *, FINT, const float *); void F77_srotmg(float *,float *,float *,const float *, float *); void F77_sswap( FINT, float *, FINT, float *, FINT); void F77_scopy( FINT, const float *, FINT, float *, FINT); void F77_saxpy( FINT, const float *, const float *, FINT, float *, FINT); void F77_sdot_sub(FINT, const float *, FINT, const float *, FINT, float *); void F77_sdsdot_sub( FINT, const float *, const float *, FINT, const float *, FINT, float *); void F77_sscal( FINT, const float *, float *, FINT); void F77_snrm2_sub( FINT, const float *, FINT, float *); void F77_sasum_sub( FINT, const float *, FINT, float *); void F77_isamax_sub( FINT, const float * , FINT, FINT2); /* Double Precision */ void F77_drot(FINT, double *, FINT, double *, FINT, const double *, const double *); void F77_drotg(double *,double *,double *,double *); void F77_drotm( FINT, double *, FINT, double *, FINT, const double *); void F77_drotmg(double *,double *,double *,const double *, double *); void F77_dswap( FINT, double *, FINT, double *, FINT); void F77_dcopy( FINT, const double *, FINT, double *, FINT); void F77_daxpy( FINT, const double *, const double *, FINT, double *, FINT); void F77_dswap( FINT, double *, FINT, double *, FINT); void F77_dsdot_sub(FINT, const float *, FINT, const float *, FINT, double *); void F77_ddot_sub( FINT, const double *, FINT, const double *, FINT, double *); void F77_dscal( FINT, const double *, double *, FINT); void F77_dnrm2_sub( FINT, const double *, FINT, double *); void F77_dasum_sub( FINT, const double *, FINT, double *); void F77_idamax_sub( FINT, const double * , FINT, FINT2); /* Single Complex Precision */ void F77_cswap( FINT, void *, FINT, void *, FINT); void F77_ccopy( FINT, const void *, FINT, void *, FINT); void F77_caxpy( FINT, const void *, const void *, FINT, void *, FINT); void F77_cswap( FINT, void *, FINT, void *, FINT); void F77_cdotc_sub( FINT, const void *, FINT, const void *, FINT, void *); void F77_cdotu_sub( FINT, const void *, FINT, const void *, FINT, void *); void F77_cscal( FINT, const void *, void *, FINT); void F77_icamax_sub( FINT, const void *, FINT, FINT2); void F77_csscal( FINT, const float *, void *, FINT); void F77_scnrm2_sub( FINT, const void *, FINT, float *); void F77_scasum_sub( FINT, const void *, FINT, float *); /* Double Complex Precision */ void F77_zswap( FINT, void *, FINT, void *, FINT); void F77_zcopy( FINT, const void *, FINT, void *, FINT); void F77_zaxpy( FINT, const void *, const void *, FINT, void *, FINT); void F77_zswap( FINT, void *, FINT, void *, FINT); void F77_zdotc_sub( FINT, const void *, FINT, const void *, FINT, void *); void F77_zdotu_sub( FINT, const void *, FINT, const void *, FINT, void *); void F77_zdscal( FINT, const double *, void *, FINT); void F77_zscal( FINT, const void *, void *, FINT); void F77_dznrm2_sub( FINT, const void *, FINT, double *); void F77_dzasum_sub( FINT, const void *, FINT, double *); void F77_izamax_sub( FINT, const void *, FINT, FINT2); /* * Level 2 Fortran Prototypes */ /* Single Precision */ void F77_sgemv(FCHAR, FINT, FINT, const float *, const float *, FINT, const float *, FINT, const float *, float *, FINT); void F77_sgbmv(FCHAR, FINT, FINT, FINT, FINT, const float *, const float *, FINT, const float *, FINT, const float *, float *, FINT); void F77_ssymv(FCHAR, FINT, const float *, const float *, FINT, const float *, FINT, const float *, float *, FINT); void F77_ssbmv(FCHAR, FINT, FINT, const float *, const float *, FINT, const float *, FINT, const float *, float *, FINT); void F77_sspmv(FCHAR, FINT, const float *, const float *, const float *, FINT, const float *, float *, FINT); void F77_strmv( FCHAR, FCHAR, FCHAR, FINT, const float *, FINT, float *, FINT); void F77_stbmv( FCHAR, FCHAR, FCHAR, FINT, FINT, const float *, FINT, float *, FINT); void F77_strsv( FCHAR, FCHAR, FCHAR, FINT, const float *, FINT, float *, FINT); void F77_stbsv( FCHAR, FCHAR, FCHAR, FINT, FINT, const float *, FINT, float *, FINT); void F77_stpmv( FCHAR, FCHAR, FCHAR, FINT, const float *, float *, FINT); void F77_stpsv( FCHAR, FCHAR, FCHAR, FINT, const float *, float *, FINT); void F77_sger( FINT, FINT, const float *, const float *, FINT, const float *, FINT, float *, FINT); void F77_ssyr(FCHAR, FINT, const float *, const float *, FINT, float *, FINT); void F77_sspr(FCHAR, FINT, const float *, const float *, FINT, float *); void F77_sspr2(FCHAR, FINT, const float *, const float *, FINT, const float *, FINT, float *); void F77_ssyr2(FCHAR, FINT, const float *, const float *, FINT, const float *, FINT, float *, FINT); /* Double Precision */ void F77_dgemv(FCHAR, FINT, FINT, const double *, const double *, FINT, const double *, FINT, const double *, double *, FINT); void F77_dgbmv(FCHAR, FINT, FINT, FINT, FINT, const double *, const double *, FINT, const double *, FINT, const double *, double *, FINT); void F77_dsymv(FCHAR, FINT, const double *, const double *, FINT, const double *, FINT, const double *, double *, FINT); void F77_dsbmv(FCHAR, FINT, FINT, const double *, const double *, FINT, const double *, FINT, const double *, double *, FINT); void F77_dspmv(FCHAR, FINT, const double *, const double *, const double *, FINT, const double *, double *, FINT); void F77_dtrmv( FCHAR, FCHAR, FCHAR, FINT, const double *, FINT, double *, FINT); void F77_dtbmv( FCHAR, FCHAR, FCHAR, FINT, FINT, const double *, FINT, double *, FINT); void F77_dtrsv( FCHAR, FCHAR, FCHAR, FINT, const double *, FINT, double *, FINT); void F77_dtbsv( FCHAR, FCHAR, FCHAR, FINT, FINT, const double *, FINT, double *, FINT); void F77_dtpmv( FCHAR, FCHAR, FCHAR, FINT, const double *, double *, FINT); void F77_dtpsv( FCHAR, FCHAR, FCHAR, FINT, const double *, double *, FINT); void F77_dger( FINT, FINT, const double *, const double *, FINT, const double *, FINT, double *, FINT); void F77_dsyr(FCHAR, FINT, const double *, const double *, FINT, double *, FINT); void F77_dspr(FCHAR, FINT, const double *, const double *, FINT, double *); void F77_dspr2(FCHAR, FINT, const double *, const double *, FINT, const double *, FINT, double *); void F77_dsyr2(FCHAR, FINT, const double *, const double *, FINT, const double *, FINT, double *, FINT); /* Single Complex Precision */ void F77_cgemv(FCHAR, FINT, FINT, const void *, const void *, FINT, const void *, FINT, const void *, void *, FINT); void F77_cgbmv(FCHAR, FINT, FINT, FINT, FINT, const void *, const void *, FINT, const void *, FINT, const void *, void *, FINT); void F77_chemv(FCHAR, FINT, const void *, const void *, FINT, const void *, FINT, const void *, void *, FINT); void F77_chbmv(FCHAR, FINT, FINT, const void *, const void *, FINT, const void *, FINT, const void *, void *, FINT); void F77_chpmv(FCHAR, FINT, const void *, const void *, const void *, FINT, const void *, void *, FINT); void F77_ctrmv( FCHAR, FCHAR, FCHAR, FINT, const void *, FINT, void *, FINT); void F77_ctbmv( FCHAR, FCHAR, FCHAR, FINT, FINT, const void *, FINT, void *, FINT); void F77_ctpmv( FCHAR, FCHAR, FCHAR, FINT, const void *, void *, FINT); void F77_ctrsv( FCHAR, FCHAR, FCHAR, FINT, const void *, FINT, void *, FINT); void F77_ctbsv( FCHAR, FCHAR, FCHAR, FINT, FINT, const void *, FINT, void *, FINT); void F77_ctpsv( FCHAR, FCHAR, FCHAR, FINT, const void *, void *,FINT); void F77_cgerc( FINT, FINT, const void *, const void *, FINT, const void *, FINT, void *, FINT); void F77_cgeru( FINT, FINT, const void *, const void *, FINT, const void *, FINT, void *, FINT); void F77_cher(FCHAR, FINT, const float *, const void *, FINT, void *, FINT); void F77_cher2(FCHAR, FINT, const void *, const void *, FINT, const void *, FINT, void *, FINT); void F77_chpr(FCHAR, FINT, const float *, const void *, FINT, void *); void F77_chpr2(FCHAR, FINT, const float *, const void *, FINT, const void *, FINT, void *); /* Double Complex Precision */ void F77_zgemv(FCHAR, FINT, FINT, const void *, const void *, FINT, const void *, FINT, const void *, void *, FINT); void F77_zgbmv(FCHAR, FINT, FINT, FINT, FINT, const void *, const void *, FINT, const void *, FINT, const void *, void *, FINT); void F77_zhemv(FCHAR, FINT, const void *, const void *, FINT, const void *, FINT, const void *, void *, FINT); void F77_zhbmv(FCHAR, FINT, FINT, const void *, const void *, FINT, const void *, FINT, const void *, void *, FINT); void F77_zhpmv(FCHAR, FINT, const void *, const void *, const void *, FINT, const void *, void *, FINT); void F77_ztrmv( FCHAR, FCHAR, FCHAR, FINT, const void *, FINT, void *, FINT); void F77_ztbmv( FCHAR, FCHAR, FCHAR, FINT, FINT, const void *, FINT, void *, FINT); void F77_ztpmv( FCHAR, FCHAR, FCHAR, FINT, const void *, void *, FINT); void F77_ztrsv( FCHAR, FCHAR, FCHAR, FINT, const void *, FINT, void *, FINT); void F77_ztbsv( FCHAR, FCHAR, FCHAR, FINT, FINT, const void *, FINT, void *, FINT); void F77_ztpsv( FCHAR, FCHAR, FCHAR, FINT, const void *, void *,FINT); void F77_zgerc( FINT, FINT, const void *, const void *, FINT, const void *, FINT, void *, FINT); void F77_zgeru( FINT, FINT, const void *, const void *, FINT, const void *, FINT, void *, FINT); void F77_zher(FCHAR, FINT, const double *, const void *, FINT, void *, FINT); void F77_zher2(FCHAR, FINT, const void *, const void *, FINT, const void *, FINT, void *, FINT); void F77_zhpr(FCHAR, FINT, const double *, const void *, FINT, void *); void F77_zhpr2(FCHAR, FINT, const double *, const void *, FINT, const void *, FINT, void *); /* * Level 3 Fortran Prototypes */ /* Single Precision */ void F77_sgemm(FCHAR, FCHAR, FINT, FINT, FINT, const float *, const float *, FINT, const float *, FINT, const float *, float *, FINT); void F77_ssymm(FCHAR, FCHAR, FINT, FINT, const float *, const float *, FINT, const float *, FINT, const float *, float *, FINT); void F77_ssyrk(FCHAR, FCHAR, FINT, FINT, const float *, const float *, FINT, const float *, float *, FINT); void F77_ssyr2k(FCHAR, FCHAR, FINT, FINT, const float *, const float *, FINT, const float *, FINT, const float *, float *, FINT); void F77_strmm(FCHAR, FCHAR, FCHAR, FCHAR, FINT, FINT, const float *, const float *, FINT, float *, FINT); void F77_strsm(FCHAR, FCHAR, FCHAR, FCHAR, FINT, FINT, const float *, const float *, FINT, float *, FINT); /* Double Precision */ void F77_dgemm(FCHAR, FCHAR, FINT, FINT, FINT, const double *, const double *, FINT, const double *, FINT, const double *, double *, FINT); void F77_dsymm(FCHAR, FCHAR, FINT, FINT, const double *, const double *, FINT, const double *, FINT, const double *, double *, FINT); void F77_dsyrk(FCHAR, FCHAR, FINT, FINT, const double *, const double *, FINT, const double *, double *, FINT); void F77_dsyr2k(FCHAR, FCHAR, FINT, FINT, const double *, const double *, FINT, const double *, FINT, const double *, double *, FINT); void F77_dtrmm(FCHAR, FCHAR, FCHAR, FCHAR, FINT, FINT, const double *, const double *, FINT, double *, FINT); void F77_dtrsm(FCHAR, FCHAR, FCHAR, FCHAR, FINT, FINT, const double *, const double *, FINT, double *, FINT); /* Single Complex Precision */ void F77_cgemm(FCHAR, FCHAR, FINT, FINT, FINT, const float *, const float *, FINT, const float *, FINT, const float *, float *, FINT); void F77_csymm(FCHAR, FCHAR, FINT, FINT, const float *, const float *, FINT, const float *, FINT, const float *, float *, FINT); void F77_chemm(FCHAR, FCHAR, FINT, FINT, const float *, const float *, FINT, const float *, FINT, const float *, float *, FINT); void F77_csyrk(FCHAR, FCHAR, FINT, FINT, const float *, const float *, FINT, const float *, float *, FINT); void F77_cherk(FCHAR, FCHAR, FINT, FINT, const float *, const float *, FINT, const float *, float *, FINT); void F77_csyr2k(FCHAR, FCHAR, FINT, FINT, const float *, const float *, FINT, const float *, FINT, const float *, float *, FINT); void F77_cher2k(FCHAR, FCHAR, FINT, FINT, const float *, const float *, FINT, const float *, FINT, const float *, float *, FINT); void F77_ctrmm(FCHAR, FCHAR, FCHAR, FCHAR, FINT, FINT, const float *, const float *, FINT, float *, FINT); void F77_ctrsm(FCHAR, FCHAR, FCHAR, FCHAR, FINT, FINT, const float *, const float *, FINT, float *, FINT); /* Double Complex Precision */ void F77_zgemm(FCHAR, FCHAR, FINT, FINT, FINT, const double *, const double *, FINT, const double *, FINT, const double *, double *, FINT); void F77_zsymm(FCHAR, FCHAR, FINT, FINT, const double *, const double *, FINT, const double *, FINT, const double *, double *, FINT); void F77_zhemm(FCHAR, FCHAR, FINT, FINT, const double *, const double *, FINT, const double *, FINT, const double *, double *, FINT); void F77_zsyrk(FCHAR, FCHAR, FINT, FINT, const double *, const double *, FINT, const double *, double *, FINT); void F77_zherk(FCHAR, FCHAR, FINT, FINT, const double *, const double *, FINT, const double *, double *, FINT); void F77_zsyr2k(FCHAR, FCHAR, FINT, FINT, const double *, const double *, FINT, const double *, FINT, const double *, double *, FINT); void F77_zher2k(FCHAR, FCHAR, FINT, FINT, const double *, const double *, FINT, const double *, FINT, const double *, double *, FINT); void F77_ztrmm(FCHAR, FCHAR, FCHAR, FCHAR, FINT, FINT, const double *, const double *, FINT, double *, FINT); void F77_ztrsm(FCHAR, FCHAR, FCHAR, FCHAR, FINT, FINT, const double *, const double *, FINT, double *, FINT); #ifdef __cplusplus } #endif #endif /* CBLAS_F77_H */ ","Unknown" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/src/cblas.h",".h","32428","568","#ifndef CBLAS_H #define CBLAS_H #include /* * Enumerated and derived types */ #define CBLAS_INDEX size_t /* this may vary between platforms */ enum CBLAS_ORDER {CblasRowMajor=101, CblasColMajor=102}; enum CBLAS_TRANSPOSE {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113}; enum CBLAS_UPLO {CblasUpper=121, CblasLower=122}; enum CBLAS_DIAG {CblasNonUnit=131, CblasUnit=132}; enum CBLAS_SIDE {CblasLeft=141, CblasRight=142}; /* * =========================================================================== * Prototypes for level 1 BLAS functions (complex are recast as routines) * =========================================================================== */ float cblas_sdsdot(const int N, const float alpha, const float *X, const int incX, const float *Y, const int incY); double cblas_dsdot(const int N, const float *X, const int incX, const float *Y, const int incY); float cblas_sdot(const int N, const float *X, const int incX, const float *Y, const int incY); double cblas_ddot(const int N, const double *X, const int incX, const double *Y, const int incY); /* * Functions having prefixes Z and C only */ void cblas_cdotu_sub(const int N, const void *X, const int incX, const void *Y, const int incY, void *dotu); void cblas_cdotc_sub(const int N, const void *X, const int incX, const void *Y, const int incY, void *dotc); void cblas_zdotu_sub(const int N, const void *X, const int incX, const void *Y, const int incY, void *dotu); void cblas_zdotc_sub(const int N, const void *X, const int incX, const void *Y, const int incY, void *dotc); /* * Functions having prefixes S D SC DZ */ float cblas_snrm2(const int N, const float *X, const int incX); float cblas_sasum(const int N, const float *X, const int incX); double cblas_dnrm2(const int N, const double *X, const int incX); double cblas_dasum(const int N, const double *X, const int incX); float cblas_scnrm2(const int N, const void *X, const int incX); float cblas_scasum(const int N, const void *X, const int incX); double cblas_dznrm2(const int N, const void *X, const int incX); double cblas_dzasum(const int N, const void *X, const int incX); /* * Functions having standard 4 prefixes (S D C Z) */ CBLAS_INDEX cblas_isamax(const int N, const float *X, const int incX); CBLAS_INDEX cblas_idamax(const int N, const double *X, const int incX); CBLAS_INDEX cblas_icamax(const int N, const void *X, const int incX); CBLAS_INDEX cblas_izamax(const int N, const void *X, const int incX); /* * =========================================================================== * Prototypes for level 1 BLAS routines * =========================================================================== */ /* * Routines with standard 4 prefixes (s, d, c, z) */ void cblas_sswap(const int N, float *X, const int incX, float *Y, const int incY); void cblas_scopy(const int N, const float *X, const int incX, float *Y, const int incY); void cblas_saxpy(const int N, const float alpha, const float *X, const int incX, float *Y, const int incY); void cblas_dswap(const int N, double *X, const int incX, double *Y, const int incY); void cblas_dcopy(const int N, const double *X, const int incX, double *Y, const int incY); void cblas_daxpy(const int N, const double alpha, const double *X, const int incX, double *Y, const int incY); void cblas_cswap(const int N, void *X, const int incX, void *Y, const int incY); void cblas_ccopy(const int N, const void *X, const int incX, void *Y, const int incY); void cblas_caxpy(const int N, const void *alpha, const void *X, const int incX, void *Y, const int incY); void cblas_zswap(const int N, void *X, const int incX, void *Y, const int incY); void cblas_zcopy(const int N, const void *X, const int incX, void *Y, const int incY); void cblas_zaxpy(const int N, const void *alpha, const void *X, const int incX, void *Y, const int incY); /* * Routines with S and D prefix only */ void cblas_srotg(float *a, float *b, float *c, float *s); void cblas_srotmg(float *d1, float *d2, float *b1, const float b2, float *P); void cblas_srot(const int N, float *X, const int incX, float *Y, const int incY, const float c, const float s); void cblas_srotm(const int N, float *X, const int incX, float *Y, const int incY, const float *P); void cblas_drotg(double *a, double *b, double *c, double *s); void cblas_drotmg(double *d1, double *d2, double *b1, const double b2, double *P); void cblas_drot(const int N, double *X, const int incX, double *Y, const int incY, const double c, const double s); void cblas_drotm(const int N, double *X, const int incX, double *Y, const int incY, const double *P); /* * Routines with S D C Z CS and ZD prefixes */ void cblas_sscal(const int N, const float alpha, float *X, const int incX); void cblas_dscal(const int N, const double alpha, double *X, const int incX); void cblas_cscal(const int N, const void *alpha, void *X, const int incX); void cblas_zscal(const int N, const void *alpha, void *X, const int incX); void cblas_csscal(const int N, const float alpha, void *X, const int incX); void cblas_zdscal(const int N, const double alpha, void *X, const int incX); /* * =========================================================================== * Prototypes for level 2 BLAS * =========================================================================== */ /* * Routines with standard 4 prefixes (S, D, C, Z) */ void cblas_sgemv(const enum CBLAS_ORDER order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const float alpha, const float *A, const int lda, const float *X, const int incX, const float beta, float *Y, const int incY); void cblas_sgbmv(const enum CBLAS_ORDER order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const int KL, const int KU, const float alpha, const float *A, const int lda, const float *X, const int incX, const float beta, float *Y, const int incY); void cblas_strmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const float *A, const int lda, float *X, const int incX); void cblas_stbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const float *A, const int lda, float *X, const int incX); void cblas_stpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const float *Ap, float *X, const int incX); void cblas_strsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const float *A, const int lda, float *X, const int incX); void cblas_stbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const float *A, const int lda, float *X, const int incX); void cblas_stpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const float *Ap, float *X, const int incX); void cblas_dgemv(const enum CBLAS_ORDER order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const double alpha, const double *A, const int lda, const double *X, const int incX, const double beta, double *Y, const int incY); void cblas_dgbmv(const enum CBLAS_ORDER order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const int KL, const int KU, const double alpha, const double *A, const int lda, const double *X, const int incX, const double beta, double *Y, const int incY); void cblas_dtrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const double *A, const int lda, double *X, const int incX); void cblas_dtbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const double *A, const int lda, double *X, const int incX); void cblas_dtpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const double *Ap, double *X, const int incX); void cblas_dtrsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const double *A, const int lda, double *X, const int incX); void cblas_dtbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const double *A, const int lda, double *X, const int incX); void cblas_dtpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const double *Ap, double *X, const int incX); void cblas_cgemv(const enum CBLAS_ORDER order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_cgbmv(const enum CBLAS_ORDER order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const int KL, const int KU, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_ctrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *A, const int lda, void *X, const int incX); void cblas_ctbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const void *A, const int lda, void *X, const int incX); void cblas_ctpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *Ap, void *X, const int incX); void cblas_ctrsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *A, const int lda, void *X, const int incX); void cblas_ctbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const void *A, const int lda, void *X, const int incX); void cblas_ctpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *Ap, void *X, const int incX); void cblas_zgemv(const enum CBLAS_ORDER order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_zgbmv(const enum CBLAS_ORDER order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const int KL, const int KU, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_ztrmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *A, const int lda, void *X, const int incX); void cblas_ztbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const void *A, const int lda, void *X, const int incX); void cblas_ztpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *Ap, void *X, const int incX); void cblas_ztrsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *A, const int lda, void *X, const int incX); void cblas_ztbsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const int K, const void *A, const int lda, void *X, const int incX); void cblas_ztpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int N, const void *Ap, void *X, const int incX); /* * Routines with S and D prefixes only */ void cblas_ssymv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const float *A, const int lda, const float *X, const int incX, const float beta, float *Y, const int incY); void cblas_ssbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const int K, const float alpha, const float *A, const int lda, const float *X, const int incX, const float beta, float *Y, const int incY); void cblas_sspmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const float *Ap, const float *X, const int incX, const float beta, float *Y, const int incY); void cblas_sger(const enum CBLAS_ORDER order, const int M, const int N, const float alpha, const float *X, const int incX, const float *Y, const int incY, float *A, const int lda); void cblas_ssyr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const float *X, const int incX, float *A, const int lda); void cblas_sspr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const float *X, const int incX, float *Ap); void cblas_ssyr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const float *X, const int incX, const float *Y, const int incY, float *A, const int lda); void cblas_sspr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const float *X, const int incX, const float *Y, const int incY, float *A); void cblas_dsymv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const double *A, const int lda, const double *X, const int incX, const double beta, double *Y, const int incY); void cblas_dsbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const int K, const double alpha, const double *A, const int lda, const double *X, const int incX, const double beta, double *Y, const int incY); void cblas_dspmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const double *Ap, const double *X, const int incX, const double beta, double *Y, const int incY); void cblas_dger(const enum CBLAS_ORDER order, const int M, const int N, const double alpha, const double *X, const int incX, const double *Y, const int incY, double *A, const int lda); void cblas_dsyr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const double *X, const int incX, double *A, const int lda); void cblas_dspr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const double *X, const int incX, double *Ap); void cblas_dsyr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const double *X, const int incX, const double *Y, const int incY, double *A, const int lda); void cblas_dspr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const double *X, const int incX, const double *Y, const int incY, double *A); /* * Routines with C and Z prefixes only */ void cblas_chemv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_chbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const int K, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_chpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *Ap, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_cgeru(const enum CBLAS_ORDER order, const int M, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda); void cblas_cgerc(const enum CBLAS_ORDER order, const int M, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda); void cblas_cher(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const void *X, const int incX, void *A, const int lda); void cblas_chpr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const float alpha, const void *X, const int incX, void *A); void cblas_cher2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda); void cblas_chpr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *Ap); void cblas_zhemv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_zhbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const int K, const void *alpha, const void *A, const int lda, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_zhpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *Ap, const void *X, const int incX, const void *beta, void *Y, const int incY); void cblas_zgeru(const enum CBLAS_ORDER order, const int M, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda); void cblas_zgerc(const enum CBLAS_ORDER order, const int M, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda); void cblas_zher(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const void *X, const int incX, void *A, const int lda); void cblas_zhpr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const double alpha, const void *X, const int incX, void *A); void cblas_zher2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *A, const int lda); void cblas_zhpr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo, const int N, const void *alpha, const void *X, const int incX, const void *Y, const int incY, void *Ap); /* * =========================================================================== * Prototypes for level 3 BLAS * =========================================================================== */ /* * Routines with standard 4 prefixes (S, D, C, Z) */ void cblas_sgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const int K, const float alpha, const float *A, const int lda, const float *B, const int ldb, const float beta, float *C, const int ldc); void cblas_ssymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const int M, const int N, const float alpha, const float *A, const int lda, const float *B, const int ldb, const float beta, float *C, const int ldc); void cblas_ssyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const float alpha, const float *A, const int lda, const float beta, float *C, const int ldc); void cblas_ssyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const float alpha, const float *A, const int lda, const float *B, const int ldb, const float beta, float *C, const int ldc); void cblas_strmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const float alpha, const float *A, const int lda, float *B, const int ldb); void cblas_strsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const float alpha, const float *A, const int lda, float *B, const int ldb); void cblas_dgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const int K, const double alpha, const double *A, const int lda, const double *B, const int ldb, const double beta, double *C, const int ldc); void cblas_dsymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const int M, const int N, const double alpha, const double *A, const int lda, const double *B, const int ldb, const double beta, double *C, const int ldc); void cblas_dsyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const double alpha, const double *A, const int lda, const double beta, double *C, const int ldc); void cblas_dsyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const double alpha, const double *A, const int lda, const double *B, const int ldb, const double beta, double *C, const int ldc); void cblas_dtrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const double alpha, const double *A, const int lda, double *B, const int ldb); void cblas_dtrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const double alpha, const double *A, const int lda, double *B, const int ldb); void cblas_cgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const int K, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_csymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const int M, const int N, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_csyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const void *alpha, const void *A, const int lda, const void *beta, void *C, const int ldc); void cblas_csyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_ctrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const void *alpha, const void *A, const int lda, void *B, const int ldb); void cblas_ctrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const void *alpha, const void *A, const int lda, void *B, const int ldb); void cblas_zgemm(const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const int K, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_zsymm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const int M, const int N, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_zsyrk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const void *alpha, const void *A, const int lda, const void *beta, void *C, const int ldc); void cblas_zsyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_ztrmm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const void *alpha, const void *A, const int lda, void *B, const int ldb); void cblas_ztrsm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag, const int M, const int N, const void *alpha, const void *A, const int lda, void *B, const int ldb); /* * Routines with prefixes C and Z only */ void cblas_chemm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const int M, const int N, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_cherk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const float alpha, const void *A, const int lda, const float beta, void *C, const int ldc); void cblas_cher2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const float beta, void *C, const int ldc); void cblas_zhemm(const enum CBLAS_ORDER Order, const enum CBLAS_SIDE Side, const enum CBLAS_UPLO Uplo, const int M, const int N, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const void *beta, void *C, const int ldc); void cblas_zherk(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const double alpha, const void *A, const int lda, const double beta, void *C, const int ldc); void cblas_zher2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo, const enum CBLAS_TRANSPOSE Trans, const int N, const int K, const void *alpha, const void *A, const int lda, const void *B, const int ldb, const double beta, void *C, const int ldc); void cblas_xerbla(int p, const char *rout, const char *form, ...); #endif ","Unknown" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/src/qcprot.h",".h","6372","153","/******************************************************************************* * -/_|:|_|_\- * * File: qcprot.h * * Function: Rapid calculation of the least-squares rotation using a * quaternion-based characteristic polynomial and * a cofactor matrix * * Author(s): Douglas L. Theobald * Department of Biochemistry * MS 009 * Brandeis University * 415 South St * Waltham, MA 02453 * USA * * dtheobald@brandeis.edu * * Pu Liu * Johnson & Johnson Pharmaceutical Research and Development, L.L.C. * 665 Stockton Drive * Exton, PA 19341 * USA * * pliu24@its.jnj.com * * * If you use this QCP rotation calculation method in a publication, please * reference: * * Douglas L. Theobald (2005) * ""Rapid calculation of RMSD using a quaternion-based characteristic * polynomial."" * Acta Crystallographica A 61(4):478-480. * * Pu Liu, Dmitris K. Agrafiotis, and Douglas L. Theobald (2009) * ""Fast determination of the optimal rotational matrix for macromolecular * superpositions."" * in press, Journal of Computational Chemistry * * * Copyright (c) 2009, Pu Liu and Douglas L. Theobald * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, are permitted * provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, this list of * conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, this list * of conditions and the following disclaimer in the documentation and/or other materials * provided with the distribution. * * Neither the name of the nor the names of its contributors may be used to * endorse or promote products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Source: started anew. * * Change History: * 2009/04/13 Started source * ******************************************************************************/ #include #include #include /* Calculate the RMSD & rotational matrix. Input: coords1 -- reference structure coords2 -- candidate structure len -- the size of the system weight -- the weight array of size len; set to NULL if not needed Output: rot[9] -- rotation matrix Return: RMSD value */ double CalcRMSDRotationalMatrix(double **coords1, double **coords2, const int len, double *rot, const double *weight); /* Calculate the inner product of two structures. If weight array is not NULL, calculate the weighted inner product. Input: coords1 -- reference structure coords2 -- candidate structure len -- the size of the system weight -- the weight array of size len: set to NULL if not needed Output: A[9] -- the inner product matrix Return: (G1 + G2) * 0.5; used as E0 in function 'FastCalcRMSDAndRotation' Warning: 1. You MUST center the structures, coords1 and coords2, before calling this function. 2. Please note how the structure coordinates are stored in the double **coords arrays. They are 3xN arrays, not Nx3 arrays as is also commonly used (where the x, y, z axes are interleaved). The difference is something like this for storage of a structure with 8 atoms: Nx3: xyzxyzxyzxyzxyzxyzxyzxyz 3xN: xxxxxxxxyyyyyyyyzzzzzzzz The functions can be easily modified, however, to accomodate any data format preference. I chose this format because it is readily used in vectorized functions (SIMD, Altivec, MMX, SSE2, etc.). */ double InnerProduct(double *A, double **coords1, double **coords2, const int len, const double *weight); /* Calculate the RMSD, and/or the optimal rotation matrix. Input: A[9] -- the inner product of two structures E0 -- (G1 + G2) * 0.5 len -- the size of the system minScore-- if( minScore > 0 && rmsd < minScore) then calculate only the rmsd; otherwise, calculate both the RMSD & the rotation matrix Output: rot[9] -- the rotation matrix in the order of xx, xy, xz, yx, yy, yz, zx, zy, zz rmsd -- the RMSD value Return: only the rmsd was calculated if < 0 both the RMSD & rotational matrix calculated if > 0 */ int FastCalcRMSDAndRotation(double *rot, double *A, double *rmsd, double E0, int len, double minScore); /* Center the coordinates. Warning: If you are doing a full superposition (the usual least squares way), you MUST center each structure first. That is, you must translate each structure so that its centroid is at the origin. You can use CenterCoords() for this. */ void CenterCoords(double **coords, const int len, const double *weight); ","Unknown" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/src/theobald_rmsd.h",".h","675","21","#ifndef _THEOBALD_RMSD_H_ #define _THEOBALD_RMSD_H_ #ifdef USE_DOUBLE #define real double #else #define real float #endif typedef real rvec[3]; int solve_cubic_equation(double c3, double c2, double c1, double c0, double *x1, double *x2, double *x3); int quartic_equation_solve_exact(double *r1, double *r2, double *r3, double *r4, int *nr12, int *nr34,double d0,double d1,double d2, double d3, double d4); real ls_rmsd2_aligned_T_g(const int nrealatoms, const int npaddedatoms, const int rowstride, const float* aT, const float* bT, const real G_a, const real G_b, float *msd, int NeedMat, double *rot); #endif ","Unknown" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/src/apc.h",".h","104","7","#ifndef _PERMUTATION_H_ #define _PERMUTATION_H_ int apc(int n,int *a,int INF,int *z_p,int *f); #endif ","Unknown" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/src/qcprot.c",".c","14025","421","/******************************************************************************* * -/_|:|_|_\- * * File: qcprot.c * Version: 1.3 * * Function: Rapid calculation of the least-squares rotation using a * quaternion-based characteristic polynomial and * a cofactor matrix * * Author(s): Douglas L. Theobald * Department of Biochemistry * MS 009 * Brandeis University * 415 South St * Waltham, MA 02453 * USA * * dtheobald@brandeis.edu * * Pu Liu * Johnson & Johnson Pharmaceutical Research and Development, L.L.C. * 665 Stockton Drive * Exton, PA 19341 * USA * * pliu24@its.jnj.com * * * If you use this QCP rotation calculation method in a publication, please * reference: * * Douglas L. Theobald (2005) * ""Rapid calculation of RMSD using a quaternion-based characteristic * polynomial."" * Acta Crystallographica A 61(4):478-480. * * Pu Liu, Dmitris K. Agrafiotis, and Douglas L. Theobald (2009) * ""Fast determination of the optimal rotational matrix for macromolecular * superpositions."" * in press, Journal of Computational Chemistry * * * Copyright (c) 2009-2011, Pu Liu and Douglas L. Theobald * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, are permitted * provided that the following conditions are met: * * * Redistributions of source code must retain the above copyright notice, this list of * conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, this list * of conditions and the following disclaimer in the documentation and/or other materials * provided with the distribution. * * Neither the name of the nor the names of its contributors may be used to * endorse or promote products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Source: started anew. * * Change History: * 2009/04/13 Started source * 2010/03/28 Modified FastCalcRMSDAndRotation() to handle tiny qsqr * If trying all rows of the adjoint still gives too small * qsqr, then just return identity matrix. (DLT) * 2010/06/30 Fixed prob in assigning A[9] = 0 in InnerProduct() * invalid mem access * 2011/02/21 Made CenterCoords use weights * 2011/05/02 Finally changed CenterCoords declaration in qcprot.h * Also changed some functions to static * 2011/07/08 put in fabs() to fix taking sqrt of small neg numbers, fp error * ******************************************************************************/ #include ""qcprot.h"" double InnerProduct(double *A, double **coords1, double **coords2, const int len, const double *weight) { double x1, x2, y1, y2, z1, z2; int i; const double *fx1 = coords1[0], *fy1 = coords1[1], *fz1 = coords1[2]; const double *fx2 = coords2[0], *fy2 = coords2[1], *fz2 = coords2[2]; double G1 = 0.0, G2 = 0.0; A[0] = A[1] = A[2] = A[3] = A[4] = A[5] = A[6] = A[7] = A[8] = 0.0; if (weight != NULL) { for (i = 0; i < len; ++i) { x1 = weight[i] * fx1[i]; y1 = weight[i] * fy1[i]; z1 = weight[i] * fz1[i]; G1 += x1 * fx1[i] + y1 * fy1[i] + z1 * fz1[i]; x2 = fx2[i]; y2 = fy2[i]; z2 = fz2[i]; G2 += weight[i] * (x2 * x2 + y2 * y2 + z2 * z2); A[0] += (x1 * x2); A[1] += (x1 * y2); A[2] += (x1 * z2); A[3] += (y1 * x2); A[4] += (y1 * y2); A[5] += (y1 * z2); A[6] += (z1 * x2); A[7] += (z1 * y2); A[8] += (z1 * z2); } } else { for (i = 0; i < len; ++i) { x1 = fx1[i]; y1 = fy1[i]; z1 = fz1[i]; G1 += x1 * x1 + y1 * y1 + z1 * z1; x2 = fx2[i]; y2 = fy2[i]; z2 = fz2[i]; G2 += (x2 * x2 + y2 * y2 + z2 * z2); A[0] += (x1 * x2); A[1] += (x1 * y2); A[2] += (x1 * z2); A[3] += (y1 * x2); A[4] += (y1 * y2); A[5] += (y1 * z2); A[6] += (z1 * x2); A[7] += (z1 * y2); A[8] += (z1 * z2); } } return (G1 + G2) * 0.5; } int FastCalcRMSDAndRotation(double *rot, double *A, double *rmsd, double E0, int len, double minScore) { double Sxx, Sxy, Sxz, Syx, Syy, Syz, Szx, Szy, Szz; double Szz2, Syy2, Sxx2, Sxy2, Syz2, Sxz2, Syx2, Szy2, Szx2, SyzSzymSyySzz2, Sxx2Syy2Szz2Syz2Szy2, Sxy2Sxz2Syx2Szx2, SxzpSzx, SyzpSzy, SxypSyx, SyzmSzy, SxzmSzx, SxymSyx, SxxpSyy, SxxmSyy; double C[4]; int i; double mxEigenV; double oldg = 0.0; double b, a, delta, rms, qsqr; double q1, q2, q3, q4, normq; double a11, a12, a13, a14, a21, a22, a23, a24; double a31, a32, a33, a34, a41, a42, a43, a44; double a2, x2, y2, z2; double xy, az, zx, ay, yz, ax; double a3344_4334, a3244_4234, a3243_4233, a3143_4133,a3144_4134, a3142_4132; double evecprec = 1e-6; double evalprec = 1e-11; Sxx = A[0]; Sxy = A[1]; Sxz = A[2]; Syx = A[3]; Syy = A[4]; Syz = A[5]; Szx = A[6]; Szy = A[7]; Szz = A[8]; Sxx2 = Sxx * Sxx; Syy2 = Syy * Syy; Szz2 = Szz * Szz; Sxy2 = Sxy * Sxy; Syz2 = Syz * Syz; Sxz2 = Sxz * Sxz; Syx2 = Syx * Syx; Szy2 = Szy * Szy; Szx2 = Szx * Szx; SyzSzymSyySzz2 = 2.0*(Syz*Szy - Syy*Szz); Sxx2Syy2Szz2Syz2Szy2 = Syy2 + Szz2 - Sxx2 + Syz2 + Szy2; C[2] = -2.0 * (Sxx2 + Syy2 + Szz2 + Sxy2 + Syx2 + Sxz2 + Szx2 + Syz2 + Szy2); C[1] = 8.0 * (Sxx*Syz*Szy + Syy*Szx*Sxz + Szz*Sxy*Syx - Sxx*Syy*Szz - Syz*Szx*Sxy - Szy*Syx*Sxz); SxzpSzx = Sxz + Szx; SyzpSzy = Syz + Szy; SxypSyx = Sxy + Syx; SyzmSzy = Syz - Szy; SxzmSzx = Sxz - Szx; SxymSyx = Sxy - Syx; SxxpSyy = Sxx + Syy; SxxmSyy = Sxx - Syy; Sxy2Sxz2Syx2Szx2 = Sxy2 + Sxz2 - Syx2 - Szx2; C[0] = Sxy2Sxz2Syx2Szx2 * Sxy2Sxz2Syx2Szx2 + (Sxx2Syy2Szz2Syz2Szy2 + SyzSzymSyySzz2) * (Sxx2Syy2Szz2Syz2Szy2 - SyzSzymSyySzz2) + (-(SxzpSzx)*(SyzmSzy)+(SxymSyx)*(SxxmSyy-Szz)) * (-(SxzmSzx)*(SyzpSzy)+(SxymSyx)*(SxxmSyy+Szz)) + (-(SxzpSzx)*(SyzpSzy)-(SxypSyx)*(SxxpSyy-Szz)) * (-(SxzmSzx)*(SyzmSzy)-(SxypSyx)*(SxxpSyy+Szz)) + (+(SxypSyx)*(SyzpSzy)+(SxzpSzx)*(SxxmSyy+Szz)) * (-(SxymSyx)*(SyzmSzy)+(SxzpSzx)*(SxxpSyy+Szz)) + (+(SxypSyx)*(SyzmSzy)+(SxzmSzx)*(SxxmSyy-Szz)) * (-(SxymSyx)*(SyzpSzy)+(SxzmSzx)*(SxxpSyy-Szz)); mxEigenV = E0; for (i = 0; i < 100; ++i) { oldg = mxEigenV; x2 = mxEigenV*mxEigenV; b = (x2 + C[2])*mxEigenV; a = b + C[1]; delta = ((a*mxEigenV + C[0])/(2.0*x2*mxEigenV + b + a)); mxEigenV -= delta; //printf(""\n diff[%3d]: %16g %16g %16g"", i, mxEigenV - oldg, evalprec*mxEigenV, mxEigenV); if (fabs(mxEigenV - oldg) < fabs(evalprec*mxEigenV)) break; } if (i == 100) fprintf(stderr,""\nMore than %d iterations needed!\n"", i); /* the fabs() is to guard against extremely small, but *negative* numbers due to floating point error */ rms = sqrt(fabs(2.0 * (E0 - mxEigenV)/len)); // LPW Har har! (*rmsd) = rms*rms; //printf("" %16g %16g %16g "", rms, E0, 2.0 * (E0 - mxEigenV)/len); if (minScore > 0) { if (rms < minScore) { rot[0] = rot[4] = rot[8] = 1.0; rot[1] = rot[2] = rot[3] = rot[5] = rot[6] = rot[7] = 0.0; printf(""qcprot borked\n""); return (-1); // Don't bother with rotation. } } a11 = SxxpSyy + Szz-mxEigenV; a12 = SyzmSzy; a13 = - SxzmSzx; a14 = SxymSyx; a21 = SyzmSzy; a22 = SxxmSyy - Szz-mxEigenV; a23 = SxypSyx; a24= SxzpSzx; a31 = a13; a32 = a23; a33 = Syy-Sxx-Szz - mxEigenV; a34 = SyzpSzy; a41 = a14; a42 = a24; a43 = a34; a44 = Szz - SxxpSyy - mxEigenV; a3344_4334 = a33 * a44 - a43 * a34; a3244_4234 = a32 * a44-a42*a34; a3243_4233 = a32 * a43 - a42 * a33; a3143_4133 = a31 * a43-a41*a33; a3144_4134 = a31 * a44 - a41 * a34; a3142_4132 = a31 * a42-a41*a32; q1 = a22*a3344_4334-a23*a3244_4234+a24*a3243_4233; q2 = -a21*a3344_4334+a23*a3144_4134-a24*a3143_4133; q3 = a21*a3244_4234-a22*a3144_4134+a24*a3142_4132; q4 = -a21*a3243_4233+a22*a3143_4133-a23*a3142_4132; qsqr = q1 * q1 + q2 * q2 + q3 * q3 + q4 * q4; //printf (""%f\n"",qsqr); /* The following code tries to calculate another column in the adjoint matrix when the norm of the current column is too small. Usually this commented block will never be activated. To be absolutely safe this should be uncommented, but it is most likely unnecessary. */ if (qsqr < evecprec) { //printf(""qcprot escalating to level 1\n""); q1 = a12*a3344_4334 - a13*a3244_4234 + a14*a3243_4233; q2 = -a11*a3344_4334 + a13*a3144_4134 - a14*a3143_4133; q3 = a11*a3244_4234 - a12*a3144_4134 + a14*a3142_4132; q4 = -a11*a3243_4233 + a12*a3143_4133 - a13*a3142_4132; qsqr = q1*q1 + q2 *q2 + q3*q3+q4*q4; if (qsqr < evecprec) { //printf(""qcprot escalating to level 2\n""); float a1324_1423 = a13 * a24 - a14 * a23, a1224_1422 = a12 * a24 - a14 * a22; float a1223_1322 = a12 * a23 - a13 * a22, a1124_1421 = a11 * a24 - a14 * a21; float a1123_1321 = a11 * a23 - a13 * a21, a1122_1221 = a11 * a22 - a12 * a21; q1 = a42 * a1324_1423 - a43 * a1224_1422 + a44 * a1223_1322; q2 = -a41 * a1324_1423 + a43 * a1124_1421 - a44 * a1123_1321; q3 = a41 * a1224_1422 - a42 * a1124_1421 + a44 * a1122_1221; q4 = -a41 * a1223_1322 + a42 * a1123_1321 - a43 * a1122_1221; qsqr = q1*q1 + q2 *q2 + q3*q3+q4*q4; if (qsqr < evecprec) { //printf(""qcprot escalating to level 3\n""); q1 = a32 * a1324_1423 - a33 * a1224_1422 + a34 * a1223_1322; q2 = -a31 * a1324_1423 + a33 * a1124_1421 - a34 * a1123_1321; q3 = a31 * a1224_1422 - a32 * a1124_1421 + a34 * a1122_1221; q4 = -a31 * a1223_1322 + a32 * a1123_1321 - a33 * a1122_1221; qsqr = q1*q1 + q2 *q2 + q3*q3 + q4*q4; if (qsqr < evecprec) { printf(""Broken rotation in qcprot.c!\n""); /* if qsqr is still too small, return the identity matrix. */ rot[0] = rot[4] = rot[8] = 1.0; rot[1] = rot[2] = rot[3] = rot[5] = rot[6] = rot[7] = 0.0; return(0); } } } } normq = sqrt(qsqr); q1 /= normq; q2 /= normq; q3 /= normq; q4 /= normq; a2 = q1 * q1; x2 = q2 * q2; y2 = q3 * q3; z2 = q4 * q4; xy = q2 * q3; az = q1 * q4; zx = q4 * q2; ay = q1 * q3; yz = q3 * q4; ax = q1 * q2; rot[0] = a2 + x2 - y2 - z2; rot[1] = 2 * (xy + az); rot[2] = 2 * (zx - ay); rot[3] = 2 * (xy - az); rot[4] = a2 - x2 + y2 - z2; rot[5] = 2 * (yz + ax); rot[6] = 2 * (zx + ay); rot[7] = 2 * (yz - ax); rot[8] = a2 - x2 - y2 + z2; return (1); } /* static void CenterCoords(double **coords, const int len, const double *weight) { int i; double xsum, ysum, zsum, wsum; double *x = coords[0], *y = coords[1], *z = coords[2]; xsum = ysum = zsum = 0.0; if (weight != NULL) { wsum = 0.0; for (i = 0; i < len; ++i) { xsum += weight[i] * x[i]; ysum += weight[i] * y[i]; zsum += weight[i] * z[i]; wsum += weight[i]; } xsum /= wsum; ysum /= wsum; zsum /= wsum; } else { for (i = 0; i < len; ++i) { xsum += x[i]; ysum += y[i]; zsum += z[i]; } xsum /= len; ysum /= len; zsum /= len; } for (i = 0; i < len; ++i) { x[i] -= xsum; y[i] -= ysum; z[i] -= zsum; } } */ double CalcRMSDRotationalMatrix(double **coords1, double **coords2, const int len, double *rot, const double *weight) { double A[9], rmsd; /* center the structures */ //CenterCoords(coords1, len, weight); //CenterCoords(coords2, len, weight); /* calculate the (weighted) inner product of two structures */ double E0 = InnerProduct(A, coords1, coords2, len, weight); /* calculate the RMSD & rotational matrix */ FastCalcRMSDAndRotation(rot, A, &rmsd, E0, len, -1); return rmsd; } ","C" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/src/lprmsd.c",".c","35003","932","// This file is part of MSMBuilder. // // Copyright 2011 Stanford University // // MSMBuilder is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 2 of the License, or // (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // You should have received a copy of the GNU General Public License // along with this program; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // #include ""Python.h"" #include ""arrayobject.h"" #include #include #include #include ""theobald_rmsd.h"" #include ""apc.h"" #include #include #define CHECKARRAYFLOAT(ary,name) if (PyArray_TYPE(ary) != NPY_FLOAT32) { \ PyErr_SetString(PyExc_ValueError,name"" was not of type float32"");\ return NULL;\ } #define CHECKARRAYINT(ary,name) if (PyArray_TYPE(ary) != NPY_INT64) {\ PyErr_SetString(PyExc_ValueError,name"" was not of type int"");\ return NULL;\ } #define CHECKARRAYCARRAY(ary,name) if ((PyArray_FLAGS(ary) & NPY_CARRAY) != NPY_CARRAY) {\ PyErr_SetString(PyExc_ValueError,name"" was not a contiguous well-behaved array in C order"");\ return NULL;\ } double APCTime = 0.0 ; double DistMatTime = 0.0 ; int compare (const void * a, const void * b) { return ( *(int*)a - *(int*)b ); } double get_time_precise() { struct timeval tim; double Answer; gettimeofday(&tim,NULL); Answer = tim.tv_sec + (tim.tv_usec/1000000.0); return Answer; } void time_accumulate(double *acc, double start) { double end = get_time_precise(); *(acc) += (end-start); } void drive_permute(int DIM, int STEP, int START, float *xa, float *xb, int *indices, int Subset) { // Input: A bunch of indices. // Result: The indices are swapped. int dx, dy, dz; float x1, y1, z1; float x2, y2, z2; int dr2; int bRect = (Subset != 0 && Subset < DIM); // Conversion factor to go from nanometers to picometers int conv = 1000; int conv2 = conv*conv; // Threshold beyond which the pairwise distance is not computed at all int Thresh = 1000; // A big number used to fill in the distance matrix elements that are thresholded out int BIG = conv2*3; // Allocate the distance matrix (integer). The units are in squared picometers. int *DistanceMatrix, *DistanceMatrixA, *DistanceMatrixB; int *indicesA, *indicesBT, *indicesB, *indicesCount; int *FillIdx; int *FillDist; int *FillSort; DistanceMatrix = calloc(DIM*DIM,sizeof(int)); if (bRect) { DistanceMatrixA = calloc(DIM*DIM,sizeof(int)); DistanceMatrixB = calloc(DIM*DIM,sizeof(int)); indicesA = calloc(DIM,sizeof(int)); indicesB = calloc(DIM,sizeof(int)); indicesBT = calloc(DIM,sizeof(int)); indicesCount = calloc(DIM,sizeof(int)); FillSort = calloc(DIM,sizeof(int)); FillDist = calloc(DIM,sizeof(int)); FillIdx = calloc(DIM,sizeof(int)); } int ENum = 0; int z_p; int INF = 2000000000; double start = get_time_precise(); for (int i=0;i Thresh) dr2 = BIG; else { y2 = xb[1*STEP+j+START]; dy = (int) conv*(y2 - y1); if (dy > Thresh) dr2 = BIG; else { z2 = xb[2*STEP+j+START]; dz = (int) conv*(z2 - z1); if (dz > Thresh) dr2 = BIG; else { dr2 = (dx*dx + dy*dy + dz*dz); } } } if (bRect) { if (i < Subset) { DistanceMatrixA[j*DIM+i] = dr2; } if (j < Subset) { DistanceMatrixB[i*DIM+j] = dr2; } } DistanceMatrix[j*DIM+i] = dr2; } } time_accumulate(&DistMatTime,start); ////////////////////////// /// LPW Drive the APC! /// ////////////////////////// start = get_time_precise(); double ElementA, ElementB; int MapCount = 0; int Fill = 0; if (bRect) { apc(DIM,DistanceMatrixA,INF,&z_p,indicesA); apc(DIM,DistanceMatrixB,INF,&z_p,indicesBT); for (int i=0; ind; i++) { j = (int) array->dimensions[i]; k = (int) array->strides[i]; printf (""%i [stride %i]"", j, k); if (i < (array->nd - 1)) { printf("", ""); } } printf ("")\n""); } static PyObject *_LPRMSD_Multipurpose(PyObject *self, PyObject *args) { /* The all-purpose routine for permutation-invariant and alternate-indexed RMSD. Written by Lee-Ping Wang, 2012. This routine was written with these two capabilities in mind: 1) Permute sets of identical and exchangable atom labels to minimize the RMSD (lets us build MSMs with explicit solvent!) 2) Align using one set of atom labels (i.e. protein) and compute the RMSD using another set of labels (i.e. ligand), motivated by Morgan's projects 3) Align using one set of atom labels and permutable atoms, and compute the RMSD using another set of labels + the same permutable atoms (combines 1 and 2) Conceptually there are three different sets of atomic indices: - AtomIndices are the distinguishable atoms used for alignment - PermuteIndices are identical and exchangeable atoms (more than one batch is possible) - AltIndices are the alternate labels used instead of the AtomIndices when computing the RMSD Note that I can't use PermuteIndices and AltIndices at the same time because that would just be ridiculous. There are several ways in which a user might run this: +- If there are AtomIndices: | |- Perform alignment using AtomIndices; this sets the RMSD values and optionally gets the rotation matrices. | +- If there are no PermuteIndices: | | +- If there are AltIndices: | | | |- Rotate the atoms in AltIndices using the rotation matrix. | | | |- Set the RMSD values by explicitly computing them from pairwise distances. | | +- If we want output coordinates: | | | |- Rotate the whole frame using the rotation matrix | | | |- Assign the rotation matrix to the RotOut array | +- If there are PermuteIndices: | | |- (Not implemented yet, but thinking): If the estimated final answer is larger than some lower bound, then don't go on. | | |- Rotate the atoms in (Atom+Permute)Indices using the rotation matrix +- If there are PermuteIndices: | |- Permute the atomic indices for each batch in PermuteIndices (This is the bottleneck). | |- Perform alignment using (Atom+Permute)Indices; this sets the RMSD values and gets the rotation matrices | +- If output coordinates are requested, or if there are AltIndices: | | |- Rotate the whole frame using the rotation matrix | | |- Relabel the frame using the permutations | | +- If there are AltIndices: | | | |- Loop through the AltIndices and the PermuteAtoms to get the RMSD explicitly +- If output coordinates are requested: | |- Assign the rotated frame to the XYZOut array |- Assign the RMSD values to the RMSDOut array Done!!! The options (codified in the Usage integer): - Whether we have a set of AtomicIndices - Whether we have a set of AltIndices - Whether we have a set of PermuteIndices - Whether we want the output coordinates The arguments: - Input: Flag for usage mode (1 integer) - Input: TheoData for the AtomIndices (7 variables) - Input: TheoData for the AtomIndices+PermuteAtoms (7 variables) - Input: The set of PermuteIndices / AltIndices (1 array) - Input: An array of batch sizes in PermuteIndices (1 array) - Output (pointer): Rotation matrices (1 variable, size NShots * 9) - Input/Output (pointer): Entire trajectory (1 array, size NShots * 3 * NAtoms) - Input: The trajectory frame for the reference coordinate (1 array, size 3 * NAtoms) - Output (return): RMSD array (1 variable, size NShots) */ struct timeval tv; double start, end, dif; /**********************************/ /* Initialize input variables */ /**********************************/ // TheoData for distinguishable atoms PyArrayObject *XYZ_id_a_, *XYZ_id_b_, *G_id_a_; int nreal_id=-1,npad_id=-1,strd_id=-1; float G_id_b=-1; // Arrays for permutable indices and permutable atom 'batch' size (i.e. oxygens, hydrogens) PyArrayObject *LP_Flat_,*LP_Lens_,*LP_Lens_B_; // Array for alternate indices PyArrayObject *Alt_Idx_; // Array for distinguishable indices PyArrayObject *Id_Idx_; // Arrays for RMSD and rotation matrices PyArrayObject *RMSD_, *Rotations_; // The entire set of XYZ coordinates for fitting trajectory and reference frame PyArrayObject *XYZ_all_a_, *XYZ_all_b_; int Usage=-1; // Rectangular permutations (EXPERIMENTAL) int bRect=0; // Debug printout on or off. int DebugPrint = 0; float msd; if (!PyArg_ParseTuple(args, ""iiiiiOOOfOOOOOOOO"", &Usage, &DebugPrint, &nreal_id, &npad_id, &strd_id, &XYZ_id_a_, &XYZ_id_b_, &G_id_a_, &G_id_b, &Id_Idx_, &LP_Flat_, &LP_Lens_, &LP_Lens_B_, &Alt_Idx_, &Rotations_, &XYZ_all_a_, &XYZ_all_b_)) { printf(""Mao says: Inputs / outputs not correctly specified!\n""); return NULL; } if (DebugPrint) { start = get_time_precise(); printf(""Preparing...\n""); } /**********************************/ /* Initialize local variables */ /**********************************/ // Settings for running this subroutine int HaveID = Usage / 1000; int HaveLP = (Usage % 1000) / 100; int HaveAlt = (Usage % 100) / 10; int WantXYZ = (Usage % 10) / 1; // The number of frames. int ns = XYZ_id_a_->dimensions[0]; // Total number of atoms. int na_all = XYZ_all_a_->dimensions[2]; // Number of permutable atom groups int n_lp_grps = LP_Lens_->dimensions[0]; // Number of permutable (or alternate) atoms int lplen = LP_Flat_->dimensions[0]; // Number of alternate index atoms int altlen = Alt_Idx_->dimensions[0]; // Number of distinguishable atoms (true) int na_id = nreal_id; // Number of distinguishable+permutable atoms int na_lp = na_id + lplen; // TheoData for distinguishable atoms float *IDAtoms_Traj_f = (float*) XYZ_id_a_->data; float *IDAtoms0_f = (float*) XYZ_id_b_->data; float *G_id_a = (float*) G_id_a_->data; // Arrays for permutable indices and permutable atom group size long unsigned int *lp_lens = (long unsigned int*) LP_Lens_->data; long unsigned int *lp_lens_B = (long unsigned int*) LP_Lens_B_->data; long unsigned int *lp_idx = (long unsigned int*) LP_Flat_->data; // Arrays for distinguishable atom indices long unsigned int *id_idx = (long unsigned int*) Id_Idx_->data; // Arrays for alternate indices long unsigned int *alt_idx = (long unsigned int*) Alt_Idx_->data; // Arrays for RMSD and rotation matrices; allocate the RMSD array npy_intp dim2[2]; dim2[0] = ns; dim2[1] = 1; RMSD_ = (PyArrayObject*) PyArray_SimpleNew(1,dim2,NPY_FLOAT); float *RMSD = (float*) PyArray_DATA(RMSD_); float *Rotations = (float*) Rotations_->data; // The entire set of XYZ coordinates for fitting trajectory and reference frame float *XYZ_all_a = (float*) XYZ_all_a_->data; float *AllAtoms0_f = (float*) XYZ_all_b_->data; /********************************/ /* LPW Debug Printout */ /********************************/ if (DebugPrint) { printf(""HaveID = %i HaveLP = %i HaveAlt = %i WantXYZ = %i\n"",HaveID,HaveLP,HaveAlt,WantXYZ); PrintDimensions(""XYZ_id_a_"", XYZ_id_a_); PrintDimensions(""XYZ_id_b_"", XYZ_id_b_); PrintDimensions(""G_id_a_"", G_id_a_); printf(""nreal_id: %i, npad_id: %i, stride_id: %i\n"",nreal_id,npad_id,strd_id); printf(""\n""); printf(""Usage Mode: %i\n"",Usage); PrintDimensions(""Rotations_"", Rotations_); PrintDimensions(""XYZ_all_a_"", XYZ_all_a_); PrintDimensions(""XYZ_all_b_"", XYZ_all_b_); PrintDimensions(""LP_Lens_"", LP_Lens_); PrintDimensions(""LP_Lens_B_"", LP_Lens_B_); PrintDimensions(""LP_Flat_"", LP_Flat_); PrintDimensions(""Alt_Idx_"", Alt_Idx_); printf(""LP_Lens has this many dimensions: %i\n"",LP_Lens_->nd); } /*********************************/ /* Initialize internal variables */ /* (Memory is allocated here) */ /*********************************/ // Temporary labels for old and new index int StartIdx; int *lp_starts; float *LPAtoms0_f; if (HaveLP) { // Create an array from the batch size which points to where the batches start // For example [5, 5, 6, 3] -> [0, 5, 10, 16], you know what i mean. lp_starts = calloc(n_lp_grps,sizeof(int)); StartIdx = 0; for (int i = 0; idata[i]; if (DebugPrint) { printf(""Index Group %i : Starts at %i and has Length %i \n"",i,lp_starts[i],*(lp_lens+i)); for (int j = 0; j<*(lp_lens+i); j++) printf(""%i "",lp_idx[lp_starts[i] + j]); printf(""\n""); } } LPAtoms0_f = calloc(na_lp * 3, sizeof(double)); for (int j=0; j= 0) { Old = na_id + lp_starts[k] + p; New = na_id + lp_starts[k] + *(LPIndices_Local+lp_starts[k]+p) ; MapAtoms_d[0*na_lp + Count] = (double)LPAtoms_d[0*na_lp + New]; MapAtoms_d[1*na_lp + Count] = (double)LPAtoms_d[1*na_lp + New]; MapAtoms_d[2*na_lp + Count] = (double)LPAtoms_d[2*na_lp + New]; MapAtoms0_d[0*na_lp + Count] = (double)LPAtoms0_f[0*na_lp + Old]; MapAtoms0_d[1*na_lp + Count] = (double)LPAtoms0_f[1*na_lp + Old]; MapAtoms0_d[2*na_lp + Count] = (double)LPAtoms0_f[2*na_lp + Old]; Count++; New = lp_idx[lp_starts[k] + *(LPIndices_Local+lp_starts[k]+p)]; LPIndices_Global[lp_starts[k]+p] = New; } else { LPIndices_Global[lp_starts[k]+p] = -1; } } time_accumulate(&RelabelTime,start); } // This block computes the center of mass and the Theobald G-value. // It looks like previously I had been trying to determine the sizes of the ""mapatoms"" dynamically. // This was probably because of the ""boundary problem"". // Disabling this so that we recover the original functionality. //nreal_map = Count; //npad_map = Count+4-Count%4; xcena = 0.0; ycena = 0.0; zcena = 0.0; xcenb = 0.0; ycenb = 0.0; zcenb = 0.0; G_map_d = 0.0; G_map0_d = 0.0; for (k=0; k MaxRMSD) MaxRMSD = RMSD[i]; if (RMSD[i] < MinRMSD) MinRMSD = RMSD[i]; } printf(""Min / Max RMSD = % .4f / % .4f\n"",MinRMSD, MaxRMSD); } if (HaveLP) { free(lp_starts); free(LPAtoms0_f); } return PyArray_Return(RMSD_); } static PyMethodDef _lprmsd_methods[] = { {""LPRMSD_Multipurpose"", (PyCFunction)_LPRMSD_Multipurpose, METH_VARARGS, ""Multipurpose permutation-invariant RMSD.""}, {NULL, NULL, 0, NULL} }; DL_EXPORT(void) init_lprmsd(void) { Py_InitModule3(""_lprmsd"", _lprmsd_methods, ""Numpy wrappers for RMSD calculation with linear-programming atomic index permutation.""); import_array(); } ","C" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/scripts/CalculateLPRMSD.py",".py","3955","95","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import numpy as np from msmbuilder import Trajectory, Project from msmbuilder.metrics import RMSD from lprmsd.lprmsd import LPRMSD, ReadPermFile from msmbuilder import arglib def run(project, pdb, traj_fn, atom_indices, alt_indices, permute_indices): #project = Project.load_from_hdf(options.projectfn) traj = Trajectory.load_trajectory_file(traj_fn, Conf=project.Conf) # you could replace this with your own metric if you like metric = LPRMSD(atom_indices, permute_indices, alt_indices) ppdb = metric.prepare_trajectory(pdb) ptraj = metric.prepare_trajectory(traj) print ppdb['XYZList'].shape print ptraj['XYZList'].shape distances, xout = metric.one_to_all_aligned(ppdb, ptraj, 0) print distances return distances if __name__ == '__main__': parser = arglib.ArgumentParser(""""""Takes a trajectory (the input data, 'INPUT') and a PDB, and calculates the RMSD between every frame of the trajectory and PDB for the atoms specified in the atom indicies file. Note that trajectory can be any trajectory-like format, including generators and random conformation files. Output: a flat file vector of RMSDs, in nm. Note that MSMBuilder's RMSD calculator is highly optimized, so this calculation should be rapid. Output: RMSD.dat, a flat text file of the RMSDs."""""") parser.add_argument('pdb') parser.add_argument('input', help='Path to a trajectory-like file') parser.add_argument('project') parser.add_argument('atom_indices', help='Indices of atoms to compare', default='AtomIndices.dat') parser.add_argument('lprmsd_alt_indices', help='''Optional alternate atom indices for RMSD. If you want to align the trajectories using one set of atom indices but then compute the distance using a different set of indices, use this option. If supplied, the regular atom_indices will be used for the alignment and these indices for the distance calculation''', default='AltIndices.dat') parser.add_argument('lprmsd_permute_atoms', default='None', help='''Atom labels to be permuted. Sets of indistinguishable atoms that can be permuted to minimize the RMSD. On disk this should be stored as a list of newline separated indices with a ""--"" separating the sets of indices if there are more than one set of indistinguishable atoms''') parser.add_argument('output', help='Flat text file for the output', default='RMSD.dat') args = parser.parse_args() if args.lprmsd_permute_atoms == 'None': permute_indices = None else: permute_indices = ReadPermFile(args.lprmsd_permute_atoms) arglib.die_if_path_exists(args.output) project = Project.load_from_hdf(args.project) pdb = Trajectory.load_trajectory_file(args.pdb) atom_indices = np.loadtxt(args.atom_indices, dtype=int) lprmsd_alt_indices = np.loadtxt(args.lprmsd_alt_indices, dtype=int) distances = run(project, pdb, args.input, atom_indices, lprmsd_alt_indices, permute_indices) print 'Saving Output: %s' % args.output np.savetxt(args.output, distances) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/scripts/SaveAlignedPDBs.py",".py","9537","200","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import os, sys from msmbuilder import arglib from msmbuilder import Trajectory, io, Project from lprmsd import LPRMSD, ReadPermFile from collections import defaultdict from msmbuilder.clustering import concatenate_trajectories import copy import numpy as np import random import resource def get_size(start_path = '.'): total_size = 0 num_files = 0 for dirpath, dirnames, filenames in os.walk(start_path): for f in filenames: fp = os.path.join(dirpath, f) total_size += os.path.getsize(fp) num_files += 1 return num_files, total_size def get_file_size(fnm): return os.path.getsize(fnm) def run(project, assignments, conformations_per_state, states, output_dir, gens_file, atom_indices, permute_indices, alt_indices, total_memory): if states == ""all"": states = np.arange(assignments['arr_0'].max()+1) # This is a dictionary: {generator : ((traj1, frame1), (traj1, frame3), (traj2, frame1), ... )} inverse_assignments = defaultdict(lambda: []) for i in xrange(assignments['arr_0'].shape[0]): for j in xrange(assignments['arr_0'].shape[1]): inverse_assignments[assignments['arr_0'][i,j]].append((i,j)) if not os.path.exists(output_dir): os.makedirs(output_dir) print ""Setting up the metric."" rmsd_metric = LPRMSD(atom_indices,permute_indices,alt_indices) # This trickery allows us to get the correct number of leading # zeros in the output file name no matter how many generators we have digits = len(str(max(states))) # Create a trajectory of generators and prepare it. if os.path.exists(gens_file): gens_traj = Trajectory.load_trajectory_file(gens_file) p_gens_traj = rmsd_metric.prepare_trajectory(gens_traj) formstr_pdb = '\""Generator-%%0%ii.pdb\""' % digits formstr_xtc = '\""Cluster-%%0%ii.xtc\""' % digits print ""Loading up the trajectories."" traj_bytes = sum([get_file_size(project.traj_filename(i)) for i in range(project.n_trajs)]) LoadAll = 0 MaxMem = 0.0 # LPW This is my hack that decides whether to load trajectories into memory, or to read them from disk. if (traj_bytes * 5) < total_memory * 1073741824: # It looks like the Python script uses roughly 5x the HDF file size in terms of memory. print ""Loading all trajectories into memory."" LoadAll = 1 AllTraj = [project.load_traj(i) for i in np.arange(project.n_trajs)] #print ""After loading trajectories, memory usage is % .3f GB"" % (float(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss) / 1048576) if not os.path.exists(gens_file): if not 'AllTraj' in locals(): raise Exception(('To get away with not supplying a Gens.lh5 structure to align to for each state ' 'you need to have enough memory to load all the trajectories simultaniously. This could be worked around...')) print 'Randomly Sampling from state for structure to align everything to' centers_list = [] for s in states: chosen = inverse_assignments[np.random.randint(len(inverse_assignments[s]))] centers_list.append(AllTraj[chosen[0]][chosen[1]]) gens_traj = concatenate_trajectories(centers_list) p_gens_traj = rmsd_metric.prepare_trajectory(gens_traj) formstr_pdb = '\""Center-%%0%ii.pdb\""' % digits cluster_traj = project.empty_traj() # Loop through the generators. for s in states: if len(inverse_assignments[s]) == 0: raise ValueError('No assignments to state! %s' % s) if conformations_per_state == 'all': confs = inverse_assignments[s] else: random.shuffle(inverse_assignments[s]) if len(inverse_assignments[s]) >= conformations_per_state: confs = inverse_assignments[s][0:conformations_per_state] else: confs = inverse_assignments[s] print 'Not enough assignments in state %s' % s FrameDict = {} for (traj, frame) in confs: FrameDict.setdefault(traj,[]).append(frame) # Create a single trajectory corresponding to the frames that # belong to the current generator. if ""XYZList"" in cluster_traj: cluster_traj[""XYZList""] = None #cluster_traj.pop(""XYZList"") print ""Generator %i"" % s, TrajNums = set([i[0] for i in confs]) for i in TrajNums: if LoadAll: T = AllTraj[i][np.array(FrameDict[i])] else: T = project.load_traj(i)[np.array(FrameDict[i])] cluster_traj += T print "" loaded %i conformations, aligning"" % len(cluster_traj), # Prepare the trajectory, align to the generator, and reassign the coordinates. p_cluster_traj = rmsd_metric.prepare_trajectory(cluster_traj) rmsd, xout = rmsd_metric.one_to_all_aligned(p_gens_traj, p_cluster_traj, s) p_cluster_traj['XYZList'] = xout.copy() # Now save the generator / cluster to a PDB / XTC file. outpdb = eval(formstr_pdb) % s outxtc = eval(formstr_xtc) % s this_gen_traj = p_gens_traj[s] print "", saving PDB to %s"" % os.path.join(output_dir,outpdb), this_gen_traj.save_to_pdb(os.path.join(output_dir,outpdb)) print "", saving XTC to %s"" % os.path.join(output_dir,outxtc), p_cluster_traj.save_to_xtc(os.path.join(output_dir,outxtc)) print "", saved"" NowMem = float(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss) / 1048576 if NowMem > MaxMem: MaxMem = NowMem #print ""This script used at least % .3f GB of memory"" % MaxMem if __name__ == '__main__': parser = arglib.ArgumentParser("""""" Pulls the specified number of random structures (or optionally all structures) from each state in an assignments file, aligned to the generators. Specify which states to pull from with space-seperated ints Output: A bunch of PDB files named: State-, inside the directory 'PDBs' Note: If you want to get structures for all states, it is more efficient to use GetRandomConfs.py"""""") parser.add_argument('project') parser.add_argument('assignments', default='Data/Assignments.Fixed.h5') parser.add_argument('conformations_per_state', default=5, type=int, help='Number of conformations to sample from each state: to specify ALL of the conformations, pass the integer -1.') parser.add_argument('states', nargs='+', type=int, help='''Which states to sample from. Pass a list of integers, separated by whitespace. To specify ALL of the states (Although the script GetRandomConfs.py is more efficient for this purpose), pass the integer -1.''') parser.add_argument('lprmsd_atom_indices', help='Regular atom indices', default='AtomIndices.dat') parser.add_argument('lprmsd_alt_indices', default='None', help='Alternate atom indices') parser.add_argument('lprmsd_permute_atoms', default='None', help='''Atom labels to be permuted. Sets of indistinguishable atoms that can be permuted to minimize the RMSD. On disk this should be stored as a list of newline separated indices with a ""--"" separating the sets of indices if there are more than one set of indistinguishable atoms''') parser.add_argument('total_memory_gb', default=4, type=int, help='Available memory in GB; this determines whether to load all trajectories into memory or to read them one-by-one from disk.') parser.add_argument('generators', help='''Trajectory file containing the structures of each of the cluster centers. Produced using Cluster.py.''', default='Data/Gens.lh5') parser.add_argument('output_dir', default='PDBs') args = parser.parse_args() if -1 in args.states: print ""Ripping PDBs for all states"" args.states = 'all' if args.conformations_per_state == -1: print ""Getting all PDBs for each state"" args.conformations_per_state = 'all' atom_indices = np.loadtxt(args.lprmsd_atom_indices, np.int) assignments = io.loadh(args.assignments) project = Project.load_from(args.project) if args.lprmsd_permute_atoms == 'None': permute_indices = None else: permute_indices = ReadPermFile(args.lprmsd_permute_atoms) if args.lprmsd_alt_indices == 'None': alt_indices = None else: alt_indices = np.loadtxt(args.lprmsd_alt_indices, np.int) run(project, assignments, args.conformations_per_state, args.states, args.output_dir, args.generators, atom_indices, permute_indices, alt_indices, args.total_memory_gb) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/LPRMSD/tests/TestLPRMSD_00.py",".py","943","31","import numpy as np import numpy.testing as npt import IPython as ip # LPRMSD is a class defined in lprmsd.py which is the lprmsd package. from lprmsd import LPRMSD from msmbuilder import Trajectory from msmbuilder.metrics import RMSD def test_lprmsd(): t = Trajectory.load_trajectory_file('trj0.lh5') MyIdx = np.array([1, 4, 5, 6, 8, 10, 14, 15, 16, 18]) lprmsd = LPRMSD(atomindices=MyIdx, debug=True) lptraj = lprmsd.prepare_trajectory(t) dists = lprmsd.one_to_all(lptraj, lptraj, 0) lprmsd_alt = LPRMSD(atomindices=MyIdx, altindices=MyIdx, debug=True) lptraj_alt = lprmsd_alt.prepare_trajectory(t) dists_alt = lprmsd_alt.one_to_all(lptraj_alt, lptraj_alt, 0) rmsd = RMSD(atomindices=MyIdx) reftraj = rmsd.prepare_trajectory(t) ref_dists = rmsd.one_to_all(reftraj, reftraj, 0) npt.assert_array_almost_equal(dists, ref_dists) npt.assert_array_almost_equal(dists_alt, ref_dists) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/FAHTools/StripWatersFAH.py",".py","2499","75","import os import string def run(): ProjNum=10424 NumClones=1 NumRuns=50000 ServerIP=""171.64.65.79"" IntServerIP=int(string.replace(ServerIP,""."","""")) ProjName=""PROJ%d""%ProjNum CleanDir=""./CleanData/"" OutDir=""%s/%s""%(CleanDir,ProjName) SourceDir=""./data/SVR%d/%s/""%(IntServerIP,ProjName) NDXFile=""/home/server.171.64.65.79/server2/kyleb/10424/notsol.ndx"" TPRFile=SourceDir+""/RUN0/CLONE0/frame0.tpr"" MinGens=77 MaxGens=1000 CreateFolders(CleanDir,OutDir,NumRuns,NumClones) StripWaters(OutDir,NumRuns,NumClones,SourceDir,NDXFile,TPRFile,MinGens,MaxGens) def CreateFolders(CleanDir,OutDir,NumRuns,NumClones): """"""Create folders to store preprocessed XTC files from a FAH project."""""" try: os.mkdir(CleanDir) os.mkdir(OutDir) except OSError: print(""Directory %s already found. No directories will be created.""%OutDir) return for i in range(NumRuns): DirName=""./%s/RUN%d/""%(OutDir,i) os.mkdir(DirName) for j in range(NumClones): DirName=""./%s/RUN%d/CLONE%d/""%(OutDir,i,j) print(""Making Directory %s""%DirName) os.mkdir(DirName) def StripWaters(OutDir,NumRuns,NumClones,SourceDir,NDXFile,TPRFile,MinGens=1,MaxGens=1000): """"""Preprocess XTC files from a FAH project. """""" for i in range(NumRuns): print(""RUN%d""%i) for j in range(NumClones): DirName=""%s/RUN%d/CLONE%d/""%(OutDir,i,j) InDirName=""%s/RUN%d/CLONE%d/""%(SourceDir,i,j) CurrentNumGens=0 for k in range(MaxGens): InXTCFile=InDirName+""/frame%d.xtc""%k OutXTCFile=DirName+""/frame%d.xtc""%k if os.path.exists(InXTCFile): CurrentNumGens+=1 if CurrentNumGens<=MinGens: CurrentNumGens=0 for k in range(CurrentNumGens): InXTCFile=InDirName+""/frame%d.xtc""%k OutXTCFile=DirName+""/frame%d.xtc""%k if os.path.exists(OutXTCFile): print(""Skipping %s; already copied.""%OutXTCFile) else: print(""Copying %s.""%OutXTCFile) cmd=""trjconv -f %s -n %s -pbc whole -o %s -s %s""%(InXTCFile,NDXFile,OutXTCFile,TPRFile) print(cmd) os.system(cmd) if __name__ == ""__main__"": print """""" Strip Waters and Preprocess XTCs in FAH project. """""" run() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/parallel_assign/setup.py",".py","458","14","import sys import glob from setuptools import setup setup(name='parallel_assign', version = '1.0', description = 'Parallel Assignment MSMBuilder', packages=['parallel_assign', 'parallel_assign.scripts'], package_dir={'parallel_assign':'lib', 'parallel_assign.scripts':'scripts'}, install_requires=['ipython==0.13'], scripts=filter(lambda elem: '_' not in elem, glob.glob('scripts/*'))) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/parallel_assign/assign_pbs_example.sh",".sh","1362","49","#PBS -N assign #PBS -l walltime=1:00:00 #PBS -l nodes=2:ppn=24 #PBS -q default #PBS -o /dev/null #PBS -e /dev/null PROJECT=$HOME/WW/ProjectInfo.h5 GENS=$HOME/WW/rmsd/hybrid5k/Gens.lh5 OUT_DIR=$HOME/test CHUNK_SIZE=1000 METRIC=""rmsd -a $HOME/WW/AtomIndices.dat"" LOG_FILE=$OUT_DIR/assign.log #make sure the outdir exists mkdir -p $OUT_DIR #set 11 threads so that one is available for AssignIPP and ipcontroller export OMP_NUM_THREADS=11 if [ -n ""$PBS_ENVIRONMENT"" ]; then # execute inside PBS environment cd $PBS_O_WORKDIR ipcontroller --ip='*' --cluster-id $PBS_JOBID &> $LOG_FILE.ipcontroller & sleep 2 mpirun --npernode 1 -np $PBS_NUM_NODES --machinefile $PBS_NODEFILE ipengine --cluster-id $PBS_JOBID &> $LOG_FILE.mpirun & sleep 5 # leave enough time for the engines to connect to the controller AssignIPP.py -p $PROJECT -g $GENS -o $OUT_DIR -c $CHUNK_SIZE -C $PBS_JOBID $METRIC &> $LOG_FILE else # we're not executing in a PBS environment, but we want # to test this script anyways CLUSTER_ID=$0 ipcontroller --ip='*' --cluster-id $CLUSTER_ID & # &> $LOG_FILE.ipcontroller & sleep 5 ipengine --cluster-id $CLUSTER_ID & # &> $LOG_FILE.mpirun & sleep 5 AssignIPP.py -p $PROJECT -g $GENS -o $OUT_DIR -c $CHUNK_SIZE -C $CLUSTER_ID $METRIC # &> $LOG_FILE kill %1 %2 %3 fi echo ""finished"" ","Shell" "Conformation","msmbuilder/msmbuilder-legacy","Extras/parallel_assign/lib/remote.py",".py","1953","72",""""""" Functions that execute remotely on the workers Note that there are thre globals on each worker, pgens, conf and metric. Also, due to the way that IPython.parallel works, we do imports inside the functions """""" PREPARED, PGENS, CONF, METRIC = False, None, None, None def load_gens(gens_fn, conf_fn, metric): """"""Setup a worker by adding pgens to its global namespace This is necessary because pgens are not necessarily picklable, so we can't just prepare them on the master and then push them to the remote workers -- instead we want to actually load the pgens from disk and prepare them on the remote node """""" from msmbuilder import Trajectory global PGENS, CONF, METRIC, PREPARED METRIC = metric CONF = Trajectory.load_trajectory_file(conf_fn) gens = Trajectory.load_trajectory_file(gens_fn) PGENS = metric.prepare_trajectory(gens) PREPARED = True def assign(vtraj, gens_fn, metric): """""" Assign a VTraj to the generators This executes on the remote workers. It uses two global variables which are worker-local Parameters ---------- vtraj : VTraj A list of tuples like (traj_index, slice(start, end)) Globals ------- conf : msmbuilder.Trajectory metric : msmbuilder.metrics.AbstractDistanceMetric """""" import numpy as np global CONF if not PREPARED: load_gens(gens_fn, vtraj.project.conf_filename, metric) traj = vtraj.load(CONF) ptraj = METRIC.prepare_trajectory(traj) n_frames = len(traj) distances = np.zeros(n_frames) assignments = np.zeros(n_frames, dtype=int) for i in xrange(n_frames): d_o2a = METRIC.one_to_all(ptraj, PGENS, i) #d = np.zeros(len(ptraj)) assignments[i] = np.argmin(d_o2a) distances[i] = d_o2a[assignments[i]] return assignments, distances, vtraj ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/parallel_assign/lib/vtraj.py",".py","3665","122","from hashlib import sha1 import numpy import tables from msmbuilder import Trajectory from msmbuilder.Trajectory import _convert_from_lossy_integers class Chunk(object): def __init__(self, traj, start, stop): self.traj = traj self.start = start self.stop = stop def __repr__(self): return str((self.traj, self.start, self.stop)) def __iter__(self): return (e for e in (self.traj, self.start, self.stop)) def __len__(self): return self.stop - self.start class VTraj(object): """"""A ""Virtual Trajectory"" -- a logical collection of frames that do not necessarily come from the same physical trajectory. Each VTraj is represented as a list of Chunks. Each Chunk represents a slice of a physical trajectory, and itself is represented by the index of the physical trajectory, and a starting ending index (of where) the slice is The VTraj provides a load() method to load the frames from disk. """""" def __init__(self, project, *args): self.chunks = [] self.project = project for arg in args: if isinstance(arg, tuple): self.append(Chunk(*arg)) elif isinstance(arg, Chunk): self.append(arg) else: raise TypeError() def __repr__(self): return str(self.chunks) def append(self, arg): if isinstance(arg, tuple): self.chunks.append(Chunk(*arg)) elif isinstance(arg, Chunk): self.chunks.append(arg) else: raise TypeError() def __iter__(self): return (e for e in self.chunks) def __len__(self): return sum(len(e) for e in self.chunks) def hash(self): """"""Unique identifier of VTraj The identifier is based only on the chunks, and not on the actual data in the project file. Returns ------- hash : str A unique identifier (sha1 hash) """""" return sha1(str([str(e) for e in self.chunks])).hexdigest() def load(self, conf): """"""Load the coordinates and get a physical trajectory The filename to load from is taken from the project file. Parameters ---------- conf : msmbuilder.Trajectory When we load the trajectories from disk, at this point we're only getting the XYZ coordinates. The XYZ coordinates will be injected into conf as a ""container"" Returns ------- traj : msmbuilder.Trajectory This is `conf`, with the XYZ coordinates loaded from disk """""" n_atoms = conf.GetNumberOfAtoms() xyzlist = numpy.zeros((len(self), n_atoms, 3), dtype=numpy.float32) last_frame = 0 for trj_i, start, stop in self.chunks: f = tables.File(self.project.traj_filename(trj_i)) frames = _convert_from_lossy_integers(f.root.XYZList[start:stop], 1000) xyzlist[last_frame:last_frame + len(frames), :, :] = frames last_frame += len(frames) f.close() conf['XYZList'] = xyzlist return conf def canonical(self): """"""Simple representation for testing Returns ------- canonical_rep : list representation of the VTraj as a list of (traj, start, stop) tuples. """""" return list(tuple(e) for e in self) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/parallel_assign/lib/__init__.py",".py","0","0","","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/parallel_assign/lib/local.py",".py","5649","166","import os import numpy as np import tables from parallel_assign.vtraj import VTraj from msmbuilder import io def partition(project, chunk_size): """"""Partition the frames in a project into a list of virtual trajectories (VTraj) of length <= chunk_size Returns ------- vtrajs : list list of VTrajs """""" if not all(int(e) == e for e in project.traj_lengths): raise ValueError('must me ints') if not all(e > 0 for e in project.traj_lengths): raise ValueError('must be >0') def generate(): ""generator for the sections"" last = VTraj(project) for i in xrange(0, project.n_trajs): end = 0 if len(last) != 0: end = chunk_size - len(last) if end < project.traj_lengths[i]: last.append((i, 0, end)) yield last last = VTraj(project) else: end = project.traj_lengths[i] last.append((i, 0, end)) for j in xrange(end, project.traj_lengths[i], chunk_size): if j + chunk_size <= project.traj_lengths[i]: yield VTraj(project, (i, j, j + chunk_size)) last = VTraj(project) else: last.append((i, j, project.traj_lengths[i])) if len(last) > 0: yield last all_vtrajs = list(generate()) if sum(len(vt) for vt in all_vtrajs) != np.sum(project.traj_lengths): raise ValueError('Chunking error. Lengths dont match') return all_vtrajs def setup_containers(outputdir, project, all_vtrajs): """""" Setup the files on disk (Assignments.h5 and Assignments.h5.distances) that results will be sent to. Check to ensure that if they exist (and contain partial results), the containers are not corrupted Parameters ---------- outputdir : str path to save/find the files project : msmbuilder.Project The msmbuilder project file. Only the NumTrajs and TrajLengths are actully used (if you want to spoof it, you can just pass a dict) all_vtrajs : list The VTrajs are used to check that the containers on disk, if they exist, contain the right stuff Returns ------- f_assignments : tables.File pytables handle to the assignments file, open in 'append' mode f_distances : tables.File pytables handle to the assignments file, open in 'append' mode """""" if not os.path.exists(outputdir): os.mkdir(outputdir) assignments_fn = os.path.join(outputdir, 'Assignments.h5') distances_fn = os.path.join(outputdir, 'Assignments.h5.distances') n_trajs = project.n_trajs max_n_frames = np.max(project.traj_lengths) n_vtrajs = len(all_vtrajs) hashes = np.array([c.hash() for c in all_vtrajs]) minus_ones = -1 * np.ones((n_trajs, max_n_frames)) def save_container(filename, dtype): io.saveh(filename, arr_0=np.array(minus_ones, dtype=dtype), completed_vtrajs=np.zeros((n_vtrajs), dtype=np.bool), hashes=hashes) def check_container(filename): ondisk = io.loadh(filename, deferred=False) if n_vtrajs != len(ondisk['hashes']): raise ValueError('You asked for {} vtrajs, but your checkpoint \ file has {}'.format(n_vtrajs, len(ondisk['hashes']))) if not np.all(ondisk['hashes'] == hashes): raise ValueError('Hash mismatch. Are these checkpoint files for \ the right project?') # save assignments container if (not os.path.exists(assignments_fn)) \ and (not os.path.exists(distances_fn)): save_container(assignments_fn, np.int) save_container(distances_fn, np.float32) elif os.path.exists(assignments_fn) and os.path.exists(distances_fn): check_container(assignments_fn) check_container(distances_fn) else: raise ValueError(""You're missing one of the containers"") # append mode is read and write f_assignments = tables.openFile(assignments_fn, mode='a') f_distances = tables.openFile(distances_fn, mode='a') return f_assignments, f_distances def save(f_assignments, f_distances, assignments, distances, vtraj): """""" Save assignments to disk Parameters ---------- f_assignments : tables.File pytables handle to the assignments file to write to f_distances : tables.File pytables handle to the assignments file to write to assignments : np.ndarray 1D array of the assignments for vtraj. should be dtype=np.int distanes : np.ndarray 1D array of the distances for vtraj. should be dtype=np.float32 vtraj : passign.VTraj logical trajectory object listing which physical trajectory/frames these assignments/distances correspond to """""" ptr = 0 for trj_i, start, stop in vtraj: end = ptr + stop - start f_assignments.root.arr_0[trj_i, start:stop] = assignments[ptr:end] f_distances.root.arr_0[trj_i, start:stop] = distances[ptr:end] ptr = end vtraj_i = np.where(f_assignments.root.hashes[:] == vtraj.hash())[0] if len(vtraj_i) != 1: raise ValueError('no matching vtraj?') vtraj_i = vtraj_i[0] f_assignments.root.completed_vtrajs[vtraj_i] = True f_assignments.flush() f_distances.flush() return vtraj_i ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/parallel_assign/scripts/AssignParallel.py",".py","7120","184","#!/usr/bin/env python import sys, os import numpy as np import logging import IPython as ip from IPython import parallel from IPython.parallel.error import RemoteError from msmbuilder import arglib from msmbuilder import metrics from msmbuilder import Project from parallel_assign import remote, local def setup_logger(console_stream=sys.stdout): """""" Setup the logger """""" formatter = logging.Formatter('%(name)s: %(asctime)s: %(message)s', '%I:%M:%S %p') console_handler = logging.StreamHandler(console_stream) console_handler.setFormatter(formatter) logger = logging.getLogger(os.path.split(sys.argv[0])[1]) logger.root.handlers = [console_handler] return logger def main(args, metric, logger): project = Project.load_from(args.project) if not os.path.exists(args.generators): raise IOError('Could not open generators') generators = os.path.abspath(args.generators) output_dir = os.path.abspath(args.output_dir) # connect to the workers try: json_file = client_json_file(args.profile, args.cluster_id) client = parallel.Client(json_file, timeout=2) except parallel.error.TimeoutError as exception: msg = '\nparallel.error.TimeoutError: ' + str(exception) msg += ""\n\nPerhaps you didn't start a controller?\n"" msg += ""(hint, use ipcluster start)"" print >> sys.stderr, msg sys.exit(1) lview = client.load_balanced_view() # partition the frames into a bunch of vtrajs all_vtrajs = local.partition(project, args.chunk_size) # initialze the containers to save to disk f_assignments, f_distances = local.setup_containers(output_dir, project, all_vtrajs) # get the chunks that have not been computed yet valid_indices = np.where(f_assignments.root.completed_vtrajs[:] == False)[0] remaining_vtrajs = np.array(all_vtrajs)[valid_indices].tolist() logger.info('%d/%d jobs remaining', len(remaining_vtrajs), len(all_vtrajs)) # send the workers the files they need to get started # dview.apply_sync(remote.load_gens, generators, project['ConfFilename'], # metric) # get the workers going n_jobs = len(remaining_vtrajs) amr = lview.map(remote.assign, remaining_vtrajs, [generators]*n_jobs, [metric]*n_jobs, chunksize=1) pending = set(amr.msg_ids) while pending: client.wait(pending, 1e-3) # finished is the set of msg_ids that are complete finished = pending.difference(client.outstanding) # update pending to exclude those that just finished pending = pending.difference(finished) for msg_id in finished: # we know these are done, so don't worry about blocking async = client.get_result(msg_id) try: assignments, distances, chunk = async.result[0] except RemoteError as e: print 'Remote Error:' e.print_traceback() raise vtraj_id = local.save(f_assignments, f_distances, assignments, distances, chunk) log_status(logger, len(pending), n_jobs, vtraj_id, async) f_assignments.close() f_distances.close() logger.info('All done, exiting.') def log_status(logger, n_pending, n_jobs, job_id, async_result): """"""After a job has completed, log the status of the map to the console Parameters ---------- logger : logging.Logger logger to print to n_pending : int number of jobs still remaining n_jobs : int total number of jobs in map job_id : int the id of the job that just completed (between 0 and n_jobs) async_esult : IPython.parallel.client.asyncresult.AsyncMapResult the container with the job results. includes not only the output, but also metadata describing execution time, etc. """""" if ip.release.version >= '0.13': t_since_submit = async_result.completed - async_result.submitted time_remaining = n_pending * (t_since_submit) / (n_jobs - n_pending) td = (async_result.completed - async_result.started) #this is equivalent to the td.total_seconds() method, which was #introduced in python 2.7 execution_time = (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / float(10**6) eta = (async_result.completed + time_remaining).strftime('%I:%M %p') else: execution_time, eta = '?', '?' logger.info('engine: %s; chunk %s; %ss; status: %s; %s/%s remaining; eta %s', async_result.metadata.engine_id, job_id, execution_time, async_result.status, n_pending, n_jobs, eta) def setup_parser(): parser = arglib.ArgumentParser("""""" Assign data that were not originally used in the clustering (because of striding) to the microstates. This is applicable to all medoid-based clustering algorithms, which includes all those implemented by Cluster.py except the hierarchical methods. (For assigning to a hierarchical clustering, use AssignHierarchical.py) This code uses IPython.parallel to get parallelism accross many nodes. Consult the documentation for details on how to run it"""""", get_metric=True) parser.add_argument('project') parser.add_argument( dest='generators', help='''Trajectory file containing the structures of each of the cluster centers.''') parser.add_argument('output_dir') parser.add_argument('chunk_size', help='''Number of frames to processes per worker. Each chunk requires some communication overhead, so you should use relativly large chunks''', default=1000, type=int) parser.add_argument('profile', help='IPython.parallel profile to use.', default='default') parser.add_argument('cluster_id', help='IPython.parallel cluster_id to use', default='') args, metric = parser.parse_args() return args, metric def client_json_file(profile='default', cluster_id=None): """""" Get the path to the ipcontroller-client.json file. This really shouldn't be necessary, except that IPython doesn't automatically insert the cluster_id in the way that it should. I submitted a pull request to fix it, but here is a monkey patch in the mean time """""" from IPython.core.profiledir import ProfileDir from IPython.utils.path import get_ipython_dir profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile) if not cluster_id: client_json = 'ipcontroller-client.json' else: client_json = 'ipcontroller-%s-client.json' % cluster_id filename = os.path.join(profile_dir.security_dir, client_json) if not os.path.exists(filename): raise ValueError('controller information not found at: %s' % filename) return filename if __name__ == '__main__': args, metric = setup_parser() logger = setup_logger() main(args, metric, logger) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/parallel_assign/scripts/__init__.py",".py","0","0","","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/parallel_assign/tests/test_remote.py",".py","1936","49","import os import numpy as np import numpy.testing as npt import IPython as ip from msmbuilder import Trajectory, Project from msmbuilder import metrics from parallel_assign import remote from parallel_assign.remote import assign from parallel_assign.local import partition from parallel_assign.vtraj import VTraj from common import fixtures_dir class test_assign(): def setup(self): self.metric = metrics.Dihedral() self.pdb_fn = os.path.join(fixtures_dir(), 'native.pdb') self.trj_fn = os.path.join(fixtures_dir(), 'trj0.lh5') self.project = Project({'traj_lengths': [501], 'traj_paths': [self.trj_fn], 'conf_filename': self.pdb_fn, 'traj_converted_from': [None], 'traj_errors': [None]}) self.vtraj = partition(self.project, chunk_size=501)[0] def test_0(self): assert os.path.exists(self.pdb_fn), 'file for testing not found' assert os.path.exists(self.trj_fn), 'file for testing not found' def test_1(self): # assigning some confs to themselves a,d,vtraj = assign(self.vtraj, self.trj_fn, self.metric) npt.assert_array_equal(a, np.arange(501)) npt.assert_array_almost_equal(d, np.zeros(501), decimal=3) assert vtraj == self.vtraj def test_2(self): # reset the global remote.PREPARED=False # get a smaller vtraj, and just assign it to only the pDB vtraj = partition(self.project, chunk_size=10)[1] a,d,vtraj = assign(vtraj, self.pdb_fn, self.metric) # these are the right RMSD distances correct_d = np.array([ 0.26932446, 0.53129266, 0.64795935, 1.56435365, 1.05962805, 0.60572095, 0.47062515, 0.5758602 , 0.24565975, 0.69161412], dtype=np.float32) npt.assert_array_almost_equal(d, correct_d) npt.assert_array_equal(a, np.zeros(10)) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/parallel_assign/tests/common.py",".py","266","7","import os import inspect def fixtures_dir(): #http://stackoverflow.com/questions/50499/in-python-how-do-i-get-the-path-and-name-of-the-file-that-is-currently-executin return os.path.join(os.path.dirname(inspect.getfile(inspect.currentframe())), 'fixtures') ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/parallel_assign/tests/__init__.py",".py","0","0","","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/parallel_assign/tests/test_local.py",".py","3091","110","import numpy as np import numpy.testing as npt from collections import namedtuple from parallel_assign.local import partition, setup_containers, save from nose.tools import raises import tempfile import tables import IPython as ip import os import glob Project = namedtuple('Project', 'traj_lengths n_trajs') def test_partition_0(): project = Project([2,5], 2) chunk_size = 3 got = partition(project, chunk_size) correct = [[(0, 0, 2), (1, 0, 1)], [(1, 1, 4)], [(1, 4,5)]] assert [e.canonical() for e in got] == correct assert sum(len(e) for e in got) == sum(project.traj_lengths) def test_partition_1(): project = Project([2,1,10], 3) chunk_size = 4 got = partition(project, chunk_size) correct = [[(0,0,2), (1,0,1), (2,0,1)], [(2,1,5)], [(2,5,9)], [(2,9,10)]] assert [e.canonical() for e in got] == correct assert sum(len(e) for e in got) == sum(project.traj_lengths) @raises(ValueError) def test_partition_2(): project = Project([1,1,-1], 3) chunk_size = 1 partition(project, chunk_size) @raises(TypeError) def test_partition_3(): project = Project([1,1.5,1], 3) chunk_size = 1 partition(project, chunk_size) @raises(ValueError) def test_partition_3(): project = Project([1,0], 2) chunk_size = 1 partition(project, chunk_size) def test_partition_4(): project = Project([1], 1) chunk_size = 11 got = partition(project, chunk_size) correct = [[(0,0,1)]] assert [e.canonical() for e in got] == correct class test_containers(): def setup(self): self.d = tempfile.mkdtemp() project = Project([9,10], 2) self.vtrajs = partition(project, 3) self.fa, self.fd = setup_containers(self.d, project, self.vtrajs) def test_0(self): assert isinstance(self.fa, tables.file.File) assert isinstance(self.fd, tables.file.File) assert self.fa.root.arr_0.shape == (2,10) assert self.fd.root.arr_0.shape == (2,10) assert self.fa.root.hashes.shape == (len(self.vtrajs), ) assert self.fd.root.hashes.shape == (len(self.vtrajs), ) assert self.fa.root.completed_vtrajs.shape == (len(self.vtrajs), ) assert self.fd.root.completed_vtrajs.shape == (len(self.vtrajs), ) def test_1(self): vtraj = self.vtrajs[2] assert len(vtraj) == 3 assignments = 1234 * np.ones(len(vtraj)) distances = np.random.randn(len(vtraj)).astype(np.float32) save(self.fa, self.fd, assignments, distances, vtraj) AData = -1 * np.ones((2,10)) AData[0,6:9] = 1234 DData = -1 * np.ones((2,10), dtype=np.float32) DData[0,6:9] = distances npt.assert_equal(self.fa.root.arr_0, AData) npt.assert_equal(self.fd.root.arr_0, DData) def teardown(self): self.fa.close() self.fd.close() for e in glob.glob(os.path.join(self.d, '*')): os.unlink(e) os.rmdir(self.d) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/parallel_assign/tests/test_script.py",".py","3191","92","import sys, os, shutil import subprocess import tempfile import time import numpy.testing as npt from nose.tools import eq_, ok_ import IPython as ip from msmbuilder import io, metrics from common import fixtures_dir from parallel_assign.scripts import AssignParallel def test_setup_logger(): progname = 'TEST PROGNAME' message = 'TEST MESSAGE' sys.argv[0] = progname fid, path = tempfile.mkstemp() stream = open(path, 'w') logger = AssignParallel.setup_logger(console_stream=stream) logger.info(message) stream.flush() line = open(path).readlines()[0] os.unlink(path) ok_(line.startswith(progname)) ok_(line.endswith(message + '\n')) class test_main: class Args: project = os.path.join(fixtures_dir(), 'ProjectInfo.h5') generators = os.path.join(fixtures_dir(), 'Gens.lh5') profile = 'default' cluster_id = '' chunk_size=10 def setup(self): self.metric = metrics.Dihedral() def test_1(self): try: subprocess.Popen('ipcluster start --n=1 --daemonize', shell=True) time.sleep(5) args = self.Args() args.output_dir = tempfile.mkdtemp() logger = AssignParallel.setup_logger() AssignParallel.main(args, self.metric, logger) assignments = io.loadh(os.path.join(args.output_dir, 'Assignments.h5'), 'arr_0') r_assignments = io.loadh(os.path.join(fixtures_dir(), 'Assignments.h5'), 'Data') distances = io.loadh(os.path.join(args.output_dir, 'Assignments.h5.distances'), 'arr_0') r_distances = io.loadh(os.path.join(fixtures_dir(), 'Assignments.h5.distances'), 'Data') npt.assert_array_equal(assignments, r_assignments) npt.assert_array_almost_equal(distances, r_distances) except: raise finally: shutil.rmtree(args.output_dir) subprocess.Popen('ipcluster stop', shell=True).wait() def test_2(self): try: subprocess.Popen('ipcluster start --cluster-id=testclusterid --n=1 --daemonize', shell=True) time.sleep(5) args = self.Args() args.output_dir = tempfile.mkdtemp() args.cluster_id = 'testclusterid' logger = AssignParallel.setup_logger() AssignParallel.main(args, self.metric, logger) assignments = io.loadh(os.path.join(args.output_dir, 'Assignments.h5'), 'arr_0') r_assignments = io.loadh(os.path.join(fixtures_dir(), 'Assignments.h5'), 'Data') distances = io.loadh(os.path.join(args.output_dir, 'Assignments.h5.distances'), 'arr_0') r_distances = io.loadh(os.path.join(fixtures_dir(), 'Assignments.h5.distances'), 'Data') npt.assert_array_equal(assignments, r_assignments) npt.assert_array_almost_equal(distances, r_distances) except: raise finally: shutil.rmtree(args.output_dir) subprocess.Popen('ipcluster stop --cluster-id=testclusterid', shell=True).wait() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/GPURMSD/setup.py",".py","5311","137","import os from os.path import join as pjoin from setuptools import setup from distutils.extension import Extension from distutils.command.build_ext import build_ext import subprocess import numpy def find_in_path(name, path): ""Find a file in a search path"" #adapted fom http://code.activestate.com/recipes/52224-find-a-file-given-a-search-path/ for dir in path.split(os.pathsep): binpath = pjoin(dir, name) if os.path.exists(binpath): return os.path.abspath(binpath) return None def locate_cuda(): """"""Locate the CUDA environment on the system Returns a dict with keys 'home', 'nvcc', 'include', and 'lib64' and values giving the absolute path to each directory. Starts by looking for the CUDAHOME env variable. If not found, everything is based on finding 'nvcc' in the PATH. """""" # first check if the CUDAHOME env variable is in use if 'CUDAHOME' in os.environ: home = os.environ['CUDAHOME'] nvcc = pjoin(home, 'bin', 'nvcc') else: # otherwise, search the PATH for NVCC nvcc = find_in_path('nvcc', os.environ['PATH']) if nvcc is None: raise EnvironmentError('The nvcc binary could not be ' 'located in your $PATH. Either add it to your path, or set $CUDAHOME') home = os.path.dirname(os.path.dirname(nvcc)) cudaconfig = {'home':home, 'nvcc':nvcc, 'include': pjoin(home, 'include'), 'lib64': pjoin(home, 'lib64')} for k, v in cudaconfig.iteritems(): if not os.path.exists(v): raise EnvironmentError('The CUDA %s path could not be located in %s' % (k, v)) return cudaconfig CUDA = locate_cuda() def customize_compiler_for_nvcc(self): """"""inject deep into distutils to customize how the dispatch to gcc/nvcc works. If you subclass UnixCCompiler, it's not trivial to get your subclass injected in, and still have the right customizations (i.e. distutils.sysconfig.customize_compiler) run on it. So instead of going the OO route, I have this. Note, it's kindof like a wierd functional subclassing going on."""""" # tell the compiler it can processes .cu self.src_extensions.append('.cu') # save references to the default compiler_so and _comple methods default_compiler_so = self.compiler_so super = self._compile # now redefine the _compile method. This gets executed for each # object but distutils doesn't have the ability to change compilers # based on source extension: we add it. def _compile(obj, src, ext, cc_args, extra_postargs, pp_opts): if os.path.splitext(src)[1] == '.cu': # use the cuda for .cu files self.set_executable('compiler_so', CUDA['nvcc']) # use only a subset of the extra_postargs, which are 1-1 translated # from the extra_compile_args in the Extension class postargs = extra_postargs['nvcc'] else: postargs = extra_postargs['gcc'] super(obj, src, ext, cc_args, postargs, pp_opts) # reset the default compiler_so, which we might have changed for cuda self.compiler_so = default_compiler_so # inject our redefined _compile method into the class self._compile = _compile # run the customize_compiler class custom_build_ext(build_ext): def build_extensions(self): customize_compiler_for_nvcc(self.compiler) build_ext.build_extensions(self) # Obtain the numpy include directory. This logic works across numpy versions. try: numpy_include = numpy.get_include() except AttributeError: numpy_include = numpy.get_numpy_include() # check for swig if find_in_path('swig', os.environ['PATH']): subprocess.check_call('swig -python -c++ -o gpurmsd/swGPURMSD.cpp gpurmsd/swig.i', shell=True) else: raise EnvironmentError('the swig executable was not found in your PATH') ext = Extension('gpurmsd._swGPURMSD', sources=['gpurmsd/swGPURMSD.cpp', 'gpurmsd/RMSD.cu'], library_dirs=[CUDA['lib64']], libraries=['cudart'], runtime_library_dirs=[CUDA['lib64']], # this syntax is specific to this build system # we're only going to use certain compiler args with nvcc and not with gcc # the implementation of this trick is in customize_compiler() below extra_compile_args={'gcc': [], 'nvcc': ['-arch=sm_20', '--ptxas-options=-v', '-c', '--compiler-options', ""'-fPIC'""]}, include_dirs = [numpy_include, CUDA['include'], 'src']) setup(name='msmbuilder.metrics.gpurmsd', author='Yutong Zhao, Robert McGibbon', description='MSMBuilder Plugin for GPU Accelerated RMSD calculation', version='0.2', packages = ['gpurmsd'], ext_modules=[ext], cmdclass={'build_ext': custom_build_ext}, # this is the critical section that registers the plugin with msmbuilder # by telling it where to find the classes and functions required. entry_points="""""" [msmbuilder.metrics] metric_class=gpurmsd.gpurmsd:GPURMSD add_metric_parser=gpurmsd.gpurmsd:add_metric_parser construct_metric=gpurmsd.gpurmsd:construct_gpurmsd """""") ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/GPURMSD/gpurmsd/__init__.py",".py","1","2"," ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/GPURMSD/gpurmsd/Xrange.py",".py","3614","112","#http://code.activestate.com/recipes/578070-extending-xrange-to-support-slicing-and-indexing/ # MIT License import numpy as np def read_xrange(xrange_object): '''returns the xrange object's start, stop, and step''' start = xrange_object[0] if len(xrange_object) > 1: step = xrange_object[1] - xrange_object[0] else: step = 1 stop = xrange_object[-1] + step return start, stop, step class Xrange(object): ''' creates an xrange-like object that supports slicing and indexing. ex: a = Xrange(20) a.index(10) will work Also a[:5] will return another Xrange object with the specified attributes Also allows for the conversion from an existing xrange object ''' def __init__(self, *inputs): # allow inputs of xrange objects if len(inputs) == 1: test, = inputs if type(test) == xrange: self.xrange = test self.start, self.stop, self.step = read_xrange(test) return # or create one from start, stop, step self.start, self.step = 0, 1 if len(inputs) == 1: self.stop, = inputs elif len(inputs) == 2: self.start, self.stop = inputs elif len(inputs) == 3: self.start, self.stop, self.step = inputs else: raise ValueError(inputs) self.xrange = xrange(self.start, self.stop, self.step) def __iter__(self): return iter(self.xrange) def __getitem__(self, item): if type(item) is int: if item < 0: item += len(self) return self.xrange[item] if type(item) is slice: # get the indexes, and then convert to the number start, stop, step = item.start, item.stop, item.step start = start if start != None else 0 # convert start = None to start = 0 if start < 0: start += start start = self[start] if start < 0: raise IndexError(item) step = (self.step if self.step != None else 1) * (step if step != None else 1) stop = stop if stop is not None else self.xrange[-1] if stop < 0: stop += stop stop = self[stop] stop = stop if stop > self.stop: raise IndexError if start < self.start: raise IndexError return Xrange(start, stop, step) if isinstance(item, np.ndarray): # slicing an xrange with an ndarray -- we need to bail and # just convert the Xrange to an ndarray #print 'start', self.start #print 'stop', self.stop #print 'step', self.step #print 'item', item return np.r_[self.to_slice()][item] else: raise ValueError(""I don't know how to be sliced by %s (type %s)"" % (item, type(item))) def index(self, value): error = ValueError('object.index({0}): {0} not in object'.format(value)) index = (value - self.start)/self.step if index % 1 != 0: raise error index = int(index) try: self.xrange[index] except (IndexError, TypeError): raise error return index def __len__(self): return len(self.xrange) def to_slice(self): return slice(self.start, self.stop, self.step) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/GPURMSD/gpurmsd/RMSD.hh",".hh","2217","76","#ifndef __RMSD_CUH__ #define __RMSD_CUH__ //AUTHOR: Yutong Zhao | proteneer@gmail.com //Please refer to Theobald et. al's paper on the RMSD algorithm here-in used: // //Liu P, Agrafiotis DK, & Theobald DL (2010) //""Fast determination of the optimal rotation matrix for macromolecular superpositions."" //Journal of Computational Chemistry 31(7):1561-1563. [Open Access] // //Douglas L Theobald (2005) //""Rapid calculation of RMSDs using a quaternion-based characteristic polynomial."" //Acta Crystallogr A 61(4):478-480. [Open Access, pdf] class RMSD { public: // construct an RMSD object, // h_X is stored in ADP format RMSD(int numAtoms, int numDimens, int numConfs, float* h_X); ~RMSD(); // if set to non-NULL, automatically assumes we want to use only a subset of the atoms // when doing the RMSD calculations void set_subset_flag_array(int numAtoms, int *h_subset_flag); //centers conformers and precompute_G(); void center_and_precompute_G(); void all_against_one_rmsd(int test_conf); void all_against_one_lprmsd(int test_conf); void print_params(); void retrieve_rmsds_from_device(int numConfs, float* h_rmsds); private: // check GPU parameters void set_gpu_parameters(); //kernel methods void center_conformers(); void precompute_G(); //system parameters const int numAtoms_; const int numConfs_; const int numBlocks_; const int size_; // sanity flags bool have_precomputed_G_; bool have_centered_; // GPU-specific variables static const int threadsperblock_ = 512; size_t capacity_; float compute_capability_; // pointers to data storage float *h_X_; // pointer host_data float *d_X_; // pointer to cuda data float *d_G_; // pointer to precomputed inner products //float *h_rot_mat_; int *h_subset_flag_; // host atom flags float *d_rmsds_; // pointer to device rmsds (all against 1) int *d_subset_flag_; // host subset flags }; #endif ","Unknown" "Conformation","msmbuilder/msmbuilder-legacy","Extras/GPURMSD/gpurmsd/gpurmsd.py",".py","3552","107","import sys, os import numpy as np import hashlib import IPython as ip from msmbuilder.metrics import AbstractDistanceMetric from msmbuilder.clustering import concatenate_trajectories from msmbuilder import Project import argparse import logging logger = logging.getLogger('gpurmsd') from swGPURMSD import RMSD as _GPURMSD from Xrange import Xrange description = """"""Please cite Zhao, Yutong; Sheong, Fu-Kit, Sun, Jian; Huang, Xuhui, ""A Fast, GPU-powered, Clustering Algorithm of Conformations"" In Press. """""" class GPURMSD(AbstractDistanceMetric): def __init__(self, atomindices=None): self.atomindices = atomindices self._gpurmsd = None def prepare_trajectory(self, trajectory): """"""Prepare a trajectory for disance calculation on the GPU. Parameters ---------- trajectory : msmbuilder trajectory The trajectory to send to the GPU Returns ------- prepared_trajectory : np.ndarray Don't worry about what the return value is :) its just input that you should give to GPURMSD.one_to_all(). Notes ----- - the GPU kernels except the xyz coordinates to be layed out as n_atoms x n_dimensions x n_frames, which means we need to first reorder them on the GPU before sending them. - You can only run prepare_trajectory once -- you have to send all the frames to the GPU in one go. """""" logger.info('GPU preparing') if self._gpurmsd != None: raise ValueError(""messed up call pattern"") xyzlist = trajectory['XYZList'] n_confs, n_atoms = xyzlist.shape[0:2] if self.atomindices != None: xyzlist = xyzlist[:, self.atomindices, :] n_atoms = len(self.atomindices) xyzlist = np.array(xyzlist.swapaxes(1,2).swapaxes(0,2), copy=True, order='C') self._gpurmsd = _GPURMSD(xyzlist) self._gpurmsd.set_subset_flag_array(np.ones(n_atoms, dtype=np.int32)) self._gpurmsd.center_and_precompute_G() self._n_confs = n_confs return Xrange(self._n_confs) def one_to_all(self, ptraj1, ptraj2, index1): """"""Compute the distance from the `index1th` frame in ptraj1 to the rest of the frames in ptraj2 """""" # should do some sanity checking to ensure that # ptraj1 and ptraj2 are really associated with # self._gpurmsd. Could ""annotate"" the xrange returned # by prepare_trajectory and then check for its watermark # here # the problem is that ptraj can either be a ndarray or an Xrange #logger.info('GPU computing') results = np.empty(self._n_confs, dtype=np.float32) self._gpurmsd.all_against_one_rmsd(int(index1)) self._gpurmsd.retrieve_rmsds_from_device(results) if isinstance(ptraj2, Xrange): # get its slice representation return results[ptraj2.to_slice()] return results[ptraj2] def add_metric_parser(parsergroup, add_argument): logger.info('GPU adding parser') gpurmsd = parsergroup.add_parser('GPURMSD', description=description, formatter_class=argparse.RawDescriptionHelpFormatter) add_argument(gpurmsd, '-a', dest='gpurmsd_atom_indices', default='AtomIndices.dat') return gpurmsd def construct_gpurmsd(args): if args.metric != 'GPURMSD': return None atomindices = np.loadtxt(args.gpurmsd_atom_indices, dtype=np.int) return GPURMSD(atomindices) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","Extras/GPURMSD/tests/test_gpurmsd.py",".py","2916","95","import os, sys import inspect import numpy as np from msmbuilder import Trajectory from gpurmsd.gpurmsd import GPURMSD from msmbuilder.metrics import RMSD import matplotlib.pyplot as pp import numpy.testing as npt def fixtures_dir(): #http://stackoverflow.com/questions/50499/in-python-how-do-i-get-the-path-and-name-of-the-file-that-is-currently-executin return os.path.join(os.path.dirname(inspect.getfile(inspect.currentframe())), 'fixtures') trj_path = os.path.join(fixtures_dir(), 'trj0.lh5') ww_conf = Trajectory.load_trajectory_file(os.path.join(fixtures_dir(), 'ww.pdb')) ww_1 = os.path.join(fixtures_dir(), 'ww.xtc') ww_2 = os.path.join(fixtures_dir(), 'ww-aligned.xtc') def test_gpurmsd(): traj = Trajectory.load_trajectory_file(trj_path) gpurmsd = GPURMSD() ptraj = gpurmsd.prepare_trajectory(traj) gpurmsd._gpurmsd.print_params() gpu_distances = gpurmsd.one_to_all(ptraj, ptraj, 0) cpurmsd = RMSD() ptraj = cpurmsd.prepare_trajectory(traj) cpu_distances = cpurmsd.one_to_all(ptraj, ptraj, 0) npt.assert_array_almost_equal(cpu_distances, gpu_distances, decimal=4) def plot_gpu_cmd_correlation(): traj1 = Trajectory.load_trajectory_file(ww_1, Conf=ww_conf) traj1_copy = Trajectory.load_trajectory_file(ww_1, Conf=ww_conf) #traj2 = Trajectory.load_trajectory_file(ww_2, Conf=ww_conf) #traj2_copy = Trajectory.load_trajectory_file(ww_2, Conf=ww_conf) def gpudist(t): gpurmsd = GPURMSD() pt = gpurmsd.prepare_trajectory(t) gpurmsd._gpurmsd.print_params() return gpurmsd.one_to_all(pt, pt, 0) def cpudist(t): rmsd = RMSD() pt = rmsd.prepare_trajectory(t) return rmsd.one_to_all(pt, pt, 0) g1 = gpudist(traj1) #, gpudist(traj2) c1 = cpudist(traj1_copy) #, cpudist(traj2_copy) pp.subplot(231) pp.plot(c1) pp.title('cpu rmsd drift along traj') pp.xlabel('frame index') pp.xlabel('cpurmsd($X_{0}$, $X_{frame_index}$)') pp.subplot(232) pp.scatter(g1, c1) pp.xlabel('gpu rmsd') pp.ylabel('cpu rmsd') pp.subplot(233) pp.plot(g1) pp.title('gpu rmsd drift along traj') pp.xlabel('frame index') pp.xlabel('gpurmsd($X_{0}$, $X_{frame_index}$)') #PLOT c2 and g2 in the lower portion of the graph #pp.subplot(234) #pp.plot(c2) #pp.title('cpu rmsd drift along pre-aligned traj') #pp.xlabel('frame index') #pp.xlabel('cpurmsd($X_{0}$, $X_{frame_index}$)') #pp.subplot(235) #pp.scatter(g2, c2) #pp.xlabel('gpu rmsd') #pp.ylabel('cpu rmsd') #pp.subplot(236) #pp.plot(g2) #pp.title('gpu rmsd drift along pre-aligned traj') #pp.xlabel('frame index') #pp.xlabel('gpurmsd($X_{0}$, $X_{frame_index}$)') #pp.subplots_adjust(hspace=0.4) #pp.savefig('gpucpu_correlation.png') pp.show() if __name__ == '__main__': plot_gpu_cmd_correlation() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","reference/tICA_tutorial.ipynb",".ipynb","392059","339","{ ""metadata"": { ""name"": ""tICA_tutorial"" }, ""nbformat"": 3, ""nbformat_minor"": 0, ""worksheets"": [ { ""cells"": [ { ""cell_type"": ""code"", ""collapsed"": false, ""input"": [ ""from msmbuilder import io\n"", ""matplotlib.rcParams['font.size'] = 22"" ], ""language"": ""python"", ""metadata"": {}, ""outputs"": [], ""prompt_number"": 1 }, { ""cell_type"": ""code"", ""collapsed"": false, ""input"": [ ""f = io.loadh('tICAData.h5')\n"", ""f.keys()"" ], ""language"": ""python"", ""metadata"": {}, ""outputs"": [ { ""output_type"": ""pyout"", ""prompt_number"": 2, ""text"": [ ""['vals', 'cov_mat', 'timelag_corr_mat', 'vecs']"" ] } ], ""prompt_number"": 2 }, { ""cell_type"": ""code"", ""collapsed"": false, ""input"": [ ""subplot(153)\n"", ""hlines(f['vals'], 0, 1, lw=3)\n"", ""xticks([])\n"", ""xlim(0,1)\n"", ""ylabel('eigenvalue')"" ], ""language"": ""python"", ""metadata"": {}, ""outputs"": [ { ""output_type"": ""pyout"", ""prompt_number"": 7, ""text"": [ """" ] }, { ""output_type"": ""display_data"", ""png"": ""iVBORw0KGgoAAAANSUhEUgAAAKQAAAD9CAYAAAAyNNx+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nYII=\n"", ""text"": [ """" ] } ], ""prompt_number"": 7 }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Notice that there are largely two timescales associated with alanine dipeptide, which largely agrees with most other analysis."" ] }, { ""cell_type"": ""code"", ""collapsed"": false, ""input"": [ ""aa = np.loadtxt('HeavyAtomPairs.dat').astype(int)"" ], ""language"": ""python"", ""metadata"": {}, ""outputs"": [], ""prompt_number"": 9 }, { ""cell_type"": ""code"", ""collapsed"": false, ""input"": [ ""v0 = f['vecs'][:,0]\n"", ""v1 = f['vecs'][:,1]\n"", ""#plot(v0, lw=3, label='tIC 0')\n"", ""#plot(v1, lw=3, label='tIC 1')\n"", ""p = Trajectory.load_from_pdb('native.pdb')\n"", ""\n"", ""atms = np.unique(aa) \n"", ""\n"", ""lbls = [ '$%s_{%d}$' % (p['AtomNames'][i], p['ResidueID'][i]) for i in atms ]\n"", ""\n"", ""print atms\n"", ""m0 = np.zeros((len(atms), len(atms)))\n"", ""m1 = np.zeros((len(atms), len(atms)))\n"", ""\n"", ""for i, (x, y) in enumerate(aa):\n"", "" xi = np.where(atms == x )\n"", "" yi = np.where(atms == y )\n"", "" \n"", "" m0[xi,yi] = v0[i]\n"", "" m1[xi,yi] = v1[i]\n"", ""\n"", ""\n"", ""atmsi = np.arange(len(atms))\n"", ""figure(figsize=(12,8))\n"", ""ax = axes()\n"", ""im=ax.matshow(m0 + m0.T, vmin=-100, vmax=100, cmap=cm.RdBu)\n"", ""xticks(atmsi, lbls)\n"", ""yticks(atmsi, lbls)\n"", ""c=colorbar(im, )\n"", ""#c.set_ticks([-100,-50, 0,50,100])\n"", ""c.set_ticks([])\n"", ""savefig('tic0.pdf')\n"", ""figure(figsize=(8,6))\n"", ""ax = axes()\n"", ""im=ax.matshow(m1 + m1.T, vmin=-100, vmax=100, cmap=cm.RdBu)\n"", ""xticks(atmsi, lbls)\n"", ""yticks(atmsi, lbls)\n"", ""c = colorbar(im)\n"", ""#c.set_ticks([-100,-50, 0,50,100])\n"", ""c.set_ticks([])"" ], ""language"": ""python"", ""metadata"": {}, ""outputs"": [ { ""output_type"": ""stream"", ""stream"": ""stdout"", ""text"": [ ""[ 4 5 6 8 10 14 15 16]\n"" ] }, { ""output_type"": ""display_data"", ""png"": ""iVBORw0KGgoAAAANSUhEUgAAAjIAAAHqCAYAAAAeSaSGAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n"", ""text"": [ """" ] }, { ""output_type"": ""display_data"", ""png"": ""iVBORw0KGgoAAAANSUhEUgAAAbIAAAF7CAYAAAC3lA5gAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQkZERLrGQkZERLr2/wEq8Lic7GrMhgAAAABJRU5ErkJggg==\n"", ""text"": [ """" ] } ], ""prompt_number"": 146 }, { ""cell_type"": ""code"", ""collapsed"": false, ""input"": [ ""from msmbuilder import metrics\n"", ""\n"", ""dih = metrics.Dihedral(angles='phi/psi')\n"", ""atmpairs = metrics.AtomPairs(atom_pairs=aa)\n"", ""tica = metrics.RedDimPNorm(proj_object_fn='tICAData.h5', prep_with=atmpairs, num_vecs=4)"" ], ""language"": ""python"", ""metadata"": {}, ""outputs"": [ { ""output_type"": ""stream"", ""stream"": ""stdout"", ""text"": [ ""Kept 4 out of 28 total vectors\n"", ""[ 0.38427369 0.23986044 0.03442272 0.02800612]\n"" ] } ], ""prompt_number"": 48 }, { ""cell_type"": ""code"", ""collapsed"": false, ""input"": [ ""from msmbuilder import Trajectory\n"", ""from msmbuilder import geometry"" ], ""language"": ""python"", ""metadata"": {}, ""outputs"": [] }, { ""cell_type"": ""code"", ""collapsed"": false, ""input"": [ ""def plot_t(i):\n"", "" t0 = Trajectory.load_from_lhdf('Trajectories/trj%d.lh5' %i)\n"", ""\n"", "" phi0 = geometry.dihedral.compute_dihedrals(t0, indices=geometry.dihedral.get_indices(t0, angles='phi'))\n"", "" psi0 = geometry.dihedral.compute_dihedrals(t0, indices=geometry.dihedral.get_indices(t0, angles='psi'))\n"", ""\n"", "" t0 = tica.prepare_trajectory(t0)\n"", ""\n"", "" subplot(121)\n"", "" scatter(psi0, t0[:,0])\n"", "" xlim([-180,180])\n"", "" subplot(122)\n"", "" scatter(phi0, t0[:,0])\n"", "" xlim([-180,180])\n"" ], ""language"": ""python"", ""metadata"": {}, ""outputs"": [], ""prompt_number"": 77 }, { ""cell_type"": ""code"", ""collapsed"": false, ""input"": [ ""figure(figsize=(10,5))\n"", ""for i in range(100):\n"", "" plot_t(i)"" ], ""language"": ""python"", ""metadata"": {}, ""outputs"": [ { ""output_type"": ""display_data"", ""png"": ""iVBORw0KGgoAAAANSUhEUgAAAl0AAAFBCAYAAABNfhpWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrkJggg==\n"", ""text"": [ """" ] } ], ""prompt_number"": 80 }, { ""cell_type"": ""code"", ""collapsed"": false, ""input"": [ ""def scat_t(i, j, x=True, y=True):\n"", "" t0 = Trajectory.load_from_lhdf('Trajectories/trj%d.lh5' %i)\n"", ""\n"", "" phi0 = geometry.dihedral.compute_dihedrals(t0, indices=geometry.dihedral.get_indices(t0, angles='phi'))\n"", "" psi0 = geometry.dihedral.compute_dihedrals(t0, indices=geometry.dihedral.get_indices(t0, angles='psi'))\n"", ""\n"", "" t0 = tica.prepare_trajectory(t0)\n"", ""\n"", "" #subplot(121)\n"", "" #scatter(psi0, t0[:,0])\n"", "" #xlim([-180,180])\n"", "" #subplot(122)\n"", "" #scatter(phi0, t0[:,0])\n"", "" #xlim([-180,180])\n"", "" \n"", "" scatter(phi0.flatten(), psi0.flatten(), c=t0[:,j], edgecolor='none', alpha=0.8)\n"", "" xlim(-180,180)\n"", "" ylim(-180,180)\n"", "" \n"", ""# xi = [-180, -90, 0, 90, 180]\n"", ""# xl = ['$-\\pi$', '$-\\pi / 2$', '$0$', '$\\pi / 2$', '$\\pi$']\n"", "" \n"", "" xi = [-180, 0, 180]\n"", "" xl = ['$-\\pi$', '$0$', '$\\pi$']\n"", ""\n"", "" \n"", "" if x:\n"", "" xlabel('$\\phi$')\n"", "" xticks(xi, xl)\n"", "" else:\n"", "" xticks([])\n"", "" \n"", "" if y: \n"", "" ylabel('$\\psi$')\n"", "" yticks(xi, xl)\n"", "" else:\n"", "" yticks([])"" ], ""language"": ""python"", ""metadata"": {}, ""outputs"": [], ""prompt_number"": 138 }, { ""cell_type"": ""code"", ""collapsed"": false, ""input"": [ ""figure(figsize=(10,10))\n"", ""\n"", ""subplot(334)\n"", ""for i in range(100):\n"", "" scat_t(i, 0)\n"", ""title('tIC 0')\n"", ""\n"", ""subplot(335)\n"", ""for i in range(100):\n"", "" scat_t(i, 1, y=False)\n"", "" \n"", ""title('tIC 1')\n"", ""subplot(336)\n"", ""for i in range(100):\n"", "" scat_t(i, 2, y=False)\n"", "" \n"", ""title('tIC 2')\n"", ""subplots_adjust(wspace=0.2)\n"", ""\n"", ""savefig('/Users/schwancr/Installed/schwancrforks/msmbuilder/Docs/tICA/tics.png', dpi=200)"" ], ""language"": ""python"", ""metadata"": {}, ""outputs"": [ { ""output_type"": ""display_data"", ""png"": ""iVBORw0KGgoAAAANSUhEUgAAAoUAAAEACAYAAADFvAwiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nERERQU2hiIiIiAD/ByPtpwkNigvvAAAAAElFTkSuQmCC\n"", ""text"": [ """" ] } ], ""prompt_number"": 139 }, { ""cell_type"": ""code"", ""collapsed"": false, ""input"": [], ""language"": ""python"", ""metadata"": {}, ""outputs"": [] } ], ""metadata"": {} } ] }","Unknown" "Conformation","msmbuilder/msmbuilder-legacy","reference/transition_path_theory_reference/generate_tpt_ref.py",".py","3034","102","from __future__ import print_function import os import sys import datetime import numpy as np import scipy.sparse from scipy import io from msmbuilder import transition_path_theory as tpt from msmbuilder import Serializer d = datetime.date.today() BACKUP_DIR = 'tpt_ref_%s.%s.%s' % (d.month, d.day, d.year) os.mkdir(BACKUP_DIR) def save_new_ref(filename, data): """""" Saves a new version of the reference data, and backs up the old """""" ext = filename.split('.')[-1] if (data == None): print(""WARNING: Error generating file: %s"" % filename) print(""Skipped... try again."") return if os.path.exists(filename): os.system( 'mv %s %s' % (filename, BACKUP_DIR) ) if ext in ['h5', 'lh5']: if scipy.sparse.issparse(data): data = data.toarray() Serializer.SaveData(filename, data) elif ext == 'mtx': io.mmwrite(filename, data) elif ext == 'pkl': f = open(filename, 'w') pickle.dump(f, data) f.close() else: raise ValueError('Could not understand extension (.%s) for %s' % (ext, filename)) return # hard-coding these right now - would be better to read them from a common # place, where the actual unit test also gets these values tpt_ref_dir = '.' tprob = io.mmread( os.path.join( ""tProb.mtx"") ) #.toarray() # strange bug?? sources = [0] # chosen arbitarily by TJL sinks = [70] # chosen arbitarily by TJL waypoints = [60] # chosen arbitarily by TJL lag_time = 1.0 # chosen arbitarily by TJL # committors Q = tpt.calculate_committors(sources, sinks, tprob) save_new_ref('committors.h5', Q) # flux flux = tpt.calculate_fluxes(sources, sinks, tprob) save_new_ref('flux.h5', flux) net_flux = tpt.calculate_net_fluxes(sources, sinks, tprob) save_new_ref('net_flux.h5', net_flux) # path calculations paths, bottlenecks, fluxes = tpt.find_top_paths(sources, sinks, tprob) save_new_ref('dijkstra_paths.h5', paths) save_new_ref('dijkstra_fluxes.h5', fluxes) save_new_ref('dijkstra_bottlenecks.h5', bottlenecks) # MFPTs mfpt = tpt.calculate_mfpt(sinks, tprob, lag_time=lag_time) save_new_ref('mfpt.h5', mfpt) ensemble_mfpt = tpt.calculate_ensemble_mfpt(sources, sinks, tprob, lag_time) save_new_ref('ensemble_mfpt.h5', ensemble_mfpt) all_to_all_mfpt = tpt.calculate_all_to_all_mfpt(tprob) save_new_ref('all_to_all_mfpt.h5', all_to_all_mfpt) # TP Time tp_time = tpt.calculate_avg_TP_time(sources, sinks, tprob, lag_time) save_new_ref('tp_time.h5', tp_time) # hub scores #frac_visits = tpt.calculate_fraction_visits(tprob, waypoints, # sources, sinks) #save_new_ref('frac_visits.h5', frac_visits) #hub_score = tpt.calculate_hub_score(tprob, waypoints) #save_new_ref('hub_score.h5', hub_score) #all_hub_scores = tpt.calculate_all_hub_scores(tprob) #save_new_ref('all_hub_scores.h5', all_hub_scores) # done! print(""Done generating new reference for transition_path_theory.py!"") ","Python" "Conformation","msmbuilder/msmbuilder-legacy","reference/transition_path_theory_reference/hub_ref/hub_simulator.py",".py","1440","62"," """""" A simple (dumb) simulator to check the hub score calculation. """""" from __future__ import print_function import sys import numpy as np from msmbuilder import msm_analysis # manual parameters steps = 10**6 # sample steps triples = [ (0, 1, 2), # (waypoint, source, sink) to test (0, 1, 3), (0, 1, 4) ] # load in the transition matrx N = 11 T = np.transpose( np.genfromtxt('mat_1.dat')[:,:-3] ) print(T) print(T.shape) print(T.sum(1)) # sample from it print(""Making a len: %d traj"" % steps) traj = msm_analysis.sample(T, np.random.randint(11), steps, force_dense=True) print(""Generated traj"") # count the fraction visits n_visited_waypoint = 0 n_notvisited_waypoint = 0 started = False visited = False for (waypoint, source, sink) in triples: for n,i in enumerate(traj): if n % 10000 == 0: print(""%d/%d"" % (n, steps)) if i == source: started = True visited = False elif i == waypoint: visited = True elif i == sink: if started: if visited: n_visited_waypoint += 1 else: n_notvisited_waypoint += 1 started = False hc = float(n_visited_waypoint) / float(n_visited_waypoint + n_notvisited_waypoint) print(""For triple:"", (waypoint, source, sink)) print(""hc ="", hc) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","reference/project_reference/project.builder/test.py",".py","196","7","from __future__ import print_function from msmbuilder.project import FahProjectBuilder pb = FahProjectBuilder('./fah_style_data', '.xtc', './fah_style_data/native.pdb') p = pb.convert() print(p) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","docs/tutorial_slides/Commands.sh",".sh","813","27","cd $PREFIX/share/msmbuilder_tutorial tar -xvf XTC.tar ConvertDataToHDF.py -s native.pdb -i XTC Cluster.py rmsd hybrid -d 0.045 -l 50 CalculateImpliedTimescales.py -l 1,25 -i 1 -o Data/ImpliedTimescales.dat -e 5 PlotImpliedTimescales.py -d 1. -i Data/ImpliedTimescales.dat BuildMSM.py -l 1 PCCA.py -n 4 -a Data/Assignments.Fixed.h5 -t Data/tProb.mtx -o Macro4/ -A PCCA+ python PlotDihedrals.py Macro4/MacroAssignments.h5 CalculateImpliedTimescales.py -l 1,25 -i 1 \ -o Macro4/ImpliedTimescales.dat -a Macro4/MacroAssignments.h5 -e 3 PlotImpliedTimescales.py -i Macro4/ImpliedTimescales.dat -d 1 BuildMSM.py -l 6 -a Macro4/MacroAssignments.h5 -o Macro4/ SaveStructures.py -s -1 -a Macro4/MacroAssignments.h5 -c 1 -S sep pymol PDBs/State0-0.pdb PDBs/State1-0.pdb PDBs/State2-0.pdb PDBs/State3-0.pdb ","Shell" "Conformation","msmbuilder/msmbuilder-legacy","docs/sphinx/conf.py",".py","9909","302","# -*- coding: utf-8 -*- # # msmbuilder documentation build configuration file, created by # sphinx-quickstart on Mon Nov 5 15:08:06 2012. # # This file is execfile()d with the current directory set to its containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. import sys, os import msmbuilder.version sys.path.insert(0, os.path.abspath('sphinxext')) import msmb_theme # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. #sys.path.insert(0, os.path.abspath('.')) # -- General configuration ----------------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['sphinx.ext.mathjax', 'sphinx.ext.ifconfig', 'sphinx.ext.autosummary', 'sphinx.ext.viewcode', 'sphinx.ext.autodoc', 'numpy_ext.numpydoc', 'sphinx.ext.intersphinx', 'sphinx.ext.viewcode'] intersphinx_mapping = { 'http://docs.python.org/': None, 'http://docs.scipy.org/doc/numpy': None, 'http://docs.scipy.org/doc/scipy/reference/': None, 'http://matplotlib.sourceforge.net/' : None, } # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' # The encoding of source files. #source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' #autoclass_content = 'both' # just put an extra autosummary_generate = True numpydoc_show_class_members = False # this doesn't work that well # General information about the project. project = u'MSMBuilder' copyright = u'2014, MSMBuilder Team' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = '2.8' #msmbuilder.version.short_version # The full version, including alpha/beta/rc tags. release = '2.8' #msmbuilder.version.version # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. exclude_patterns = ['_build'] # The reST default role (used for this markup: `text`) to use for all documents. #default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. #add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). #add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. #show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. html_theme = 'msmb_theme' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} html_theme_options ={'base_url' : 'http://msmbuilder.org'} # Add any paths that contain custom themes here, relative to this directory. html_theme_path = [msmb_theme.get_html_theme_path()] # The name for this set of Sphinx documents. If None, it defaults to # "" v documentation"". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. html_logo = 'msmb_logo.png' # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named ""default.css"" will overwrite the builtin ""default.css"". html_static_path = ['_static'] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. #html_domain_indices = True # If false, no index is generated. #html_use_index = True # If true, the index is split into individual pages for each letter. #html_split_index = False # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True # If true, ""Created using Sphinx"" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, ""(C) Copyright ..."" is shown in the HTML footer. Default is True. #html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. "".xhtml""). #html_file_suffix = None # Output file base name for HTML help builder. htmlhelp_basename = 'MSMBuilderdoc' # -- Options for LaTeX output -------------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). #'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). #'pointsize': '10pt', # Additional stuff for the LaTeX preamble. 'preamble': ''' \usepackage{amsmath} \usepackage{amsfonts} \usepackage{graphicx} \usepackage{epstopdf} \epstopdfDeclareGraphicsRule{.gif}{png}{.png}{convert gif:#1 png:\OutputFile} \AppendGraphicsExtensions{.gif} ''', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). latex_documents = [ ('index', 'MSMBuilder.tex', u'MSMBuilder Documentation', u'MSMBuilder Team', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For ""manual"" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # If true, show page references after internal links. #latex_show_pagerefs = False # If true, show URL addresses after external links. #latex_show_urls = False # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_domain_indices = True # -- Options for manual page output -------------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ ('index', 'MSMBuilder', u'MSMBuilder Documentation', [u'MSMBuilder Team'], 1) ] # If true, show URL addresses after external links. #man_show_urls = False # -- Options for Texinfo output ------------------------------------------------ # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ ('index', 'MSMBuilder', u'MSMBuilder Documentation', u'MSMBuilder Team', 'MSMBuilder', 'One line description of project.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. #texinfo_appendices = [] # If false, no module index is generated. #texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' # MOCK MODULES FOR READ-THE-DOCS #http://read-the-docs.readthedocs.org/en/latest/faq.html html_context = {'html_logo' : html_logo, 'base_url' : 'http://msmbuilder.org'} import sys class Mock(object): def __init__(self, *args, **kwargs): pass def __call__(self, *args, **kwargs): return Mock() @classmethod def __getattr__(cls, name): if name in ('__file__', '__path__'): return '/dev/null' elif name[0] == name[0].upper(): return type(name, (), {}) else: return Mock() MOCK_MODULES = ['argparse', 'numpy', 'scipy', 'tables', 'deap', 'fastcluster', 'networkx', 'scipy.sparse', 'numpy.ctypeslib', 'scipy.cluster', 'scipy.stats', 'scipy.cluster.hierarchy', 'scipy.spatial', 'scipy.spatial.distance', 'scipy.linalg', 'scipy.optimize', 'scipy.sparse.linalg', 'scipy.io', 'scipy.weave', 'numpy.ma', 'matplotlib', 'matplotlib.pyplot', 'statsmodels', 'mdtraj'] for mod_name in MOCK_MODULES: sys.modules[mod_name] = Mock() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","docs/sphinx/sphinxext/gen_rst.py",".py","32950","923",""""""" Example generation for the scikit learn Generate the rst files for the examples by iterating over the python example files. Files that generate images should start with 'plot' """""" from time import time import os import shutil import traceback import glob import sys from StringIO import StringIO import cPickle import re import urllib2 import gzip import posixpath try: from PIL import Image except: import Image import matplotlib matplotlib.use('Agg') import token import tokenize import numpy as np ############################################################################### # A tee object to redict streams to multiple outputs class Tee(object): def __init__(self, file1, file2): self.file1 = file1 self.file2 = file2 def write(self, data): self.file1.write(data) self.file2.write(data) def flush(self): self.file1.flush() self.file2.flush() ############################################################################### # Documentation link resolver objects def get_data(url): """"""Helper function to get data over http or from a local file"""""" if url.startswith('http://'): resp = urllib2.urlopen(url) encoding = resp.headers.dict.get('content-encoding', 'plain') data = resp.read() if encoding == 'plain': pass elif encoding == 'gzip': data = StringIO(data) data = gzip.GzipFile(fileobj=data).read() else: raise RuntimeError('unknown encoding') else: with open(url, 'r') as fid: data = fid.read() fid.close() return data def parse_sphinx_searchindex(searchindex): """"""Parse a Sphinx search index Parameters ---------- searchindex : str The Sphinx search index (contents of searchindex.js) Returns ------- filenames : list of str The file names parsed from the search index. objects : dict The objects parsed from the search index. """""" def _select_block(str_in, start_tag, end_tag): """"""Select first block delimited by start_tag and end_tag"""""" start_pos = str_in.find(start_tag) if start_pos < 0: raise ValueError('start_tag not found') depth = 0 for pos in range(start_pos, len(str_in)): if str_in[pos] == start_tag: depth += 1 elif str_in[pos] == end_tag: depth -= 1 if depth == 0: break sel = str_in[start_pos + 1:pos] return sel def _parse_dict_recursive(dict_str): """"""Parse a dictionary from the search index"""""" dict_out = dict() pos_last = 0 pos = dict_str.find(':') while pos >= 0: key = dict_str[pos_last:pos] if dict_str[pos + 1] == '[': # value is a list pos_tmp = dict_str.find(']', pos + 1) if pos_tmp < 0: raise RuntimeError('error when parsing dict') value = dict_str[pos + 2: pos_tmp].split(',') # try to convert elements to int for i in range(len(value)): try: value[i] = int(value[i]) except ValueError: pass elif dict_str[pos + 1] == '{': # value is another dictionary subdict_str = _select_block(dict_str[pos:], '{', '}') value = _parse_dict_recursive(subdict_str) pos_tmp = pos + len(subdict_str) else: raise ValueError('error when parsing dict: unknown elem') key = key.strip('""') if len(key) > 0: dict_out[key] = value pos_last = dict_str.find(',', pos_tmp) if pos_last < 0: break pos_last += 1 pos = dict_str.find(':', pos_last) return dict_out # parse objects query = 'objects:' pos = searchindex.find(query) if pos < 0: raise ValueError('""objects:"" not found in search index') sel = _select_block(searchindex[pos:], '{', '}') objects = _parse_dict_recursive(sel) # parse filenames query = 'filenames:' pos = searchindex.find(query) if pos < 0: raise ValueError('""filenames:"" not found in search index') filenames = searchindex[pos + len(query) + 1:] filenames = filenames[:filenames.find(']')] filenames = [f.strip('""') for f in filenames.split(',')] return filenames, objects class SphinxDocLinkResolver(object): """""" Resolve documentation links using searchindex.js generated by Sphinx Parameters ---------- doc_url : str The base URL of the project website. searchindex : str Filename of searchindex, relative to doc_url. extra_modules_test : list of str List of extra module names to test. relative : bool Return relative links (only useful for links to documentation of this package). """""" def __init__(self, doc_url, searchindex='searchindex.js', extra_modules_test=None, relative=False): self.doc_url = doc_url self.relative = relative self._link_cache = {} self.extra_modules_test = extra_modules_test self._page_cache = {} if doc_url.startswith('http://'): if relative: raise ValueError('Relative links are only supported for local ' 'URLs (doc_url cannot start with ""http://)""') searchindex_url = doc_url + '/' + searchindex else: searchindex_url = os.path.join(doc_url, searchindex) # detect if we are using relative links on a Windows system if os.name.lower() == 'nt' and not doc_url.startswith('http://'): if not relative: raise ValueError('You have to use relative=True for the local' 'package on a Windows system.') self._is_windows = True else: self._is_windows = False # download and initialize the search index sindex = get_data(searchindex_url) filenames, objects = parse_sphinx_searchindex(sindex) self._searchindex = dict(filenames=filenames, objects=objects) def _get_link(self, cobj): """"""Get a valid link, False if not found"""""" fname_idx = None full_name = cobj['module_short'] + '.' + cobj['name'] if full_name in self._searchindex['objects']: value = self._searchindex['objects'][full_name] if isinstance(value, dict): value = value[value.keys()[0]] fname_idx = value[0] elif cobj['module_short'] in self._searchindex['objects']: value = self._searchindex['objects'][cobj['module_short']] if cobj['name'] in value.keys(): fname_idx = value[cobj['name']][0] if fname_idx is not None: fname = self._searchindex['filenames'][fname_idx] + '.html' if self._is_windows: fname = fname.replace('/', '\\') link = os.path.join(self.doc_url, fname) else: link = posixpath.join(self.doc_url, fname) if link in self._page_cache: html = self._page_cache[link] else: html = get_data(link) self._page_cache[link] = html # test if cobj appears in page comb_names = [cobj['module_short'] + '.' + cobj['name']] if self.extra_modules_test is not None: for mod in self.extra_modules_test: comb_names.append(mod + '.' + cobj['name']) url = False for comb_name in comb_names: if html.find(comb_name) >= 0: url = link + '#' + comb_name link = url else: link = False return link def resolve(self, cobj, this_url): """"""Resolve the link to the documentation, returns None if not found Parameters ---------- cobj : dict Dict with information about the ""code object"" for which we are resolving a link. cobi['name'] : function or class name (str) cobj['module_short'] : shortened module name (str) cobj['module'] : module name (str) this_url: str URL of the current page. Needed to construct relative URLs (only used if relative=True in constructor). Returns ------- link : str | None The link (URL) to the documentation. """""" full_name = cobj['module_short'] + '.' + cobj['name'] link = self._link_cache.get(full_name, None) if link is None: # we don't have it cached link = self._get_link(cobj) # cache it for the future self._link_cache[full_name] = link if link is False or link is None: # failed to resolve return None if self.relative: link = os.path.relpath(link, start=this_url) if self._is_windows: # replace '\' with '/' so it on the web link = link.replace('\\', '/') # for some reason, the relative link goes one directory too high up link = link[3:] return link ############################################################################### rst_template = """""" .. _example_%(short_fname)s: %(docstring)s **Python source code:** :download:`%(fname)s <%(fname)s>` .. literalinclude:: %(fname)s :lines: %(end_row)s- """""" plot_rst_template = """""" .. _example_%(short_fname)s: %(docstring)s %(image_list)s %(stdout)s **Python source code:** :download:`%(fname)s <%(fname)s>` .. literalinclude:: %(fname)s :lines: %(end_row)s- **Total running time of the example:** %(time_elapsed) .2f seconds """""" # The following strings are used when we have several pictures: we use # an html div tag that our CSS uses to turn the lists into horizontal # lists. HLIST_HEADER = """""" .. rst-class:: horizontal """""" HLIST_IMAGE_TEMPLATE = """""" * .. image:: images/%s :scale: 47 """""" SINGLE_IMAGE = """""" .. image:: images/%s :align: center """""" def extract_docstring(filename): """""" Extract a module-level docstring, if any """""" lines = file(filename).readlines() start_row = 0 if lines[0].startswith('#!'): lines.pop(0) start_row = 1 docstring = '' first_par = '' tokens = tokenize.generate_tokens(iter(lines).next) for tok_type, tok_content, _, (erow, _), _ in tokens: tok_type = token.tok_name[tok_type] if tok_type in ('NEWLINE', 'COMMENT', 'NL', 'INDENT', 'DEDENT'): continue elif tok_type == 'STRING': docstring = eval(tok_content) # If the docstring is formatted with several paragraphs, extract # the first one: paragraphs = '\n'.join(line.rstrip() for line in docstring.split('\n')).split('\n\n') if len(paragraphs) > 0: first_par = paragraphs[0] break return docstring, first_par, erow + 1 + start_row def generate_example_rst(app): """""" Generate the list of examples, as well as the contents of examples. """""" root_dir = os.path.join(app.builder.srcdir, 'auto_examples') example_dir = os.path.abspath(app.builder.srcdir + '/../' + 'examples') try: plot_gallery = eval(app.builder.config.plot_gallery) except TypeError: plot_gallery = bool(app.builder.config.plot_gallery) if not os.path.exists(example_dir): os.makedirs(example_dir) if not os.path.exists(root_dir): os.makedirs(root_dir) # we create an index.rst with all examples fhindex = file(os.path.join(root_dir, 'index.rst'), 'w') #Note: The sidebar button has been removed from the examples page for now # due to how it messes up the layout. Will be fixed at a later point fhindex.write(""""""\ .. raw:: html Examples ======== .. _examples-index: """""") # Here we don't use an os.walk, but we recurse only twice: flat is # better than nested. generate_dir_rst('.', fhindex, example_dir, root_dir, plot_gallery) for dir in sorted(os.listdir(example_dir)): if os.path.isdir(os.path.join(example_dir, dir)): generate_dir_rst(dir, fhindex, example_dir, root_dir, plot_gallery) fhindex.flush() def extract_line_count(filename, target_dir): # Extract the line count of a file example_file = os.path.join(target_dir, filename) lines = file(example_file).readlines() start_row = 0 if lines[0].startswith('#!'): lines.pop(0) start_row = 1 tokens = tokenize.generate_tokens(lines.__iter__().next) check_docstring = True erow_docstring = 0 for tok_type, _, _, (erow, _), _ in tokens: tok_type = token.tok_name[tok_type] if tok_type in ('NEWLINE', 'COMMENT', 'NL', 'INDENT', 'DEDENT'): continue elif ((tok_type == 'STRING') and (check_docstring == True)): erow_docstring = erow check_docstring = False return erow_docstring+1+start_row, erow+1+start_row def line_count_sort(file_list, target_dir): # Sort the list of examples by line-count new_list = filter(lambda x: x.endswith('.py'), file_list) unsorted = np.zeros(shape=(len(new_list), 2)) unsorted = unsorted.astype(np.object) for count, exmpl in enumerate(new_list): docstr_lines, total_lines = extract_line_count(exmpl, target_dir) unsorted[count][1] = total_lines - docstr_lines unsorted[count][0] = exmpl index = np.lexsort((unsorted[:,0].astype(np.str), unsorted[:,1].astype(np.float))) return np.array(unsorted[index][:,0]).tolist() def generate_dir_rst(dir, fhindex, example_dir, root_dir, plot_gallery): """""" Generate the rst file for an example directory. """""" if not dir == '.': target_dir = os.path.join(root_dir, dir) src_dir = os.path.join(example_dir, dir) else: target_dir = root_dir src_dir = example_dir if not os.path.exists(os.path.join(src_dir, 'README.txt')): print 80 * '_' print ('Example directory %s does not have a README.txt file' % src_dir) print 'Skipping this directory' print 80 * '_' return fhindex.write("""""" %s """""" % file(os.path.join(src_dir, 'README.txt')).read()) if not os.path.exists(target_dir): os.makedirs(target_dir) sorted_listdir = line_count_sort(os.listdir(src_dir), src_dir) for fname in sorted_listdir: if fname.endswith('py'): generate_file_rst(fname, target_dir, src_dir, plot_gallery) thumb = os.path.join(dir, 'images', 'thumb', fname[:-3] + '.png') link_name = os.path.join(dir, fname).replace(os.path.sep, '_') fhindex.write("""""" .. raw:: html
"""""") fhindex.write('.. figure:: %s\n' % thumb) if link_name.startswith('._'): link_name = link_name[2:] if dir != '.': fhindex.write(' :target: ./%s/%s.html\n\n' % (dir, fname[:-3])) else: fhindex.write(' :target: ./%s.html\n\n' % link_name[:-3]) fhindex.write("""""" :ref:`example_%s` .. raw:: html
.. toctree:: :hidden: %s/%s """""" % (link_name, dir, fname[:-3])) fhindex.write("""""" .. raw:: html
"""""") # clear at the end of the section # modules for which we embed links into example code DOCMODULES = ['sklearn', 'matplotlib', 'numpy', 'scipy'] def make_thumbnail(in_fname, out_fname, width, height): """"""Make a thumbnail with the same aspect ratio centered in an image with a given width and height """""" img = Image.open(in_fname) width_in, height_in = img.size scale_w = width / float(width_in) scale_h = height / float(height_in) if height_in * scale_w <= height: scale = scale_w else: scale = scale_h width_sc = int(round(scale * width_in)) height_sc = int(round(scale * height_in)) # resize the image img.thumbnail((width_sc, height_sc), Image.ANTIALIAS) # insert centered thumb = Image.new('RGB', (width, height), (255, 255, 255)) pos_insert = ((width - width_sc) / 2, (height - height_sc) / 2) thumb.paste(img, pos_insert) thumb.save(out_fname) def get_short_module_name(module_name, obj_name): """""" Get the shortest possible module name """""" parts = module_name.split('.') short_name = module_name for i in range(len(parts) - 1, 0, -1): short_name = '.'.join(parts[:i]) try: exec('from %s import %s' % (short_name, obj_name)) except ImportError: # get the last working module name short_name = '.'.join(parts[:(i + 1)]) break return short_name def generate_file_rst(fname, target_dir, src_dir, plot_gallery): """""" Generate the rst file for a given example. """""" base_image_name = os.path.splitext(fname)[0] image_fname = '%s_%%s.png' % base_image_name this_template = rst_template last_dir = os.path.split(src_dir)[-1] # to avoid leading . in file names, and wrong names in links if last_dir == '.' or last_dir == 'examples': last_dir = '' else: last_dir += '_' short_fname = last_dir + fname src_file = os.path.join(src_dir, fname) example_file = os.path.join(target_dir, fname) shutil.copyfile(src_file, example_file) # The following is a list containing all the figure names figure_list = [] image_dir = os.path.join(target_dir, 'images') thumb_dir = os.path.join(image_dir, 'thumb') if not os.path.exists(image_dir): os.makedirs(image_dir) if not os.path.exists(thumb_dir): os.makedirs(thumb_dir) image_path = os.path.join(image_dir, image_fname) stdout_path = os.path.join(image_dir, 'stdout_%s.txt' % base_image_name) time_path = os.path.join(image_dir, 'time_%s.txt' % base_image_name) thumb_file = os.path.join(thumb_dir, fname[:-3] + '.png') time_elapsed = 0 if plot_gallery and fname.startswith('plot'): # generate the plot as png image if file name # starts with plot and if it is more recent than an # existing image. first_image_file = image_path % 1 if os.path.exists(stdout_path): stdout = open(stdout_path).read() else: stdout = '' if os.path.exists(time_path): time_elapsed = float(open(time_path).read()) if (not os.path.exists(first_image_file) or os.stat(first_image_file).st_mtime <= os.stat(src_file).st_mtime): # We need to execute the code print 'plotting %s' % fname t0 = time() import matplotlib.pyplot as plt plt.close('all') cwd = os.getcwd() try: # First CD in the original example dir, so that any file # created by the example get created in this directory orig_stdout = sys.stdout os.chdir(os.path.dirname(src_file)) my_buffer = StringIO() my_stdout = Tee(sys.stdout, my_buffer) sys.stdout = my_stdout my_globals = {'pl': plt} execfile(os.path.basename(src_file), my_globals) time_elapsed = time() - t0 sys.stdout = orig_stdout my_stdout = my_buffer.getvalue() # get variables so we can later add links to the documentation example_code_obj = {} for var_name, var in my_globals.iteritems(): if not hasattr(var, '__module__'): continue if not isinstance(var.__module__, basestring): continue if var.__module__.split('.')[0] not in DOCMODULES: continue # get the type as a string with other things stripped tstr = str(type(var)) tstr = (tstr[tstr.find('\'') + 1:tstr.rfind('\'')].split('.')[-1]) # get shortened module name module_short = get_short_module_name(var.__module__, tstr) cobj = {'name': tstr, 'module': var.__module__, 'module_short': module_short, 'obj_type': 'object'} example_code_obj[var_name] = cobj # find functions so we can later add links to the documentation funregex = re.compile('[\w.]+\(') with open(src_file, 'rt') as fid: for line in fid.readlines(): if line.startswith('#'): continue for match in funregex.findall(line): fun_name = match[:-1] try: exec('this_fun = %s' % fun_name, my_globals) except Exception as err: print 'extracting function failed' print err continue this_fun = my_globals['this_fun'] if not callable(this_fun): continue if not hasattr(this_fun, '__module__'): continue if not isinstance(this_fun.__module__, basestring): continue if (this_fun.__module__.split('.')[0] not in DOCMODULES): continue # get shortened module name fun_name_short = fun_name.split('.')[-1] module_short = get_short_module_name( this_fun.__module__, fun_name_short) cobj = {'name': fun_name_short, 'module': this_fun.__module__, 'module_short': module_short, 'obj_type': 'function'} example_code_obj[fun_name] = cobj fid.close() if len(example_code_obj) > 0: # save the dictionary, so we can later add hyperlinks codeobj_fname = example_file[:-3] + '_codeobj.pickle' with open(codeobj_fname, 'wb') as fid: cPickle.dump(example_code_obj, fid, cPickle.HIGHEST_PROTOCOL) fid.close() if '__doc__' in my_globals: # The __doc__ is often printed in the example, we # don't with to echo it my_stdout = my_stdout.replace( my_globals['__doc__'], '') my_stdout = my_stdout.strip() if my_stdout: stdout = '**Script output**::\n\n %s\n\n' % ( '\n '.join(my_stdout.split('\n'))) open(stdout_path, 'w').write(stdout) open(time_path, 'w').write('%f' % time_elapsed) os.chdir(cwd) # In order to save every figure we have two solutions : # * iterate from 1 to infinity and call plt.fignum_exists(n) # (this requires the figures to be numbered # incrementally: 1, 2, 3 and not 1, 2, 5) # * iterate over [fig_mngr.num for fig_mngr in # matplotlib._pylab_helpers.Gcf.get_all_fig_managers()] for fig_num in (fig_mngr.num for fig_mngr in matplotlib._pylab_helpers.Gcf.get_all_fig_managers()): # Set the fig_num figure as the current figure as we can't # save a figure that's not the current figure. plt.figure(fig_num) plt.savefig(image_path % fig_num) figure_list.append(image_fname % fig_num) except: print 80 * '_' print '%s is not compiling:' % fname traceback.print_exc() print 80 * '_' finally: os.chdir(cwd) sys.stdout = orig_stdout print "" - time elapsed : %.2g sec"" % time_elapsed else: figure_list = [f[len(image_dir):] for f in glob.glob(image_path % '[1-9]')] #for f in glob.glob(image_path % '*')] # generate thumb file this_template = plot_rst_template if os.path.exists(first_image_file): make_thumbnail(first_image_file, thumb_file, 200, 140) if not os.path.exists(thumb_file): # create something to replace the thumbnail make_thumbnail('images/no_image.png', thumb_file, 200, 140) docstring, short_desc, end_row = extract_docstring(example_file) # Depending on whether we have one or more figures, we're using a # horizontal list or a single rst call to 'image'. if len(figure_list) == 1: figure_name = figure_list[0] image_list = SINGLE_IMAGE % figure_name.lstrip('/') else: image_list = HLIST_HEADER for figure_name in figure_list: image_list += HLIST_IMAGE_TEMPLATE % figure_name.lstrip('/') f = open(os.path.join(target_dir, fname[:-2] + 'rst'), 'w') f.write(this_template % locals()) f.flush() def embed_code_links(app, exception): """"""Embed hyperlinks to documentation into example code"""""" try: if exception is not None: return print 'Embedding documentation hyperlinks in examples..' # Add resolvers for the packages for which we want to show links doc_resolvers = {} doc_resolvers['sklearn'] = SphinxDocLinkResolver(app.builder.outdir, relative=True) doc_resolvers['matplotlib'] = SphinxDocLinkResolver( 'http://matplotlib.org') doc_resolvers['numpy'] = SphinxDocLinkResolver( 'http://docs.scipy.org/doc/numpy-1.6.0') doc_resolvers['scipy'] = SphinxDocLinkResolver( 'http://docs.scipy.org/doc/scipy-0.11.0/reference') example_dir = os.path.join(app.builder.srcdir, 'auto_examples') html_example_dir = os.path.abspath(os.path.join(app.builder.outdir, 'auto_examples')) # patterns for replacement link_pattern = '%s' orig_pattern = '%s' period = '.' for dirpath, _, filenames in os.walk(html_example_dir): for fname in filenames: print '\tprocessing: %s' % fname full_fname = os.path.join(html_example_dir, dirpath, fname) subpath = dirpath[len(html_example_dir) + 1:] pickle_fname = os.path.join(example_dir, subpath, fname[:-5] + '_codeobj.pickle') if os.path.exists(pickle_fname): # we have a pickle file with the objects to embed links for with open(pickle_fname, 'rb') as fid: example_code_obj = cPickle.load(fid) fid.close() str_repl = {} # generate replacement strings with the links for name, cobj in example_code_obj.iteritems(): this_module = cobj['module'].split('.')[0] if this_module not in doc_resolvers: continue link = doc_resolvers[this_module].resolve(cobj, full_fname) if link is not None: parts = name.split('.') name_html = orig_pattern % parts[0] for part in parts[1:]: name_html += period + orig_pattern % part str_repl[name_html] = link_pattern % (link, name_html) # do the replacement in the html file if len(str_repl) > 0: with open(full_fname, 'rb') as fid: lines_in = fid.readlines() with open(full_fname, 'wb') as fid: for line in lines_in: line = line.decode('utf-8') for name, link in str_repl.iteritems(): line = line.replace(name, link) fid.write(line.encode('utf-8')) except urllib2.HTTPError, e: print (""The following HTTP Error has occurred:\n"") print e.code except urllib2.URLError, e: print (""\n...\n"" ""Warning: Embedding the documentation hyperlinks requires "" ""internet access.\nPlease check your network connection.\n"" ""Unable to continue embedding due to a URL Error: \n"") print e.args print '[done]' def setup(app): app.connect('builder-inited', generate_example_rst) app.add_config_value('plot_gallery', True, 'html') # embed links after build is finished app.connect('build-finished', embed_code_links) # Sphinx hack: sphinx copies generated images to the build directory # each time the docs are made. If the desired image name already # exists, it appends a digit to prevent overwrites. The problem is, # the directory is never cleared. This means that each time you build # the docs, the number of images in the directory grows. # # This question has been asked on the sphinx development list, but there # was no response: http://osdir.com/ml/sphinx-dev/2011-02/msg00123.html # # The following is a hack that prevents this behavior by clearing the # image build directory each time the docs are built. If sphinx # changes their layout between versions, this will not work (though # it should probably not cause a crash). Tested successfully # on Sphinx 1.0.7 build_image_dir = '_build/html/_images' if os.path.exists(build_image_dir): filelist = os.listdir(build_image_dir) for filename in filelist: if filename.endswith('png'): os.remove(os.path.join(build_image_dir, filename)) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","docs/sphinx/sphinxext/numpy_ext/docscrape_sphinx.py",".py","8279","246","import re import inspect import textwrap import pydoc import sphinx from docscrape import NumpyDocString from docscrape import FunctionDoc from docscrape import ClassDoc class SphinxDocString(NumpyDocString): def __init__(self, docstring, config=None): config = {} if config is None else config self.use_plots = config.get('use_plots', False) NumpyDocString.__init__(self, docstring, config=config) # string conversion routines def _str_header(self, name, symbol='`'): return ['.. rubric:: ' + name, ''] def _str_field_list(self, name): if name == 'Other Parameters': # this makes the ""Other Params"" part of the table narrow enough # that docutils will put it into a single column. It looks better # this way. return [':Other Params:'] return [':' + name + ':'] def _str_indent(self, doc, indent=4): out = [] for line in doc: out += [' ' * indent + line] return out def _str_signature(self): return [''] if self['Signature']: return ['``%s``' % self['Signature']] + [''] else: return [''] def _str_summary(self): return self['Summary'] + [''] def _str_extended_summary(self): return self['Extended Summary'] + [''] def _str_param_list(self, name): out = [] if self[name]: out += self._str_field_list(name) out += [''] for param, param_type, desc in self[name]: out += self._str_indent(['**%s** : %s' % (param.strip(), param_type)]) out += [''] out += self._str_indent(desc, 8) out += [''] return out @property def _obj(self): if hasattr(self, '_cls'): return self._cls elif hasattr(self, '_f'): return self._f return None def _str_member_list(self, name): """""" Generate a member listing, autosummary:: table where possible, and a table where not. """""" out = [] if self[name]: out += ['.. rubric:: %s' % name, ''] prefix = getattr(self, '_name', '') if prefix: prefix = '~%s.' % prefix autosum = [] others = [] for param, param_type, desc in self[name]: param = param.strip() if not self._obj or hasattr(self._obj, param): autosum += ["" %s%s"" % (prefix, param)] else: others.append((param, param_type, desc)) if autosum: # GAEL: Toctree commented out below because it creates # hundreds of sphinx warnings # out += ['.. autosummary::', ' :toctree:', ''] out += ['.. autosummary::', ''] out += autosum if others: maxlen_0 = max([len(x[0]) for x in others]) maxlen_1 = max([len(x[1]) for x in others]) hdr = ""="" * maxlen_0 + "" "" + ""="" * maxlen_1 + "" "" + ""="" * 10 fmt = '%%%ds %%%ds ' % (maxlen_0, maxlen_1) n_indent = maxlen_0 + maxlen_1 + 4 out += [hdr] for param, param_type, desc in others: out += [fmt % (param.strip(), param_type)] out += self._str_indent(desc, n_indent) out += [hdr] out += [''] return out def _str_section(self, name): out = [] if self[name]: out += self._str_header(name) out += [''] content = textwrap.dedent(""\n"".join(self[name])).split(""\n"") out += content out += [''] return out def _str_see_also(self, func_role): out = [] if self['See Also']: see_also = super(SphinxDocString, self)._str_see_also(func_role) out = ['.. seealso::', ''] out += self._str_indent(see_also[2:]) return out def _str_warnings(self): out = [] if self['Warnings']: out = ['.. warning::', ''] out += self._str_indent(self['Warnings']) return out def _str_index(self): idx = self['index'] out = [] if len(idx) == 0: return out out += ['.. index:: %s' % idx.get('default', '')] for section, references in idx.iteritems(): if section == 'default': continue elif section == 'refguide': out += [' single: %s' % (', '.join(references))] else: out += [' %s: %s' % (section, ','.join(references))] return out def _str_references(self): out = [] if self['References']: out += self._str_header('References') if isinstance(self['References'], str): self['References'] = [self['References']] out.extend(self['References']) out += [''] # Latex collects all references to a separate bibliography, # so we need to insert links to it if sphinx.__version__ >= ""0.6"": out += ['.. only:: latex', ''] else: out += ['.. latexonly::', ''] items = [] for line in self['References']: m = re.match(r'.. \[([a-z0-9._-]+)\]', line, re.I) if m: items.append(m.group(1)) out += [' ' + "", "".join([""[%s]_"" % item for item in items]), ''] return out def _str_examples(self): examples_str = ""\n"".join(self['Examples']) if (self.use_plots and 'import matplotlib' in examples_str and 'plot::' not in examples_str): out = [] out += self._str_header('Examples') out += ['.. plot::', ''] out += self._str_indent(self['Examples']) out += [''] return out else: return self._str_section('Examples') def __str__(self, indent=0, func_role=""obj""): out = [] out += self._str_signature() out += self._str_index() + [''] out += self._str_summary() out += self._str_extended_summary() for param_list in ('Parameters', 'Returns', 'Raises', 'Other Parameters'): out += self._str_param_list(param_list) out += self._str_warnings() out += self._str_see_also(func_role) out += self._str_section('Notes') out += self._str_references() out += self._str_examples() for param_list in ('Attributes', 'Methods'): out += self._str_member_list(param_list) out = self._str_indent(out, indent) return '\n'.join(out) class SphinxFunctionDoc(SphinxDocString, FunctionDoc): def __init__(self, obj, doc=None, config={}): self.use_plots = config.get('use_plots', False) FunctionDoc.__init__(self, obj, doc=doc, config=config) class SphinxClassDoc(SphinxDocString, ClassDoc): def __init__(self, obj, doc=None, func_doc=None, config={}): self.use_plots = config.get('use_plots', False) ClassDoc.__init__(self, obj, doc=doc, func_doc=None, config=config) class SphinxObjDoc(SphinxDocString): def __init__(self, obj, doc=None, config=None): self._f = obj SphinxDocString.__init__(self, doc, config=config) def get_doc_object(obj, what=None, doc=None, config={}): if what is None: if inspect.isclass(obj): what = 'class' elif inspect.ismodule(obj): what = 'module' elif callable(obj): what = 'function' else: what = 'object' if what == 'class': return SphinxClassDoc(obj, func_doc=SphinxFunctionDoc, doc=doc, config=config) elif what in ('function', 'method'): return SphinxFunctionDoc(obj, doc=doc, config=config) else: if doc is None: doc = pydoc.getdoc(obj) return SphinxObjDoc(obj, doc, config=config) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","docs/sphinx/sphinxext/numpy_ext/__init__.py",".py","0","0","","Python" "Conformation","msmbuilder/msmbuilder-legacy","docs/sphinx/sphinxext/numpy_ext/docscrape.py",".py","15906","520","""""""Extract reference documentation from the NumPy source tree. """""" import inspect import textwrap import re import pydoc from StringIO import StringIO from warnings import warn class Reader(object): """"""A line-based string reader. """""" def __init__(self, data): """""" Parameters ---------- data : str String with lines separated by '\n'. """""" if isinstance(data, list): self._str = data else: self._str = data.split('\n') # store string as list of lines self.reset() def __getitem__(self, n): return self._str[n] def reset(self): self._l = 0 # current line nr def read(self): if not self.eof(): out = self[self._l] self._l += 1 return out else: return '' def seek_next_non_empty_line(self): for l in self[self._l:]: if l.strip(): break else: self._l += 1 def eof(self): return self._l >= len(self._str) def read_to_condition(self, condition_func): start = self._l for line in self[start:]: if condition_func(line): return self[start:self._l] self._l += 1 if self.eof(): return self[start:self._l + 1] return [] def read_to_next_empty_line(self): self.seek_next_non_empty_line() def is_empty(line): return not line.strip() return self.read_to_condition(is_empty) def read_to_next_unindented_line(self): def is_unindented(line): return (line.strip() and (len(line.lstrip()) == len(line))) return self.read_to_condition(is_unindented) def peek(self, n=0): if self._l + n < len(self._str): return self[self._l + n] else: return '' def is_empty(self): return not ''.join(self._str).strip() class NumpyDocString(object): def __init__(self, docstring, config={}): docstring = textwrap.dedent(docstring).split('\n') self._doc = Reader(docstring) self._parsed_data = { 'Signature': '', 'Summary': [''], 'Extended Summary': [], 'Parameters': [], 'Returns': [], 'Raises': [], 'Warns': [], 'Other Parameters': [], 'Attributes': [], 'Methods': [], 'See Also': [], 'Notes': [], 'Warnings': [], 'References': '', 'Examples': '', 'index': {} } self._parse() def __getitem__(self, key): return self._parsed_data[key] def __setitem__(self, key, val): if not self._parsed_data.has_key(key): warn(""Unknown section %s"" % key) else: self._parsed_data[key] = val def _is_at_section(self): self._doc.seek_next_non_empty_line() if self._doc.eof(): return False l1 = self._doc.peek().strip() # e.g. Parameters if l1.startswith('.. index::'): return True l2 = self._doc.peek(1).strip() # ---------- or ========== return l2.startswith('-' * len(l1)) or l2.startswith('=' * len(l1)) def _strip(self, doc): i = 0 j = 0 for i, line in enumerate(doc): if line.strip(): break for j, line in enumerate(doc[::-1]): if line.strip(): break return doc[i:len(doc) - j] def _read_to_next_section(self): section = self._doc.read_to_next_empty_line() while not self._is_at_section() and not self._doc.eof(): if not self._doc.peek(-1).strip(): # previous line was empty section += [''] section += self._doc.read_to_next_empty_line() return section def _read_sections(self): while not self._doc.eof(): data = self._read_to_next_section() name = data[0].strip() if name.startswith('..'): # index section yield name, data[1:] elif len(data) < 2: yield StopIteration else: yield name, self._strip(data[2:]) def _parse_param_list(self, content): r = Reader(content) params = [] while not r.eof(): header = r.read().strip() if ' : ' in header: arg_name, arg_type = header.split(' : ')[:2] else: arg_name, arg_type = header, '' desc = r.read_to_next_unindented_line() desc = dedent_lines(desc) params.append((arg_name, arg_type, desc)) return params _name_rgx = re.compile(r""^\s*(:(?P\w+):`(?P[a-zA-Z0-9_.-]+)`|"" r"" (?P[a-zA-Z0-9_.-]+))\s*"", re.X) def _parse_see_also(self, content): """""" func_name : Descriptive text continued text another_func_name : Descriptive text func_name1, func_name2, :meth:`func_name`, func_name3 """""" items = [] def parse_item_name(text): """"""Match ':role:`name`' or 'name'"""""" m = self._name_rgx.match(text) if m: g = m.groups() if g[1] is None: return g[3], None else: return g[2], g[1] raise ValueError(""%s is not a item name"" % text) def push_item(name, rest): if not name: return name, role = parse_item_name(name) items.append((name, list(rest), role)) del rest[:] current_func = None rest = [] for line in content: if not line.strip(): continue m = self._name_rgx.match(line) if m and line[m.end():].strip().startswith(':'): push_item(current_func, rest) current_func, line = line[:m.end()], line[m.end():] rest = [line.split(':', 1)[1].strip()] if not rest[0]: rest = [] elif not line.startswith(' '): push_item(current_func, rest) current_func = None if ',' in line: for func in line.split(','): push_item(func, []) elif line.strip(): current_func = line elif current_func is not None: rest.append(line.strip()) push_item(current_func, rest) return items def _parse_index(self, section, content): """""" .. index: default :refguide: something, else, and more """""" def strip_each_in(lst): return [s.strip() for s in lst] out = {} section = section.split('::') if len(section) > 1: out['default'] = strip_each_in(section[1].split(','))[0] for line in content: line = line.split(':') if len(line) > 2: out[line[1]] = strip_each_in(line[2].split(',')) return out def _parse_summary(self): """"""Grab signature (if given) and summary"""""" if self._is_at_section(): return summary = self._doc.read_to_next_empty_line() summary_str = "" "".join([s.strip() for s in summary]).strip() if re.compile('^([\w., ]+=)?\s*[\w\.]+\(.*\)$').match(summary_str): self['Signature'] = summary_str if not self._is_at_section(): self['Summary'] = self._doc.read_to_next_empty_line() else: self['Summary'] = summary if not self._is_at_section(): self['Extended Summary'] = self._read_to_next_section() def _parse(self): self._doc.reset() self._parse_summary() for (section, content) in self._read_sections(): if not section.startswith('..'): section = ' '.join([s.capitalize() for s in section.split(' ')]) if section in ('Parameters', 'Attributes', 'Methods', 'Other Parameters', 'Returns', 'Raises', 'Warns'): self[section] = self._parse_param_list(content) elif section.startswith('.. index::'): self['index'] = self._parse_index(section, content) elif section == 'See Also': self['See Also'] = self._parse_see_also(content) else: self[section] = content # string conversion routines def _str_header(self, name, symbol='-'): return [name, len(name) * symbol] def _str_indent(self, doc, indent=4): out = [] for line in doc: out += [' ' * indent + line] return out def _str_signature(self): if self['Signature']: return [self['Signature'].replace('*', '\*')] + [''] else: return [''] def _str_summary(self): if self['Summary']: return self['Summary'] + [''] else: return [] def _str_extended_summary(self): if self['Extended Summary']: return self['Extended Summary'] + [''] else: return [] def _str_param_list(self, name): out = [] if self[name]: out += self._str_header(name) for param, param_type, desc in self[name]: out += ['%s : %s' % (param, param_type)] out += self._str_indent(desc) out += [''] return out def _str_section(self, name): out = [] if self[name]: out += self._str_header(name) out += self[name] out += [''] return out def _str_see_also(self, func_role): if not self['See Also']: return [] out = [] out += self._str_header(""See Also"") last_had_desc = True for func, desc, role in self['See Also']: if role: link = ':%s:`%s`' % (role, func) elif func_role: link = ':%s:`%s`' % (func_role, func) else: link = ""`%s`_"" % func if desc or last_had_desc: out += [''] out += [link] else: out[-1] += "", %s"" % link if desc: out += self._str_indent([' '.join(desc)]) last_had_desc = True else: last_had_desc = False out += [''] return out def _str_index(self): idx = self['index'] out = [] out += ['.. index:: %s' % idx.get('default', '')] for section, references in idx.iteritems(): if section == 'default': continue out += [' :%s: %s' % (section, ', '.join(references))] return out def __str__(self, func_role=''): out = [] out += self._str_signature() out += self._str_summary() out += self._str_extended_summary() for param_list in ('Parameters', 'Returns', 'Raises', 'Other Parameters'): out += self._str_param_list(param_list) out += self._str_section('Warnings') out += self._str_see_also(func_role) for s in ('Notes', 'References', 'Examples'): out += self._str_section(s) for param_list in ('Attributes', 'Methods'): out += self._str_param_list(param_list) out += self._str_index() return '\n'.join(out) def indent(str, indent=4): indent_str = ' ' * indent if str is None: return indent_str lines = str.split('\n') return '\n'.join(indent_str + l for l in lines) def dedent_lines(lines): """"""Deindent a list of lines maximally"""""" return textwrap.dedent(""\n"".join(lines)).split(""\n"") def header(text, style='-'): return text + '\n' + style * len(text) + '\n' class FunctionDoc(NumpyDocString): def __init__(self, func, role='func', doc=None, config={}): self._f = func self._role = role # e.g. ""func"" or ""meth"" if doc is None: if func is None: raise ValueError(""No function or docstring given"") doc = inspect.getdoc(func) or '' NumpyDocString.__init__(self, doc) if not self['Signature'] and func is not None: func, func_name = self.get_func() try: # try to read signature argspec = inspect.getargspec(func) if hasattr(func, '__argspec__'): # hack for decorators that manually set the argspec argspec = func.__argspec__ argspec = inspect.formatargspec(*argspec) # hack to remove self from the list that gets shown # I think this is only happening with decorated functions if argspec == '(self)': argspec = '' else: argspec = argspec.replace('(self, ', '(') argspec = argspec.replace('*', '\*') signature = '%s%s' % (func_name, argspec) except TypeError, e: signature = '%s()' % func_name self['Signature'] = signature def get_func(self): func_name = getattr(self._f, '__name__', self.__class__.__name__) if inspect.isclass(self._f): func = getattr(self._f, '__call__', self._f.__init__) else: func = self._f return func, func_name def __str__(self): out = '' func, func_name = self.get_func() signature = self['Signature'].replace('*', '\*') roles = {'func': 'function', 'meth': 'method'} if self._role: if not roles.has_key(self._role): print ""Warning: invalid role %s"" % self._role out += '.. %s:: %s\n \n\n' % (roles.get(self._role, ''), func_name) out += super(FunctionDoc, self).__str__(func_role=self._role) return out class ClassDoc(NumpyDocString): def __init__(self, cls, doc=None, modulename='', func_doc=FunctionDoc, config=None): if not inspect.isclass(cls) and cls is not None: raise ValueError(""Expected a class or None, but got %r"" % cls) self._cls = cls if modulename and not modulename.endswith('.'): modulename += '.' self._mod = modulename if doc is None: if cls is None: raise ValueError(""No class or documentation string given"") doc = pydoc.getdoc(cls) NumpyDocString.__init__(self, doc) if config is not None and config.get('show_class_members', True): if not self['Methods']: self['Methods'] = [(name, '', '') for name in sorted(self.methods)] if not self['Attributes']: self['Attributes'] = [(name, '', '') for name in sorted(self.properties)] @property def methods(self): if self._cls is None: return [] return [name for name, func in inspect.getmembers(self._cls) if not name.startswith('_') and callable(func)] @property def properties(self): if self._cls is None: return [] return [name for name, func in inspect.getmembers(self._cls) if not name.startswith('_') and func is None] ","Python" "Conformation","msmbuilder/msmbuilder-legacy","docs/sphinx/sphinxext/numpy_ext/numpydoc.py",".py","5593","178",""""""" ======== numpydoc ======== Sphinx extension that handles docstrings in the Numpy standard format. [1] It will: - Convert Parameters etc. sections to field lists. - Convert See Also section to a See also entry. - Renumber references. - Extract the signature from the docstring, if it can't be determined otherwise. .. [1] http://projects.scipy.org/numpy/wiki/CodingStyleGuidelines#docstring-standard """""" import os import re import pydoc from docscrape_sphinx import get_doc_object from docscrape_sphinx import SphinxDocString from sphinx.util.compat import Directive import inspect def mangle_docstrings(app, what, name, obj, options, lines, reference_offset=[0]): cfg = dict(use_plots=app.config.numpydoc_use_plots, show_class_members=app.config.numpydoc_show_class_members) if what == 'module': # Strip top title title_re = re.compile(ur'^\s*[#*=]{4,}\n[a-z0-9 -]+\n[#*=]{4,}\s*', re.I | re.S) lines[:] = title_re.sub(u'', u""\n"".join(lines)).split(u""\n"") else: doc = get_doc_object(obj, what, u""\n"".join(lines), config=cfg) lines[:] = unicode(doc).split(u""\n"") if app.config.numpydoc_edit_link and hasattr(obj, '__name__') and \ obj.__name__: if hasattr(obj, '__module__'): v = dict(full_name=u""%s.%s"" % (obj.__module__, obj.__name__)) else: v = dict(full_name=obj.__name__) lines += [u'', u'.. htmlonly::', ''] lines += [u' %s' % x for x in (app.config.numpydoc_edit_link % v).split(""\n"")] # replace reference numbers so that there are no duplicates references = [] for line in lines: line = line.strip() m = re.match(ur'^.. \[([a-z0-9_.-])\]', line, re.I) if m: references.append(m.group(1)) # start renaming from the longest string, to avoid overwriting parts references.sort(key=lambda x: -len(x)) if references: for i, line in enumerate(lines): for r in references: if re.match(ur'^\d+$', r): new_r = u""R%d"" % (reference_offset[0] + int(r)) else: new_r = u""%s%d"" % (r, reference_offset[0]) lines[i] = lines[i].replace(u'[%s]_' % r, u'[%s]_' % new_r) lines[i] = lines[i].replace(u'.. [%s]' % r, u'.. [%s]' % new_r) reference_offset[0] += len(references) def mangle_signature(app, what, name, obj, options, sig, retann): # Do not try to inspect classes that don't define `__init__` if (inspect.isclass(obj) and (not hasattr(obj, '__init__'))): return '', '' if not (callable(obj) or hasattr(obj, '__argspec_is_invalid_')): return if not hasattr(obj, '__doc__'): return doc = get_doc_object(obj, what) if doc['Signature']: sig = re.sub(u""^[^(]*"", u"""", doc['Signature']) return sig, u'' def setup(app, get_doc_object_=get_doc_object): global get_doc_object get_doc_object = get_doc_object_ app.connect('autodoc-process-docstring', mangle_docstrings) app.connect('autodoc-process-signature', mangle_signature) app.add_config_value('numpydoc_edit_link', None, False) app.add_config_value('numpydoc_use_plots', None, False) app.add_config_value('numpydoc_show_class_members', True, True) # Extra mangling domains app.add_domain(NumpyPythonDomain) app.add_domain(NumpyCDomain) #----------------------------------------------------------------------------- # Docstring-mangling domains #----------------------------------------------------------------------------- from docutils.statemachine import ViewList from sphinx.domains.c import CDomain from sphinx.domains.python import PythonDomain class ManglingDomainBase(object): directive_mangling_map = {} def __init__(self, *a, **kw): super(ManglingDomainBase, self).__init__(*a, **kw) self.wrap_mangling_directives() def wrap_mangling_directives(self): for name, objtype in self.directive_mangling_map.items(): self.directives[name] = wrap_mangling_directive( self.directives[name], objtype) class NumpyPythonDomain(ManglingDomainBase, PythonDomain): name = 'np' directive_mangling_map = { 'function': 'function', 'class': 'class', 'exception': 'class', 'method': 'function', 'classmethod': 'function', 'staticmethod': 'function', 'attribute': 'attribute', } class NumpyCDomain(ManglingDomainBase, CDomain): name = 'np-c' directive_mangling_map = { 'function': 'function', 'member': 'attribute', 'macro': 'function', 'type': 'class', 'var': 'object', } def wrap_mangling_directive(base_directive, objtype): class directive(base_directive): def run(self): env = self.state.document.settings.env name = None if self.arguments: m = re.match(r'^(.*\s+)?(.*?)(\(.*)?', self.arguments[0]) name = m.group(2).strip() if not name: name = self.arguments[0] lines = list(self.content) mangle_docstrings(env.app, objtype, name, None, None, lines) self.content = ViewList(lines, self.content.parent) return base_directive.run(self) return directive ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/SaveStructures.py",".py","4986","124","from __future__ import print_function, absolute_import, division from mdtraj.utils.six.moves import xrange import os import numpy as np from mdtraj import io from msmbuilder import arglib from msmbuilder import Project from msmbuilder import MSMLib from msmbuilder.clustering import concatenate_trajectories import logging logger = logging.getLogger('msmbuilder.scripts.SaveStructures') DEBUG = True parser = arglib.ArgumentParser(description="""""" Yank a number of randomly selected conformations from each state in a model. The conformations can either be saved in separate files (i.e. one PDB file per conformations), or in the same file. """""") parser.add_argument('project') parser.add_argument('assignments', default='Data/Assignments.Fixed.h5') parser.add_argument('conformations_per_state', default=5, type=int, help='Number of conformations to sample from each state') parser.add_argument('states', nargs='+', type=int, help='''Which states to sample from. Pass a list of integers, separated by whitespace. To specify ALL of the states, include the integer -1.''', default=[-1]) # nargs=+ means the values will come out as type list, but this isn't # naturally applied to the default, so we just put the default as [-1] parser.add_argument('format', choices=['pdb', 'xtc', 'h5'], help='''Format for the outputted conformations. PDB is the standard plaintext protein databank format. XTC is the gromacs binary trajectory format, and h5 is the MDTraj hdf format''', default='pdb') parser.add_argument('style', choices=['sep', 'tps', 'one'], help='''Controls the number of conformations save per file. If ""sep"" (SEPARATE), all of the conformations will be saved in separate files, named in the format State{i}-{j}.{ext} for the `j`th conformation sampled from the `i`th state. If ""tps"" (Trajectory Per State), each of the conformations sampled from a given state `i` will be saved in a single file, named State{i}.{ext}. If ""one"", all of the conformations will be saved in a single file, such that the `j`th conformation from the `states[i]`-th microstate will be the `i+j*N`th frame in the trajectory file. The file will be namaed Confs.{ext} ''', default='sep') parser.add_argument('replacement', type=bool, help='''Draw random stuctures from those assigned to a state either with replacement or without. If you ask for k structures from a state with < k assignments and are drawing with --replacement False, you will get an error.''', default=True) def save(confs_by_state, states, style, format, outdir): ""Save the results to disk"" if style == 'sep': for i, trj in enumerate(confs_by_state): for j in xrange(len(trj)): fn = os.path.join(outdir, 'State%d-%d.%s' % (states[i], j, format)) arglib.die_if_path_exists(fn) logger.info(""Saving file: %s"" % fn) trj[j].save(fn) elif style == 'tps': for i, trj in enumerate(confs_by_state): fn = os.path.join(outdir, 'State%d.%s' % (states[i], format)) arglib.die_if_path_exists(fn) logger.info(""Saving file: %s"" % fn) trj.save(fn) elif style == 'one': fn = os.path.join(outdir, 'Confs.%s' % format) arglib.die_if_path_exists(fn) logger.info(""Saving file: %s"" % fn) concatenate_trajectories(confs_by_state).save(fn) else: raise ValueError('Invalid style: %s' % style) def entry_point(): """"""Parse command line inputs, load up files, then call run() and save() to do the real work"""""" parser.add_argument('output_dir', default='PDBs') args = parser.parse_args() # load... # project project = Project.load_from(args.project) # assignments try: assignments = io.loadh(args.assignments, 'arr_0') except KeyError: assignments = io.loadh(args.assignments, 'Data') # states if -1 in args.states: states = np.unique(assignments[np.where(assignments != -1)]) logger.info('Yanking from all %d states', len(states)) else: # ensure that the states are sorted, and that they're unique -- you # can only request each state once states = np.unique(args.states) logger.info(""Yanking from the following states: %s"", states) # extract the conformations using np.random for the randomness confs_by_state = project.get_random_confs_from_states( assignments, states=states, num_confs=args.conformations_per_state, replacement=args.replacement) # save the conformations to disk, in the requested style save(confs_by_state=confs_by_state, states=states, style=args.style, format=args.format, outdir=args.output_dir) if __name__ == '__main__': entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/CalculateClusterRadii.py",".py","3783","106","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ############################################################################## # Imports ############################################################################## import logging import numpy as np from mdtraj import io from msmbuilder import arglib from msmbuilder.MSMLib import invert_assignments ############################################################################## # Globals ############################################################################## logger = logging.getLogger('msmbuilder.scripts.CalculateClusterRadii') parser = arglib.ArgumentParser(description="""""" Calculates the cluster radius for all clusters in the model. Here, we define radius is simply the average distance of all conformations in a cluster to its generator. Does this by taking averaging the distance of each assigned state to its generator. Output: A flat txt file, 'ClusterRadii.dat', the average RMSD distance to the generator, measured by what ever distance metric was used in assigning."""""") parser.add_argument( 'assignments', type=str, default='Data/Assignments.Fixed.h5') parser.add_argument('distances', help='''Path to assignment distances file.''', default='Data/Assignments.h5.distances') parser.add_argument('output', default='ClusterRadii.dat') ############################################################################## # Code ############################################################################## def main(assignments, distances): """""" Calculate the mean radii of each state Parameters ---------- assignments : np.ndarray, shape=[n_trajs, n_frames], dtype=int The array of assignments, indicating which cluster each frame is assigned to. distances : np.ndarray, shape=[n_trajs, n_frames], dtype=float/double The array of distances, indicating the distance (measured by some metric used in the Assign step) from each frame to its assigned generator Returns ------- radii : np.ndarray, shape=[n_states], dtype=float/double The mean radii of each state """""" inverse_mapping = invert_assignments(assignments) states = inverse_mapping.keys() # don't count the minus one state, since it indicates the absense of # an assignments if -1 in states: states.remove(-1) n_states = len(states) radii = np.nan * np.ones(n_states) for s in states: trj, frame = inverse_mapping[s] radii[s] = distances[trj, frame].mean() return radii if __name__ == ""__main__"": args = parser.parse_args() arglib.die_if_path_exists(args.output) try: assignments = io.loadh(args.assignments, 'arr_0') distances = io.loadh(args.distances, 'arr_0') except KeyError: assignments = io.loadh(args.assignments, 'Data') distances = io.loadh(args.distances, 'Data') radii = main(assignments, distances) np.savetxt(args.output, radii) logger.info(""Wrote: %s"", args.output) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/RebuildProject.py",".py","1725","53","import os import glob import logging import numpy as np from msmbuilder import Project, utils, arglib import mdtraj as md logger = logging.getLogger('msmbuilder.scripts.RebuildProject') parser = arglib.ArgumentParser(description="""""" Rebuild the project file (ProjectInfo.yaml). This is useful when trajectory files have been deleted, or when you have lost your ProjectInfo file. \nOutput: ProjectInfo.yaml"""""") parser.add_argument('traj_dir', default=""./Trajectories/"") parser.add_argument('conf_filename', default=""native.pdb"") parser.add_argument('project_filename', default=""./ProjectInfo.yaml"") parser.add_argument('iext', default="".h5"") def run(traj_dir, conf_filename, project_filename, iext): logger.info(""Rebuilding project."") file_list = glob.glob(traj_dir + ""/trj*%s"" % iext) num_traj = len(file_list) traj_lengths = np.zeros(num_traj, 'int') traj_paths = [] if not os.path.exists(conf_filename): raise(IOError(""Cannot find conformation file %s"" % conf_filename)) file_list = sorted(file_list, key=utils.keynat) for i, filename in enumerate(file_list): traj_lengths[i] = len(md.open(filename)) traj_paths.append(filename) records = { ""conf_filename"": conf_filename, ""traj_lengths"": traj_lengths, ""traj_paths"": traj_paths, ""traj_errors"": [None for i in xrange(num_traj)], ""traj_converted_from"": [[] for i in xrange(num_traj)] } p = Project(records) p.save(project_filename) logger.info(""Wrote %s"" % project_filename) def entry_point(): args = parser.parse_args() run(args.traj_dir, args.conf_filename, args.project_filename, args.iext) if __name__ == ""__main__"": entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/ConvertDataToHDF.py",".py","7660","172","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import os import sys import logging import numpy as np from msmbuilder.project import validators, ProjectBuilder, FahProjectBuilder from msmbuilder import Project from msmbuilder.arglib import ArgumentParser, die_if_path_exists from mdtraj.utils import ensure_type logger = logging.getLogger('msmbuilder.scripts.ConvertDataToHDF') parser = ArgumentParser(description="""""" Merges individual MD trajectory files into continuous HDF5 (.h5) trajectories. Can read data from a FAH project (PROJECT/RUN*/CLONE*/frame*.xtc) or from a directory containing one directory for each trajectory, with all the relevant XTCs inside that directory (PROJECT/TRAJ*/frame*.xtc). Can read any format compatible with mdtraj. Output: -- 'Trajectories' directory containing all the merged h5 files -- 'ProjectInfo' file containing information MSMBuilder uses in subsequent calculations. NOTE: There has been a change from previous versions of MSMBuilder with regards to the way snapshots are discarded. In the 'FAH' style reader, there is an automatic check to see if any two snapshots are the same at the beginning/end of consecutive xtc/dcd files. If they are the same, one gets discarded. Further, the FahProject object retains a little more discard functionality. """""") parser.add_argument('project', type=str, help='''The ProjectInfo (.h5) to write to disk. Contains metadata associated with your project''') parser.add_argument('pdb') parser.add_argument('input_dir', help='''Path to the parent directory containing subdirectories with MD data. See the description above for the appropriate formatting for directory architecture.''') parser.add_argument('source', help='''Data source: ""file"", or ""fah"". For ""file"" format, each of the trajectories needs to be in a different directory. For example, if you supply input_dir='XTC', then it is expected that the directory 'XTC' contains a set of subdirectories, each of which contains one or more files of a single MD trajectory that will be concatenated together. The glob pattern used would be XTC/*/*.*'. If 'fah', then standard folding@home-style directory architecture is required. If the IEXT option is given, the glob pattern will be restricted to the given file extension (behavior is the same for file and fah)''', default='file', choices=['fah', 'file']) parser.add_argument('min_length', help='''Minimum number of frames per trajectory required to include data in Project. Used to discard extremely short trajectories.''', default=0, type=int) parser.add_argument('stride', help='''Integer number to subsample by. Every ""u-th"" frame will be taken from the data and converted to msmbuilder format''', default=1, type=int) parser.add_argument('rmsd_cutoff', help='''A safe-guard that discards any structure with and RMSD higher than the specified value (in nanometers, with respect to the input PDB file). Pass -1 to disable this feature''', default=-1, type=float) parser.add_argument('atom_indices', help='''If specified, load atom indices using np.loadtxt() and pass along to the converter. This allows you to extract only a subset of atoms during the file conversion process.''', default="""", type=str) parser.add_argument('iext', help='''The file extension of input trajectory files. Must be a filetype that mdtraj.load() can recognize. If this option is not supplied, all filetypes known to mdtraj.load() will be loaded.''', default="""", type=str) def run(projectfn, conf_filename, input_dir, source, min_length, stride, rmsd_cutoff, atom_indices, iext): # check if we are doing an update or a fresh run # if os.path.exists(projectfn): # logger.info(""Found project info file encoding previous work, running in update mode..."") # update = True # else: # update = False # # logger.info(""Looking for %s style data in %s"", source, input_dir) # if update: # raise NotImplementedError(""Ack! Update mode is not yet ready yet."") # if the source is fah, we'll use some special FaH specific loading functions # to (1) try to recover in case of errors and (2) load the specific directory # hierarchy of FaH (RUN/CLONE/GEN/frame.xtc) if os.path.exists(projectfn): project = Project.load_from(projectfn) logger.warn( ""%s exists, will modify it and update the trajectories in %s"", projectfn, '/'.join(project._traj_paths[0].split('/')[:-1])) else: project = None if source.startswith('file'): pb = ProjectBuilder( input_dir, input_traj_ext=iext, conf_filename=conf_filename, stride=stride, project=project, atom_indices=atom_indices) elif source == 'fah': pb = FahProjectBuilder( input_dir, input_traj_ext=iext, conf_filename=conf_filename, stride=stride, project=project, atom_indices=atom_indices) else: raise ValueError(""Invalid argument for source: %s"" % source) # check that trajectories to not go farther than a certain RMSD # from the PDB. Useful to check for blowing up or other numerical # instabilities if rmsd_cutoff is not None: # TODO: this is going to use ALL of the atom_indices, including hydrogen. This is # probably not the desired functionality # KAB: Apparently needed to use correctly subsetted atom_indices here to avoid an error validator = validators.RMSDExplosionValidator( conf_filename, max_rmsd=rmsd_cutoff, atom_indices=atom_indices) pb.add_validator(validator) # Only accept trajectories with more snapshots than min_length. if min_length > 0: validator = validators.MinLengthValidator(min_length) pb.add_validator(validator) # everyone wants to be centered pb.add_validator(validators.TrajCenterer()) pb.get_project().save(projectfn) assert os.path.exists(projectfn), '%s does not exist' % projectfn logger.info(""Finished data conversion successfully."") logger.info(""Generated: %s, Trajectories/"", projectfn) return def entry_point(): args = parser.parse_args() rmsd_cutoff = args.rmsd_cutoff if rmsd_cutoff <= 0.0: rmsd_cutoff = None else: logger.warning( ""Will discard any frame that is %f nm from the PDB conformation..."", rmsd_cutoff) if args.atom_indices == """": atom_indices = None else: atom_indices = np.loadtxt(args.atom_indices) atom_indices = ensure_type(atom_indices, 'int', 1, ""atom_indices"") run(args.project, args.pdb, args.input_dir, args.source, args.min_length, args.stride, rmsd_cutoff, atom_indices, args.iext) if __name__ == '__main__': entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/PCCA.py",".py","5296","138","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import os import logging import scipy.io import numpy as np from mdtraj import io from msmbuilder import MSMLib from msmbuilder import lumping from msmbuilder import arglib logger = logging.getLogger('msmbuilder.scripts.PCCA') float_or_none = lambda s: None if s.lower() == 'none' else float(s) parser = arglib.ArgumentParser(description="""""" Applies the (f)PCCA(+) algorithm to lump your microstates into macrostates. You may specify a transition matrix if you wish - this matrix is used to determine the dynamics of the microstate model for lumping into kinetically relevant macrostates. Output: MacroAssignments.h5, a new assignments HDF file, for the Macro MSM."""""") parser.add_argument('assignments', default='Data/Assignments.Fixed.h5') parser.add_argument('num_macrostates', type=int) parser.add_argument('tProb') parser.add_argument('output_dir') parser.add_argument('algorithm', help='Which algorithm to use', choices=['PCCA', 'PCCA+'], default='PCCA') parser.add_argument_group('Extra PCCA+ Options') parser.add_argument('flux_cutoff', help='''Discard eigenvectors below this flux''', default='None', type=float_or_none) parser.add_argument('objective_function', help='''Minimize which PCCA+ objective function (crisp_metastability, metastability, or crispness)''', default=""crisp_metastability"") parser.add_argument( 'do_minimization', help='Use PCCA+ minimization', default=True) def run_pcca(num_macrostates, assignments, tProb): logger.info(""Running PCCA..."") if len(np.unique(assignments[np.where(assignments != -1)])) != tProb.shape[0]: raise ValueError( 'Different number of states in assignments and tProb!') PCCA = lumping.PCCA(tProb, num_macrostates) MAP = PCCA.microstate_mapping # MAP the new assignments and save, make sure don't # mess up negaitve one's (ie where don't have data) MSMLib.apply_mapping_to_assignments(assignments, MAP) return MAP, assignments def run_pcca_plus(num_macrostates, assignments, tProb, flux_cutoff=0.0, objective_function=""crispness"", do_minimization=True): logger.info(""Running PCCA+..."") pcca_plus = lumping.PCCAPlus( tProb, num_macrostates, flux_cutoff=flux_cutoff, do_minimization=do_minimization, objective_function=objective_function) A, chi, MAP = pcca_plus.A, pcca_plus.chi, pcca_plus.microstate_mapping MSMLib.apply_mapping_to_assignments(assignments, MAP) return chi, A, MAP, assignments def entry_point(): args = parser.parse_args() # load args try: assignments = io.loadh(args.assignments, 'arr_0') except KeyError: assignments = io.loadh(args.assignments, 'Data') tProb = scipy.io.mmread(args.tProb) # workaround for arglib funniness? if args.do_minimization in [""False"", ""0""]: args.do_minimization = False else: args.do_minimization = True if args.algorithm == 'PCCA': MacroAssignmentsFn = os.path.join( args.output_dir, ""MacroAssignments.h5"") MacroMapFn = os.path.join(args.output_dir, ""MacroMapping.dat"") arglib.die_if_path_exists([MacroAssignmentsFn, MacroMapFn]) MAP, assignments = run_pcca(args.num_macrostates, assignments, tProb) np.savetxt(MacroMapFn, MAP, ""%d"") io.saveh(MacroAssignmentsFn, assignments) logger.info(""Saved output to: %s, %s"", MacroAssignmentsFn, MacroMapFn) elif args.algorithm == 'PCCA+': MacroAssignmentsFn = os.path.join( args.output_dir, ""MacroAssignments.h5"") MacroMapFn = os.path.join(args.output_dir, ""MacroMapping.dat"") ChiFn = os.path.join(args.output_dir, 'Chi.dat') AFn = os.path.join(args.output_dir, 'A.dat') arglib.die_if_path_exists([MacroAssignmentsFn, MacroMapFn, ChiFn, AFn]) chi, A, MAP, assignments = run_pcca_plus(args.num_macrostates, assignments, tProb, args.flux_cutoff, objective_function=args.objective_function, do_minimization=args.do_minimization) np.savetxt(ChiFn, chi) np.savetxt(AFn, A) np.savetxt(MacroMapFn, MAP, ""%d"") io.saveh(MacroAssignmentsFn, assignments) logger.info('Saved output to: %s, %s, %s, %s', ChiFn, AFn, MacroMapFn, MacroAssignmentsFn) else: raise Exception() if __name__ == ""__main__"": entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/TrimAssignments.py",".py","2751","74","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import sys import numpy as np from mdtraj import io from msmbuilder import arglib import logging logger = logging.getLogger('msmbuilder.scripts.TrimAssignments') parser = arglib.ArgumentParser(description="""""" Trims assignments based on the distance to their generator. Useful for eliminating bad assignments from a coase clustering. Note that this discards (expensive!) data, so should only be used if an optimal clustering is not available. Note: Check your cluster sized with CalculateClusterRadii.py to get a handle on how big they are before you trim. Recall the radius is the *average* distance to the generator, here you are enforcing the *maximum* distance. Output: A trimmed assignments file (Assignments.Trimmed.h5)."""""") parser.add_argument('assignments', default='Data/Assignments.Fixed.h5') parser.add_argument('distances', default='Data/Assignments.h5.distances') parser.add_argument('rmsd_cutoff', help=""""""distance value at which to trim, in. Data further than this value to its generator will be discarded. Note: this is measured with whatever distance metric you used to cluster"""""", type=float) parser.add_argument('output', default='Data/Assignments.Trimmed.h5') def run(assignments, distances, cutoff): number = np.count_nonzero(distances > cutoff) logger.info('Discarding %d assignments', number) assignments[np.where(distances > cutoff)] = -1 return assignments def entry_point(): args = parser.parse_args() arglib.die_if_path_exists(args.output) try: assignments = io.loadh(args.assignments, 'arr_0') distances = io.loadh(args.distances, 'arr_0') except KeyError: assignments = io.loadh(args.assignments, 'Data') distances = io.loadh(args.distances, 'Data') trimmed = run(assignments, distances, args.rmsd_cutoff) io.saveh(args.output, trimmed) logger.info('Saved output to %s', args.output) if __name__ == ""__main__"": entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/tICA_train.py",".py","3687","103","#!/usr/bin/env python from __future__ import print_function, absolute_import, division import logging import os import sys import re import numpy as np import scipy import mdtraj as md from mdtraj import io from mdtraj.utils.six.moves import xrange from msmbuilder import arglib from msmbuilder import Project from msmbuilder.reduce.tICA import tICA logger = logging.getLogger('msmbuilder.scripts.tICA_train') parser = arglib.ArgumentParser(get_metric=True, description="""""" Calculate the time-lag correlation and covariance matrices for use in the tICA metric. This method attempts to find projection vectors such that they have a maximal autocorrelation function. For more details see: Schwantes, CR and Pande, VS. J. Chem. Theory Comput., 2013, 9 (4), pp 2000-2009. DOI: 10.1021/ct300878a"""""") parser.add_argument('project') parser.add_argument('stride', type=int, default=1, help='stride to subsample input trajectories') parser.add_argument('atom_indices', default='all', help='atom indices to restrict trajectories to') parser.add_argument('output', default='tICAData.h5', help='output filename to save results to') parser.add_argument('delta_time', type=int, help=""""""delta time to use in calculating the time-lag correlation matrix"""""") parser.add_argument('min_length', type=int, default=0, help=""""""only train on trajectories greater than number of frames"""""") def run(prep_metric, project, delta_time, atom_indices=None, output='tICAData.h5', min_length=0, stride=1): # We will load the trajectories at the stride, so we need to find # what dt should be once we've strided by some amount lag = delta_time / stride if (float(delta_time) / stride) != lag: raise Exception(""Stride must be a divisor of delta_time."") if lag > 0: # Then we're doing tICA tica_obj = tICA(lag=lag, calc_cov_mat=True, prep_metric=prep_metric) else: # If lag is zero, this is equivalent to regular PCA tica_obj = tICA(lag=lag, calc_cov_mat=False, prep_metric=prep_metric) for i in xrange(project.n_trajs): logger.info(""Working on trajectory %d"" % i) if project.traj_lengths[i] <= lag: logger.info(""Trajectory is not long enough for this lag "" ""(%d vs %d)"", project.traj_lengths[i], lag) continue if project.traj_lengths[i] < min_length: logger.info(""Trajectory is not longer than min_length "" ""(%d vs %d)"", project.traj_lengths[i], min_length) continue # it would be more memory efficient if we trained incrementally # at least for long trajectories traj_chunk = md.load(project.traj_filename( i), stride=stride, atom_indices=atom_indices) tica_obj.train(trajectory=traj_chunk) tica_obj.solve() tica_obj.save(output) logger.info(""Saved output to %s"", output) return tica_obj def entry_point(): args, prep_metric = parser.parse_args() arglib.die_if_path_exists(args.output) if args.atom_indices.lower() == 'all': atom_indices = None else: atom_indices = np.loadtxt(args.atom_indices).astype(int) project = Project.load_from(args.project) min_length = int(float(args.min_length)) # need to convert to float first because int can't # convert a string that is '1E3' for example...weird. tica_obj = run( prep_metric, project, args.delta_time, atom_indices=atom_indices, output=args.output, min_length=min_length, stride=args.stride) if __name__ == ""__main__"": entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/__init__.py",".py","1294","43","# This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # list of all the modules (files) that are part of msmbuilder scripts __all__ = [ 'Assign', 'AssignHierarchical', 'BACE_Coarse_Graining', 'BuildMSM', 'CalculateClusterRadii', 'CalculateImpliedTimescales', 'CalculateMFPTs', 'CalculateProjectDistance', 'CalculateProjectSASA', 'CalculateTPT', 'Cluster', 'ConvertDataToHDF', 'CreateAtomIndices', 'FindPaths', 'InteractiveSCRE', 'PCCA', 'PlotImpliedTimescales', 'RebuildProject', 'SampleTrajectory', 'SaveStructures', 'TrimAssignments', 'tICA_train'] ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/FindPaths.py",".py","3157","92","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # TJL 2011, PANDE GROUP import numpy as np import logging import scipy.io from mdtraj import io from msmbuilder import tpt from msmbuilder import arglib logger = logging.getLogger('msmbuilder.scripts.FindPaths') parser = arglib.ArgumentParser(description= """"""Finds the highest flux paths through an MSM. Returns: an HDF5 file (default: Paths.h5), which contains three items: (1) The highest flux pathways (a list of ints) (2) The bottlenecks in these pathways (a list of 2-tuples) (3) The flux of each pathway"""""") parser.add_argument('number', help='''Number of pathways you want to retreive''', type=int) parser.add_argument('tprob', help='Transition probability matrix', default='tProb.mtx') parser.add_argument('starting', help='''Vector of states in the starting/reactants/unfolded ensemble.''', default='U_states.dat') parser.add_argument('ending', help='''Vector of states in the ending/products/folded ensemble.''', default='F_states.dat') parser.add_argument('output', default='Paths.h5') def run(tprob, A, B, n): Paths, Bottlenecks, Fluxes = tpt.find_top_paths(A, B, tprob, num_paths=n) # We have to pad the paths with -1s to make a square array maxi = 0 # the maximum path length for path in Paths: if len(path) > maxi: maxi = len(path) PaddedPaths = -1 * np.ones((len(Paths), maxi)) for i, path in enumerate(Paths): PaddedPaths[i, :len(path)] = np.array(path) return PaddedPaths, np.array(Bottlenecks), np.array(Fluxes) def entry_point(): args = parser.parse_args() F = np.loadtxt(args.ending).astype(int) U = np.loadtxt(args.starting).astype(int) tprob = scipy.io.mmread(args.tprob) # deal with case where have single start or end state # TJL note: this should be taken care of in library now... keeping it just # in case if F.shape == (): tmp = np.zeros(1, dtype=int) tmp[0] = int(F) F = tmp.copy() if U.shape == (): tmp = np.zeros(1, dtype=int) tmp[0] = int(U) U = tmp.copy() arglib.die_if_path_exists(args.output) paths, bottlenecks, fluxes = run(tprob, U, F, args.number) io.saveh(args.output, Paths=paths, Bottlenecks=bottlenecks, fluxes=fluxes) logger.info('Saved output to %s', args.output) if __name__ == ""__main__"": entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/CalculateImpliedTimescales.py",".py","3945","91","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import logging import numpy as np from msmbuilder import arglib from msmbuilder import msm_analysis logger = logging.getLogger('msmbuilder.scripts.CalculateImpliedTimescales') parser = arglib.ArgumentParser(description="""""" \nCalculates the implied timescales of a set of assigned data, up to the argument 'lagtime'. Returns: ImpliedTimescales.dat, a flat file that contains all the lag times.\n"""""") parser.add_argument('assignments', type=str) parser.add_argument('lagtime', help=""""""The lagtime range to calculate. Pass two ints as X,Y with NO WHITESPACE, where X is the lowest timescale you want and Y is the biggest. EG: '-l 5,50'."""""") parser.add_argument('output', help=""""""The name of the implied timescales data file (use .dat extension)"""""", default='ImpliedTimescales.dat') parser.add_argument('procs', help='''Number of concurrent processes (cores) to use''', default=1, type=int) parser.add_argument('eigvals', help=""""""Number of slowest implied timescales to retrieve at each lag time. Note: an n-state model will have n-1 implied timescales."""""", default=10, type=int) parser.add_argument('interval', help=""""""Interval between times (intervals) to calculate lagtimes for"""""", default=1, type=int) parser.add_argument('symmetrize', help=""""""Method by which to estimate a symmetric counts matrix. Symmetrization ensures reversibility, but may skew dynamics. We recommend maximum likelihood estimation (MLE) when tractable, else try Transpose. It is strongly recommended you read the documentation surrounding this choice."""""", default='MLE', choices=['MLE', 'Transpose', 'None']) parser.add_argument('notrim', help=""""""Do not apply an ergodic trim. By default, we keep only the largest observed ergodic subset of the data. supplied, keeps everything."""""", action='store_true') def run(MinLagtime, MaxLagtime, Interval, NumEigen, AssignmentsFn, trimming, symmetrize, nProc): logger.info( ""Getting %d eigenvalues (timescales) for each lagtime..."", NumEigen) lagTimes = range(MinLagtime, MaxLagtime + 1, Interval) logger.info(""Building MSMs at the following lag times: %s"", lagTimes) assert np.all(np.array(lagTimes) > 0), ""Please specify a range of positive lag times."" # Get the implied timescales (eigenvalues) impTimes = msm_analysis.get_implied_timescales( AssignmentsFn, lagTimes, n_implied_times=NumEigen, sliding_window=True, trimming=trimming, symmetrize=symmetrize, n_procs=nProc) return impTimes def entry_point(): args = parser.parse_args() arglib.die_if_path_exists(args.output) LagTimes = args.lagtime.split(',') MinLagtime = int(LagTimes[0]) MaxLagtime = int(LagTimes[1]) # Pass the symmetric flag if args.symmetrize in [""None"", ""none"", None]: args.symmetrize = None impTimes = run( MinLagtime, MaxLagtime, args.interval, args.eigvals, args.assignments, (not args.notrim), args.symmetrize, args.procs) np.savetxt(args.output, impTimes) logger.info(""Saved output to %s"", args.output) if __name__ == '__main__': entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/CreateAtomIndices.py",".py","7916","165","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA from __future__ import print_function import sys import logging import numpy as np from msmbuilder import arglib import mdtraj as md logger = logging.getLogger('msmbuilder.scripts.CreateAtomIndices') parser = arglib.ArgumentParser( description=""Creates an atom indices file for RMSD from a PDB."") parser.add_argument('pdb') parser.add_argument('output', default='AtomIndices.dat') parser.add_argument('atom_type', help='''Atoms to include in index file. One of four options: (1) minimal (CA, CB, C, N, O, recommended), (2) heavy, (3) alpha (carbons), or (4) all. Use ""all"" in cases where protein nomenclature may be inapproprate, although you may want to define your own indices in such situations. Note that ""heavy"" keeps all heavy atoms that are not symmetry equivalent. By symmetry equivalent, we mean atoms identical under an exchange of labels. For example, heavy will exclude the two pairs of equivalent carbons (CD, CE) in a PHE ring. Note that AtomIndices.dat should be zero-indexed--that is, a 0 in AtomIndices.dat corresponds to the first atom in your PDB''', choices=['minimal', 'heavy', 'alpha', 'all'], default='minimal') def run(PDBfn, atomtype): # dictionaries with residue types as keys and list of atoms to keep for # given residue as entries toKeepDict = { ""ALA"": [""N"", ""CA"", ""CB"", ""C"", ""O""], ""ACE"": [""N"", ""CA"", ""CB"", ""C"", ""O""], ""CALA"": [""N"", ""CA"", ""CB"", ""C"", ""O""], ""NALA"": [""N"", ""CA"", ""CB"", ""C"", ""O""], ""ARG"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD"", ""NE"", ""CZ""], ""CARG"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD"", ""NE"", ""CZ""], ""NARG"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD"", ""NE"", ""CZ""], ""ASN"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""OD1"", ""ND2""], ""CASN"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""OD1"", ""ND2""], ""NASN"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""OD1"", ""ND2""], ""ASP"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG""], ""CASP"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG""], ""NASP"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG""], ""CYS"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""SG""], ""CYX"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""SG""], ""CCYS"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""SG""], ""NCYS"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""SG""], ""GLU"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD""], ""CGLU"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD""], ""NGLU"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD""], ""GLN"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD"", ""OE1"", ""NE2""], ""CGLN"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD"", ""OE1"", ""NE2""], ""NGLN"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD"", ""OE1"", ""NE2""], ""GLY"": [""N"", ""CA"", ""C"", ""O""], ""CGLY"": [""N"", ""CA"", ""C"", ""O""], ""NGLY"": [""N"", ""CA"", ""C"", ""O""], ""HSD"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""ND1"", ""CE1"", ""NE2"", ""CD2""], ""HIS"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""ND1"", ""CE1"", ""NE2"", ""CD2""], ""HID"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""ND1"", ""CE1"", ""NE2"", ""CD2""], ""CHID"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""ND1"", ""CE1"", ""NE2"", ""CD2""], ""NHID"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""ND1"", ""CE1"", ""NE2"", ""CD2""], ""HIE"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""ND1"", ""CE1"", ""NE2"", ""CD2""], ""CHIE"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""ND1"", ""CE1"", ""NE2"", ""CD2""], ""NHIE"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""ND1"", ""CE1"", ""NE2"", ""CD2""], ""HIP"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""ND1"", ""CE1"", ""NE2"", ""CD2""], ""CHIP"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""ND1"", ""CE1"", ""NE2"", ""CD2""], ""NHIP"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""ND1"", ""CE1"", ""NE2"", ""CD2""], ""ILE"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG1"", ""CG2"", ""CD""], ""CILE"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG1"", ""CG2"", ""CD""], ""NILE"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG1"", ""CG2"", ""CD""], ""LEU"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG""], ""CLEU"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG""], ""NLEU"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG""], ""LYP"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD"", ""CE"", ""NZ""], ""LYS"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD"", ""CE"", ""NZ""], ""CLYP"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD"", ""CE"", ""NZ""], ""NLYP"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD"", ""CE"", ""NZ""], ""MET"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""SD"", ""CE""], ""CMET"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""SD"", ""CE""], ""NMET"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""SD"", ""CE""], ""NME"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""SD"", ""CE""], ""PHE"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CZ""], ""CPHE"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CZ""], ""NPHE"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CZ""], ""PRO"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CD"", ""CG""], ""CPRO"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CD"", ""CG""], ""NPRO"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CD"", ""CG""], ""SER"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""OG""], ""CSER"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""OG""], ""NSER"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""OG""], ""THR"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG2"", ""OG1""], ""CTHR"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG2"", ""OG1""], ""NTHR"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG2"", ""OG1""], ""TRP"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD1"", ""NE1"", ""CE2"", ""CZ2"", ""CH2"", ""CZ3"", ""CE3"", ""CD2""], ""CTRP"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD1"", ""NE1"", ""CE2"", ""CZ2"", ""CH2"", ""CZ3"", ""CE3"", ""CD2""], ""NTRP"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD1"", ""NE1"", ""CE2"", ""CZ2"", ""CH2"", ""CZ3"", ""CE3"", ""CD2""], ""TYR"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CZ"", ""OH""], ""CTYR"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CZ"", ""OH""], ""NTYR"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CZ"", ""OH""], ""VAL"": [""N"", ""CA"", ""CB"", ""C"", ""O""], ""CVAL"": [""N"", ""CA"", ""CB"", ""C"", ""O""], ""NVAL"": [""N"", ""CA"", ""CB"", ""C"", ""O""], ""NLE"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD"", ""CE""], ""CNLE"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD"", ""CE""], ""NNLE"": [""N"", ""CA"", ""CB"", ""C"", ""O"", ""CG"", ""CD"", ""CE""], ""SOL"": [], ""Cl-"": [], ""Na+"": [] } if atomtype == 'heavy': pass elif atomtype == 'minimal': for key, value in toKeepDict.items(): toKeepDict[key] = set(value).intersection( [""N"", ""CA"", ""CB"", ""C"", ""O""]) elif atomtype == 'alpha': for key in toKeepDict.keys(): toKeepDict[key] = [""CA""] elif atomtype == ""all"": pass else: logger.error(""Cannot understand atom type: %s"", atomtype) sys.exit(1) pdb = md.load(PDBfn) selector = lambda a: True if atomtype != ""all"": selector = lambda a: ( a.residue.name in toKeepDict) and a.name in toKeepDict[a.residue.name] indices = [a.index for a in pdb.topology.atoms if selector(a)] return np.array(indices) def entry_point(): args = parser.parse_args() arglib.die_if_path_exists(args.output) indices = run(args.pdb, args.atom_type) np.savetxt(args.output, indices, '%d') logger.info('Saved output to %s', args.output) if __name__ == ""__main__"": entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/CalculateTPT.py",".py","2880","85","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import os import logging import numpy as np import scipy.io from msmbuilder.tpt import calculate_committors, calculate_net_fluxes from msmbuilder import arglib logger = logging.getLogger('msmbuilder.scripts.CalculateTPT') parser = arglib.ArgumentParser(description="""""" Calculates a number of kinetic transition properties of a given MSM. Returns: (1) committors.dat - the forward committors of the MSM (numpy savetxt) (3) net_flux.mtx - the net flux matrix (scipy sparse fmt)"""""") parser.add_argument('tProb') parser.add_argument('starting', help='''Vector of states in the starting/reactants/unfolded ensemble.''', default='U_states.dat') parser.add_argument('ending', help='''Vector of states in the ending/products/folded ensemble.''', default='F_states.dat') parser.add_argument('output_dir', default='.') def run(TC, Uv, Fv): # Get committors and flux logger.info(""Getting committors and flux..."") Fc = calculate_committors(Uv, Fv, TC) logger.info(""Calculated forward committors."") NFlux = calculate_net_fluxes(Uv, Fv, TC) logger.info(""Calculated net flux."") return Fc, NFlux def entry_point(): args = parser.parse_args() T = scipy.io.mmread(args.tProb) U = np.loadtxt(args.starting).astype(int) F = np.loadtxt(args.ending).astype(int) # deal with case where have single start or end state # TJL note: This should be done in the library now... but leaving it if U.shape == (): tmp = np.zeros(1, dtype=int) tmp[0] = int(U) U = tmp.copy() if F.shape == (): tmp = np.zeros(1, dtype=int) tmp[0] = int(F) F = tmp.copy() # Check output isn't taken output_list = [""committors.dat"", ""net_flux.mtx""] output_flist = [os.path.join(args.output_dir, f) for f in output_list] arglib.die_if_path_exists(output_flist) Fc, NFlux = run(T, U, F) np.savetxt(output_flist[0], Fc) scipy.io.mmwrite(output_flist[1], NFlux) logger.info(""Saved output to %s"", ', '.join(output_flist)) if __name__ == ""__main__"": entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/AssignHierarchical.py",".py","3191","81","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ############################################################################## # Imports ############################################################################## import os import sys import logging from mdtraj import io from msmbuilder import Project from msmbuilder.clustering import Hierarchical from msmbuilder import arglib import numpy as np ############################################################################## # Globals ############################################################################## logger = logging.getLogger('msmbuilder.scripts.AssignHierarchical') parser = arglib.ArgumentParser(description='Assign data using a hierarchical clustering.') parser.add_argument('hierarchical_clustering_zmatrix', default='./Data/ZMatrix.h5', help='Path to hierarchical clustering zmatrix') parser.add_argument('stride', type=int, help='stride used when generating ZMatrix.h5') parser.add_argument('project') parser.add_argument('num_states', help='Number of States', default='none') parser.add_argument( 'cutoff_distance', help='Maximum cophenetic distance', default='none') parser.add_argument('assignments', type=str) ############################################################################## # Code ############################################################################## def main(k, d, zmatrix_fn, stride, project): hierarchical = Hierarchical.load_from_disk(zmatrix_fn) assignments = hierarchical.get_assignments(k=k, cutoff_distance=d) new_assignments = np.ones( (project.n_trajs, project.traj_lengths.max()), dtype=np.int) * -1 new_assignments[:, ::stride] = assignments return new_assignments def entry_point(): args = parser.parse_args() k = int(args.num_states) if args.num_states != 'none' else None d = float(args.cutoff_distance) if args.cutoff_distance != 'none' else None arglib.die_if_path_exists(args.assignments) if k is None and d is None: logger.error( 'You need to supply either a number of states or a cutoff distance') sys.exit(1) project = Project.load_from(args.project) assignments = main( k, d, args.hierarchical_clustering_zmatrix, args.stride, project) io.saveh(args.assignments, assignments) logger.info('Saved assignments to %s', args.assignments) if __name__ == '__main__': entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/PlotImpliedTimescales.py",".py","1980","57","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import sys import numpy as np from msmbuilder import arglib parser = arglib.ArgumentParser(description="""""" \nPlots data generated from CalculateImpliedTimescales.py. You may want to use this as a template for a pylab session We recommend modifying this script for your own purposes"""""") parser.add_argument('input', help='Path to ImpledTimescales.dat', default='ImpliedTimescales.dat') parser.add_argument('dt', help='Time between snapshots in your data', default=1, type=float) parser.add_argument( 'filename', help='Filename to save plot to. Leave blank to render plot to sceen', default='') parser.add_argument('title', help='Title for plot', default='Relaxation Timescale versus Lagtime') def entry_point(): import matplotlib.pyplot as pp args = parser.parse_args() input = np.loadtxt(args.input) pp.scatter(input[:, 0] * args.dt, input[:, 1] * args.dt) pp.yscale('log') pp.title(args.title) pp.xlabel('Lag Time') pp.ylabel('Relaxation Timescale') if args.filename: pp.savefig(args.filename) else: pp.show() if __name__ == ""__main__"": entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/InteractiveSCRE.py",".py","3288","109","#!/usr/bin/env python """"""Interactively estimate a rate matrix usign SCRE. """""" import os, sys import scipy.io from mdtraj import io from msmbuilder import MSMLib, SCRE, arglib import numpy as np import string import logging logger = logging.getLogger('msmbuilder.scripts.Interactive-SCRE') parser = arglib.ArgumentParser(description=__doc__) parser.add_argument('output_dir') parser.add_argument('assignments') def interactive_scre(assignments): Counts = MSMLib.get_count_matrix_from_assignments(assignments, lag_time=1) CountsAfterTrimming,Mapping = MSMLib.ErgodicTrim(Counts) MSMLib.ApplyMappingToAssignments(assignments,Mapping) ReversibleCounts = MSMLib.EstimateReversibleCountMatrix(CountsAfterTrimming) T = MSMLib.EstimateTransitionMatrix(ReversibleCounts).toarray() populations = np.array(ReversibleCounts.sum(0)).flatten() populations /= populations.sum() K0=SCRE.ConvertTIntoK(T) M,X=SCRE.get_parameter_mapping(K0) while len(X) > 0: lagtime_list = get_lagtimes() KList = scre_iteration(assignments,K0,lagtime_list,M,X,populations) matplotlib.pyplot.show() if len(X) > 1: i,j,lagtime = get_input() SCRE.FixEntry(M,X,populations,K0,i,j,KList[lagtime][i,j]) else: lagtime = get_lagtime() return KList[lagtime] def get_lagtime(): try: lagtime = int(raw_input(""Enter a lagtime (int), in units of the data storage step.\n"")) except ValueError: lagtimes = get_lagtimes() return lagtime - 1 def get_lagtimes(): try: max_lagtime = int(raw_input(""Enter a maximum lagtime (int), in units of the data storage step.\n"")) lagtimes = np.arange(1,max_lagtime) except ValueError: lagtimes = get_lagtimes() return lagtimes def get_input(): try: s = raw_input(""Enter i,j,lagtime (int, int, int), where lagtime is in units of the data storage step.\n"") i,j,lagtime = np.array(string.split(s,','),'int') except ValueError: i,j,lagtime = get_input() return i,j,lagtime - 1 def scre_iteration(assignments,K0,lagtime_list,M,X,populations): KList=[] counts_list = [] for LagTime in lagtime_list: logger.info(""Estimating rates at lagtime %d"", LagTime) K=K0.copy() * float(LagTime) C0=MSMLib.get_count_matrix_from_assignments(assignments, lag_time=LagTime).toarray() Counts=C0.sum(1) Counts/=LagTime X2=SCRE.MaximizeRateLikelihood(X,M,populations,C0,K) K=SCRE.ConstructRateFromParams(X2,M,populations,K) K/=(LagTime) KList.append(K) counts_list.append(Counts) KList=np.array(KList) SCRE.PlotRates(KList,lagtime_list,counts_list) return KList run = interactive_scre def entry_point(): import matplotlib args = parser.parse_args() try: assignments = io.loadh(args.assignments, 'arr_0') except KeyError: assignments = io.loadh(args.assignments, 'Data') K = run(assignments) T = scipy.linalg.matfuncs.expm(K) np.savetxt(os.path.join(args.output_dir, ""Rate.dat""), K) scipy.io.mmwrite(os.path.join(args.output_dir, ""tProb.mtx.tl""), T) if __name__ == ""__main__"": entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/BuildMSM.py",".py","5662","138","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ############################################################################## # Imports ############################################################################## import os import logging import numpy as np import scipy.io from msmbuilder import arglib from mdtraj import io from msmbuilder import MSMLib def str2bool(v): return v.lower() in (""yes"", ""y"", ""true"", ""t"", ""1"") ############################################################################## # globals ############################################################################## logger = logging.getLogger('msmbuilder.scripts.BuildMSM') parser = arglib.ArgumentParser(description= """"""Estimates the counts and transition matrices from an Assignments.h5 file. Reversible models can be calculated either from naive symmetrization or estimation of the most likely reversible matrices (MLE, recommended). Also calculates the equilibrium populations for the model produced. Outputs will be saved in the directory of your input Assignments.h5 file. \nOutput: tCounts.mtx, tProb.mtx, Populations.dat, Mapping.dat, Assignments.Fixed.h5"""""") parser.add_argument('assignments') parser.add_argument('symmetrize', help=""""""Method by which to estimate a symmetric counts matrix. Symmetrization ensures reversibility, but may skew dynamics. We recommend maximum likelihood estimation (MLE) when tractable, else try Transpose. It is strongly recommended you read the documentation surrounding this choice."""""", default='MLE', choices=['MLE', 'Transpose', 'None']) parser.add_argument('lagtime', help='''Lag time to use in model (in number of snapshots. EG, if you have snapshots every 200ps, and set the lagtime=50, you'll get a model with a lagtime of 10ns)''', type=int) parser.add_argument('mapping', help='''Mapping, EG from microstates to macrostates. If given, this mapping will be applied to the specified assignments before creating an MSM.''', default=""None"") parser.add_argument('trim', help=""""""Whether or not to apply an ergodic trim. If true, keeps only the largest observed ergodic subset of the data, if false, keeps everything. Default: True."""""", default=True, type=str2bool) parser.add_argument('output_dir') ############################################################################## # Code ############################################################################## def run(lagtime, assignments, symmetrize='MLE', input_mapping=""None"", trim=True, out_dir=""./Data/""): # set the filenames for output FnTProb = os.path.join(out_dir, ""tProb.mtx"") FnTCounts = os.path.join(out_dir, ""tCounts.mtx"") FnMap = os.path.join(out_dir, ""Mapping.dat"") FnAss = os.path.join(out_dir, ""Assignments.Fixed.h5"") FnPops = os.path.join(out_dir, ""Populations.dat"") # make sure none are taken outputlist = [FnTProb, FnTCounts, FnMap, FnAss, FnPops] arglib.die_if_path_exists(outputlist) # Check for valid lag time assert lagtime > 0, 'Please specify a positive lag time.' # if given, apply mapping to assignments if input_mapping != ""None"": MSMLib.apply_mapping_to_assignments(assignments, input_mapping) n_assigns_before_trim = len(np.where(assignments.flatten() != -1)[0]) counts = MSMLib.get_count_matrix_from_assignments(assignments, lag_time=lagtime, sliding_window=True) rev_counts, t_matrix, populations, mapping = MSMLib.build_msm(counts, symmetrize=symmetrize, ergodic_trimming=trim) if trim: MSMLib.apply_mapping_to_assignments(assignments, mapping) n_assigns_after_trim = len(np.where(assignments.flatten() != -1)[0]) # if had input mapping, then update it if input_mapping != ""None"": mapping = mapping[input_mapping] # Print a statement showing how much data was discarded in trimming percent = (1.0 - float(n_assigns_after_trim) / float(n_assigns_before_trim)) * 100.0 logger.warning(""Ergodic trimming discarded: %f percent of your data"", percent) else: logger.warning(""No ergodic trimming applied"") # Save all output np.savetxt(FnPops, populations) np.savetxt(FnMap, mapping, ""%d"") scipy.io.mmwrite(str(FnTProb), t_matrix) scipy.io.mmwrite(str(FnTCounts), rev_counts) io.saveh(FnAss, assignments) for output in outputlist: logger.info(""Wrote: %s"", output) return def entry_point(): args = parser.parse_args() try: assignments = io.loadh(args.assignments, 'arr_0') except KeyError: assignments = io.loadh(args.assignments, 'Data') if args.mapping != ""None"": args.mapping = np.array(np.loadtxt(args.mapping), dtype=int) run(args.lagtime, assignments, args.symmetrize, args.mapping, args.trim, args.output_dir) if __name__ == ""__main__"": entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/CalculateProjectDistance.py",".py","2895","88","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import os import sys import logging import numpy as np from msmbuilder import Project import mdtraj as md from mdtraj import io from msmbuilder import arglib logger = logging.getLogger('msmbuilder.scripts.CalculateProjectDistance') parser = arglib.ArgumentParser(description="""""" Calculate the distance between an input PDB and all conformations in your project. Alternatively, you can limit the distance calculate to a single trajectory by passing a trajectory filename. Output as a HDF5 file (load using msmbuilder.io.loadh())"""""", get_metric=True) parser.add_argument('pdb') parser.add_argument('output', help='''Output file name. Output is an .h5 file with RMSD entries corresponding to the Assignments.h5 file.''', default='Data/RMSD.h5') parser.add_argument('project') parser.add_argument('traj_fn', help='''Pass a trajectory file, to return just the distance for a particular trajectory. Pass 'all' to get all distances in the project.''', default='all') def run(project, pdb, metric, traj_fn=None): ppdb = metric.prepare_trajectory(pdb) if traj_fn == None: distances = -1 * \ np.ones((project.n_trajs, np.max(project.traj_lengths))) for i in xrange(project.n_trajs): logger.info(""Working on Trajectory %d"", i) ptraj = metric.prepare_trajectory(project.load_traj(i)) d = metric.one_to_all(ppdb, ptraj, 0) distances[i, 0:len(d)] = d else: traj = md.load(traj_fn, top=pdb) ptraj = metric.prepare_trajectory(traj) distances = metric.one_to_all(ppdb, ptraj, 0) return distances def entry_point(): args, metric = parser.parse_args() arglib.die_if_path_exists(args.output) project = Project.load_from(args.project) pdb = md.load(args.pdb) if args.traj_fn.lower() == 'all': traj_fn = None else: traj_fn = args.traj_fn distances = run(project, pdb, metric, traj_fn) io.saveh(args.output, distances) logger.info('Saved to %s', args.output) if __name__ == ""__main__"": entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/Cluster.py",".py","13125","291","#!/usr/bin/env python from __future__ import print_function, absolute_import, division from mdtraj.utils.six.moves import xrange import sys, os import warnings import numpy as np import mdtraj as md from mdtraj import io from msmbuilder import arglib from msmbuilder import clustering from msmbuilder import Project from msmbuilder import metrics from msmbuilder.arglib import die_if_path_exists from msmbuilder.utils import highlight import logging logger = logging.getLogger('msmbuilder.scripts.Cluster') def add_argument(group, *args, **kwargs): if 'default' in kwargs: d = 'Default: {d}'.format(d=kwargs['default']) if 'help' in kwargs: kwargs['help'] += ' {d}'.format(d=d) else: kwargs['help'] = d group.add_argument(*args, **kwargs) ################################################################################ parser = arglib.ArgumentParser(description=''' Cluster MD trajectories into microstates using a geometric criterion. Output: Assignments.h5, and other files depending on your choice of distance metric and/or clustering algorithm. Note that there are many distance metrics and clustering algorithms available Many of which have multiple options and parameters. ''' + highlight('''MAKE LIBERAL USE OF THE -h OPTION. The help text changes significantly depending on which level in the options tree you are currently in''', color='green', bold=True),get_metric=True) parser.add_argument('project') parser.add_argument(dest='stride', help='Subsample by striding', default=1, type=int) parser.add_argument('output_dir', help='''Output directory to save clustering data. This will include some of the following depending on the clustering algorithm: (1) Assignments.h5 (If clustering is not hierarchical and stride=1): Contains the state assignments (2) Assignments.h5.distances (If clustering is not hierarchical and stride=1): Contains the distance to the generator according to the distance metric that was employed (3) Gens.h5 (If clustering is not hierarchical): Trajectory object representing the generators for each state (4) ZMatrix.h5 (If clustering is hierarchical): This is the ZMatrix corresponding to the result of hierarchical clustering. use it with AssignHierarchical.py to build your assignments file.''') ################################################################################ for metric_parser in parser.metric_parser_list: # arglib stores the metric subparsers in that list subparser = metric_parser.add_subparsers( description='''Choose one of the following clustering algorithms.''', dest='alg' ) kcenters = subparser.add_parser('kcenters') add_argument(kcenters, '-s', help='seed for initial cluster center.', default=0, type=int, dest='kcenters_seed') kcenters_cutoff = kcenters.add_argument_group('cutoff (use one)').add_mutually_exclusive_group(required=True) add_argument(kcenters_cutoff, '-k', help='number of clusters', type=int, dest='kcenters_num_clusters') add_argument(kcenters_cutoff, '-d', help='no greater cophenetic distance than this cutoff', type=float, dest='kcenters_distance_cutoff') hybrid = subparser.add_parser('hybrid') add_argument(hybrid, '-l', dest='hybrid_local_num_iters', default=10, type=int) add_argument(hybrid, '-g', dest='hybrid_global_iters', default=0, type=int) add_argument(hybrid, '-i', dest='hybrid_ignore_max_objective', type=bool, default=False) add_argument(hybrid, '-t', dest='hybrid_too_close_cutoff', default=0.0001, type=float) hybrid_cutoff = hybrid.add_argument_group('cutoff (use one)').add_mutually_exclusive_group(required=True) add_argument(hybrid_cutoff, '-k', help='number of clusters', type=int, dest='hybrid_num_clusters') add_argument(hybrid_cutoff, '-d', help='no greater cophenetic distance than this cutoff', type=float, dest='hybrid_distance_cutoff') clarans = subparser.add_parser('clarans') claransR = clarans.add_argument_group('required') add_argument(claransR, '-k', help='number of clusters', type=int, dest='clarans_num_clusters') add_argument(clarans, '-u', dest='clarans_num_local_minima', default=10, type=int, help='Number of local minima to find.') add_argument(clarans, '-m', dest='clarans_max_neighbors', default=20, type=int, help='Max number of neighbors to search before declaring a minima.') add_argument(clarans, '-l', dest='clarans_local_swap', default=True, type=bool, help='Perform loval swaps or global swaps.') sclarans = subparser.add_parser('sclarans') sclaransR = sclarans.add_argument_group('required') add_argument(sclaransR, '-k', help='number of clusters', type=int, dest='sclarans_num_clusters', required=True) add_argument(sclaransR, '-n', help='number of samples to draw', type=int, dest='sclarans_num_samples', required=True) add_argument(sclaransR, '-s', help='shrink multiple', type=int, dest='sclarans_shrink_multiple', required=True) add_argument(sclarans, '-u', dest='sclarans_num_local_minima', default=10, type=int, help='Number of local minima to find.') add_argument(sclarans, '-m', dest='sclarans_max_neighbors', default=20, type=int, help='Max number of neighbors to search before declaring a minima.') add_argument(sclarans, '-l', dest='sclarans_local_swap', default=True, type=bool, help='Perform loval swaps or global swaps.') add_argument(sclarans, '-p', dest='sclarans_parallel', choices=['multiprocessing', 'dtm', 'none'], help='Perform in parallel.', default='none') hier = subparser.add_parser('hierarchical') add_argument(hier, '-m', default='ward', help='method. default=ward', choices=['single', 'complete', 'average', 'weighted', 'centroid', 'median', 'ward'], dest='hierarchical_method') def load_prep_trajectories(project, stride, atom_indices, metric): """"""load the trajectories but prepare them during the load. This is helpful for metrics that use dimensionality reduction so you can use more frames without a MemoryError """""" list_of_ptrajs = [] which = [] for i in xrange(project.n_trajs): which_frames = np.arange(0, project.traj_lengths[i], stride) which.extend(zip([i] * len(which_frames), which_frames)) ptraj = [] for chunk in md.iterload(project.traj_filename(i), stride=stride, atom_indices=atom_indices): ptrj_chunk = metric.prepare_trajectory(chunk) ptraj.append(ptrj_chunk) ptraj = np.concatenate(ptraj) list_of_ptrajs.append(ptraj) return list_of_ptrajs, np.array(which) def load_trajectories(project, stride, atom_indices): list_of_trajs = [] for i in xrange(project.n_trajs): # note, LoadTraj is only using the fast strided loading for # HDF5 formatted trajs traj = project.load_traj(i, stride=stride, atom_indices=atom_indices) if atom_indices != None: assert len(atom_indices) == traj.n_atoms list_of_trajs.append(traj) return list_of_trajs def cluster(metric, trajectories, ptrajs, args, **kwargs): if args.alg == 'kcenters': clusterer = clustering.KCenters(metric, trajectories=trajectories, prep_trajectories=ptrajs, k=args.kcenters_num_clusters, distance_cutoff=args.kcenters_distance_cutoff, seed=args.kcenters_seed) elif args.alg == 'hybrid': clusterer = clustering.HybridKMedoids(metric, trajectories=trajectories, prep_trajectories=ptrajs, k=args.hybrid_num_clusters, distance_cutoff=args.hybrid_distance_cutoff, local_num_iters=args.hybrid_local_num_iters, global_num_iters=args.hybrid_global_iters, too_close_cutoff=args.hybrid_too_close_cutoff, ignore_max_objective=args.hybrid_ignore_max_objective) elif args.alg == 'clarans': clusterer = clustering.Clarans(metric, trajectories=trajectories, prep_trajectories=ptrajs, k=args.clarans_num_clusters, num_local_minima=args.clarans_num_local_minima, max_neighbors=args.clarans_max_neighbors, local_swap=args.clarans_local_swap) elif args.alg == 'sclarans': clusterer = clustering.SubsampledClarans(metric, trajectories=trajectories, prep_trajectories=ptrajs, k=args.sclarans_num_clusters, num_samples=args.sclarans_num_samples, shrink_multiple=args.sclarans_shrink_multiple, num_local_minima=args.sclarans_num_local_minima, max_neighbors=args.sclarans_max_neighbors, local_swap=args.sclarans_local_swap, parallel=args.sclarans_parallel) elif args.alg == 'hierarchical': zmatrix_fn = kwargs['zmatrix_fn'] clusterer = clustering.Hierarchical(metric, trajectories=trajectories, method=args.hierarchical_method) clusterer.save_to_disk(zmatrix_fn) logger.info('ZMatrix saved to %s. Use AssignHierarchical.py to assign the data', zmatrix_fn) else: raise ValueError('Unrecognized algorithm %s' % args.alg) return clusterer def main(args, metric): if args.alg == 'sclarans' and args.stride != 1: logger.error(""""""You don't want to use a stride with sclarans. The whole point of sclarans is to use a shrink multiple to accomplish the same purpose, but in parallel with stochastic subsampling. If you cant fit all your frames into memory at the same time, maybe you could stride a little at the begining, but its not recommended."""""") sys.exit(1) # if we have a metric that explicitly operates on a subset of indices, # then we provide the option to only load those indices into memory # WARNING: I also do something a bit dirty, and inject `None` for the # RMSD.atomindices to get the metric to not splice if isinstance(metric, metrics.RMSD): atom_indices = metric.atomindices metric.atomindices = None # probably bad... logger.info('RMSD metric - loading only the atom indices required') else: atom_indices = None # In case the clustering / algorithm needs extra arguments, use # this dictionary extra_kwargs = {} # Check to be sure we won't overwrite any data if args.alg == 'hierarchical': zmatrix_fn = os.path.join(args.output_dir, 'ZMatrix.h5') die_if_path_exists(zmatrix_fn) extra_kwargs['zmatrix_fn'] = zmatrix_fn else: generators_fn = os.path.join(args.output_dir, 'Gens.h5') die_if_path_exists(generators_fn) if args.stride == 1: assignments_fn = os.path.join(args.output_dir, 'Assignments.h5') distances_fn = os.path.join(args.output_dir, 'Assignments.h5.distances') die_if_path_exists([assignments_fn, distances_fn]) project = Project.load_from(args.project) if isinstance(metric, metrics.Vectorized) and not args.alg == 'hierarchical': # if the metric is vectorized then # we can load prepared trajectories # which may allow for better memory # efficiency ptrajs, which = load_prep_trajectories(project, args.stride, atom_indices, metric) trajectories = None n_trajs = len(ptrajs) num_frames = np.sum([len(p) for p in ptrajs]) if num_frames != len(which): raise Exception(""something went wrong in loading step (%d v %d)"" % (num_frames, len(which))) else: trajectories = load_trajectories(project, args.stride, atom_indices) ptrajs = None which = None n_trajs = len(trajectories) logger.info('Loaded %d trajs', n_trajs) clusterer = cluster(metric, trajectories, ptrajs, args, **extra_kwargs) if not isinstance(clusterer, clustering.Hierarchical): if isinstance(metric, metrics.Vectorized): gen_inds = clusterer.get_generator_indices() generators = project.load_frame(which[gen_inds,0], which[gen_inds,1]) else: generators = clusterer.get_generators_as_traj() logger.info('Saving %s', generators_fn) generators.save(generators_fn) if args.stride == 1: assignments = clusterer.get_assignments() distances = clusterer.get_distances() logger.info('Since stride=1, Saving %s', assignments_fn) logger.info('Since stride=1, Saving %s', distances_fn) io.saveh(assignments_fn, assignments) io.saveh(distances_fn, distances) def entry_point(): args, metric = parser.parse_args() if hasattr(args, 'sclarans_parallel') and args.sclarans_parallel == 'dtm': from deap import dtm dtm.start(main, args) else: main(args, metric) if __name__ == ""__main__"": entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/SampleTrajectory.py",".py","1673","48","import numpy as np from mdtraj import io from msmbuilder import arglib from msmbuilder import msm_analysis from msmbuilder import Project import scipy.io import logging logger = logging.getLogger('msmbuilder.scripts.SampleTrajectory') DEBUG = True parser = arglib.ArgumentParser(description="""""" Create an MSM movie by sampling a sequence of states and sampling a random conformation from each state in the sequence. """""") parser.add_argument('project') parser.add_argument('assignments', default='Data/Assignments.Fixed.h5') parser.add_argument('tprob', default='Data/tProb.mtx') parser.add_argument('num_steps') parser.add_argument('starting_state', type=int, help='''Which state to start trajectory from.''') parser.add_argument('output', default='sample_traj.pdb', help=""""""The filename of your output trajectory. The filetype suffix will be used to select the output file format."""""") def entry_point(): """"""Parse command line inputs, load up files, and build a movie."""""" args = parser.parse_args() try: assignments = io.loadh(args.assignments, 'arr_0') except KeyError: assignments = io.loadh(args.assignments, 'Data') num_steps = int(args.num_steps) starting_state = int(args.starting_state) project = Project.load_from(args.project) T = scipy.io.mmread(args.tprob).tocsr() state_traj = msm_analysis.sample(T, starting_state, num_steps) sampled_traj = project.get_random_confs_from_states( assignments, state_traj, 1) traj = sampled_traj[0] traj = traj.join(sampled_traj[1:]) traj.save(args.output) if __name__ == '__main__': entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/CalculateProjectSASA.py",".py","3184","84","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import numpy as np import mdtraj as md from mdtraj import io from msmbuilder import Project, arglib import logging logger = logging.getLogger('msmbuilder.scripts.CalculateProjectSASA') parser = arglib.ArgumentParser(description=""""""Calculates the Solvent Accessible Surface Area of all atoms in a given trajectory, or for all trajectories in the project. The output is a hdf5 file which contains the SASA for each atom in each frame in each trajectory (or the single trajectory you passed in."""""" ) parser.add_argument('project') parser.add_argument('atom_indices', help='Indices of atoms to calculate SASA', default='all') parser.add_argument('output', help='''hdf5 file for output. Note this will be THREE dimensional: ( trajectory, frame, atom ), unless you just ask for one trajectory, in which case it will be shape (frame, atom).''', default='SASA.h5') parser.add_argument('traj_fn', help='''Pass a trajectory file if you only want to calclate the SASA for a single trajectory''', default='all' ) def run(project, atom_indices=None, traj_fn = 'all'): n_atoms = project.load_conf().n_atoms if traj_fn.lower() == 'all': SASA = np.ones((project.n_trajs, np.max(project.traj_lengths), n_atoms)) * -1 for traj_ind in xrange(project.n_trajs): traj_asa = [] logger.info(""Working on Trajectory %d"", traj_ind) traj_fn = project.traj_filename(traj_ind) chunk_ind = 0 for traj_chunk in md.iterload(traj_fn, atom_indices=atom_indices, chunk=1000): traj_asa.extend(md.shrake_rupley(traj_chunk)) chunk_ind += 1 SASA[traj_ind, 0:project.traj_lengths[traj_ind]] = traj_asa else: traj_asa = [] for traj_chunk in Trajectory.enum_chunks_from_lhdf( traj_fn, AtomIndices=atom_indices ): traj_asa.extend( asa.calculate_asa( traj_chunk ) ) SASA = np.array(traj_asa) return SASA def entry_point(): args = parser.parse_args() arglib.die_if_path_exists(args.output) if args.atom_indices.lower() == 'all': atom_indices = None else: atom_indices = np.loadtxt(args.atom_indices).astype(int) project = Project.load_from(args.project) SASA = run(project, atom_indices, args.traj_fn) io.saveh(args.output, SASA) if __name__ == '__main__': entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/msmb.py",".py","1801","55","#!/usr/bin/env python """"""MSMBuilder: Analyzing conformational dynamics via the construction of Markov state models. """""" ############################################################################## # Imports ############################################################################## import re import os import sys import inspect import warnings import argparse from mdtraj.utils import import_ from msmbuilder import scripts parser = argparse.ArgumentParser(description=__doc__, usage='msmb [subcommand]') ############################################################################## # Code ############################################################################## def entry_point(): subparsers = parser.add_subparsers(dest=""subparser_name"") scriptfiles = {} argv = sys.argv[:] if len(argv) == 1: argv.append('-h') for scriptname in scripts.__all__: # get the name and first sentence of the description from each of the # msmbuilder commands with warnings.catch_warnings(): warnings.filterwarnings(""ignore"") script = import_('msmbuilder.scripts.%s' % scriptname) scriptparser = getattr(script, 'parser', None) scriptfiles[scriptname] = script.__file__ try: description = scriptparser.description except: description = scriptparser.parser.description # http://stackoverflow.com/a/17124446/1079728 first_sentence = ' '.join(' '.join(re.split(r'(?<=[.:;])\s', description)[:1]).split()) subparsers.add_parser(scriptname, help=first_sentence) args = parser.parse_args(argv[1:2]) sys.argv = argv[1:] getattr(scripts, args.subparser_name).entry_point() if __name__ == '__main__': entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/Assign.py",".py","4504","103","#!/usr/bin/env python ############################################################################## # imports ############################################################################## import sys import os import numpy as np #from msmbuilder import arglib import argparse from msmbuilder import arglib from msmbuilder.assigning import assign_with_checkpoint from msmbuilder import metrics from msmbuilder import Project import logging import mdtraj as md ############################################################################## # Globals ############################################################################## logger = logging.getLogger('msmbuilder.scripts.Assign') parser = arglib.ArgumentParser(description="""""" Assign data that were not originally used in the clustering (because of striding) to the microstates. This is applicable to all medoid-based clustering algorithms, which includes all those implemented by Cluster.py except the hierarchical methods. (For assigning to a hierarchical clustering, use AssignHierarchical.py) Outputs: -Assignments.h5 -Assignments.h5.distances Assignments.h5 contains the assignment of each frame of each trajectory to a microstate in a rectangular array of ints. Assignments.h5.distances is an array of real numbers of the same dimension containing the distance (according to whichever metric you choose) from each frame to to the medoid of the microstate it is assigned to."""""", get_metric=True) # , formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument('project') parser.add_argument( dest='generators', help='''Output trajectory file containing the structures of each of the cluster centers. Note that for hierarchical clustering methods, this file will not be produced.''', default='Data/Gens.h5') parser.add_argument('output_dir') def main(args, metric): assignments_path = os.path.join(args.output_dir, ""Assignments.h5"") distances_path = os.path.join(args.output_dir, ""Assignments.h5.distances"") # arglib.die_if_path_exists(args.output_dir) if not os.path.exists(args.output_dir): os.mkdir(args.output_dir) project = Project.load_from(args.project) gens = md.load(args.generators) if isinstance(metric, metrics.RMSD): # this is really bad design, and we're going to fix it soon in # MSMBuilder3, but here's the deal. When Cluster.py loads up the # trajectories (Cluster.py:load_trajectories()), it only loads the # required indices for RMSD. This means that when it saves the Gens # file, that file contains only a subset of the atoms. So when # we run *this* script, we need to perform a restricted load of the # the trajectories on disk, but we need to NOT perform a restricted # load of the gens.h5 file. (By restricted load, I mean loading # only a subset of the data in the file) if gens.n_atoms != len(metric.atomindices): msg = ('Using RMSD clustering/assignment, this script expects ' 'that the Cluster.py script saves a generators file that ' 'only contains the indices of the atoms of interest, and ' 'not any of the superfluous degrees of freedom that were ' 'not used for clustering. But you supplied %d cluster ' 'centers each containg %d atoms. Your atom indices file ' 'on the other hand contains %d atoms') \ % (gens.xyz.shape[0], gens.xyz.shape[1], len(metric.atomindices)) raise ValueError(msg) # now that we're telling the assign function only to load up a # subset of the atoms, an the generator is already only a subset, # the actual RMSD object needs to, from ITS perspective, operate on # every degree of freedom. So it shouldn't be aware of any special # atom_indices atom_indices = metric.atomindices metric.atomindices = None # this runs assignment and prints them to disk assign_with_checkpoint(metric, project, gens, assignments_path, distances_path, atom_indices_to_load=atom_indices) else: assign_with_checkpoint(metric, project, gens, assignments_path, distances_path) logger.info('All Done!') def entry_point(): args, metric = parser.parse_args() main(args, metric) if __name__ == '__main__': entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/BACE_Coarse_Graining.py",".py","19053","485","# This file is part of BACE. # # Copyright 2012 University of California, Berkeley # # BACE is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # from __future__ import print_function version = 1.0 LicenseString = """"""-------------------------------------------------------------------------------- BACE version %s Written by Gregory R. Bowman, UC Berkeley -------------------------------------------------------------------------------- Copyright 2012 University of California, Berkeley. BACE comes with ABSOLUTELY NO WARRANTY. BACE is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. -------------------------------------------------------------------------------- Please cite: GR Bowman. Improved coarse-graining of Markov state models via explicit consideration of statistical uncertainty. J Chem Phys 2012;137;134111. Currently available as arXiv:1201.3867 2012. -------------------------------------------------------------------------------- """""" % version ############################################################################## # imports ############################################################################## import argparse import functools import multiprocessing import numpy as np import os import scipy.io import scipy.sparse import sys import logging ############################################################################## # globals ############################################################################## logger = logging.getLogger('msmbuilder.scripts.BACE') logger.setLevel(logging.INFO) sh = logging.StreamHandler(stream=sys.stdout) formatter = logging.Formatter( fmt='%(asctime)s - %(message)s', datefmt=""%H:%M:%S"") sh.setFormatter(formatter) logger.addHandler(sh) logger.propagate = False def add_argument(group, *args, **kwargs): if 'default' in kwargs: d = 'Default: {d}'.format(d=kwargs['default']) if 'help' in kwargs: kwargs['help'] += ' {d}'.format(d=d) else: kwargs['help'] = d group.add_argument(*args, **kwargs) parser = argparse.ArgumentParser(description='''Bayesian agglomerative clustering engine (BACE) for coarse-graining MSMs. For example, building macrostate models from microstate models. The algorithm works by iteratively merging states until the final desired number of states (the nMacro parameter) is reached. Results are often obtained most quickly by forcing the program to use dense matrices (with the -f option) and using a single processor. Sparse matrices (and possibly multiple processors) are useful when insufficient memory is available to use dense matrices. A macrostate model may be attractive for further analysis if further reducing the number of macrostates (M) causes a large increase in the Bayes factor (cost), as reported in the bayesFactors.dat output file described below. For example, if the Bayes factor increases steadily as one goes from models with M-5, M-4, ..., M states but increases much more dramatically when going from M to M-1 states, then a model with M states may be of interest because the sudden increase in the Bayes factor for going to M-1 states suggests two very distinct free energy basins are being merged. To make these judgments, it is often useful to plot the Bayes factor as a function of the number of macrostates. Once you have chosen the number of macrostates (M) you wish to analyze further, you can calculate the appropriate transition matrices using the BuildMSM.py script. For example, to build a model with 5 macrostates you might run something like BuildMSM.py -l 1 -a Data/Assignments.Fixed.h5 -m Output_BACE/map5.dat -o BACE_5state The -m option is the crucial addition for directing the script to apply the specified mapping from the microstates in the h5 file to the macrostates specified by the -m option. Outputs (stored in the directory specified with outDir): bayesFactors.dat = the Bayes factors (cost) for each merging of two states. The first column is the number of macrostates (M) and the second column is the Bayes factor (cost) for coarse-graining from M+1 states to M states. mapX.dat = the mapping from the original state numbering to X coarse-grained states.''' , formatter_class=argparse.RawDescriptionHelpFormatter) add_argument(parser, '-c', dest='tCountFn', help='Path to transition count matrix file (sparse and dense formats accepted).', required=True) add_argument(parser, '-n', dest='nMacro', help='Minimum number of macrostates to make.', default=2, type=int) add_argument(parser, '-p', dest='nProc', help='Number of processors to use.', default=1, type=int, required=False) add_argument( parser, '-f', dest='forceDense', help='If true, the program will force the transition matrix into a dense format. Using the dense format is faster if you have enough memory.', default=False, type=bool, required=False, nargs='?', const=True) add_argument(parser, '-o', dest='outDir', help='Path to save the output to.', default=""Output_BACE"", required=False) ############################################################################## # Code ############################################################################## def getInds(c, stateInds, chunkSize, isSparse, updateSingleState=None): indices = [] for s in stateInds: if isSparse: dest = np.where(c[s,:].toarray()[0] > 1)[0] else: dest = np.where(c[s,:] > 1)[0] if updateSingleState != None: dest = dest[np.where(dest != updateSingleState)[0]] else: dest = dest[np.where(dest > s)[0]] if dest.shape[0] == 0: continue elif dest.shape[0] < chunkSize: indices.append((s, dest)) else: i = 0 while dest.shape[0] > i: if i + chunkSize > dest.shape[0]: indices.append((s, dest[i:])) else: indices.append((s, dest[i:i + chunkSize])) i += chunkSize return indices def run(c, nMacro, nProc, multiDist, outDir, filterFunc, chunkSize=100): # perform filter logger.info(""Checking for states with insufficient statistics"") c, map, statesKeep = filterFunc(c, nProc) # get num counts in each state (or weight) w = np.array(c.sum(axis=1)).flatten() w[statesKeep] += 1 unmerged = np.zeros(w.shape[0], dtype=np.int8) unmerged[statesKeep] = 1 # get nonzero indices in upper triangle indRecalc = getInds(c, statesKeep, chunkSize, scipy.sparse.issparse(c)) if scipy.sparse.issparse(c): dMat = scipy.sparse.lil_matrix(c.shape) else: dMat = np.zeros(c.shape, dtype=np.float32) if scipy.sparse.issparse(c): c = c.tocsr() i = 0 nCurrentStates = statesKeep.shape[0] if not os.path.exists(outDir): os.mkdir(outDir) fBayesFact = open(""%s/bayesFactors.dat"" % outDir, 'w') dMat, minX, minY = calcDMat( c, w, fBayesFact, indRecalc, dMat, nProc, statesKeep, multiDist, unmerged, chunkSize) logger.info(""Coarse-graining..."") while nCurrentStates > nMacro: logger.info(""Iteration %d, merging %d states"", i, nCurrentStates) c, w, indRecalc, dMat, map, statesKeep, unmerged, minX, minY = mergeTwoClosestStates( c, w, fBayesFact, indRecalc, dMat, nProc, map, statesKeep, minX, minY, multiDist, unmerged, chunkSize) nCurrentStates -= 1 np.savetxt(""%s/map%d.dat"" % (outDir, nCurrentStates), map, fmt=""%d"") i += 1 fBayesFact.close() def mergeTwoClosestStates(c, w, fBayesFact, indRecalc, dMat, nProc, map, statesKeep, minX, minY, multiDist, unmerged, chunkSize): cIsSparse = scipy.sparse.issparse(c) if cIsSparse: c = c.tolil() if unmerged[minX]: c[minX, statesKeep] += unmerged[statesKeep] * 1.0 / c.shape[0] unmerged[minX] = 0 if cIsSparse: c[statesKeep, minX] += np.matrix( unmerged[statesKeep]).transpose() * 1.0 / c.shape[0] else: c[statesKeep, minX] += unmerged[statesKeep] * 1.0 / c.shape[0] if unmerged[minY]: c[minY, statesKeep] += unmerged[statesKeep] * 1.0 / c.shape[0] unmerged[minY] = 0 if cIsSparse: c[statesKeep, minY] += np.matrix( unmerged[statesKeep]).transpose() * 1.0 / c.shape[0] else: c[statesKeep, minY] += unmerged[statesKeep] * 1.0 / c.shape[0] c[minX, statesKeep] += c[minY, statesKeep] c[statesKeep, minX] += c[statesKeep, minY] c[minY, statesKeep] = 0 c[statesKeep, minY] = 0 dMat[minX,:] = 0 dMat[:, minX] = 0 dMat[minY,:] = 0 dMat[:, minY] = 0 if cIsSparse: c = c.tocsr() w[minX] += w[minY] w[minY] = 0 statesKeep = statesKeep[np.where(statesKeep != minY)[0]] indChange = np.where(map == map[minY])[0] map = renumberMap(map, map[minY]) map[indChange] = map[minX] indRecalc = getInds( c, [minX], chunkSize, cIsSparse, updateSingleState=minX) dMat, minX, minY = calcDMat( c, w, fBayesFact, indRecalc, dMat, nProc, statesKeep, multiDist, unmerged, chunkSize) return c, w, indRecalc, dMat, map, statesKeep, unmerged, minX, minY def renumberMap(map, stateDrop): for i in xrange(map.shape[0]): if map[i] >= stateDrop: map[i] -= 1 return map def calcDMat(c, w, fBayesFact, indRecalc, dMat, nProc, statesKeep, multiDist, unmerged, chunkSize): nRecalc = len(indRecalc) if nRecalc > 1 and nProc > 1: if nRecalc < nProc: nProc = nRecalc pool = multiprocessing.Pool(processes=nProc) n = len(indRecalc) stepSize = int(n / nProc) if n % stepSize > 3: dlims = zip( range(0, n, stepSize), range(stepSize, n, stepSize) + [n]) else: dlims = zip(range(0, n - stepSize, stepSize), range(stepSize, n - stepSize, stepSize) + [n]) args = [] for start, stop in dlims: args.append(indRecalc[start:stop]) result = pool.map_async( functools.partial(multiDist, c=c, w=w, statesKeep=statesKeep, unmerged=unmerged, chunkSize=chunkSize), args) result.wait() d = np.vstack(result.get()) pool.close() else: d = multiDist(indRecalc, c, w, statesKeep, unmerged, chunkSize) for i in xrange(len(indRecalc)): dMat[indRecalc[i][0], indRecalc[i][1]] = d[i][:len(indRecalc[i][1])] # BACE BF inverted so can use sparse matrices if scipy.sparse.issparse(dMat): minX = minY = -1 maxD = 0 for x in statesKeep: if len(dMat.data[x]) == 0: continue pos = np.argmax(dMat.data[x]) if dMat.data[x][pos] > maxD: maxD = dMat.data[x][pos] minX = x minY = dMat.rows[x][pos] else: indMin = dMat.argmax() minX = np.floor(indMin / dMat.shape[1]) minY = indMin % dMat.shape[1] fBayesFact.write(""%d %f\n"" % (statesKeep.shape[0] - 1, 1. / dMat[minX, minY])) return dMat, minX, minY def multiDistDense(indicesList, c, w, statesKeep, unmerged, chunkSize): d = np.zeros((len(indicesList), chunkSize), dtype=np.float32) for j in xrange(len(indicesList)): indices = indicesList[j] ind1 = indices[0] c1 = c[ind1, statesKeep] + unmerged[ind1] * \ unmerged[statesKeep] * 1.0 / c.shape[0] # BACE BF inverted so can use sparse matrices d[j, :indices[1].shape[0]] = 1. / multiDistDenseHelper( indices[1], c1, w[ind1], c, w, statesKeep, unmerged) return d def multiDistDenseHelper(indices, c1, w1, c, w, statesKeep, unmerged): d = np.zeros(indices.shape[0], dtype=np.float32) p1 = c1 / w1 for i in xrange(indices.shape[0]): ind2 = indices[i] c2 = c[ind2, statesKeep] + unmerged[ind2] * \ unmerged[statesKeep] * 1.0 / c.shape[0] p2 = c2 / w[ind2] cp = c1 + c2 cp /= (w1 + w[ind2]) d[i] = c1.dot(np.log(p1 / cp)) + c2.dot(np.log(p2 / cp)) return d def multiDistSparse(indicesList, c, w, statesKeep, unmerged, chunkSize): d = np.zeros((len(indicesList), chunkSize), dtype=np.float32) for j in xrange(len(indicesList)): indices = indicesList[j] ind1 = indices[0] c1 = c[ind1, statesKeep].toarray()[0] + unmerged[ ind1] * unmerged[statesKeep] * 1.0 / c.shape[0] # BACE BF inverted so can use sparse matrices d[j, :indices[1].shape[0]] = 1. / multiDistSparseHelper( indices[1], c1, w[ind1], c, w, statesKeep, unmerged) return d def multiDistSparseHelper(indices, c1, w1, c, w, statesKeep, unmerged): d = np.zeros(indices.shape[0], dtype=np.float32) p1 = c1 / w1 for i in xrange(indices.shape[0]): ind2 = indices[i] c2 = c[ind2, statesKeep].toarray()[0] + unmerged[ ind2] * unmerged[statesKeep] * 1.0 / c.shape[0] p2 = c2 / w[ind2] cp = c1 + c2 cp /= (w1 + w[ind2]) d[i] = c1.dot(np.log(p1 / cp)) + c2.dot(np.log(p2 / cp)) return d def filterFuncDense(c, nProc): # get num counts in each state (or weight) w = np.array(c.sum(axis=1)).flatten() w += 1 # init map from micro to macro states map = np.arange(c.shape[0], dtype=np.int32) # pseudo-state (just pseudo counts) pseud = np.ones(c.shape[0], dtype=np.float32) pseud /= c.shape[0] indices = np.arange(c.shape[0], dtype=np.int32) statesKeep = np.arange(c.shape[0], dtype=np.int32) unmerged = np.ones(c.shape[0], dtype=np.float32) nInd = len(indices) if nInd > 1 and nProc > 1: if nInd < nProc: nProc = nInd pool = multiprocessing.Pool(processes=nProc) stepSize = int(nInd / nProc) if nInd % stepSize > 3: dlims = zip(range(0, nInd, stepSize), range(stepSize, nInd, stepSize) + [nInd]) else: dlims = zip(range(0, nInd - stepSize, stepSize), range(stepSize, nInd - stepSize, stepSize) + [nInd]) args = [] for start, stop in dlims: args.append(indices[start:stop]) result = pool.map_async( functools.partial(multiDistDenseHelper, c1=pseud, w1=1, c=c, w=w, statesKeep=statesKeep, unmerged=unmerged), args) result.wait() d = np.concatenate(result.get()) pool.close() else: d = multiDistDenseHelper(indices, pseud, 1, c, w, statesKeep, unmerged) # prune states with Bayes factors less than 3:1 ratio (log(3) = 1.1) statesPrune = np.where(d < 1.1)[0] statesKeep = np.where(d >= 1.1)[0] logger.info( ""Merging %d states with insufficient statistics into their kinetically-nearest neighbor"", statesPrune.shape[0]) for s in statesPrune: row = c[s,:] row[s] = 0 dest = row.argmax() c[dest,:] += c[s,:] c[:, dest] += c[:, s] c[s,:] = 0 c[:, s] = 0 map = renumberMap(map, map[s]) map[s] = map[dest] return c, map, statesKeep def filterFuncSparse(c, nProc): # get num counts in each state (or weight) w = np.array(c.sum(axis=1)).flatten() w += 1 # init map from micro to macro states map = np.arange(c.shape[0], dtype=np.int32) # pseudo-state (just pseudo counts) pseud = np.ones(c.shape[0], dtype=np.float32) pseud /= c.shape[0] indices = np.arange(c.shape[0], dtype=np.int32) statesKeep = np.arange(c.shape[0], dtype=np.int32) unmerged = np.ones(c.shape[0], dtype=np.int8) nInd = len(indices) if nInd > 1 and nProc > 1: if nInd < nProc: nProc = nInd pool = multiprocessing.Pool(processes=nProc) stepSize = int(nInd / nProc) if nInd % stepSize > 3: dlims = zip(range(0, nInd, stepSize), range(stepSize, nInd, stepSize) + [nInd]) else: dlims = zip(range(0, nInd - stepSize, stepSize), range(stepSize, nInd - stepSize, stepSize) + [nInd]) args = [] for start, stop in dlims: args.append(indices[start:stop]) result = pool.map_async( functools.partial(multiDistSparseHelper, c1=pseud, w1=1, c=c, w=w, statesKeep=statesKeep, unmerged=unmerged), args) result.wait() d = np.concatenate(result.get()) pool.close() else: d = multiDistSparseHelper( indices, pseud, 1, c, w, statesKeep, unmerged) # prune states with Bayes factors less than 3:1 ratio (log(3) = 1.1) statesPrune = np.where(d < 1.1)[0] statesKeep = np.where(d >= 1.1)[0] logger.info( ""Merging %d states with insufficient statistics into their kinetically-nearest neighbor"", statesPrune.shape[0]) for s in statesPrune: row = c[s,:].toarray()[0] row[s] = 0 dest = row.argmax() c[dest,:] += c[s,:] c[:, dest] += c[:, s] c[s,:] = 0 c[:, s] = 0 map = renumberMap(map, map[s]) map[s] = map[dest] return c, map, statesKeep def entry_point(): print(LicenseString) args = parser.parse_args() if args.tCountFn[-4:] == "".mtx"": c = scipy.sparse.lil_matrix( scipy.io.mmread(args.tCountFn), dtype=np.float32) multiDist = multiDistSparse filterFunc = filterFuncSparse if args.forceDense: logger.info(""Forcing dense"") c = c.toarray() multiDist = multiDistDense filterFunc = filterFuncDense else: c = np.loadtxt(args.tCountFn, dtype=np.float32) multiDist = multiDistDense filterFunc = filterFuncDense if args.nProc == None: args.nProc = multiprocessing.cpu_count() logger.info(""Set number of processors to %s"", args.nProc) run(c, args.nMacro, args.nProc, multiDist, args.outDir, filterFunc, chunkSize=100) if __name__ == '__main__': entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","scripts/CalculateMFPTs.py",".py","2477","79","#!/usr/bin/env python # This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import os import logging import numpy as np import scipy.io from msmbuilder import tpt from msmbuilder import arglib logger = logging.getLogger('msmbuilder.scripts.CalculateMFPTs') parser = arglib.ArgumentParser(description="""""" Calculates the mean first passage times (MFPTs) to one or all states. Returns: MFPTs_X.dat or PairwiseMFPTs.dat, where X is the state ID. Note: PairwiseMFPTs.dat is written if state=-1. Otherwise, MFPTs_X.dat is written. """""") parser.add_argument('tProb') parser.add_argument( 'state', help='''ID of state to which we calculate MFPT. If state=-1, then calculate all pairwise MFPTs.''', default=""-1"", type=int) parser.add_argument('output_dir', default='.') def run(T, state): if state != -1: logger.info(""Calculating MFPTs to state %d"" % state) m = tpt.calculate_mfpt([state], T) logger.info(""Finished calculating MFPTs to state %d"" % state) else: logger.info(""Calculating MFPTs to all states"") m = tpt.calculate_all_to_all_mfpt(T) logger.info(""Finished calculating MFPTs to all states"") return m def entry_point(): args = parser.parse_args() T = scipy.io.mmread(args.tProb) state = int(args.state) print(args.state, state) # Check output isn't taken if state == -1: base_filename = ""PairwiseMFPTs.dat"" else: base_filename = ""MFPTs_%d.dat"" % state output_filename = os.path.join(args.output_dir, base_filename) arglib.die_if_path_exists(output_filename) MFPTs = run(T, state) np.savetxt(output_filename, MFPTs) logger.info(""Saved output to %s"" % output_filename) if __name__ == ""__main__"": entry_point() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tests/test_rmsd.py",".py","1970","58","from __future__ import print_function from __future__ import division from __future__ import absolute_import import sys, os import numpy as np import numpy.testing as npt import scipy.spatial.distance from unittest import skipIf from mdtraj.utils.six.moves import xrange from msmbuilder import metrics from common import load_traj class TestRMSD(): ""Test the msmbuilder.metrics.RMSD module"" def setup(self): self.traj = load_traj() self.n_frames = self.traj.n_frames self.n_atoms = self.traj.n_atoms # RMSD from frame 0 to other frames self.target = np.array([0,0,0.63297522]) def test_prepare(self): rmsds = [metrics.RMSD(), # all atom indices metrics.RMSD(range(self.n_atoms)), metrics.RMSD(xrange(self.n_atoms)), metrics.RMSD(np.arange(self.n_atoms))] for metric in rmsds: ptraj = metric.prepare_trajectory(self.traj) def test_one_to_all(self): for rmsd in [metrics.RMSD(), metrics.RMSD(omp_parallel=False)]: ptraj = rmsd.prepare_trajectory(self.traj) d0 = rmsd.one_to_all(ptraj, ptraj, 0) npt.assert_array_almost_equal(d0, self.target) def test_one_to_many(self): for rmsd in [metrics.RMSD(), metrics.RMSD(omp_parallel=False)]: ptraj = rmsd.prepare_trajectory(self.traj) for i in range(self.n_frames): di = rmsd.one_to_many(ptraj, ptraj, 0, [i]) npt.assert_approx_equal(self.target[i], di) def test_all_pairwise(self): sys.stderr = open('/dev/null') for rmsd in [metrics.RMSD(), metrics.RMSD(omp_parallel=False)]: ptraj = rmsd.prepare_trajectory(self.traj) d1 = rmsd.all_pairwise(ptraj) target = [ 0., 0.63297522, 0.63297522] npt.assert_array_almost_equal(d1, target) sys.stderr=sys.__stderr__ ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tests/test_tpt.py",".py","5760","146","from __future__ import print_function from __future__ import division from __future__ import absolute_import import sys import os import numpy as np import numpy.testing as npt import scipy.sparse import scipy.io from mdtraj import io from msmbuilder import tpt from msmbuilder.scripts import FindPaths from msmbuilder.testing import get def tpt_get(filename): """""" a little hack to save headache -- returns the path to a file in the hub_ref subdir inside reference/ """""" return get( os.path.join('transition_path_theory_reference', filename), just_filename=True ) def hub_get(filename): """""" a little hack to save headache -- returns the path to a file in the hub_ref subdir inside reference/ """""" return get( os.path.join('transition_path_theory_reference', 'hub_ref', filename), just_filename=True ) class TestTPT(): """""" Test the transition_path_theory library """""" def setUp(self): # load in the reference data self.tprob = get(""transition_path_theory_reference/tProb.mtx"") self.sources = [0] # chosen arbitarily by TJL self.sinks = [70] # chosen arbitarily by TJL self.waypoints = [60] # chosen arbitarily by TJL self.lag_time = 1.0 # chosen arbitarily by TJL self.multi_sources = get(""transition_path_theory_reference/many_state/sources.dat"").astype(int) self.multi_sinks = get(""transition_path_theory_reference/many_state/sinks.dat"").astype(int) self.num_paths = 10 # set up the reference data for hub scores K = np.loadtxt( hub_get('ratemat_1.dat') ) #self.hub_T = scipy.linalg.expm( K ) # delta-t should not affect hub scores self.hub_T = np.transpose( np.genfromtxt( hub_get('mat_1.dat') )[:,:-3] ) for i in range(self.hub_T.shape[0]): self.hub_T[i,:] /= np.sum(self.hub_T[i,:]) self.hc = np.loadtxt( hub_get('fraction_visited.dat') ) self.Hc = np.loadtxt( hub_get('hub_scores.dat') )[:,2] def test_committors(self): Q = tpt.calculate_committors(self.sources, self.sinks, self.tprob) Q_ref = io.loadh(tpt_get(""committors.h5""), 'Data') npt.assert_array_almost_equal(Q, Q_ref) def test_flux(self): flux = tpt.calculate_fluxes(self.sources, self.sinks, self.tprob) flux_ref = io.loadh(tpt_get(""flux.h5""), 'Data') npt.assert_array_almost_equal(flux.toarray(), flux_ref) net_flux = tpt.calculate_net_fluxes(self.sources, self.sinks, self.tprob) net_flux_ref = io.loadh(tpt_get(""net_flux.h5""), 'Data') npt.assert_array_almost_equal(net_flux.toarray(), net_flux_ref) def test_path_calculations(self): path_output = tpt.find_top_paths(self.sources, self.sinks, self.tprob) paths_ref = io.loadh( tpt_get(""dijkstra_paths.h5""), 'Data') fluxes_ref = io.loadh( tpt_get(""dijkstra_fluxes.h5""), 'Data') bottlenecks_ref = io.loadh( tpt_get(""dijkstra_bottlenecks.h5""), 'Data') for i in range(len(paths_ref)): npt.assert_array_almost_equal(path_output[0][i], paths_ref[i]) npt.assert_array_almost_equal(path_output[1], bottlenecks_ref) npt.assert_array_almost_equal(path_output[2], fluxes_ref) def test_multi_state_path_calculations(self): path_output = FindPaths.run(self.tprob, self.multi_sources, self.multi_sinks, self.num_paths) path_result_ref = io.loadh(tpt_get(""many_state/Paths.h5"")) paths_ref = path_result_ref['Paths'] bottlenecks_ref = path_result_ref['Bottlenecks'] fluxes_ref = path_result_ref['fluxes'] npt.assert_array_almost_equal(path_output[0], paths_ref) npt.assert_array_almost_equal(path_output[1], bottlenecks_ref) npt.assert_array_almost_equal(path_output[2], fluxes_ref) def test_mfpt(self): mfpt = tpt.calculate_mfpt(self.sinks, self.tprob, lag_time=self.lag_time) mfpt_ref = io.loadh( tpt_get(""mfpt.h5""), 'Data') npt.assert_array_almost_equal(mfpt, mfpt_ref) ensemble_mfpt = tpt.calculate_ensemble_mfpt(self.sources, self.sinks, self.tprob, self.lag_time) ensemble_mfpt_ref = io.loadh( tpt_get(""ensemble_mfpt.h5""), 'Data') npt.assert_array_almost_equal(ensemble_mfpt, ensemble_mfpt_ref) all_to_all_mfpt = tpt.calculate_all_to_all_mfpt(self.tprob) all_to_all_mfpt_ref = io.loadh( tpt_get(""all_to_all_mfpt.h5""), 'Data') npt.assert_array_almost_equal(all_to_all_mfpt, all_to_all_mfpt_ref) def test_TP_time(self): tp_time = tpt.calculate_avg_TP_time(self.sources, self.sinks, self.tprob, self.lag_time) tp_time_ref = io.loadh( tpt_get(""tp_time.h5""), 'Data') npt.assert_array_almost_equal(tp_time, tp_time_ref) def test_fraction_visits(self): num_to_test = 11**2 # this can be changed to shorten the test a little for i in range(num_to_test): waypoint = int(self.hc[i,0]) source = int(self.hc[i,1]) sink = int(self.hc[i,2]) hc = tpt.calculate_fraction_visits(self.hub_T, waypoint, source, sink) assert np.abs(hc - self.hc[i,3]) < 0.0001 def test_hub_scores(self): all_hub_scores = tpt.calculate_all_hub_scores(self.hub_T) npt.assert_array_almost_equal( all_hub_scores, self.Hc ) for waypoint in range(self.hub_T.shape[0]): hub_score = tpt.calculate_hub_score(self.hub_T, waypoint) assert np.abs(hub_score - all_hub_scores[waypoint]) < 0.0001 ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tests/common.py",".py","889","32","from __future__ import print_function from __future__ import division from __future__ import absolute_import import nose import functools import numpy as np from nose.tools import eq_, ok_, raises from numpy.testing import dec import mdtraj as md import os import inspect def load_traj(): ""Load up a 3 frame, 4 atom trajectory for testing"" empty = np.array([]) frame0 = np.array([[[1, 1, 1], [2, 2, 2], [3, 3, 3], [4, 4, 4]]]) frame1 = np.array([[[-1, -1, -1], [-2, -2, -2], [-3, -3, -3], [-4, -4, -4]]]) frame2 = np.array([[[1, 2, 1], [3, 2, 2], [3, 4, 3], [5, 4, 4]]]) return md.Trajectory(xyz=np.concatenate((frame0, frame1, frame2)), topology=None) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tests/test_cfep.py",".py","3888","135"," """""" This is TJL's slightly modified version of Sergei Krivov's original python code to calculate min-cut max-flow reaction coordinates. TJL basically just made it compatible with MSMBuidler by employing numpy/scipy. To Do ----- Test all code: need generators for WW domain """""" from __future__ import print_function from __future__ import division from __future__ import absolute_import import os import nose import numpy as np import scipy from scipy import io from mdtraj.utils.six import PY3 from msmbuilder import cfep from msmbuilder.testing import get def ref_calc_cFEP(counts, lag_time, rxn_coordinate, rescale=True): """""" Computes the partition function of the cut-based free energy profile based on transition network and reaction coordinate. Employs an MSM to do so, thus taking input in the form of a discrete state space and the observed dynamics in that space (assignments). Further, one can provide a ""reaction coordiante"" who's values will be employed to find the min-cut/max-flow coordinate describing dynamics on that space. Generously contributed by Sergei Krivov Optimizations and modifications due to TJL """""" counts = counts.tolil() # initialize data structures zc = {} # cut-based partition function (1/2 number of transitions) zh = {} # histogram-based partition function (number seen / bin width) # find the counts elements = len(counts.nonzero()[0]) N = counts.shape[0] # loop over all elements in the counts matrix for x,(i,j) in enumerate( np.array( counts.nonzero() ).T ): nij = counts[i,j] xi = rxn_coordinate[i] xj = rxn_coordinate[j] zh[xj] = zh.get(xj, 0) + nij if xi > xj: zc[xj] = zc.get(xj, 0) + nij zc[xi] = zc.get(xi, 0) - nij elif xj > xi: zc[xi] = zc.get(xi, 0) + nij zc[xj] = zc.get(xj, 0) - nij zc_keys = list(zc.keys()) zc_keys.sort() # If no reaction coordinate is provided, calculate the ""natural"" # coordinate where D(x) = 1 and cfep(x) = hfep(x) if rescale: print(""rescaling to the natural coordinate"") szc = 0 sx = 0 x2nx = {} zcn = {} for x in zc_keys: szc = szc + zc[x] / 2.0 if x in zh and szc > 0: sx += float(zh[x]) / (szc * math.sqrt(math.pi)) zcn[sx] = szc x2nx[x] = sx else: for k in list(zc.keys()): zc[k] /= 2.0 return zc, zh class TestCfep(): """""" test the cfep library in msmbuilder by comparing to the reference implementation above """""" def setUp(self): if PY3: raise nose.SkipTest('TestCfep requires scipy.weave which doesnt exist on python3') self.generators = get('cfep_reference/Gens.lh5') N = len(self.generators) self.counts = get('cfep_reference/tCounts.mtx') self.lag_time = 1.0 self.pfolds = np.random.rand(N) self.rescale = False self.reactant = 0 self.product = N def test_feps(self): pfold_cfep = cfep.CutCoordinate(self.counts, self.generators, self.reactant, self.product) if self.rescale: pfold_cfep.rescale_to_natural_coordinate() pfold_cfep.set_coordinate_values(self.pfolds) zc = pfold_cfep.zc zh = pfold_cfep.zh zc_ref, zh_ref = ref_calc_cFEP(self.counts, self.lag_time, self.pfolds, self.rescale) error = 0.0 for k in list(zc_ref.keys()): error += np.abs(zc_ref[k] - zc[np.where( self.pfolds == k )].flatten()[0]) assert np.abs( error ) < 0.0000001 return if __name__ == '__main__': test() ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tests/test_arglib.py",".py","2580","102","from __future__ import print_function from __future__ import division from __future__ import absolute_import import sys, os from msmbuilder.testing import * from msmbuilder.arglib import ArgumentParser, add_argument def test_iterator(): from msmbuilder.arglib import _iter_both_cases got = [e for e in _iter_both_cases(""string"")] expected = ['s', 'S', 't', 'T', 'r', 'R', 'i', 'I', 'n', 'N', 'g', 'G'] eq_(got, expected) class tester(): def setup(self): self.p = ArgumentParser() def cmd(self, value): sys.argv = [os.path.abspath(__file__)] for e in value.split(): sys.argv.append(e) @property def v(self): return self.p.parse_args(print_banner=False) def add(self, *args, **kwargs): self.p.add_argument(*args, **kwargs) def test_0(self): self.add('a', nargs='+') self.cmd('-a 1 2') eq_(self.v.a, ['1', '2']) def test_1(self): self.add('a', nargs='+', type=int) self.cmd('-a 1 2') eq_(self.v.a, [1, 2]) def test_2(self): self.add('a', type=int) self.cmd('-a 4') eq_(self.v.a, 4) def test_3(self): self.add('a', type=float) self.cmd('-a 5') eq_(self.v.a, 5.0) @raises(SystemExit) def test_4(self): sys.stderr = open('/dev/null', 'w') self.add('a', choices=[1,2], type=float) self.cmd('-a 5') eq_(self.v.a, 5.0) sys.stderr = sys.__stderr__ def test_5(self): self.add('a', choices=['1', '2'], type=int) self.cmd('-a 1') eq_(self.v.a, 1.0) def test_6(self): self.add('a', choices=[1, 2], type=int) self.cmd('-a 1') eq_(self.v.a, 1) def test_7(self): self.add('a', action='store_true', type=bool) self.cmd('-a') eq_(self.v.a, True) def test_71(self): self.add('a', action='store_false', type=bool) self.cmd('-a') eq_(self.v.a, False) def test_8(self): self.add('a', action='store_true') self.cmd('-a') eq_(self.v.a, True) def test_81(self): self.add('b', action='store_false') self.cmd('-b') eq_(self.v.b, False) def test_9(self): self.add('a', default=False, action='store_true', type=bool) self.cmd('') eq_(self.v.a, False) def test_10(self): self.add('a', action='store_true', type=bool) self.cmd('') eq_(self.v.a, False) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tests/test_wrappers.py",".py","13037","359","# This file is part of MSMBuilder. # # Copyright 2011 Stanford University # # MSMBuilder is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """""" New tests for the scripts. The idea is to replace the current TestWrappers.py with this. The improvements are basically towards maintainability, and are documented in PR 48 at https://github.com/SimTk/msmbuilder/pull/48 """""" from __future__ import print_function from __future__ import division from __future__ import absolute_import import numpy as np import tempfile import shutil import os import tarfile from unittest import skipIf import nose import mdtraj as md from msmbuilder import MSMLib from msmbuilder import metrics from msmbuilder.testing import get, eq, load from msmbuilder.scripts import ConvertDataToHDF from msmbuilder.scripts import CreateAtomIndices from msmbuilder.scripts import tICA_train from msmbuilder.scripts import Cluster from msmbuilder.scripts import Assign from msmbuilder.scripts import AssignHierarchical from msmbuilder.scripts import BuildMSM from msmbuilder.scripts import CalculateImpliedTimescales from msmbuilder.scripts import PCCA from msmbuilder.scripts import CalculateTPT from msmbuilder.scripts import FindPaths from msmbuilder.scripts import CalculateClusterRadii from msmbuilder.scripts import CalculateMFPTs from msmbuilder.scripts import CalculateProjectDistance def pjoin(*args): return os.path.join(*args) # CRS: is this function really necessary? # subclassing this will get you a test where you have a temporary # directory (self.td) that will get cleaned up when you tes finishes # (whether it passes or fails) class WTempdir(object): def setup(self): self.td = tempfile.mkdtemp() os.chdir(self.td) def teardown(self): shutil.rmtree(self.td) class test_ConvertDataToHDF(WTempdir): def test(self): # extract xtcs to a temp dir xtc_fn = get('XTC.tgz', just_filename=True) fh = tarfile.open(xtc_fn, mode='r:gz') fh.extractall(self.td) fh.close() outfn = pjoin(self.td, 'ProjectInfo.yaml') # move to that directory os.chdir(self.td) ConvertDataToHDF.run(projectfn=outfn, conf_filename=get('native.pdb', just_filename=True), input_dir=pjoin(self.td, 'XTC'), source='file', min_length=0, stride=1, rmsd_cutoff=np.inf, atom_indices=None, iext="".xtc"") eq(load(outfn), get('ProjectInfo.yaml')) class test_ConvertDataToHDF_atomindices(WTempdir): def test(self): # extract xtcs to a temp dir xtc_fn = get('XTC.tgz', just_filename=True) fh = tarfile.open(xtc_fn, mode='r:gz') fh.extractall(self.td) fh.close() outfn = pjoin(self.td, 'ProjectInfo.yaml') # move to that directory os.chdir(self.td) atom_indices = np.arange(4) ConvertDataToHDF.run(projectfn=outfn, conf_filename=get('native.pdb', just_filename=True), input_dir=pjoin(self.td, 'XTC'), source='file', min_length=0, stride=1, rmsd_cutoff=np.inf, atom_indices=atom_indices, iext="".xtc"") project = load(outfn) traj = project.load_conf() eq(traj.n_atoms, 4) class test_tICA_train(WTempdir): def test(self): prep_metric = metrics.Dihedral(angles='phi/psi') project = get('ProjectInfo.yaml') os.chdir(self.td) tICA_train.run(prep_metric, project, delta_time=10, atom_indices=None, output='tICAtest.h5', min_length=0, stride=1) ref_tICA = get('tICA_ref_mle.h5') ref_vals = ref_tICA['vals'] ref_vecs = ref_tICA['vecs'] ref_inds = np.argsort(ref_vals) ref_vals = ref_vals[ref_inds] ref_vecs = ref_vecs[:, ref_inds] test_tICA = load('tICAtest.h5') test_vals = test_tICA['vals'] test_vecs = test_tICA['vecs'] test_inds = np.argsort(test_vals) test_vals = test_vals[test_inds] test_vecs = test_vecs[:, test_inds] eq(test_vals, ref_vals) eq(test_vecs, test_vecs) def test_CreateAtomIndices(): indices = CreateAtomIndices.run(get('native.pdb', just_filename=True), 'minimal') eq(indices, get('AtomIndices.dat')) class test_Cluster_kcenters(WTempdir): # this one tests kcenters def test(self): args, metric = Cluster.parser.parse_args([ '-p', get('points_on_cube/ProjectInfo.yaml', just_filename=True), '-o', self.td, 'rmsd', '-a', get('points_on_cube/AtomIndices.dat', just_filename=True), 'kcenters', '-k', '4'], print_banner=False) Cluster.main(args, metric) assignments = load(pjoin(self.td, 'Assignments.h5'))[""arr_0""] assignment_counts = np.bincount(assignments.flatten()) eq(assignment_counts, np.array([2, 2, 2, 2])) distances = load(pjoin(self.td, 'Assignments.h5.distances'))[""arr_0""] eq(distances, np.zeros((1,8))) class test_Cluster_hybrid(WTempdir): # this one tests hybrid kcenters kmedoids def test(self): args, metric = Cluster.parser.parse_args([ '-p', get('points_on_cube/ProjectInfo.yaml', just_filename=True), '-o', self.td, 'rmsd', '-a', get('points_on_cube/AtomIndices.dat', just_filename=True), 'hybrid', '-k', '4'], print_banner=False) Cluster.main(args, metric) class test_Cluster_hierarchical(WTempdir): def test(self): if os.getenv('TRAVIS', None) == 'true': raise nose.SkipTest('Skipping test_Assign on TRAVIS') try: import fastcluster except ImportError: raise nose.SkipTest(""Cannot find fastcluster, so skipping hierarchical clustering test."") args, metric = Cluster.parser.parse_args([ '-p', get('ProjectInfo.yaml', just_filename=True), '-s', '10', '-o', self.td, 'rmsd', '-a', get('AtomIndices.dat', just_filename=True), 'hierarchical'], print_banner=False) Cluster.main(args, metric) eq(load(pjoin(self.td, 'ZMatrix.h5')), get('ZMatrix.h5')) class test_Assign(WTempdir): def test(self): args, metric = Assign.parser.parse_args([ '-p', get('ProjectInfo.yaml', just_filename=True), '-g', get('Gens.lh5', just_filename=True), '-o', self.td, 'rmsd', '-a', get('OldAtomIndices.dat', just_filename=True)], print_banner=False) if os.getenv('TRAVIS', None) == 'true': raise nose.SkipTest('Skipping test_Assign on TRAVIS') Assign.main(args, metric) eq(load(pjoin(self.td, 'Assignments.h5')), get('assign/Assignments.h5')) eq(load(pjoin(self.td, 'Assignments.h5.distances')), get('assign/Assignments.h5.distances'), decimal=5) class test_AssignHierarchical(WTempdir): def test(self): project = get('ProjectInfo.yaml') asgn = AssignHierarchical.main(k=100, d=None, zmatrix_fn=get('ZMatrix.h5', just_filename=True), stride=10, project=project) eq(asgn, get('WardAssignments.h5')['arr_0']) class test_BuildMSM(WTempdir): def test(self): BuildMSM.run(lagtime=1, assignments=get('Assignments.h5')['arr_0'], symmetrize='MLE', out_dir=self.td) eq(load(pjoin(self.td, 'tProb.mtx')), get('tProb.mtx'), decimal=5) eq(load(pjoin(self.td, 'tCounts.mtx')), get('tCounts.mtx'), decimal=3) eq(load(pjoin(self.td, 'Mapping.dat')), get('Mapping.dat')) eq(load(pjoin(self.td, 'Assignments.Fixed.h5')), get('Assignments.Fixed.h5')) eq(load(pjoin(self.td, 'Populations.dat')), get('Populations.dat')) def test_CalculateImpliedTimescales(): impTimes = CalculateImpliedTimescales.run(MinLagtime=3, MaxLagtime=5, Interval=1, NumEigen=10, AssignmentsFn=get('Assignments.h5', just_filename=True), trimming=True, symmetrize='Transpose', nProc=1) eq(impTimes, get('ImpliedTimescales.dat')) def test_CalculateMFPTs(mfpt_state=70): mfpt = CalculateMFPTs.run(get('transition_path_theory_reference/tProb.mtx'), mfpt_state) mfpt0 = get(pjoin(""transition_path_theory_reference"", ""mfpt.h5""))['Data'] eq(mfpt, mfpt0) def test_CalculateTPT(): T = get(""transition_path_theory_reference/tProb.mtx"") sources = [0] # chosen arb. for ref. by TJL sinks = [70] # chosen arb. for ref. by TJL script_out = CalculateTPT.run(T, sources, sinks) committors_ref = get(pjoin(""transition_path_theory_reference"", ""committors.h5""))['Data'] net_flux_ref = get(pjoin(""transition_path_theory_reference"", ""net_flux.h5""))['Data'] eq(script_out[0], committors_ref) eq(script_out[1].toarray(), net_flux_ref) def test_CalculateClusterRadii(): cr = CalculateClusterRadii.main(get(""Assignments.h5"")['arr_0'], get(""Assignments.h5.distances"")['arr_0']) cr_r = get(""ClusterRadii.dat"") eq(cr, cr_r) def test_FindPaths(): tprob = get(""transition_path_theory_reference/tProb.mtx"") sources = [0] sinks = [70] paths, bottlenecks, fluxes = FindPaths.run(tprob, sources, sinks, 10) # paths are hard to test due to type issues, adding later --TJL bottlenecks_ref = get(pjoin(""transition_path_theory_reference"", ""dijkstra_bottlenecks.h5""))['Data'] fluxes_ref = get(pjoin(""transition_path_theory_reference"", ""dijkstra_fluxes.h5""))['Data'] eq(bottlenecks, bottlenecks_ref) eq(fluxes, fluxes_ref) class test_PCCA(WTempdir): def test(self): num_macro = 5 TC = get(""PCCA_ref/tProb.mtx"") A = get(""PCCA_ref/Assignments.Fixed.h5"")['arr_0'] macro_map, macro_assign = PCCA.run_pcca(num_macro, A, TC) r_macro_map = get(""PCCA_ref/MacroMapping.dat"") macro_map = macro_map.astype(np.int) r_macro_map = r_macro_map.astype(np.int) # The order of macrostates might be different between the reference and # new lumping. We therefore find a permutation to match them. permutation_mapping = np.zeros(macro_assign.max() + 1, 'int') for i in range(num_macro): j = np.where(macro_map == i)[0][0] permutation_mapping[i] = r_macro_map[j] macro_map_permuted = permutation_mapping[macro_map] MSMLib.apply_mapping_to_assignments(macro_assign, permutation_mapping) r_macro_assign = get(""PCCA_ref/MacroAssignments.h5"")['arr_0'] eq(macro_map_permuted, r_macro_map) eq(macro_assign, r_macro_assign) class test_SaveStructures(WTempdir): def test(self): from msmbuilder.scripts.SaveStructures import save os.chdir(self.td) project = get('ProjectInfo.yaml') assignments = get('Assignments.h5')['arr_0'] which_states = [0, 1, 2] list_of_trajs = project.get_random_confs_from_states(assignments, which_states, num_confs=2, replacement=True, random=np.random.RandomState(42)) assert isinstance(list_of_trajs, list) assert isinstance(list_of_trajs[0], md.Trajectory) eq(len(list_of_trajs), len(which_states)) for t in list_of_trajs: eq(len(t), 2) # sep, tps, one save(list_of_trajs, which_states, style='sep', format='lh5', outdir=self.td) save(list_of_trajs, which_states, style='tps', format='lh5', outdir=self.td) save(list_of_trajs, which_states, style='one', format='lh5', outdir=self.td) names = ['State0-0.lh5', 'State0-1.lh5', 'State0.lh5', 'State1-0.lh5', 'State1-1.lh5', 'State1.lh5', 'State2-0.lh5', 'State2-1.lh5', 'State2.lh5'] for name in names: t = md.load(pjoin(self.td, name)) eq(t.xyz, get('save_structures/' + name).xyz) # Just checking coordinates because atom names / bonds in reference data are incompatible with MDTraj. ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tests/test_msmlib.py",".py","7027","227","from __future__ import print_function from __future__ import division from __future__ import absolute_import import numpy as np from msmbuilder.testing import eq import scipy.sparse from msmbuilder import MSMLib def test_get_count_matrix_from_assignments_1(): assignments = np.zeros((10, 10),'int') val = MSMLib.get_count_matrix_from_assignments(assignments).todense() correct = np.matrix([[90.0]]) eq(val, correct) def test_get_count_matrix_from_assignments_2(): np.random.seed(42) assignments = np.random.randint(3, size=(10, 10)) val = MSMLib.get_count_matrix_from_assignments(assignments).todense() correct = np.matrix([[11., 9., 10.], [9., 17., 7.], [10., 7., 10.]]) eq(val, correct) def test_get_count_matrix_from_assignments_3(): np.random.seed(42) assignments = np.random.randint(3, size=(10, 10)) val = MSMLib.get_count_matrix_from_assignments( assignments, lag_time=2, sliding_window=False).todense() eq(val, np.matrix([[5., 3., 4.], [2., 12., 3.], [4., 3., 4.]])) val = MSMLib.get_count_matrix_from_assignments( assignments, lag_time=2, sliding_window=True).todense() eq(val, np.matrix([[8., 9., 11.], [5., 18., 6.], [11., 5., 7.]])) def test_estimate_rate_matrix_1(): np.random.seed(42) assignments = np.random.randint(2, size=(10, 10)) counts = MSMLib.get_count_matrix_from_assignments(assignments) K = MSMLib.estimate_rate_matrix(counts, assignments).todense() correct = np.matrix([[-40.40909091, 0.5], [0.33928571, -50.55357143]]) eq(K, correct) def test_estimate_rate_matrix_2(): np.random.seed(42) counts_dense = np.random.randint(100, size=(4, 4)) counts_sparse = scipy.sparse.csr_matrix(counts_dense) t_mat_dense = MSMLib.estimate_transition_matrix(counts_dense) t_mat_sparse = MSMLib.estimate_transition_matrix(counts_sparse) correct = np.array([[0.22368421, 0.40350877, 0.06140351, 0.31140351], [0.24193548, 0.08064516, 0.33064516, 0.34677419], [0.22155689, 0.22155689, 0.26047904, 0.29640719], [0.23469388, 0.02040816, 0.21428571, 0.53061224]]) eq(t_mat_dense, correct) eq(t_mat_dense, np.array(t_mat_sparse.todense())) def test_apply_mapping_to_assignments_1(): l = 100 assignments = np.random.randint(l, size=(10, 10)) mapping = np.ones(l) MSMLib.apply_mapping_to_assignments(assignments, mapping) eq(assignments, np.ones((10, 10))) def test_apply_mapping_to_assignments_2(): ""preseve the -1s"" l = 100 assignments = np.random.randint(l, size=(10, 10)) assignments[0, 0] = -1 mapping = np.ones(l) correct = np.ones((10, 10)) correct[0, 0] = -1 MSMLib.apply_mapping_to_assignments(assignments, mapping) eq(assignments, correct) def test_ergodic_trim(): counts = scipy.sparse.csr_matrix(np.matrix('2 1 0; 1 2 0; 0 0 1')) trimmed, mapping = MSMLib.ergodic_trim(counts) eq(trimmed.todense(), np.matrix('2 1; 1 2')) eq(mapping, np.array([0, 1, -1])) def test_trim_states(): # run the (just tested) ergodic trim counts = scipy.sparse.csr_matrix(np.matrix('2 1 0; 1 2 0; 0 0 1')) trimmed, mapping = MSMLib.ergodic_trim(counts) # now try the segmented method states_to_trim = MSMLib.ergodic_trim_indices(counts) trimmed_counts = MSMLib.trim_states( states_to_trim, counts, assignments=None) eq(trimmed.todense(), trimmed_counts.todense()) assignments = np.array([np.arange(counts.shape[0])]) states_to_trim = MSMLib.ergodic_trim_indices(counts) trimmed_counts, trimmed_assignments = MSMLib.trim_states(states_to_trim, counts, assignments=assignments) # Test that code works with assignments given trimmed_assignments_ref = np.array([[0, 1, -1]]) # State 2 is strong-disconnected so set to -1 eq(trimmed_assignments, trimmed_assignments_ref) class test_build_msm(object): def setup(self): self.assignments = np.array( np.matrix('0 1 0 0 0 1 0 0 0 1; 0 0 0 0 1 0 1 1 1 0')) self.lag_time = 1 def test_1(self): C = MSMLib.get_count_matrix_from_assignments(self.assignments, 2) rc, t, p, m = MSMLib.build_msm( C, symmetrize='MLE', ergodic_trimming=True) eq(rc.todense(), np.matrix([[6.46159184, 4.61535527], [4.61535527, 2.30769762]]), decimal=4) eq(t.todense(), np.matrix([[0.58333689, 0.41666311], [0.66666474, 0.33333526]]), decimal=4) eq(p, np.array([0.61538595, 0.38461405]), decimal=5) eq(m, np.array([0, 1])) def test_estimate_transition_matrix_1(): np.random.seed(42) count_matrix = np.array([[6, 3, 7], [4, 6, 9], [2, 6, 7]]) t = MSMLib.estimate_transition_matrix(count_matrix) eq(t, np.array([[0.375, 0.1875, 0.4375], [0.21052632, 0.31578947, 0.47368421], [0.13333333, 0.4, 0.46666667]])) def test_invert_assignments_1(): pass def test_renumber_states_1(): a = np.random.randint(3, size=(2, 10)) a[np.where(a == 0)] = 1 a[0, 0] = -1 # since its inplace new_a = a.copy() mapping = MSMLib.renumber_states(new_a) eq(int(new_a[0, 0]), -1) eq(np.where(a == 2)[0], np.where(new_a == 1)[0]) eq(np.where(a == 2)[1], np.where(new_a == 1)[1]) eq(mapping, np.array([1, 2])) eq(mapping[new_a][np.where(a != -1)], a[np.where(a != -1)]) def test_log_likelihood_1(): pass class test_mle_reversible_count_matrix(object): def test_1(self): """"""Checks that the MLE code (kyle) agrees with the reference implemenation (Lutz). """""" counts = scipy.sparse.csr_matrix( [[10, 5, 1], [0, 25, 10], [3, 3, 100]]) self.compare_kyle_to_lutz(counts) def test_2(self): """"""Checks that a symmetric matrix is unchanged by the MLE"""""" counts = scipy.sparse.csr_matrix([[10, 5], [5, 10]]) self.compare_kyle_to_reference(counts, counts) def compare_kyle_to_lutz(self, raw_counts): """"""Kyle wrote the most recent MLE code. We compare to the previous code that was written by Lutz. """""" counts = MSMLib.ergodic_trim(raw_counts)[0] x_kyle = MSMLib.mle_reversible_count_matrix(counts) x_kyle /= x_kyle.sum() x_lutz = MSMLib.__mle_reversible_count_matrix_lutz__(counts) x_lutz /= x_lutz.sum() eq(x_kyle.toarray(), x_lutz.toarray()) def compare_kyle_to_reference(self, raw_counts, reference): """"""Compare MLE estimated reversible counts to a reference matrix"""""" counts = MSMLib.ergodic_trim(raw_counts)[0] x_kyle = MSMLib.mle_reversible_count_matrix(counts) eq(x_kyle.toarray(), reference.toarray()) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tests/test_msm_analysis.py",".py","1678","41","from __future__ import print_function from __future__ import division from __future__ import absolute_import from msmbuilder import msm_analysis, MSMLib import numpy as np import statsmodels import statsmodels.tsa.stattools from unittest import skipIf @skipIf(int(statsmodels.__version__.split('.')[1]) <= 4, ""Need developer version of statsmodels to use statsmodels.tsa.stattools.acf"") class test_msm_acf(): def __init__(self): self.epsilon = 1E-7 self.alpha = 0.001 # Confidence for uncertainty estimate # Testing is stochastic; we expect errors 0.1 % of the time. self.max_lag = 100 self.times = np.arange(self.max_lag) self.num_steps = 100000 self.C = np.array([[500, 2], [2, 50]]) self.T = MSMLib.estimate_transition_matrix(self.C) self.state_traj = np.array(msm_analysis.sample(self.T, 0, self.num_steps)) def compare_observable_to_statsmodels(self, observable_by_state): acf_msm = msm_analysis.msm_acf(self.T, observable_by_state, self.times) observable_traj = observable_by_state[self.state_traj] acf, errs = statsmodels.tsa.stattools.acf(observable_traj, nlags=self.max_lag - 1, fft=True, alpha=self.alpha) min_acf, max_acf = errs.T np.testing.assert_((acf_msm <= max_acf + self.epsilon).all()) np.testing.assert_((min_acf <= acf_msm + self.epsilon).all()) def test_1(self): observable_by_state = np.eye(2)[0] self.compare_observable_to_statsmodels(observable_by_state) def test_2(self): observable_by_state = np.array([0.25, 0.75]) self.compare_observable_to_statsmodels(observable_by_state) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tests/test_project.py",".py","3227","109","# run tests on the project class from __future__ import print_function from __future__ import division from __future__ import absolute_import import os from msmbuilder.project import FahProjectBuilder from msmbuilder import Project from msmbuilder.project import reference_data import mdtraj as md import numpy as np import numpy.testing as npt import tempfile, shutil from msmbuilder.testing import * def test_project_1(): 'ensure that the counting of errors works right' records = {'conf_filename': None, 'traj_lengths': [0,0,0], 'traj_errors': [None, 1, None], 'traj_paths': ['t0', 't1', 't2'], 'traj_converted_from': [None, None, None]} proj = Project(records, validate=False) eq_(proj.n_trajs, 2) eq_(os.path.basename(proj.traj_filename(0)), 't0') # since t1 should be skipped eq_(os.path.basename(proj.traj_filename(1)), 't2') @raises(ValueError) def test_project_2(): 'inconsistent lengths should be detected' records = {'conf_filename': None, 'traj_lengths': [0,0], # this is one too short 'traj_errors': [None, None, None], 'traj_paths': ['t0', 't1', 't2'], 'traj_converted_from': [None, None, None]} proj = Project(records, validate=False) def test_FahProjectBuilder_new1(): cd = os.getcwd() native_filename = get(""native.pdb"", just_filename=True) frames_per_gen = 10 traj = md.load(native_filename) fah_path = tempfile.mkdtemp() msmb_path = tempfile.mkdtemp() run_clone_gen = {(0, 0):5, (0, 1):6, (0, 2):7, (1, 0):20} reference_traj_lengths = np.array([5, 6, 7, 20]) * frames_per_gen ref = reference_data.FAHReferenceData(traj, fah_path, run_clone_gen, frames_per_gen) os.chdir(msmb_path) pb = FahProjectBuilder(fah_path, '.xtc', native_filename) project = pb.get_project() eq(project.conf_filename, native_filename) eq(project.traj_lengths, reference_traj_lengths) os.chdir(cd) shutil.rmtree(fah_path) shutil.rmtree(msmb_path) def test_FahProjectBuilder_subset(): cd = os.getcwd() native_filename = get(""native.pdb"", just_filename=True) frames_per_gen = 10 traj = md.load(native_filename) fah_path = tempfile.mkdtemp() msmb_path = tempfile.mkdtemp() run_clone_gen = {(0, 0):5, (0, 1):6, (0, 2):7, (1, 0):20} reference_traj_lengths = np.array([5, 6, 7, 20]) * frames_per_gen atom_indices = np.arange(5) ref = reference_data.FAHReferenceData(traj, fah_path, run_clone_gen, frames_per_gen) os.chdir(msmb_path) new_native_filename = msmb_path + ""/"" + os.path.split(native_filename)[1] shutil.copy(native_filename, new_native_filename) # Necessary on travis because we lack write permission in native.pdb directory pb = FahProjectBuilder(fah_path, '.xtc', new_native_filename, atom_indices=atom_indices) project = pb.get_project() new_traj = project.load_conf() eq(new_traj.n_atoms, 5) eq(project.traj_lengths, reference_traj_lengths) os.chdir(cd) shutil.rmtree(fah_path) shutil.rmtree(msmb_path) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tests/test_eigensolvers.py",".py","4340","94","from __future__ import print_function from __future__ import division from __future__ import absolute_import import numpy as np import scipy.sparse import scipy.sparse.linalg from msmbuilder.MSMLib import build_msm from msmbuilder.msm_analysis import get_eigenvectors, get_reversible_eigenvectors def test_get_eigenvectors_left(): # just some random counts N = 100 counts = np.random.randint(1, 10, size=(N,N)) transmat, pi = build_msm(scipy.sparse.csr_matrix(counts), 'MLE')[1:3] values0, vectors0 = get_eigenvectors(transmat, 10) values1, vectors1 = get_reversible_eigenvectors(transmat, 10) values2, vectors2 = get_reversible_eigenvectors(transmat, 10, populations=pi) # check that the eigenvalues are the same using the two methods np.testing.assert_array_almost_equal(values0, values1) # check that the eigenvectors returned by both methods are _actually_ # left eigenvectors of the transmat def test_eigenpairs(values, vectors): for value, vector in zip(values, vectors.T): np.testing.assert_array_almost_equal( (transmat.T.dot(vector) / vector).flatten(), np.ones(N)*value) np.testing.assert_array_almost_equal(pi, vectors0[:, 0]) np.testing.assert_array_almost_equal(pi, vectors1[:, 0]) np.testing.assert_array_almost_equal(pi, vectors2[:, 0]) test_eigenpairs(values0, vectors0) test_eigenpairs(values1, vectors1) test_eigenpairs(values2, vectors2) def test_get_eigenvectors_right(): # just some random counts N = 100 counts = np.random.randint(1, 10, size=(N,N)) transmat, pi = build_msm(scipy.sparse.csr_matrix(counts), 'MLE')[1:3] values0, vectors0 = get_eigenvectors(transmat, 10, right=True) values1, vectors1 = get_reversible_eigenvectors(transmat, 10, right=True) values2, vectors2 = get_reversible_eigenvectors(transmat, 10, right=True, populations=pi) # check that the eigenvalues are the same using the two methods np.testing.assert_array_almost_equal(values0, values1) # check that the eigenvectors returned by both methods are _actually_ # right eigenvectors of the transmat def test_eigenpairs(values, vectors): for value, vector in zip(values, vectors.T): np.testing.assert_array_almost_equal( (transmat.dot(vector) / vector).flatten(), np.ones(N)*value) ones_ary = np.ones(pi.shape) np.testing.assert_array_almost_equal(ones_ary, vectors0[:, 0]) np.testing.assert_array_almost_equal(ones_ary, vectors1[:, 0]) np.testing.assert_array_almost_equal(ones_ary, vectors2[:, 0]) test_eigenpairs(values0, vectors0) test_eigenpairs(values1, vectors1) test_eigenpairs(values2, vectors2) def test_eigenvector_norm(): N = 100 counts = np.random.randint(1, 10, size=(N,N)) transmat, pi = build_msm(scipy.sparse.csr_matrix(counts), 'MLE')[1:3] left_values0, left_vectors0 = get_eigenvectors(transmat, 10, right=False, normalized=True) right_values0, right_vectors0 = get_eigenvectors(transmat, 10, right=True, normalized=True) left_values1, left_vectors1 = get_reversible_eigenvectors(transmat, 10, right=False, normalized=True) right_values1, right_vectors1 = get_reversible_eigenvectors(transmat, 10, right=True, normalized=True) np.testing.assert_array_almost_equal(left_values0, right_values0) np.testing.assert_array_almost_equal(left_values1, right_values1) test_left_vectors1 = left_vectors1 * np.sign(left_vectors0[0].reshape((1,-1))) * np.sign(left_vectors1[0].reshape((1,-1))) test_right_vectors1 = right_vectors1 * np.sign(right_vectors0[0].reshape((1,-1))) * np.sign(right_vectors1[0].reshape((1,-1))) np.testing.assert_array_almost_equal(left_vectors0, test_left_vectors1) np.testing.assert_array_almost_equal(right_vectors0, test_right_vectors1) Id = np.eye(10) np.testing.assert_array_almost_equal(np.abs(left_vectors0.T.dot(right_vectors0)), Id) np.testing.assert_array_almost_equal(np.abs(left_vectors1.T.dot(right_vectors1)), Id) # ^^^ this tests whether they're normalized and also orthogonal # it's probably redundant to do both since the previous two tests look # to see if the left_vectors and right_vectors are the same # doesn't hurt to check in case normalizing screws things up ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tests/reference_generation_scripts/generate_3D_points.py",".py","1716","67","from __future__ import print_function from __future__ import division from __future__ import absolute_import import numpy as np import mdtraj as md def points_on_cube(): """"""Generate example data. Returns ------- traj : mdtraj.Trajectory Trajectory containing points on cube. Notes ----- This generates an mdtraj trajectory with 8 frames and 4 atoms. Of the 8 frames, there are only 4 distinct conformations. In particular traj.xyz[i] == traj.xyz[i + 4] for all i. If we cluster this data into 4 clusters, we expect there to be 2 conformations assigned to each cluster. We also expect the distance to each generator to be zero. """""" n_frames = 8 n_atoms = 4 top = md.Topology() chain = top.add_chain() residue = top.add_residue(""UNK"", chain) pose0 = np.zeros((n_atoms, 3)) pose1 = np.zeros((n_atoms, 3)) pose1[3, 0] = 1 pose2 = np.zeros((n_atoms, 3)) pose2[2, 1] = 1 pose2[3, 1] = 2 pose3 = np.zeros((n_atoms, 3)) pose0[0, 2] = 0. pose0[1, 2] = 1. pose0[2, 2] = 2. pose0[3, 2] = 3. for i in range(n_atoms): atom = top.add_atom(""H%d"" % i, None, residue) xyz = np.array([pose0, pose1, pose2, pose3, pose0, pose1, pose2, pose3]) traj = md.Trajectory(xyz, top) return traj if __name__ == ""__main__"": traj = points_on_cube() traj.save(""./reference/points_on_cube/Trajectories/trj0.lh5"") traj = traj[0:1] traj.save(""./reference/points_on_cube/native.pdb"") atom_indices = np.arange(traj.n_atoms) np.savetxt(""./reference/points_on_cube/AtomIndices.dat"", atom_indices, ""%d"") ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tests/reference_generation_scripts/gen_ref_dat.py",".py","804","34","from __future__ import print_function from __future__ import division from __future__ import absolute_import import numpy as np import sys, re, os def get_data( fn ): data_file = open( fn, 'r' ) lines = [ l for l in data_file.readlines() if not l[0] in ['#','@'] ] dat = np.genfromtxt(lines) return dat[:,1] os.mkdir('Atoms') for frame_ind in range(501): os.system('echo ""0 0 "" | g_sas -ndots {ndots} -f {xtc_fn} -s {pdb_fn} -b {i} -e {i} -oa Atoms/atom{i}.xvg -o Atoms/tot{i}.xvg'.format( xtc_fn='./trj0.xtc', pdb_fn='./native.pdb', i=frame_ind, ndots=960 ) ) filenames = [ 'Atoms/atom%d.xvg'%i for i in range(501) ] traj_dat = [] for i in range(501): traj_dat.append( get_data( filenames[i] ) ) traj_dat = np.array( traj_dat ) np.savetxt('ref_dat.dat', traj_dat ) ","Python" "Conformation","msmbuilder/msmbuilder-legacy","tests/reference_generation_scripts/generate_tpt_ref.py",".py","3106","105","from __future__ import print_function from __future__ import division from __future__ import absolute_import import os import sys import datetime import numpy as np import scipy.sparse from scipy import io from msmbuilder import transition_path_theory as tpt from msmbuilder import Serializer d = datetime.date.today() BACKUP_DIR = 'tpt_ref_%s.%s.%s' % (d.month, d.day, d.year) os.mkdir(BACKUP_DIR) def save_new_ref(filename, data): """""" Saves a new version of the reference data, and backs up the old """""" ext = filename.split('.')[-1] if (data == None): print(""WARNING: Error generating file: %s"" % filename) print(""Skipped... try again."") return if os.path.exists(filename): os.system( 'mv %s %s' % (filename, BACKUP_DIR) ) if ext in ['h5', 'lh5']: if scipy.sparse.issparse(data): data = data.toarray() Serializer.SaveData(filename, data) elif ext == 'mtx': io.mmwrite(filename, data) elif ext == 'pkl': f = open(filename, 'w') pickle.dump(f, data) f.close() else: raise ValueError('Could not understand extension (.%s) for %s' % (ext, filename)) return # hard-coding these right now - would be better to read them from a common # place, where the actual unit test also gets these values tpt_ref_dir = '.' tprob = io.mmread( os.path.join( ""tProb.mtx"") ) #.toarray() # strange bug?? sources = [0] # chosen arbitarily by TJL sinks = [70] # chosen arbitarily by TJL waypoints = [60] # chosen arbitarily by TJL lag_time = 1.0 # chosen arbitarily by TJL # committors Q = tpt.calculate_committors(sources, sinks, tprob) save_new_ref('committors.h5', Q) # flux flux = tpt.calculate_fluxes(sources, sinks, tprob) save_new_ref('flux.h5', flux) net_flux = tpt.calculate_net_fluxes(sources, sinks, tprob) save_new_ref('net_flux.h5', net_flux) # path calculations paths, bottlenecks, fluxes = tpt.find_top_paths(sources, sinks, tprob) save_new_ref('dijkstra_paths.h5', paths) save_new_ref('dijkstra_fluxes.h5', fluxes) save_new_ref('dijkstra_bottlenecks.h5', bottlenecks) # MFPTs mfpt = tpt.calculate_mfpt(sinks, tprob, lag_time=lag_time) save_new_ref('mfpt.h5', mfpt) ensemble_mfpt = tpt.calculate_ensemble_mfpt(sources, sinks, tprob, lag_time) save_new_ref('ensemble_mfpt.h5', ensemble_mfpt) all_to_all_mfpt = tpt.calculate_all_to_all_mfpt(tprob) save_new_ref('all_to_all_mfpt.h5', all_to_all_mfpt) # TP Time tp_time = tpt.calculate_avg_TP_time(sources, sinks, tprob, lag_time) save_new_ref('tp_time.h5', tp_time) # hub scores #frac_visits = tpt.calculate_fraction_visits(tprob, waypoints, # sources, sinks) #save_new_ref('frac_visits.h5', frac_visits) #hub_score = tpt.calculate_hub_score(tprob, waypoints) #save_new_ref('hub_score.h5', hub_score) #all_hub_scores = tpt.calculate_all_hub_scores(tprob) #save_new_ref('all_hub_scores.h5', all_hub_scores) # done! print(""Done generating new reference for transition_path_theory.py!"") ","Python" "Conformation","vvoelz/biceps","setup.py",".py","3497","96","#!/usr/bin/env python from setuptools import setup, find_packages from os import path from io import open #try: # for pip >= 10 # from pip._internal.req import parse_requirements #except ImportError: # for pip <= 9.0.3 # from pip.req import parse_requirements import sys from pip._internal.req import parse_requirements # parse_requirements() returns generator of pip.req.InstallRequirement objects # We need two seperate requirement files due to the failure to install all at once. requirements = parse_requirements('requirements.txt', session=False) #install_reqs2 = parse_requirements('requirements2.txt', session=False) # ## reqs is a list of requirement ## e.g. ['django==1.5.1', 'mezzanine==1.4.6'] requirements = list(requirements) try: requirements = [str(ir.req) for ir in requirements] except: requirements = [str(ir.requirement) for ir in requirements] #reqs1 = [str(ir.req) for ir in install_reqs1] #req_links1 = [str(ir.url) for ir in install_reqs1] # #reqs2 = [str(ir.req) for ir in install_reqs2] #req_links2 = [str(ir.url) for ir in install_reqs2] here = path.abspath(path.dirname(__file__)) # Get the long description from the README file with open(path.join(here, 'README.md'), ""r"", encoding='utf-8') as f: long_description = f.read() sys.path.append('BICePs_2.0/') setup( name=""biceps"", version=""2.0.0"", description='BICePs', long_description=long_description, long_description_content_type=""text/markdown"", classifiers=[ #'Programming Language :: Python :: 2.7', ""Programming Language :: Python :: 3"", ""License :: OSI Approved :: MIT License"", ""Operating System :: MacOS"", ""Operating System :: Unix"", #""Operating System :: OS Independent"" ""Intended Audience :: Developers"", ""Intended Audience :: Science/Research"", 'Topic :: Scientific/Engineering :: Chemistry', 'Topic :: Scientific/Engineering :: Bio-Informatics'], url=""https://biceps.readthedocs.io/en/latest/index.html"", project_urls={ ""Github"": ""https://github.com/vvoelz/biceps"", ""Documentation"": ""https://biceps.readthedocs.io/en/latest/index.html"", }, author='Robert M. Raddi, Yunhui Ge, Vincent A. Voelz', author_email='rraddi@temple.edu, yunhui.ge@gmail.com, vvoelz@gmail.com', license='MIT', #packages=exclude=['docs']), packages=find_packages(), #setup_requires=['numpy'], install_requires=requirements, #install_requires=[ # 'numpy', # 'mdtraj', # #'git+https://github.com/mdtraj/mdtraj.git' # 'pymbar==3.0.3'], #'mdtraj==1.9.4','pymbar==3.0.2'], # conda install -c conda-forge mdtraj python_requires='>=3.7', #extras_require={ # Optional # 'dev': ['check-manifest'], # 'test': ['coverage'], # }, #dependency_links=[ #""git+https://github.com/username/repo.git@MyTag"" #'git+https://github.com/mdtraj/mdtraj.git' #'https://github.com/mdtraj/mdtraj/archive/1.9.4.tar.gz', #'git+https://github.com/mdtraj/mdtraj.git@1.9.3' #'https://github.com/mdtraj/mdtraj/tarball/master#eggmdtraj-1.9.4', #'git+https://github.com/choderalab/pymbar.git@3.0.3' # ] #include_package_data=True, #zip_safe=True) ) ","Python" "Conformation","vvoelz/biceps","biceps/J_coupling.py",".py","3932","103","# -*- coding: utf-8 -*- import numpy as np from mdtraj.geometry import compute_phi J3_HN_HA_coefficients = { # See full citations below in docstring references. ""Ruterjans1999"": dict(phi0=-60 * np.pi/180., A=7.90, B=-1.05, C=0.65), # From Table 1. in paper. ""Bax2007"": dict(phi0=-60 * np.pi/180., A=8.4, B=-1.36, C=0.33), # From Table 1. in paper ""Bax1997"": dict(phi0=-60 * np.pi/180., A=7.09, B=-1.42, C=1.55), # From Table 2. in paper ""Habeck"" : dict(phi0=-60 * np.pi/180., A=7.13, B=-1.31, C=1.56), # From Table 1. in paper ""Vuister"" : dict(phi0=-60 * np.pi/180., A=6.51, B=-1.76, C=1.60), # From Figure 4. in paper ""Pardi"" : dict(phi0=-60 * np.pi/180., A=6.40, B=-1.40, C=1.90), # From Figure 3. in paper } J3_HN_HA_uncertainties = { # Values in [Hz] ""Ruterjans1999"": 0.25, ""Bax2007"": 0.36, ""Bax1997"": 0.39, ""Habeck"" : 0.34, ""Vuister"": 0.73, ""Pardi"" : 0.76 } def _J3_function(phi, A, B, C, phi0): """"""Return a scalar couplings with a given choice of karplus coefficients. :param float phi: :param float A: :param float B: :param float C: :param float phi0: .. warning:: in radians"""""" return A * np.cos(phi + phi0) ** 2. + B * np.cos(phi + phi0) + C def compute_J3_HN_HA(traj, model=""Bax2007""): """"""Calculate the scalar coupling between HN and H_alpha. This function does not take into account periodic boundary conditions (it will give spurious results if the three atoms which make up any angle jump across a PBC (are not ""wholed"")) :param mdtraj.Trajectory traj: Trajectory to compute J3_HN_HA for :param string, optional, default=""Bax2007"" model : Which scalar coupling model to use. Must be one of Bax2007, Bax1999, or Ruterjans1999 :return np.ndarray, shape=(n_phi, 4), dtype=int indices : Atom indices (zero-based) of the phi dihedrals :return np.ndarray, shape=(n_frames, n_phi) J: Scalar couplings (J3_HN_HA, in [Hz]) of this trajectory. `J[k]` corresponds to the phi dihedral associated with atoms `indices[k]` Notes ----- The coefficients are taken from the references below--please cite them. References ---------- .. [1] Schmidt, J. M., Blümel, M., Löhr, F., & Rüterjans, H. ""Self-consistent 3J coupling analysis for the joint calibration of Karplus coefficients and evaluation of torsion angles."" J. Biomol. NMR, 14, 1 1-12 (1999) .. [2] Vögeli, B., Ying, J., Grishaev, A., & Bax, A. ""Limits on variations in protein backbone dynamics from precise measurements of scalar couplings."" J. Am. Chem. Soc., 129(30), 9377-9385 (2007) .. [3] Hu, J. S., & Bax, A. ""Determination of ϕ and ξ1 Angles in Proteins from 13C-13C Three-Bond J Couplings Measured by Three-Dimensional Heteronuclear NMR. How Planar Is the Peptide Bond?."" J. Am. Chem. Soc., 119(27), 6360-6368 (1997) .. [4] Habeck, M.; Rieping, W.; Nilges, M. Bayesian Estimation of Karplus Parameters and Torsion Angles from Three-Bond Scalar Couplings Constants. J. Magn. Reson. 2005, 177 (1), 160–165. .. [5] Vuister, G. W.; Bax, A. Quantitative J Correlation: A New Approach for Measuring Homonuclear Three-Bond JHN,Hα Coupling Constants in 15N-Enriched Proteins. J. Am. Chem. Soc. 1993, 115 (17), 7772–7777. .. [6] Pardi, A.; Billeter, M.; Wüthrich, K. Calibration of the Angular Dependence of the Amide Proton-C Alpha Proton Coupling Constants, 3JHN Alpha, in a Globular Protein. Use of 3JHN Alpha for Identification of Helical Secondary Structure. J. Mol. Biol. 1984, 180 (3), 741–751. """""" indices, phi = compute_phi(traj) if model not in J3_HN_HA_coefficients: raise KeyError J = _J3_function(phi, **J3_HN_HA_coefficients[model]) return indices, J ","Python" "Conformation","vvoelz/biceps","biceps/Restraint.py",".py","50981","1162","# -*- coding: utf-8 -*- import os, sys, inspect import numpy as np import pandas as pd import mdtraj as md import biceps from biceps.KarplusRelation import * # Returns J-coupling values from dihedral angles def get_restraint_options(input_data=None): """"""Return a Pandas DataFrame of all the parameters for each of the restraint classes. If input_data is provided, then the DataFrame returned will only contain restraint parameters that corresponds to the data. When providing input_data, the order of restraints (rows) corresponds to the order of the data. NOTE: If you want to use these default options, then use `options.to_dict('records')` Args: input_data(list) - ordered list of data for each state Returns: options(pd.DataFrame) """""" options = [] current_module = sys.modules[__name__] # Pick the Restraint class upon file extension #restraints = [ key for key in vars(current_module).keys() if key.startswith(""Restraint_"") ] restraints = biceps.toolbox.list_possible_restraints() # NOTE: if input_data is given, then remove information regarding all other restraints if input_data != None: scheme = biceps.toolbox.list_res(input_data) extensions = [ res.split(""_"")[-1] for res in scheme ] _restraints = [] for rest in scheme: for restraint in restraints: if restraint.split(""_"")[-1] in rest: _restraints.append(restraint) restraints = _restraints keys_to_remove = [""data"", ""energy"", ""self"", ""verbose""] for k,restraint in enumerate(restraints): _options = {} R = getattr(current_module, ""%s""%(restraint)) # Get all the arguments for the Parent Restraint Class if given args1 = inspect.getfullargspec(R) args2 = inspect.getfullargspec(R.init_restraint) sig1 = inspect.signature(R) for key in sig1.parameters.keys(): value = sig1.parameters[key].default if value == inspect._empty: _options[key] = [] else: _options[key] = [value] sig2 = inspect.signature(R.init_restraint) for key in sig2.parameters.keys(): value = sig2.parameters[key].default if value == inspect._empty: _options[key] = [np.nan] else: _options[key] = [value] # remove all args that user doesn't control [_options.pop(key, None) for key in keys_to_remove] # if given input_data, replace the extension with suggested if input_data != None: _options[""extension""] = [extensions[k]] # construct a dataframe for each restraint type df = pd.DataFrame(_options, index=[R.__name__]) options.append(df.to_dict('records')[0]) return options class Ensemble(object): def __init__(self, lam, energies, debug=False): """"""Container class for :attr:`biceps.Restraint.Restraint` objects. Args: lam(float): lambda value to scale energies energies(np.ndarray): numpy array of energies for each state """""" self.ensemble = [] if not isinstance(lam, float): raise ValueError(""lambda should be a single number with type of 'float'"") else: self.lam = lam if np.array(energies).dtype != float: raise ValueError(""Energies should be array with type of 'float'"") else: self.energies = self.lam*energies # Scale the energies self.debug = debug def to_list(self): """"""Converts the :class:`Ensemble` class to a list. Returns: list: collection of :attr:`biceps.Restraint.Restraint` objects """""" return self.ensemble def initialize_restraints(self, input_data, options=None): """"""Initialize corresponding :attr:`biceps.Restraint.Restraint` classes based on experimental observables from **input_data** for each conformational state. Args: input_data(list of str): a sorted collection of filenames (files\ contain `exp` (experimental) and `model` (theoretical) observables) options(list of dict): dictionary containing keys that match \ :attr:`biceps.Restraint.Restraint` parameters and values are lists for each restraint.\ .. code-block:: python # In general: parameters = [dict(**kwargs),...,dict(**kwargs)] # More specifically, for J and NOE data restraints, respectively: parameters = [dict(ref='uniform', sigma=(0.05, 20.0, 1.02)), dict(ref='exp', sigma=(0.05, 5.0, 1.02), gamma=(0.2, 5.0, 1.02))] .. tip:: See the following parent :attr:`biceps.Restraint.Restraint` and child class methods for the full list of keyword arguments (**kwargs) for each restraint used inside `parameters`: :attr:`biceps.Restraint.Restraint_cs.init_restraint` :attr:`biceps.Restraint.Restraint_J.init_restraint` :attr:`biceps.Restraint.Restraint_noe.init_restraint` :attr:`biceps.Restraint.Restraint_pf.init_restraint` Print possible restraints with: :attr:`biceps.toolbox.list_possible_restraints` Print possible extensions with: :attr:`biceps.toolbox.list_possible_extensions` """""" verbose = self.debug self.options = options if options is None: options = [dict() for i in range(len(input_data[0]))] extensions = biceps.toolbox.list_extensions(input_data) lam = self.lam for i in range(self.energies.shape[0]): self.ensemble.append([]) energy = self.energies[i] for k in range(len(input_data[0])): data = input_data[i][k] extension = extensions[k] ext = data.split(""."")[-1] restraint, extension = ext.split(""_"")[0], ext.split(""_"")[-1] # Find all Child Restraint classes in the current file current_module = sys.modules[__name__] # Pick the Restraint class upon file extension R = getattr(current_module, ""Restraint_%s""%(restraint)) # Get all the arguments for the Parent Restraint Class if given args1 = {""%s""%key: val for key,val in locals().items() if key in inspect.getfullargspec(R)[0] if key != 'self'} args2 = {""%s""%key: val for key,val in locals().items() if key in inspect.getfullargspec(R.init_restraint)[0] if key != 'self'} # It shouldn't matter the ordering of the keys and values # All options are parsed as respective Restraint child class arguments for key,val in options[k].items(): if key in inspect.getfullargspec(R)[0]: args1[key] = val elif key in inspect.getfullargspec(R.init_restraint)[0]: args2[key] = val else: possible_args = np.unique(np.concatenate( [inspect.getfullargspec(R)[0], inspect.getfullargspec(R.init_restraint)[0]])) possible_args = np.delete(possible_args, np.where(possible_args == ""self"")) possible_args = np.delete(possible_args, np.where(possible_args == ""data"")) raise TypeError(f""{key} is an invalid keyword argument for {R}\n\n\ Please check your options... \n\ The input data provided suggests the ordering of dictionaries should be: {biceps.toolbox.list_extensions(input_data)}\n\ Dictionary keys for {R.__name__} are any of: {possible_args}"") if self.debug: print(R) print(f""Required args by inspect:{inspect.getfullargspec(R.init_restraint)[0]}"") print(f""args1 given: {args1}"") print(f""args2 given: {args2}"") R = R(**args1) # Initializing Restraint R.init_restraint(**args2) self.ensemble[-1].append(R) class Restraint(object): def __init__(self, ref=""uniform"", sigma=[0.05, 20.0, 1.02], use_global_ref_sigma=True, verbose=False): """"""The parent :attr:`biceps.Restraint.Restraint` class. Args: ref_pot(str): referenece potential e.g., ""uniform"". ""exp"", ""gau"".\ If None, the default reference potential will be used for\ a given experimental observable sigma(list): (sigma_min, sigma_max, dsigma) use_global_ref_sigma(bool): (defaults to True) """""" # Store restraint info self.restraints = [] # a list of data container objects for each restraint (e.g. NMR_Chemicalshift_Ca()) # used for exponential reference potential self.betas = None self.neglog_exp_ref = None self.sum_neglog_exp_ref = 0.0 # used for Gaussian reference potential self.ref_sigma = None self.ref_mean = None self.neglog_gaussian_ref = None self.sum_neglog_gaussian_ref = 0.0 self.use_global_ref_sigma = use_global_ref_sigma self.sse = None # Storing the reference potential self.ref = ref # set sigma range self.dlogsigma = np.log(sigma[2]) self.sigma_min = sigma[0] self.sigma_max = sigma[1] self.allowed_sigma = np.exp(np.arange(np.log(self.sigma_min), np.log(self.sigma_max), self.dlogsigma)) self.sigma_index = int(len(self.allowed_sigma)/2) self.sigma = self.allowed_sigma[self.sigma_index] self.verbose = verbose def load_data(self, filename, As=""pickle""): """"""Load in the experimental restraints from many possible file formats. `More information about file formats \ `_ Args: filename(str): name of file to be loaded in memory As(str): file type from `pandas IO \ `_ Returns: pd.DataFrame """""" if self.verbose: print('Loading %s as %s...'%(filename,As)) df = getattr(pd, ""read_%s""%As) #TODO: Check all formats (e.g., from=""csv"") return df(filename) def add_restraint(self, restraint): """"""Append an experimental restraint object to the list. Args: restraint(object): :attr:`biceps.Restraint.Restraint` object """""" self.restraints.append(restraint) def compute_neglog_exp_ref(self): """"""Uses the stored beta information to compute \ :math:`-log P_{ref}(r_{j}(X_{i}))` over each structure\ :math:`X_{i}` and for each observable :math:`r_{j}`. """""" self.neglog_exp_ref = np.zeros(self.n) self.sum_neglog_exp_ref = 0.0 for j in range(self.n): self.neglog_exp_ref[j] = np.log(self.betas[j])\ + self.restraints[j]['model']/self.betas[j] self.sum_neglog_exp_ref += self.restraints[j]['weight'] * self.neglog_exp_ref[j] def compute_neglog_gaussian_ref(self): """"""An alternative option for reference potential based on Gaussian distribution. (Ignoring constant terms)"""""" self.neglog_gaussian_ref = np.zeros(self.n) self.sum_neglog_gaussian_ref = 0.0 for j in range(self.n): self.neglog_gaussian_ref[j] = np.log(np.sqrt(2.0*np.pi))\ + np.log(self.ref_sigma[j]) + (self.restraints[j]['model'] \ - self.ref_mean[j])**2.0/(2.0*self.ref_sigma[j]**2.0) self.sum_neglog_gaussian_ref += self.restraints[j]['weight'] * self.neglog_gaussian_ref[j] class Restraint_cs(Restraint): """"""A :attr:`biceps.Restraint.Restraint` child class for chemical shifts."""""" _ext = [""H"", ""Ca"", ""N""] def __repr__(self): if self.extension is not None: return ""<%s.Restraint_cs_%s>""%(str(__name__),str(self.extension)) else: pass def init_restraint(self, data, energy, extension=""H"", weight=1, file_fmt=""pickle"", verbose=False): """"""Initialize the chemical shift restraints for each experimental and theoretical observable given data. Args: data(str): filename of data energy(float): The (reduced) free energy of the conformation extensions(str): ""H"", ""Ca"", ""N"" weight(float): weight for restraint """""" self.extension = extension # The (reduced) free energy f = beta*F of this structure, as predicted by modeling self.energy = energy self.Ndof = None # Reading the data from loading in filenames data = self.load_data(data, As=file_fmt) self.n = len(data.values) # Group by keys keys = ['atom_index1', 'exp', 'model'] grouped_data = data[keys].to_dict() for row in range(len(grouped_data[keys[0]])): d = {key: grouped_data[key][row] for key in grouped_data.keys()} self.add_restraint(d) # N equivalent chemical shift should only get 1/N f the weight when #... computing chi^2 (not likely in this case but just in case we need it in the future) self.restraints[-1]['weight'] = weight #1.0/3.0 used in JCTC 2020 paper # default is N=1 self.sse = self.compute_sse(f=self.restraints) def compute_sse(self, f): """"""Returns the (weighted) sum of squared errors for chemical shift values."""""" N,sse = 0.0, 0.0 for i in range(self.n): err = f[i]['model'] - f[i]['exp'] sse += (f[i]['weight']*err**2.0) N += f[i]['weight'] self.Ndof = N return sse def compute_neglogP(self, parameters, parameter_indices, sse): """"""Computes :math:`-logP` for chemical shift during MCMC sampling. :math:`-ln P(X, \\sigma | D)=(N_{j}+1) \ln \sigma+\\chi^{2}(X) / 2 \\sigma^{2}-ln P(X) -ln Q_{ref}+(N_{j} / 2) ln 2 \pi + f_{i}`, where :math:`f_i` is the free energy of conformational state :math:`i` obtained from computational simulations and :math:`\\chi^{2}(X)` is the sum of squared errors and can be computed as following in practice as \ :math:`\\chi^{2}(X)=\sum_{j} w_{j}(r_{j}(X)-r_{j}^{\exp})^{2}` Args: parameters(list): collection of parameters for a given step of MCMC parameter_indices(list): collection of indices for a given step of MCMC sse(float): sum of squared errors :rtype: float """""" result = 0 # Use with log-spaced sigma values result += (self.Ndof)*np.log(parameters[0]) result += sse / (2.0*float(parameters[0])**2.0) result += (self.Ndof)/2.0*np.log(2.0*np.pi) # for normalization if self.ref == ""exponential"": result -= self.sum_neglog_exp_ref if self.ref == ""gaussian"": result -= self.sum_neglog_gaussian_ref return result class Restraint_J(Restraint): """"""A :attr:`biceps.Restraint.Restraint` child class for J coupling constant."""""" _ext = ['J'] def init_restraint(self, data, energy, extension=""J"", weight=1, file_fmt=""pickle"", verbose=False): """"""Initialize the sclar coupling constant restraints for each **exp** (experimental) and **model** (theoretical) observable given **data**. Args: data(str): filename of data energy(float): The (reduced) free energy of the conformation weight(float): weight for restraint """""" self.extension = extension # The (reduced) free energy f = beta*F of this structure, as predicted by modeling self.energy = energy self.Ndof = None # Reading the data from loading in filenames data = self.load_data(data, As=file_fmt) self.n = len(data.values) # Group by keys keys = ['atom_index1', 'atom_index2', 'atom_index3', 'atom_index4', 'exp', 'model', 'restraint_index'] grouped_data = data[keys].to_dict() for row in range(len(grouped_data[keys[0]])): d = {key: grouped_data[key][row] for key in grouped_data.keys()} self.add_restraint(d) self.equivalency_groups = {} # Compile equivalency_groups from the list of NMR_Dihedral() objects for i in range(len(self.restraints)): d = self.restraints[i] if d['restraint_index'] != None: if d['restraint_index'] not in self.equivalency_groups: self.equivalency_groups[d['restraint_index']] = [] self.equivalency_groups[d['restraint_index']].append(i) if verbose: print(f'grouped_data = {grouped_data}') print(f'self.restraints[0] = {self.restraints[0]}') print(f'self.equivalency_groups = {self.equivalency_groups}') # adjust the weights of distances and dihedrals to account for equivalencies self.adjust_weights() self.sse = self.compute_sse(f=self.restraints) def adjust_weights(self): """"""Adjust the weights of distance and dihedral restraints based on their equivalency group."""""" for group in list(self.equivalency_groups.values()): n = float(len(group)) for i in group: self.restraints[i]['weight'] = 1.0/n def compute_sse(self, f): """"""Returns the (weighted) sum of squared errors"""""" N,sse = 0.0, 0.0 for i in range(self.n): err = f[i]['model'] - f[i]['exp'] sse += (f[i]['weight']*err**2.0) N += f[i]['weight'] self.Ndof = N return sse def compute_neglogP(self, parameters, parameter_indices, sse): """"""Computes :math:`-logP` for scalar coupling constant during MCMC sampling. Args: parameters(list): collection of parameters for a given step of MCMC parameter_indices(list): collection of indices for a given step of MCMC sse(float): sum of squared errors :rtype: float """""" result = 0 # Use with log-spaced sigma values result += (self.Ndof)*np.log(parameters[0]) result += sse / (2.0*float(parameters[0])**2.0) result += (self.Ndof)/2.0*np.log(2.0*np.pi) # for normalization if self.ref == ""exponential"": result -= self.sum_neglog_exp_ref if self.ref == ""gaussian"": result -= self.sum_neglog_gaussian_ref return result class Restraint_noe(Restraint): _ext = ['noe'] def init_restraint(self, data, energy, extension=""noe"", weight=1, file_fmt=""pickle"", verbose=False, log_normal=False, gamma=[0.2, 10.0, 1.01]): """""" Initialize the NOE distance restraints for each experimental and theoretical observable given data. When :attr:`log_normal=True`, the modified sum of squared errors is used :math:`\chi_{d}^{2}(X)=\sum_{j} w_{j}( \ln ( r_{j}(X) / \gamma' r_{j}^{exp} ))^{2}` Args: data(str): filename of data energy(float): The (reduced) free energy :math:`f=\\beta*F` of the conformation weight(float): weight for restraint log_normal(bool): use log normal distribution gamma(list): [gamma_min, gamma_max, dgamma] in log space"""""" self.extension = extension # Store info about gamma^(-1/6) scaling parameter array self.dloggamma = np.log(gamma[2]) self.gamma_min = gamma[0] self.gamma_max = gamma[1] self.allowed_gamma = np.exp(np.arange(np.log(self.gamma_min), np.log(self.gamma_max), self.dloggamma)) self.gamma_index = int(len(self.allowed_gamma)/2) self.gamma = self.allowed_gamma[self.gamma_index] # Flag to use log-normal distance errors log(d/d0) self.log_normal = log_normal # The (reduced) free energy f = beta*F of this structure, as predicted by modeling self.energy = energy self.Ndof = None # Reading the data from loading in filenames data = self.load_data(data, As=file_fmt) self.n = len(data.values) # Group by keys keys = ['exp', 'model', 'restraint_index'] grouped_data = data[keys].to_dict() for row in range(len(grouped_data[keys[0]])): d = {key: grouped_data[key][row] for key in grouped_data.keys()} self.add_restraint(d) self.equivalency_groups = {} for i in range(len(self.restraints)): d = self.restraints[i] if d['restraint_index'] != None: if d['restraint_index'] not in self.equivalency_groups: self.equivalency_groups[d['restraint_index']] = [] self.equivalency_groups[d['restraint_index']].append(i) if verbose: print(f'grouped_data = {grouped_data}') #print(f'self.restraints[0] = {self.restraints[0]}') print(f'self.equivalency_groups = {self.equivalency_groups}') # adjust the weights of distances and dihedrals to account for equivalencies self.adjust_weights() self.sse = self.compute_sse(f=self.restraints) def adjust_weights(self): """"""Adjust the weights of distance and dihedral restraints based on their equivalency group."""""" for group in list(self.equivalency_groups.values()): n = float(len(group)) for i in group: self.restraints[i]['weight'] = 1.0/n def compute_sse(self, f): """"""Returns the (weighted) sum of squared errors"""""" _sse = np.array([0.0 for gamma in self.allowed_gamma]) for g in range(len(self.allowed_gamma)): N,sse = 0.0, 0.0 for i in range(self.n): gamma = self.allowed_gamma[g] #if self.use_log_normal_noe: if self.log_normal: err = np.log(f[i]['model']/(gamma*f[i]['exp'])) else: err = gamma*f[i]['exp'] - f[i]['model'] sse += (f[i]['weight'] * err**2.0) N += f[i]['weight'] _sse[g] = sse self.Ndof = N return _sse def compute_neglogP(self, parameters, parameter_indices, sse): """"""Computes :math:`-logP` for NOE during MCMC sampling. Args: parameters(list): collection of parameters for a given step of MCMC parameter_indices(list): collection of indices for a given step of MCMC sse(float): sum of squared errors :rtype: float """""" result = 0 # Use with log-spaced sigma values result += (self.Ndof)*np.log(parameters[0]) result += sse[int(parameter_indices[1])] / (2.0*parameters[0]**2.0) result += (self.Ndof)/2.0*np.log(2.0*np.pi) # for normalization if self.ref == ""exponential"": result -= self.sum_neglog_exp_ref if self.ref == ""gaussian"": result -= self.sum_neglog_gaussian_ref return result class Restraint_pf(Restraint): """"""A :attr:`biceps.Restraint.Restraint` child class for protection factor."""""" _ext = ['pf'] def init_restraint(self, data, energy, precomputed=False, pf_prior=None, Ncs_fi=None, Nhs_fi=None, beta_c=(0.05, 0.25, 0.01), beta_h=(0.0, 5.2, 0.2), beta_0=(-10.0, 0.0, 0.2), xcs=(5.0, 8.5, 0.5), xhs=(2.0, 2.7, 0.1), bs=(15.0, 16.0, 1.0), extension=""pf"", weight=1, file_fmt=""pickle"", states=None, verbose=False): """"""Initialize protection factor restraints for each **exp** (experimental) and **model** (theoretical) observable given **data**. Args: data(str): filename of data energy(float): The (reduced) free energy :math:`f=\\beta*F` of the conformation weight(float): weight for restraint beta_c(list): [min, max, spacing] beta_h(list): [min, max, spacing] beta_0(list): [min, max, spacing] xcs(list): [min, max, spacing] xhs(list): [min, max, spacing] bs(list): [min, max, spacing] """""" self.extension = extension # TODO: make more general... (there exists two sets of the same variables, see line 585) beta_c_min, beta_c_max, dbeta_c = beta_c[0], beta_c[1], beta_c[2] beta_h_min, beta_h_max, dbeta_h = beta_h[0], beta_h[1], beta_h[2] beta_0_min, beta_0_max, dbeta_0 = beta_0[0], beta_0[1], beta_0[2] xcs_min, xcs_max, dxcs = xcs[0], xcs[1], xcs[2] xhs_min, xhs_max, dxhs = xhs[0], xhs[1], xhs[2] bs_min, bs_max, dbs = bs[0], bs[1], bs[2] allowed_xcs=np.arange(xcs_min,xcs_max,dxcs) allowed_xhs=np.arange(xhs_min,xhs_max,dxhs) allowed_bs=np.arange(bs_min,bs_max,dbs) Ncs=np.zeros((len(allowed_xcs),len(allowed_bs),107)) Nhs=np.zeros((len(allowed_xhs),len(allowed_bs),107)) for i in range(len(states)): for o in range(len(allowed_xcs)): for q in range(len(allowed_bs)): infile_Nc='%s/Nc_x%0.1f_b%d_state%03d.npy'%(Ncs_fi, allowed_xcs[o], allowed_bs[q],states[i]) Ncs[o,q,:] = (np.load(infile_Nc)) for p in range(len(allowed_xhs)): for q in range(len(allowed_bs)): infile_Nh='%s/Nh_x%0.1f_b%d_state%03d.npy'%(Nhs_fi, allowed_xhs[p], allowed_bs[q],states[i]) Nhs[p,q,:] = (np.load(infile_Nh)) # The (reduced) free energy f = beta*F of this structure, as predicted by modeling self.energy = energy self.Ndof = None self.precomputed = precomputed # load pf priors from training model if pf_prior is not None: self.pf_prior = np.load(pf_prior) if not self.precomputed: self.Ncs = Ncs self.Nhs = Nhs self.dbeta_c = dbeta_c self.beta_c_min = beta_c_min self.beta_c_max = beta_c_max self.allowed_beta_c = np.arange(self.beta_c_min, self.beta_c_max, self.dbeta_c) self.dbeta_h = dbeta_h self.beta_h_min = beta_h_min self.beta_h_max = beta_h_max self.allowed_beta_h = np.arange(self.beta_h_min, self.beta_h_max, self.dbeta_h) self.dbeta_0 = dbeta_0 self.beta_0_min = beta_0_min self.beta_0_max = beta_0_max self.allowed_beta_0 = np.arange(self.beta_0_min, self.beta_0_max, self.dbeta_0) self.dxcs = dxcs self.xcs_min = xcs_min self.xcs_max = xcs_max self.allowed_xcs = np.arange(self.xcs_min, self.xcs_max, self.dxcs) self.dxhs = dxhs self.xhs_min = xhs_min self.xhs_max = xhs_max self.allowed_xhs = np.arange(self.xhs_min, self.xhs_max, self.dxhs) self.dbs = dbs self.bs_min = bs_min self.bs_max = bs_max self.allowed_bs = np.arange(self.bs_min, self.bs_max, self.dbs) self.beta_c_index = int(len(self.allowed_beta_c)/2) self.beta_c = self.allowed_beta_c[self.beta_c_index] self.beta_h_index = int(len(self.allowed_beta_h)/2) self.beta_h = self.allowed_beta_h[self.beta_h_index] self.beta_0_index = int(len(self.allowed_beta_0)/2) self.beta_0 = self.allowed_beta_0[self.beta_0_index] self.xcs_index = int(len(self.allowed_xcs)/2) self.xcs = self.allowed_xcs[self.xcs_index] self.xhs_index = int(len(self.allowed_xhs)/2) self.xhs = self.allowed_xhs[self.xhs_index] self.bs_index = int(len(self.allowed_bs)/2) self.bs = self.allowed_bs[self.bs_index] # Reading the data from loading in filenames data = self.load_data(data, As=file_fmt) self.n = len(data.values) # Group by keys if self.precomputed: keys = ['atom_index1', 'exp', 'model'] else: keys = ['atom_index1', 'exp'] grouped_data = data[keys].to_dict() if not self.precomputed: for row in range(len(grouped_data[keys[0]])): d = {key: grouped_data[key][row] for key in grouped_data.keys()} d['model'] = self.compute_PF_multi(self.Ncs[:,:,row], self.Nhs[:,:,row], debug=False) self.add_restraint(d) self.restraints[-1]['weight'] = weight else: for row in range(len(grouped_data[keys[0]])): d = {key: grouped_data[key][row] for key in grouped_data.keys()} self.add_restraint(d) self.restraints[-1]['weight'] = weight self.sse = self.compute_sse(f=self.restraints) def compute_sse(self, f): """"""Returns the (weighted) sum of squared errors"""""" N,sse = 0.0, 0.0 if self.precomputed: for i in range(self.n): err = f[i]['model'] - f[i]['exp'] sse += (f[i]['weight']*err**2.0) N += f[i]['weight'] self.Ndof = N else: sse = np.zeros( (len(self.allowed_beta_c), len(self.allowed_beta_h), len(self.allowed_beta_0), len(self.allowed_xcs), len(self.allowed_xhs), len(self.allowed_bs)) ) self.Ndof = 0. for i in range(self.n): err = f[i]['model'] - f[i]['exp'] sse += (f[i]['weight'] * err**2.0) self.Ndof += f[i]['weight'] return sse def compute_PF(self, beta_c, beta_h, beta_0, Nc, Nh): """"""Calculate predicted (ln PF) Args: beta_c,beta_h,Nc,Nh(np.ndarray): shape(nres, 2)\ array with columns and for each residue Returns: np.ndarray: `` = beta_c + beta_h + beta_0 for all residues`` """""" return beta_c * Nc + beta_h * Nh + beta_0 #GYH: new equation for PF calculation 03/2017 ''' def compute_PF_multi(self, Ncs_i, Nhs_i, debug=False): """"""Calculate predicted (ln PF) .. tip:: A near future application... Args: Ncs_i,Nhs_i(np.ndarray, np.ndarray): array with columns and\ for each residue Returns: np.ndarray: `` = beta_c + beta_h + beta_0 for all residues`` """""" N_beta_c = len(self.allowed_beta_c) N_beta_h = len(self.allowed_beta_h) N_beta_0 = len(self.allowed_beta_0) N_xc = len(self.allowed_xcs) N_xh = len(self.allowed_xhs) N_b = len(self.allowed_bs) nuisance_shape = (N_beta_c, N_beta_h, N_beta_0, N_xc, N_xh, N_b) beta_c = self.tile_multiaxis(self.allowed_beta_c, nuisance_shape, axis=0) beta_h = self.tile_multiaxis(self.allowed_beta_h, nuisance_shape, axis=1) beta_0 = self.tile_multiaxis(self.allowed_beta_0, nuisance_shape, axis=2) Nc = self.tile_2D_multiaxis(Ncs_i, nuisance_shape, axes=[3,5]) Nh = self.tile_2D_multiaxis(Nhs_i, nuisance_shape, axes=[4,5]) if debug: print('nuisance_shape', nuisance_shape) print('beta_c.shape', beta_c.shape) print('beta_h.shape', beta_h.shape) print('beta_0.shape', beta_0.shape) print('Nc.shape', Nc.shape) print('Nh.shape', Nh.shape) return beta_c * Nc + beta_h * Nh + beta_0 def tile_multiaxis(self, p, shape, axis=None): """"""Returns a multi-dimensional array of shape (tuple), with the 1D vector p along the specified axis, and tiled in all other dimensions. .. tip:: A near future application... Args: p(np.ndarray): a 1D array to tile shape(tuple): a tuple describing the shape of the returned array axis: the specified axis for p . NOTE: len(p) must be equal to shape[axis] """""" assert shape[axis] == len(p), ""len(p) must be equal to shape[axis]!"" otherdims = [shape[i] for i in range(len(shape)) if i!=axis] result = np.tile(p, tuple(otherdims+[1])) last_axis = len(result.shape)-1 result2 = np.rollaxis(result, last_axis, axis) return result2 def tile_2D_multiaxis(self, q, shape, axes=None): """"""Returns a multi-dimensional array of shape (tuple), with the 2D vector p along the specified axis and tiled in all other dimensions. .. tip:: A near future application... Args: p(np.ndarray): a 1D array to tile shape(tuple): a tuple describing the shape of the returned array axis: the specified axis for p . NOTE: len(p) must be equal to shape[axis] """""" assert (shape[axes[0]],shape[axes[1]]) == q.shape, ""q.shape must be equal to (shape[axes[0]],shape[axes[1]])"" otherdims = [shape[i] for i in range(len(shape)) if i not in axes] result = np.tile(q, tuple(otherdims+[1,1])) last_axis = len(result.shape)-1 next_last_axis = len(result.shape)-2 result2 = np.rollaxis(result, next_last_axis, axes[0]) return np.rollaxis( result2, last_axis, axes[1]) def compute_neglog_exp_ref_pf(self): self.neglog_exp_ref= np.zeros((self.n, len(self.allowed_beta_c), len(self.allowed_beta_h), len(self.allowed_beta_0), len(self.allowed_xcs), len(self.allowed_xhs), len(self.allowed_bs))) self.sum_neglog_exp_ref = 0. for j in range(self.n): # number of residues self.neglog_exp_ref[j] = np.maximum(-1.0*self.restraints[j]['model'], 0.0) self.sum_neglog_exp_ref += self.restraints[j]['weight'] * self.neglog_exp_ref[j] def compute_neglog_gaussian_ref_pf(self): self.neglog_gaussian_ref = np.zeros((self.n, len(self.allowed_beta_c), len(self.allowed_beta_h), len(self.allowed_beta_0), len(self.allowed_xcs), len(self.allowed_xhs), len(self.allowed_bs))) self.sum_neglog_gaussian_ref = 0. for j in range(self.n): # number of residues self.neglog_gaussian_ref[j] = 0.5 * np.log(2.0*np.pi) + np.log(self.ref_sigma[j]) \ + (self.restraints[j]['model'] - self.ref_mean[j])**2.0/(2.0*self.ref_sigma[j]**2.0) self.sum_neglog_gaussian_ref += self.restraints[j]['weight'] * self.neglog_gaussian_ref[j] def compute_neglogP(self, parameters, parameter_indices, sse): """"""Computes :math:`-logP` for protection factor during MCMC sampling. Args: parameters(list): collection of parameters for a given step of MCMC parameter_indices(list): collection of indices for a given step of MCMC sse(float): sum of squared errors :rtype: float """""" result = 0 # Use with log-spaced sigma values result += (self.Ndof)*np.log(parameters[0]) if not self.precomputed: result += sse[int(parameter_indices[1])][int(parameter_indices[2])][int(parameter_indices[3])][int(parameter_indices[4])][int(parameter_indices[5])][int(parameter_indices[6])] / (2.0*parameters[0]**2.0) if self.pf_prior is not None: result += self.pf_prior[int(parameter_indices[1])][int(parameter_indices[2])][int(parameter_indices[3])][int(parameter_indices[4])][int(parameter_indices[5])][int(parameter_indices[6])] else: result += sse / (2.0*float(parameters[0])**2.0) result += (self.Ndof)/2.0*np.log(2.0*np.pi) # for normalization # Which reference potential was used for each restraint? if self.ref == ""exponential"": if isinstance(self.sum_neglog_exp_ref, float): result -= self.sum_neglog_exp_ref else: result -= self.sum_neglog_exp_ref[int(parameter_indices[1])][int(parameter_indices[2])][int(parameter_indices[3])][int(parameter_indices[4])][int(parameter_indices[5])][int(parameter_indices[6])] if self.ref == ""gaussian"": if isinstance(self.sum_neglog_gaussian_ref, float): result -= self.sum_neglog_gaussian_ref else: result -= self.sum_neglog_gaussian_ref[int(parameter_indices[1])][int(parameter_indices[2])][int(parameter_indices[3])][int(parameter_indices[4])][int(parameter_indices[5])][int(parameter_indices[6])] return result class Preparation(object): def __init__(self, nstates=0, top_file=None, outdir=None): """"""A class to prepare **input_data** for the :attr:`biceps.Ensemble.initialize_restraints` method. Args: nstates(int): number of conformational states top_file(str): relative path to the structure topology file outdir(str): relative path for output files """""" self.nstates = nstates if top_file != None: self.topology = md.load(top_file).topology else: self.topology = None self.outdir = outdir def to_sorted_list(self): """"""Uses ``biceps.toolbox.sort_data()`` to return sorted list of **input_data**."""""" return biceps.toolbox.sort_data(self.outdir) def write_DataFrame(self, filename, As=""pickle"", verbose=False): """"""Write Pandas DataFrame **As** user specified filetype. `More information about file formats \ `_ Args: filename(str): name of file to be loaded in memory As(str): file type from `pandas IO \ `_ Returns: pd.DataFrame """""" #biceps.toolbox.mkdir(self.outdir) #columns = { self.keys[i] : self.header[i] for i in range(len(self.keys)) } if verbose: print('Writing %s as %s...'%(filename,As)) df = pd.DataFrame(self.biceps_df) #dfOut = getattr(self.df.rename(columns=columns), ""to_%s""%As) dfOut = getattr(df, ""to_%s""%As) dfOut(filename) def prepare_cs(self, exp_data, model_data, indices, extension, write_as=""pickle"", verbose=False): """"""A method for preprocessing chemicalshift **exp_data** and **model_data**. Args: exp_data(list,str): experimental data, path to experimental data file (units: ppm) model_data(list,str): model data, path to model data file (units: ppm) indices(list,str): indices, path to atom indices extension(str): nuclei for the CS data (""H"" or ""Ca or ""N"") """""" #self.header = ('exp', 'exp err', 'model', 'restraint_index', 'atom_index1', 'res1', self.header = ('exp', 'model', 'restraint_index', 'atom_index1', 'res1', 'atom_name1', ) self.ind = biceps.toolbox.check_indices(indices) self.exp_data = biceps.toolbox.check_exp_data(exp_data) self.model_data = biceps.toolbox.check_model_data(model_data) if int(len(self.model_data)) != int(self.nstates): raise ValueError(""The number of states doesn't equal to file numbers"") if self.ind.shape[0] != self.exp_data.shape[0]: raise ValueError('The number of atom pairs (%d) does not match the number of restraints (%d)! Exiting.'%(self.ind.shape[0],self.exp_data.shape[0])) for j in range(len(self.model_data)): dd = { self.header[i]: [] for i in range(len(self.header)) } if type(self.model_data[j]) == str: model_data = np.loadtxt(self.model_data[j]) else: model_data = self.model_data[j] for i in range(self.ind.shape[0]): a1 = int(self.ind[i]) dd['atom_index1'].append(a1) if self.topology != None: dd['res1'].append(str([atom.residue for atom in self.topology.atoms if atom.index == a1][0])) dd['atom_name1'].append(str([atom.name for atom in self.topology.atoms if atom.index == a1][0])) else: dd.pop('res1', None) dd.pop('atom_name1', None) dd['restraint_index'].append(int(self.exp_data[i,0])) dd['exp'].append(np.float64(self.exp_data[i,1])) #if exp_err.shape[1] > 1: dd['exp err'].append(np.float64(self.exp_data[i,2])) dd['model'].append(np.float64(model_data[i])) self.biceps_df = pd.DataFrame(dd) if verbose: print(self.biceps_df) filename = ""%s.cs_%s""%(j, extension) if self.outdir: self.write_DataFrame(filename=os.path.join(self.outdir,filename), As=write_as, verbose=verbose) def prepare_noe(self, exp_data, model_data, indices, extension=None, write_as=""pickle"", verbose=False): """"""A method for preprocessing NOE **exp_data** and **model_data**. Args: exp_data(list,str): experimental data, path to experimental data file (units: :math:`Å`) model_data(list,str): model data, path to model data file (units: :math:`Å`) indices(list,str): indices, path to atom indices extension(str): nuclei for the CS data (""H"" or ""Ca or ""N"") """""" self.header = ('exp', 'model', 'restraint_index', 'atom_index1', 'res1', 'atom_name1', 'atom_index2', 'res2', 'atom_name2', ) self.ind = biceps.toolbox.check_indices(indices) self.exp_data = biceps.toolbox.check_exp_data(exp_data) self.model_data = biceps.toolbox.check_model_data(model_data) if int(len(self.model_data)) != int(self.nstates): raise ValueError(""The number of states doesn't equal to file numbers"") if self.ind.shape[0] != self.exp_data.shape[0]: raise ValueError('The number of atom pairs (%d) does not match the number of restraints (%d)! Exiting.'%(self.ind.shape[0],self.exp_data.shape[0])) for j in range(len(self.model_data)): dd = { self.header[i]: [] for i in range(len(self.header)) } if type(self.model_data[j]) == str: model_data = np.loadtxt(self.model_data[j]) else: model_data = self.model_data[j] for i in range(self.ind.shape[0]): a1, a2 = int(self.ind[i,0]), int(self.ind[i,1]) dd['atom_index1'].append(a1) dd['atom_index2'].append(a2) if self.topology != None: dd['res1'].append(str([atom.residue for atom in self.topology.atoms if atom.index == a1][0])) dd['atom_name1'].append(str([atom.name for atom in self.topology.atoms if atom.index == a1][0])) dd['res2'].append(str([atom.residue for atom in self.topology.atoms if atom.index == a2][0])) dd['atom_name2'].append(str([atom.name for atom in self.topology.atoms if atom.index == a2][0])) else: dd.pop('res1', None) dd.pop('atom_name1', None) dd.pop('res2', None) dd.pop('atom_name2', None) dd['restraint_index'].append(int(self.exp_data[i,0])) dd['exp'].append(np.float64(self.exp_data[i,1])) #if exp_err.shape[1] > 1: dd['exp err'].append(np.float64(self.exp_data[i,2])) dd['model'].append(np.float64(model_data[i])) self.biceps_df = pd.DataFrame(dd) if verbose: print(self.biceps_df) filename = ""%s.noe""%(j) if self.outdir: self.write_DataFrame(os.path.join(self.outdir,filename), As=write_as, verbose=verbose) def prepare_J(self, exp_data, model_data, indices, extension=None, write_as=""pickle"", verbose=False): """"""A method for preprocessing scalar coupling **exp_data** and **model_data**. Args: exp_data(list,str): experimental data, path to experimental data file (units: Hz) model_data(list,str): model data, path to model data file (units: Hz) indices(list,str): indices, path to atom indices extension(str): nuclei for the CS data (""H"" or ""Ca or ""N"") """""" self.header = ('exp', 'model', 'restraint_index', 'atom_index1', 'res1', 'atom_name1', 'atom_index2', 'res2', 'atom_name2', 'atom_index3', 'res3', 'atom_name3', 'atom_index4', 'res4', 'atom_name4', ) self.ind = biceps.toolbox.check_indices(indices) self.exp_data = biceps.toolbox.check_exp_data(exp_data) self.model_data = biceps.toolbox.check_model_data(model_data) if int(len(self.model_data)) != int(self.nstates): raise ValueError(""The number of states doesn't equal to file numbers"") if self.ind.shape[0] != self.exp_data.shape[0]: raise ValueError('The number of atom pairs (%d) does not match the number of restraints (%d)! Exiting.'%(self.ind.shape[0],self.exp_data.shape[0])) for j in range(len(self.model_data)): dd = { self.header[i]: [] for i in range(len(self.header)) } if type(self.model_data[j]) == str: model_data = np.loadtxt(self.model_data[j]) else: model_data = self.model_data[j] for i in range(self.ind.shape[0]): a1, a2, a3, a4 = int(self.ind[i,0]), int(self.ind[i,1]), int(self.ind[i,2]), int(self.ind[i,3]) dd['atom_index1'].append(a1);dd['atom_index2'].append(a2) dd['atom_index3'].append(a3);dd['atom_index4'].append(a4) if self.topology != None: dd['res1'].append(str([atom.residue for atom in self.topology.atoms if atom.index == a1][0])) dd['atom_name1'].append(str([atom.name for atom in self.topology.atoms if atom.index == a1][0])) dd['res2'].append(str([atom.residue for atom in self.topology.atoms if atom.index == a2][0])) dd['atom_name2'].append(str([atom.name for atom in self.topology.atoms if atom.index == a2][0])) dd['res3'].append(str([atom.residue for atom in self.topology.atoms if atom.index == a3][0])) dd['atom_name3'].append(str([atom.name for atom in self.topology.atoms if atom.index == a3][0])) dd['res4'].append(str([atom.residue for atom in self.topology.atoms if atom.index == a4][0])) dd['atom_name4'].append(str([atom.name for atom in self.topology.atoms if atom.index == a4][0])) else: dd.pop('res1', None) dd.pop('atom_name1', None) dd.pop('res2', None) dd.pop('atom_name2', None) dd.pop('res3', None) dd.pop('atom_name3', None) dd.pop('res4', None) dd.pop('atom_name4', None) dd['restraint_index'].append(int(self.exp_data[i,0])) dd['exp'].append(np.float64(self.exp_data[i,1])) #if exp_err.shape[1] > 1: dd['exp err'].append(np.float64(self.exp_data[i,2])) dd['model'].append(np.float64(model_data[i])) self.biceps_df = pd.DataFrame(dd) if verbose: print(self.biceps_df) filename = ""%s.J""%(j) if self.outdir: self.write_DataFrame(os.path.join(self.outdir,filename), As=write_as, verbose=verbose) def prepare_pf(self, exp_data, model_data=None, indices=None, extension=None, write_as=""pickle"", verbose=False): """"""A method for preprocessing HDX protection factor **exp_data** and **model_data**. Args: exp_data(list,str): experimental data, path to experimental data file (units: Hz) model_data(list,str): model data, path to model data file (units: Hz) indices(list,str): indices, path to atom indices extension(str): """""" if model_data: self.header = ('exp','model', 'restraint_index', 'atom_index1', 'res1', ) else: self.header = ('exp', 'restraint_index', 'atom_index1', 'res1',) self.ind = biceps.toolbox.check_indices(indices) self.exp_data = biceps.toolbox.check_exp_data(exp_data) self.model_data = biceps.toolbox.check_model_data(model_data) if int(len(self.model_data)) != int(self.nstates): raise ValueError(""The number of states doesn't equal to file numbers"") if self.ind.shape[0] != self.exp_data.shape[0]: raise ValueError('The number of atom pairs (%d) does not match the\ number of restraints (%d)! Exiting.'%(self.ind.shape[0],self.exp_data.shape[0])) for j in range(len(self.model_data)): dd = { self.header[i]: [] for i in range(len(self.header)) } if type(self.model_data[j]) == str: model_data = np.loadtxt(self.model_data[j]) else: model_data = self.model_data[j] for i in range(self.ind.shape[0]): a1 = int(self.ind[i,0]) dd['atom_index1'].append(a1) if self.topology != None: dd['res1'].append(str([atom.residue for atom in self.topology.atoms if atom.index == a1][0])) dd['atom_name1'].append(str([atom.name for atom in self.topology.atoms if atom.index == a1][0])) else: dd.pop('res1', None) dd.pop('atom_name1', None) dd['restraint_index'].append(int(self.exp_data[i,0])) dd['exp'].append(np.float64(self.exp_data[i,1])) #if exp_err.shape[1] > 1: dd['exp err'].append(np.float64(self.exp_data[i,2])) if model_data: dd['model'].append(np.float64(model_data[i])) self.biceps_df = pd.DataFrame(dd) if verbose: print(self.biceps_df) filename = ""%s.pf""%(j) if self.outdir: self.write_DataFrame(os.path.join(self.outdir,filename), As=write_as, verbose=verbose) if __name__ == ""__main__"": import doctest doctest.testmod() ","Python" "Conformation","vvoelz/biceps","biceps/KarplusRelation.py",".py","5281","182","import numpy as np """"""Note that this code has been adapted from MDTraj: A Python Library for Loading, Saving, and Manipulating Molecular Dynamics Trajectories. Copyright 2012-2014 Stanford University and the Authors Authors: Kyle A. Beauchamp Contributors: Robert McGibbon, TJ Lane, Osama El-Gabalawy https://github.com/mdtraj/mdtraj/blob/master/mdtraj/nmr/scalar_couplings.py """""" class KarplusRelation(object): """""" A class containing formulae giving J-coupling values from dihedral angle."""""" def __init__(self): """"""Initialize the KarplusRelation class."""""" pass def J(self, angle, key): """"""Returns the predicted J-coupling constant given an angle in degrees, and a key e.g., 'Karplus_HH'"""""" if key == 'Karplus_HH': return self.Karplus_HH(angle) elif key == 'BothnerBy_HH': return self.BothnerBy_HH(angle) elif key == 'Allylic': return self.Allylic(angle) elif key == 'Karplus_antiperiplanar_O': return self.Karplus_HH_appO(angle) else: print(""%s is not an appropriate Karplus key...""%key) def Karplus_HH(self, angle): """"""Returns predicted J-coupling constant given an angle in degrees."""""" if np.abs(angle) < 90.0: J0 = 10.0 else: J0 = 14.0 # Convert to radians theta = angle*np.pi/180.0 return J0*(np.cos(theta))**2 def Karplus_HH_appO(self, angle): """"""Returns predicted J-coupling constant given an angle in degrees, for sp3-single bond HH where there is an antiperiplanar Oxygen"""""" if np.abs(angle) < 90.0: J0 = 8.0 else: J0 = 11.0 # Convert to radians theta = angle*np.pi/180.0 return J0*(np.cos(theta))**2 def Allylic(self, angle): """"""Returns predicted J-coupling constant given an angle in degrees, for an allylic sp3-sp2 bond"""""" if np.abs(angle) < 90.0: J0 = 6.6 else: J0 = 11.6 # Convert to radians theta = angle*np.pi/180.0 return J0*(np.cos(theta))**2 + 2.6*(np.sin(theta))**2 def BothnerBy_HH(self, angle): """"""Returns predicted J-coupling constant given an angle in degrees. NOTES: good for cycloalkanes. Bothner-By, 1965 (14)"""""" # Convert to radians theta = angle*np.pi/180.0 return 7.0 - np.cos(theta) + 5.0*np.cos(2.0*theta) def Altona_HH(self, angle): """""" NOTES: From: http://janocchio.sourceforge.net/janocchio.docbook/ch04s03.html Altona is good if the protons are attached to two sp3 carbons. This equation takes into account the electronegativity of all adjacent atoms. Haasnoot, C., de Leeuw, FA, Altona, C (1980). Tetrahedron 36(19), 2783-2792 """""" # This is really complicated -- you have to know the electronegativities of substituents # TBA pass def Karplus2_HH(self, angle): """"""Returns predicted J-coupling constant given an angle in degrees. NOTES: A simple Karplus relation from the Janocchio documentation. Magnetic Resonance in Chemistry, 45(7), 595-600. doi:10.1002/mrc/2016 """""" if np.abs(angle) < 90.0: J0 = 8.5 else: J0 = 9.5 # Convert to radians theta = angle*np.pi/180.0 return J0*(np.cos(theta)**2) - 0.28 def Wasylichen_HC(self, angle): """"""Returns predicted J-coupling constant given an angle in degrees. NOTES: Recommended for general use (Can J Chem (1973) 51 961.) See also Janocchio paper"""""" # Convert to radians theta = angle*np.pi/180.0 return 3.56*np.cos(2.0*theta) - np.cos(theta) + 4.26 def Tvaroska_HC(self, angle): """"""Returns predicted J-coupling constant given an angle in degrees. NOTES: Adv. Carbohydrate Chem. Biochem. (1995) 51, 15-61 See also Janocchio paper"""""" # Convert to radians theta = angle*np.pi/180.0 return 4.5 - 0.87*np.cos(theta) + np.cos(2.0*theta) def Aydin_HC(self, angle): """"""Returns predicted J-coupling constant given an angle in degrees. NOTES: Mag. Res. Chem. (1990) 28, 448-457 See also Janocchio paper"""""" # Convert to radians theta = angle*np.pi/180.0 return 5.8*(np.cos(theta))**2 -1.6*np.cos(theta) + 0.28*np.sin(2.0*theta) + 0.52 if __name__ == '__main__': # Perform a scan of all the Karplus relations from matplotlib import pyplot as plt karplus = KarplusRelation() angles = np.arange(-180,180,1.0) results = [] results.append( [karplus.Karplus_HH(a) for a in angles] ) results.append( [karplus.BothnerBy_HH(a) for a in angles] ) results.append( [karplus.Karplus2_HH(a) for a in angles] ) plt.figure() for result in results: plt.plot(angles, result) plt.hold(True) plt.xlim(0,180) plt.ylim(-2, 16) plt.yticks(list(range(16))) plt.legend(['Karplus', 'Bothner-By', 'Karplus2'], 'upper left') plt.xlabel('angle (degrees)') plt.ylabel('$^3 J_{HH}$') plt.savefig('karplus_relation_test.png') ","Python" "Conformation","vvoelz/biceps","biceps/__init__.py",".py","848","27","#!/usr/bin/env python __version__= ""2.0"" HEADER=""""""BICePs - Bayesian Inference of Conformational Populations, Version %s""""""%(__version__) print(HEADER) name = ""biceps"" from biceps.Restraint import Preparation from biceps.Restraint import Ensemble from biceps.Restraint import get_restraint_options #from biceps.Restraint import Restraint_cs #from biceps.Restraint import Restraint_J #from biceps.Restraint import Restraint_noe #from biceps.Restraint import Restraint_pf from biceps.PosteriorSampler import PosteriorSampler from biceps.PosteriorSampler import PosteriorSamplingTrajectory from biceps.Analysis import Analysis from biceps.Analysis import find_all_state_sampled_time from biceps.convergence import Convergence import biceps.toolbox from biceps.decorators import multiprocess import biceps.J_coupling import biceps.KarplusRelation ","Python" "Conformation","vvoelz/biceps","biceps/Analysis.py",".py","20093","441","# -*- coding: utf-8 -*- import os, glob import numpy as np import pickle from pymbar import MBAR from pymbar.utils import kln_to_kn from .Restraint import * from .PosteriorSampler import * from .toolbox import get_files import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt import string def find_all_state_sampled_time(trace, nstates, verbose=True): """"""Determine which states were sampled and the states with zero counts. Args: trace(np.ndarray): trajectory trace nstates(int): number of states """""" frac = [] all_states = np.zeros(nstates) init = 0 while 0 in all_states: if init == len(trace): if verbose: print('not all state sampled, these states', np.where(all_states == 0)[0],'are not sampled') return 'null', frac else: all_states[trace[init]] += 1 frac.append(float(len(np.where(all_states!=0)[0]))/float(nstates)) init += 1 return init, frac class Analysis(object): def __init__(self, outdir, nstates=0, precheck=True, BSdir='BS.dat', popdir='populations.dat', picfile='BICePs.pdf', verbose=False): """"""A class to perform analysis and plot figures. Args: nstates(int): number of conformational states trajs(str): relative path to glob '*.npz' trajectories (analysis files and figures will be placed inside this directory) precheck(bool): find the all the states that haven't been sampled if any BSdir(str): relative path for BICePs score file name popdir(str): relative path for BICePs reweighted populations file name picfile(str): relative path for BICePs figure """""" self.verbose = verbose self.resultdir = outdir self.trajs = os.path.join(outdir,""*.npz"") self.BSdir = os.path.join(self.resultdir,BSdir) self.popdir = os.path.join(self.resultdir,popdir) self.picfile = os.path.join(self.resultdir,picfile) self.scheme = None self.traj = [] self.sampler = [] self.lam = None self.f_df = None self.P_dp = None self.precheck = precheck self.nstates = nstates if self.nstates == 0: raise ValueError(""State number cannot be zero."") # next get MABR sampling done self.MBAR_analysis() def load_data(self): """"""Load input data from BICePs sampling (*npz and *pkl files)."""""" # Load in npz trajectories files = get_files(self.trajs) for file in files: if self.verbose: print('Loading %s ...'%file) traj = np.load(file, allow_pickle=True)['arr_0'].item() self.traj.append(traj) self.nreplicas = len(traj['trajectory'][0][3]) if self.precheck: steps = [] fractions = [] for i in range(len(self.traj)): s,f = find_all_state_sampled_time(self.traj[i]['state_trace'],self.nstates) steps.append(s) fractions.append(f) total_fractions = np.concatenate(fractions) if 1. in total_fractions: plt.figure() for i in range(len(fractions)): plt.plot(list(range(len(fractions[i]))),fractions[i],label = r'$\lambda_{%s}$'%i) plt.xlabel('steps') plt.ylabel('fractions') plt.legend(loc='best') plt.savefig(os.path.join(self.resultdir,'fractions.pdf')) #else: # print('Error: Not all states are sampled in any of the lambda values') # exit() # Load in cpickled sampler objects #sampler_files = get_files(self.trajs.replace('.npz','.pkl')) sampler_files = [file.replace('.npz','.pkl') for file in files] for pkl_filename in sampler_files: if self.verbose: print('Loading %s ...'%pkl_filename) pkl_file = open(pkl_filename, 'rb') self.sampler.append( pickle.load(pkl_file) ) # parse the lambda* filenames to get the full list of lambdas self.nlambda = len(files) self.lam = [float( (s.split('lambda')[1]).replace('.npz','') ) for s in files ] if self.verbose: print('lam =', self.lam) self.scheme = self.traj[0]['rest_type'] def get_max_likelihood_parameters(self, model=0, sigma_only=False): #nParameters = self.nstates + len(self.scheme) if sigma_only: indices = [i for i,rest in enumerate(self.scheme) if ""sigma"" in rest] else: indices = [i for i,rest in enumerate(self.scheme)] t1 = self.traj[model] max_likelihood = {} for k in indices: x, y = t1['allowed_parameters'][k], t1['sampled_parameters'][k] max_likelihood[self.scheme[k]] = [x[np.argmax(y)]] max_likelihood = pd.DataFrame(max_likelihood) return max_likelihood def MBAR_analysis(self, debug=False): """"""MBAR analysis for populations and BICePs score"""""" # load necessary data first self.load_data() # Suppose the energies sampled from each simulation are u_kln, where u_kln[k,l,n] is the reduced potential energy # of snapshot n \in 1,...,N_k of simulation k \in 1,...,K evaluated at reduced potential for state l. self.K = self.nlambda # number of thermodynamic ensembles # N_k[k] will denote the number of correlated snapshots from state k N_k = np.array( [len(self.traj[i]['trajectory']) for i in range(self.nlambda)] ) nsnaps = N_k.max() u_kln = np.zeros( (self.K, self.K, nsnaps) ) nstates = self.nstates if self.verbose: print('nstates', nstates) states_kn = np.zeros( (self.K, nsnaps, self.nreplicas) ) # special treatment for neglogP function temp_parameters_indices = self.traj[0]['trajectory'][0][4:][0] #print temp_parameters_indices original_index =[] # keep tracking the original index of the parameters for ind in range(len(temp_parameters_indices)): for in_ind in temp_parameters_indices[ind]: original_index.append(ind) # Get snapshot energies rescored in the different ensembles """"""['step', 'E', 'accept', 'state', [nuisance parameters]]"""""" for n in range(nsnaps): for k in range(self.K): for l in range(self.K): if debug: print('step', self.traj[k]['trajectory'][n][0], end=' ') if k==l: u_kln[k,k,n] = self.traj[k]['trajectory'][n][1] else: state, sigma_index = self.traj[k]['trajectory'][n][3:] for r in range(self.nreplicas): states_kn[k,n,r] = state[r] temp_parameters = [] new_parameters=[[] for i in range(len(temp_parameters_indices))] temp_parameter_indices = np.concatenate(sigma_index) for ind in range(len(temp_parameter_indices)): temp_parameters.append(self.traj[k]['allowed_parameters'][ind][temp_parameter_indices[ind]]) for m in range(len(original_index)): new_parameters[original_index[m]].append(temp_parameters[m]) u_kln[k,l,n] = self.sampler[l].neglogP(state, new_parameters, sigma_index) if debug: print('E_%d evaluated in model_%d'%(k,l), u_kln[k,l,n]) # self.u_kln, self.N_k, self.states_kn = u_kln, N_k, states_kn stime = time.time() # Initialize MBAR with reduced energies u_kln and number of uncorrelated configurations from each state N_k. # u_kln[k,l,n] is the reduced potential energy beta*U_l(x_kn), where U_l(x) is the potential energy function for state l, # beta is the inverse temperature, and and x_kn denotes uncorrelated configuration n from state k. # N_k[k] is the number of configurations from state k stored in u_knm # Note that this step may take some time, as the relative dimensionless free energies f_k are determined at this point. mbar = MBAR(self.u_kln, self.N_k) # Extract dimensionless free energy differences and their statistical uncertainties. # (Deltaf_ij, dDeltaf_ij) = mbar.getFreeEnergyDifferences() #(Deltaf_ij, dDeltaf_ij, Theta_ij) = mbar.getFreeEnergyDifferences(uncertainty_method='svd-ew') # NOTE: Get biceps score # NOTE: This function may need to be altered to gather more information about individual models #(Deltaf_ij, dDeltaf_ij, Theta_ij) = mbar.getFreeEnergyDifferences(uncertainty_method='approximate') #_results = mbar.getFreeEnergyDifferences(uncertainty_method='approximate', return_theta=True, return_dict=True) _results = mbar.compute_free_energy_differences(uncertainty_method='approximate', return_theta=True) #print(_results.keys()) Deltaf_ij, dDeltaf_ij, Theta_ij = _results[""Delta_f""], _results[""dDelta_f""], _results[""Theta""] self.Deltaf_ij = Deltaf_ij self.dDeltaf_ij = dDeltaf_ij beta = 1.0 # keep in units kT #print 'Unit-bearing (units kT) free energy difference f_1K = f_K - f_1: %f +- %f' % ( (1./beta) * Deltaf_ij[0,K-1], (1./beta) * dDeltaf_ij[0,K-1]) self.f_df = np.zeros( (self.nlambda, 2) ) # first column is Deltaf_ij[0,:], second column is dDeltaf_ij[0,:] self.f_df[:,0] = Deltaf_ij[0,:] # NOTE: biceps score self.f_df[:,1] = dDeltaf_ij[0,:] # NOTE: biceps score std self.P_dP = np.zeros( (self.nstates, 2*self.K) ) # left columns are P, right columns are dP if debug: print('state\tP\tdP') self.u_kn = kln_to_kn(self.u_kln, N_k=self.N_k) self.compute_perturbed_free_energies = mbar.compute_perturbed_free_energies self.nreplicas = len(self.states_kn[-1,-1]) for i in range(self.nstates): sampled = np.array([np.where(self.states_kn[:,:,r]==i,1,0) for r in range(self.nreplicas)]) A_kn = sampled.sum(axis=0)/self.nreplicas output = mbar.compute_expectations(A_kn, uncertainty_method='approximate') p_i, dp_i = output[""mu""],output[""sigma""] self.P_dP[i,0:self.K] = p_i self.P_dP[i,self.K:2*self.K] = dp_i pops, dpops = self.P_dP[:, 0:self.K], self.P_dP[:, self.K:2*self.K] if self.verbose: print(f""Time for MBAR: %.3f s"" % (time.time() - stime)); # save results self.save_MBAR() def save_MBAR(self): """"""save results (BICePs score and populations) from MBAR analysis"""""" if self.verbose: print('Writing %s...'%self.BSdir) np.savetxt(self.BSdir, self.f_df) if self.verbose: print('Writing %s...'%self.popdir) np.savetxt(self.popdir, self.P_dP) def get_traces(self, traj_index=-1): npz = self.traj[traj_index] traj = npz[""trajectory""] rest_type = [] n = 0 rests = np.array(npz[""rest_type""]) for g in np.array(traj[0][4]): rest_type.append(rests[n:n+len(g)].tolist()) n += len(g) if n >= len(np.array(npz[""rest_type""])): break rest_type = np.array(rest_type) # Find the unique restraints unique = [] r = """" for restraint in rests: if restraint not in unique: if restraint != r: r = restraint unique.append(restraint) n_rests_dict = {f""{r}"":0 for r in unique} columns = [] for k, rest in enumerate(npz['rest_type']): columns.append(str(rest)+f""{n_rests_dict[rest]}"") n_rests_dict[rests[k]] += 1 df = pd.DataFrame(np.array(npz[""traces""]).transpose(), columns) df = df.transpose() return df def plot(self, plottype=""hist"", figname=""BICePs.pdf"", figsize=None, label_fontsize=12, legend_fontsize=10): """"""Plot figures for population and sampled nuisance parameters. Args: show(bool): show the plot in Jupyter Notebook. """""" df0 = self.get_traces(traj_index=0) df1 = self.get_traces(traj_index=-1) N = 20 if df0.shape[1] > N: if self.verbose: print(f""Number of posterior distributions of \ nuisance parameters: {df0.shape[1]}\n\ Too many distributions for a single figure... only plotting the first {N}."") df0 = df0[df0.columns.to_list()[:N]] df1 = df1[df1.columns.to_list()[:N]] else: N = len(df0.columns.to_list()) #df0 = self.get_sigmaB_trace(traj_index=0) #df1 = self.get_sigmaB_trace(traj_index=-1) ## next get MABR sampling done #self.MBAR_analysis() # load in precomputed P and dP from MBAR analysis pops0, pops1 = self.P_dP[:,0], self.P_dP[:,self.K-1] dpops0, dpops1 = self.P_dP[:,self.K], self.P_dP[:,2*self.K-1] t0 = self.traj[0] t1 = self.traj[self.K-1] # Figure Plot SETTINGS #label_fontsize = 12 #legend_fontsize = 10 fontfamily={'family':'sans-serif','sans-serif':['Arial']} plt.rc('font', **fontfamily) # determine number of row and column if (len(self.scheme[:N])+1)%2 != 0: c,r = 2, (len(self.scheme[:N])+2)/2 else: c,r = 2, (len(self.scheme[:N])+1)/2 if figsize: fig = plt.figure( figsize=figsize ) else: fig = plt.figure( figsize=(4*c,5*r) ) # Make a subplot in the upper left plt.subplot(int(r),int(c),1) plt.errorbar( pops0, pops1, xerr=dpops0, yerr=dpops1, fmt='k.') #plt.hold(True) limit = 1e-6 plt.plot([limit, 1], [limit, 1], color='k', linestyle='-', linewidth=2) plt.xlim(limit, 1.) plt.ylim(limit, 1.) plt.xlabel('$p_i$ (exp)', fontsize=label_fontsize) plt.ylabel('$p_i$ (sim+exp)', fontsize=label_fontsize) plt.xscale('log') plt.yscale('log') #label key states for i in range(len(pops1)): if (i==0) or (pops1[i] > 0.05): plt.text( pops0[i], pops1[i], str(i), color='g' , fontsize=legend_fontsize) ntop = int(int(self.nstates)/10.) if self.verbose: topN = pops1[np.argsort(pops1)[-ntop:]] topN_labels = [np.where(topN[i]==pops1)[0][0] for i in range(len(topN))] print(f""Top {ntop} states: {topN_labels}"") print(f""Top {ntop} populations: {topN}"") axs = [] ax = plt.gca() axs.append(ax) s = 0 for k in range(len(self.scheme[:N])): df0_array = df0[""%s""%(df0.columns.to_list()[k])].to_numpy() if all(df0_array == np.ones(df0_array.shape)): continue df1_array = df1[""%s""%(df1.columns.to_list()[k])].to_numpy() if all(df1_array == np.ones(len(df1_array))): continue s += 2 #plt.subplot(r,c,s) plt.subplot(r,c,k+2) ax = plt.gca() axs.append(ax) if plottype == ""step"": plt.step(t0['allowed_parameters'][k], t0['sampled_parameters'][k], 'b-', label='exp') plt.fill_between(t0['allowed_parameters'][k], t0['sampled_parameters'][k], color='b', step=""pre"", alpha=0.4, label=None) if plottype == ""hist"": #counts, bins = np.histogram(t0['sampled_parameters'][k]) #width = 0.1 #plt.bar(x=t0['allowed_parameters'][k], height=t0['sampled_parameters'][k], # width=width, # facecolor='b', alpha=0.5, edgecolor=""k"", linewidth=1.2) df0[""%s""%(df0.columns.to_list()[k])].hist(bins='auto', facecolor='b', alpha=0.5, edgecolor=""k"", ax=ax, label='exp') xmax0 = [l for l,e in enumerate(t0['sampled_parameters'][k]) if e != 0.][-1] xmin0 = [l for l,e in enumerate(t0['sampled_parameters'][k]) if e != 0.][0] xmax1 = [l for l,e in enumerate(t1['sampled_parameters'][k]) if e != 0.][-1] xmin1 = [l for l,e in enumerate(t1['sampled_parameters'][k]) if e != 0.][0] xmax = max(xmax0,xmax1) xmin = min(xmin0, xmin1) plt.xlim(t0['allowed_parameters'][k][xmin], t0['allowed_parameters'][k][xmax]) if plottype == ""step"": plt.step(t1['allowed_parameters'][k], t1['sampled_parameters'][k], 'r-', label='sim+exp') plt.fill_between(t1['allowed_parameters'][k], t1['sampled_parameters'][k], color='r', step=""pre"", alpha=0.4, label=None) if plottype == ""hist"": #counts, bins = np.histogram(t1['sampled_parameters'][k]) #plt.bar(x=t1['allowed_parameters'][k], height=t1['sampled_parameters'][k], # width=width, # facecolor='r', alpha=0.5, edgecolor=""k"", linewidth=1.2) df1[""%s""%(df1.columns.to_list()[k])].hist(bins='auto', facecolor='r', alpha=0.5, edgecolor=""k"", ax=ax, label='sim+exp') ax.set_xlim(left=0, right=df1[""%s""%(df1.columns.to_list()[k])].max()*1.1) #plt.legend(['exp', 'sim+exp'], loc='best',fontsize=legend_fontsize) plt.legend(loc='best',fontsize=legend_fontsize) if self.scheme[k].count('_') == 0: if self.scheme[k] == 'gamma': plt.xlabel(""$\%s$""%self.scheme[k],fontsize=label_fontsize) plt.ylabel(""$P(\%s)$""%self.scheme[k],fontsize=label_fontsize) else: plt.xlabel(""$%s$""%self.scheme[k],fontsize=label_fontsize) plt.ylabel(""$P(%s)$""%self.scheme[k],fontsize=label_fontsize) plt.yticks([]) elif self.scheme[k].count('_') == 1: if 'gamma' in self.scheme[k]: plt.xlabel(""${\%s_{%s}}^{-1/6}$""%(self.scheme[k].split('_')[0],self.scheme[k].split('_')[1]),fontsize=label_fontsize) plt.ylabel(""${P(\%s_{%s}}^{-1/6})$""%(self.scheme[k].split('_')[0],self.scheme[k].split('_')[1]), fontsize=label_fontsize) plt.yticks([]) else: plt.xlabel(""$\%s_{%s}$""%(self.scheme[k].split('_')[0],self.scheme[k].split('_')[1]),fontsize=label_fontsize) plt.ylabel(""$P(\%s_{%s})$""%(self.scheme[k].split('_')[0],self.scheme[k].split('_')[1]), fontsize=label_fontsize) plt.yticks([]) elif self.scheme[k].count('_') == 2: plt.xlabel(""$\%s_{{%s}_{%s}}$""%(self.scheme[k].split('_')[0],self.scheme[k].split('_')[1],self.scheme[k].split('_')[2]),fontsize=label_fontsize) plt.ylabel(""$P(\%s_{{%s}_{%s}})$""%(self.scheme[k].split('_')[0],self.scheme[k].split('_')[1],self.scheme[k].split('_')[2]),fontsize=label_fontsize) plt.yticks([]) for n, ax in enumerate(axs): #ax.imshow(np.random.randn(10,10), interpolation='none') ax.text(-0.12, 1.02, string.ascii_lowercase[n], transform=ax.transAxes, size=20, weight='bold') # Setting the ticks and tick marks ticks = [ax.xaxis.get_minor_ticks(), ax.xaxis.get_major_ticks()] marks = [ax.get_xticklabels(), ax.get_yticklabels()] for k in range(0,len(ticks)): for tick in ticks[k]: tick.label.set_fontsize(label_fontsize) for k in range(0,len(marks)): for mark in marks[k]: mark.set_size(fontsize=label_fontsize-2) #mark.set_rotation(s=65) plt.tight_layout() plt.savefig(os.path.join(self.resultdir,figname)) return fig ","Python" "Conformation","vvoelz/biceps","biceps/decorators.py",".py","2372","72","''' Author: Rob Raddi Edits on: April 4th, 2022 ''' import multiprocessing as mp from multiprocessing import Manager import numpy as np from platform import python_version def multiprocess(*args, **kwargs): """"""Decorator method for multiprocessing functions. Please refer to https://docs.python.org/3/library/multiprocessing.html#multiprocessing.sharedctypes.multiprocessing.Manager for manager types. https://docs.python.org/3.8/library/multiprocessing.html#contexts-and-start-methods # FIXME: Python >= 3.8 #process = p.Process(target=function, args=(iter,), ctx=mp.get_context(method='fork')) """""" pyVersion = python_version() pyVersion = float(""."".join(pyVersion.split(""."")[:2])) def wrapper(function): n = len(kwargs['iterable']) print(""Number of CPUs: %s""%(mp.cpu_count())) p = mp.Pool(processes=n) print(f""Number of processes: {n}"") jobs = [] mp.freeze_support() for iter in kwargs['iterable']: if pyVersion >= 3.8: process = p.Process(target=function, args=(iter,), ctx=mp.get_context(method='fork')) else: process = p.Process(target=function, args=(iter,)) jobs.append(process) jobs[-1].start() active_processors = [jobs[i].is_alive() for i in range(len(jobs))] if (len(active_processors) == mp.cpu_count()-1) and all(active_processors) == True: while all(active_processors) == True: active_processors = [jobs[i].is_alive() for i in range(len(jobs))] inactive = int(np.where(np.array(active_processors) == False)[0]) jobs[inactive].terminate() jobs.remove(jobs[inactive]) for job in jobs: job.join() p.close() return wrapper # NOTE: An example of mine that will help with Hamiltonian replica exchange. ''' with Manager() as manager: results = manager.list() cv = KFold(folds, True, 1) list_of_dict = [{""fold"":f, ""indices"":i} for f,i in enumerate(cv.split(X))] @biceps.multiprocess(iterable=list_of_dict) def function(list_of_dict): fold, indices = list_of_dict[""fold""], list_of_dict[""indices""] results.append([fold,indices]) ''' if __name__ == ""__main__"": mp.freeze_support() multiprocess() ","Python" "Conformation","vvoelz/biceps","biceps/toolbox.py",".py","34742","990","# -*- coding: utf-8 -*- import os, glob, re, pickle import numpy as np import pandas as pd from biceps.J_coupling import * from biceps.KarplusRelation import KarplusRelation import mdtraj as md import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt import biceps.Restraint as Restraint from scipy.optimize import curve_fit def sort_data(dataFiles): """"""Sorting the data by extension into lists. Data can be located in various directories. Provide a list of paths where the data can be found. Some examples of fileextensions: {.noe,.J,.cs_H,.cs_Ha}. :param list dataFiles: list of strings where the data can be found :raises ValueError: if the data directory does not exist >>> biceps.toolbox.sort_data() """""" dir_list=[] if not os.path.exists(dataFiles): raise ValueError(""data directory doesn't exist"") if ',' in dataFiles: print('Sorting out the data...\n') raw_dir = (dataFiles).split(',') for dirt in raw_dir: if dirt[-1] == '/': dir_list.append(dirt+'*') else: dir_list.append(dirt+'/*') else: raw_dir = dataFiles if raw_dir[-1] == '/': dir_list.append(dataFiles+'*') else: dir_list.append(dataFiles+'/*') # list for every extension; 7 possible experimental observables supported data = [[] for x in range(len(list_possible_extensions()))] # Sorting the data by extension into lists. Various directories is not an issue... for i in range(len(dir_list)): convert = lambda txt: int(txt) if txt.isdigit() else txt # This convert / sorted glob is a bit fishy... needs many tests for j in sorted(glob.glob(dir_list[i]),key=lambda x: [convert(s) for s in re.split(""([0-9]+)"",x)]): if not any([j.endswith(ext) for ext in list_possible_extensions()]): raise ValueError(f""Incompatible File extension. Use:{list_possible_extensions()}"") else: for k in range(len(list_possible_extensions())): if j.endswith(list_possible_extensions()[k]): data[k].append(j) data = np.array([_f for _f in data if _f]) # removing any empty lists Data = np.stack(data, axis=-1) data = Data.tolist() return data def get_files(path): """"""Return a sorted list of files that will be globbed from the path given. First, this function can handle decimals and multiple numbers that are seperated by characters. https://pypi.org/project/natsort/ Args: path(str) - path that will be globbed Returns: sorted list """""" from natsort import natsorted globbed = glob.glob(path) return natsorted(globbed) #def get_files(path): # """"""Uses a sorted glob to return a list of files in numerical order. # # Args: # path(str): path to glob (able to use *) # # >>> biceps.toolbox.get_files() # """""" # # convert = lambda txt: int(txt) if txt.isdigit() else txt # return sorted(glob.glob(path), key=lambda x:[convert(s) for s in re.split(""([0-9]+)"",x)]) def list_res(input_data): """"""Determine the ordering of the experimental restraints that will be included in sampling. Args: input_data(list): see :attr:`biceps.Ensemble.initialize_restraints` >>> biceps.toolbox.list_res() """""" scheme=[] for i in input_data[0]: if not any([i.endswith(ext) for ext in list_possible_extensions()]): raise ValueError(f""Incompatible File extension. Use:{list_possible_extensions()}"") else: scheme.append(i.split(""."")[-1]) return scheme def list_extensions(input_data): """"""Determine the ordering of the experimental restraints that will be included in sampling. Args: input_data(list): see :attr:`biceps.Ensemble.initialize_restraints` >>> biceps.toolbox.list_extensions() """""" return [ res.split(""_"")[-1] for res in list_res(input_data) ] def list_possible_restraints(): """"""Function will return a list of all possible restraint classes in Restraint.py. >>> biceps.toolbox.list_possible_restraints() """""" return [ key for key in vars(Restraint).keys() if key.startswith(""Restraint_"") ] def list_possible_extensions(): """"""Function will return a list of all possible input data file extensions. >>> biceps.toolbox.list_possible_extensions() """""" restraint_classes = list_possible_restraints() possible = list() for rest in restraint_classes: R = getattr(Restraint, rest) for ext in getattr(R, ""_ext""): #NOTE: can use _ext variable or the suffix of Restraint class possible.append(ext) return possible def check_indices(indices): if type(indices) == str: indices = np.loadtxt(indices) elif (type(indices) != np.ndarray) and (type(indices) != list): raise TypeError(f""Requires a path to a file (str) OR data as \ list/np.ndarray object. You provides {type(indices)}."") indices = np.array(indices).astype(int) return indices def check_exp_data(exp_data): if type(exp_data) == str: exp_data = np.loadtxt(exp_data) elif (type(exp_data) != np.ndarray) and (type(exp_data) != list): raise TypeError(f""Requires a path to a file (str) OR data as \ list/np.ndarray object. You provides {type(exp_data)}."") return exp_data def check_model_data(model_data): if type(model_data) == str: model_data = get_files(model_data) elif (type(model_data) != np.ndarray) and (type(model_data) != list): raise TypeError(f""Requires a path to glob files (str) OR data as \ list/np.ndarray object. You provides {type(model_data)}."") return model_data def mkdir(path): """"""Function will create a directory if given path does not exist. >>> toolbox.mkdir(""./doctest"") """""" # create a directory for each system if not os.path.exists(path): os.mkdir(path) def write_results(self, outfilename): """"""Writes a compact file of several arrays into binary format. Standardized: Yes ; Binary: Yes; Human Readable: No; :param str outfilename: name of the output file :return: numpy compressed filetype """""" np.savez_compressed(outfilename, self.results) def read_results(self,filename): """"""Reads a numpy compressed filetype(*.npz) file"""""" loaded = np.load(filename) print((list(loaded.items()))) def plot_ref(traj, debug=True): """"""Plot reference potential for each observables. Args: traj(npz, np.array): output trajectory from BICePs sampling Returns: figure: A figure of reference potential and distribution of model observables """""" if debug: print('Loading %s ...'%traj) results = np.load(traj, allow_pickle=True)['arr_0'].item() n_restraints = len(results['ref_potential']) for i in range(n_restraints): if results['ref_potential'][i][0] == 'Nan': pass else: n_model = len(results['ref_potential'][i][0]) c,r = 5, int(n_model)/5 + 1 x = np.arange(0.0,30.0,0.01) print(""plotting figures..."") plt.figure(figsize=(4*c,5*r)) if len(results['ref_potential'][i]) == 1: ## exp ## for j in range(n_model): beta = results['ref_potential'][i][0][j] model = results['model'][i][j] ref = np.exp(-x/beta)/beta counts,bins = np.histogram(model,bins = np.arange(0.0,20.0,0.2)) plt.subplot(r,c,j+1) plt.step(bins[0:-1],counts,'black',label = '$P^{d_j}$') plt.plot(x,ref*10.,'blue',label='$P_{ref}(d_j)$') plt.xlim(0.0,max(model)) plt.yticks([]) plt.legend(loc='upper right',fontsize=8) plt.tight_layout() plt.savefig('ref_distribution.pdf') plt.close() elif len(results['ref_potential'][i]) == 2: ## gau ## for j in range(n_model): mean = results['ref_potential'][i][0][j] sigma = results['ref_potential'][i][1][j] model = results['model'][i][j] ref = (1.0/(np.sqrt(2.0*np.pi*sigma**2.0)))*np.exp(-(x-mean)**2.0/(2.0*sigma**2.0)) counts,bins = np.histogram(model,bins = np.arange(0.0,20.0,0.2)) plt.subplot(r,c,j+1) plt.step(bins[0:-1],counts,'black',label = '$P^{d_j}$') plt.plot(x,ref*10.,'blue',label='$P_{ref}(d_j)$') plt.xlim(0.0,max(model)) plt.yticks([]) plt.legend(loc='upper right',fontsize=8) plt.tight_layout() plt.savefig('ref_distribution.pdf') plt.close() print(""Done!"") #TODO: # input: pandas daraframe of populations # output: ordered list of populations with labeled columns def get_state_populations(file): """"""Get the state populations given a **populations.dat** file. Returns: np.ndarray: populations """""" return np.loadtxt(file)[:][0] def print_top_N_pops(file, nlambda, N=5): pops = np.loadtxt(file)[:,nlambda-1] ntop = N#int(int(self.states)/10.) topN = pops[np.argsort(pops)[-ntop:]] topN_labels = [np.where(topN[i]==pops)[0][0] for i in range(len(topN))] print(f""Top {ntop} states: {topN_labels}"") print(f""Top {ntop} populations: {topN}"") def print_scores(file): """"""Get the BICePs Score given a **BS.dat** file Returns: np.ndarray or float: Scores """""" return np.loadtxt(file)[1,0] def npz_to_DataFrame(file, out_filename=""traj_lambda0.00.pkl"", verbose=False): """"""Converts numpy Z compressed file to Pandas DataFrame (*.pkl) >>> biceps.toolbox.npz_to_DataFrame(file, out_filename=""traj_lambda0.00.pkl"") """""" npz = np.load(file, allow_pickle=True)[""arr_0""].item() if verbose: print(npz.keys()) # get trajectory information traj = npz[""trajectory""] #freq_save_traj = traj[1][0] - traj[0][0] traj_headers = [ header.split()[0] for header in npz[""trajectory_headers""] ] t = {""%s""%header: [] for header in traj_headers} for i in range(len(traj)): for k,header in enumerate(traj_headers): t[header].append(traj[i][k]) df = pd.DataFrame(t, columns=traj_headers) df.to_pickle(out_filename) return df def convert_pop_to_energy(pop_filename, out_filename=None): """"""Convert population to energy for each state using the following: >>> U = -np.log(P) :param str pop_filename: name of file for populations :param str out_filename: output file name :return list: A list of converted energy for each conformational state """""" if pop_filename.endswith('txt') or pop_filename.endswith('dat'): pop = np.loadtxt(pop_filename) elif pop_filename.endswith('npy'): pop = np.load(pop_filename) else: raise ValueError('Incompatible file extention. Use:{.txt,.dat,.npy}') energy=[] # replace NaN in the list with a very small number pop[np.isnan(pop)]=0.001 for i in pop: energy.append(-np.log((i/float(sum(pop))))) if out_filename == None: np.savetxt('energy.txt',energy) else: np.savetxt(out_filename,energy) return energy def get_rest_type(traj): """"""Get types of experimental restraints. :param traj: output trajectory from BICePs sampling :return list: A list of types of experimental restraints """""" rest_type=[] if not traj.endswith('.npz'): raise TypeError(""trajectory file should be in the format of '*npz'"") else: t = np.load(traj)['arr_0'].item() rest = t['rest_type'] for r in rest: if r.split('_')[1] != 'noe': rest_type.append(r.split('_')[1]) elif r.split('_')[1] == 'noe': rest_type.append(r.split('_')[1]) rest_type.append('gamma') return rest_type def get_allowed_parameters(traj,rest_type=None): """"""Get nuisance parameters range. :param traj: output trajectory from BICePs sampling :var default=None rest_type: experimental restraint type :return list: A list of all nuisance parameters range """""" if not traj.endswith('.npz'): raise TypeError(""trajectory file should be in the format of '*npz'"") else: t = np.load(traj)['arr_0'].item() parameters = [] if rest_type == None: rest_type = get_rest_type(traj) if 'gamma' in rest_type: for i in range(len(rest_type)): if i == len(rest_type)-1: # means it is gamma parameters.append(t['allowed_gamma']) else: parameters.append(t['allowed_sigma'][i]) else: parameters.append(t['allowed_sigma'])[i] return parameters def get_sampled_parameters(traj,rest_type=None,allowed_parameters=None): """"""Get sampled parameters along time (steps). :param traj: output trajectory from BICePs sampling :var default=None rest_type: experimental restraint type :return list: A list of all nuisance paramters sampled """""" if not traj.endswith('.npz'): raise TypeError(""trajectory file should be in the format of '*npz'"") else: t = np.load(traj)['arr_0'].item() parameters = [] if rest_type == None: rest_type = get_rest_type(traj) parameters = [[] for i in range(len(rest_type))] if allowed_parameters == None: allowed_parameters = get_allowed_parameters(traj,rest_type=rest_type) if 'gamma' in rest_type: for i in range(len(rest_type)): if i == len(rest_type)-1: # means it is gamma for j in range(len(t['trajectory'])): parameters[i].append(allowed_parameters[i][t['trajectory'][j][4][i-1][1]]) else: for j in range(len(t['trajectory'])): parameters[i].append(allowed_parameters[i][t['trajectory'][j][4][i][0]]) else: for j in range(len(t['trajectory'])): parameters[i].append(allowed_parameters[i][t['trajectory'][4][j][i][0]]) return parameters def g(f, max_tau=10000, normalize=True): """"""Calculate the autocorrelaton function for a time-series f(t). INPUT f - a 1D numpy array containing the time series f(t) PARAMETERS max_tau - the maximum autocorrelation time to consider. normalize - if True, return g(tau)/g[0] RETURNS result - a numpy array of size (max_tau+1,) containing g(tau). """""" f_zeroed = f-f.mean() T = f_zeroed.shape[0] result = np.zeros(max_tau+1) for tau in range(max_tau+1): result[tau] = np.dot(f_zeroed[0:-1-tau],f_zeroed[tau:-1])/(T-tau) if normalize: return result/result[0] else: return result def single_exp_decay(x, a0, a1, tau1): return a0 + a1*np.exp(-(x/tau1)) def double_exp_decay(x, a0, a1, a2, tau1, tau2): return a0 + a1*np.exp(-(x/tau1)) + a2*np.exp(-(x/tau2)) def exponential_fit(ac, use_function='single'): """"""Perform a single- or double- exponential fit on an autocorrelation curve. Args: ac(np.ndarray): autocorrelation use_function(str): 'single' or 'double' Returns: yFit_data(np.ndarray): the y-values of the fit curve. """""" nsteps = ac.shape[0] if use_function == 'single': v0 = [0.0, 1.0 , 4000.] # Initial guess [a0, a1, tau1] for a0 + a1*exp(-(x/tau1)) popt, pcov = curve_fit(single_exp_decay, np.arange(nsteps), ac, p0=v0, maxfev=10000) # ignore last bin, which has 0 counts yFit_data = single_exp_decay(np.arange(nsteps), popt[0], popt[1], popt[2]) # print('best-fit a0 = ', popt[0], '+/-', pcov[0][0]) # print('best-fit a1 = ', popt[1], '+/-', pcov[1][1]) print('best-fit tau1 = ', popt[2], '+/-', pcov[2][2]) else: v0 = [0.0, 0.9, 0.1, 4000., 200.0] # Initial guess [a0, a1,a2, tau1, tau2] for a0 + a1*exp(-(x/tau1)) + a2*exp(-(x/tau2)) popt, pcov = curve_fit(double_exp_decay, np.arange(nsteps), ac, p0=v0, maxfev=10000) # ignore last bin, which has 0 counts yFit_data = double_exp_decay(np.arange(nsteps), popt[0], popt[1], popt[2], popt[3], popt[4]) # print('best-fit a0 = ', popt[0], '+/-', pcov[0][0]) #print('best-fit a1 = ', popt[1], '+/-', pcov[1][1]) #print('best-fit a2 = ', popt[2], '+/-', pcov[2][2]) print('best-fit tau1 = ', popt[3], '+/-', pcov[3][3]) print('best-fit tau2 = ', popt[4], '+/-', pcov[4][4]) return yFit_data def autocorr_valid(x,tau): """"""Cross-correlation of two 1-dimensional sequences. :var x: 1-dimensional sequence :var tau: lagtime """""" t = tau y = x[:np.size(x)-t] g = np.correlate(x, y, mode='valid') n = np.array([np.size(x)-t]*len(g)) return g/n def compute_ac(traj,tau,rest_type=None,allowed_parameters=None): """"""Compute auto-correlation time for sampled trajectory of nuisance parameters. :param traj: output trajectory from BICePs sampling :var tau: lagtime :var default=None rest_type: experimental restraint type :var default=None allowed_parameters: nuisacne parameters range :return list: a list of auto-correlation results for all nuisacne parameters :return figure: A figure of auto-correlation results for all nuisance parameters """""" if not traj.endswith('.npz'): raise TypeError(""trajectory file should be in the format of '*npz'"") else: if rest_type == None: rest_type = get_rest_type(traj) elif allowed_parameters == None: allowed_parameters = get_allowed_parameters(traj,rest_type=rest_type) else: sampled_parameters = [[] for i in range(len(rest_type))] t = np.load(traj)['arr_0'].item()['trajectory'] if 'gamma' in rest_type: for i in range(len(t)): for j in range(len(rest_type)): if j == len(rest_type)-1: # means it is gamma sampled_parameters[j].append(allowed_parameters[j][t[i][4:][0][j-1][1]]) else: sampled_parameters[j].append(allowed_parameters[j][t[i][4:][0][j][0]]) else: for i in range(len(t)): for j in range(len(rest_type)): sampled_parameters[j].append(allowed_parameters[j][t[i][4:][0][j][0]]) #ac_parameters=[[] for i in range(len(rest_type))] ac_parameters=[] for i in range(len(rest_type)): ac_parameters.append(autocorr_valid(np.array(sampled_parameters[i]),tau)) n_rest = len(rest_type) time_in_steps = np.arange(1,len(ac_parameters[0])+1,1) colors = ['red','blue','green','black','magenta','gold','navy'] plt.figure(figsize=(10,n_rest*5)) for i in range(n_rest): plt.subplot(n_rest,1,i+1) plt.plot(time_in_steps,ac_parameters[i],label=rest_type[i],color=colors[i]) plt.xlabel(r'$\tau$ (steps)') plt.legend(loc='best') plt.tight_layout() plt.savefig('autocorrelation.pdf') return ac_parameters def plot_ac(ac_paramters,rest_type): """"""Plot auto-correlation results. :var ac_parameters: computed auto-correlation results :var rest_type: experimental restraint type :return figure: A figure of auto-correlation results for all nuisance parameters """""" n_rest = len(rest_type) time_in_steps = np.arange(1,n_rest+1,1) colors = ['red','blue','green','black','magenta','gold','navy'] plt.figure(figsize=(10,n_rest*5)) for i in range(n_rest): plt.subplot(n_rest,1,i+1) plt.plot(time_in_steps,ac_parameters[i],label=rest_type[i],color=colors[i]) plt.xlabel(r'$\tau$ (steps)') plt.legend(loc='best') plt.tight_layout() plt.savefig('autocorrelation.pdf') def compute_JSD(T1,T2,T_total,rest_type,allowed_parameters): """"""Compute JSD for a given part of trajectory. :var T1, T2, T_total: part 1, part2 and total (part1 + part2) :var rest_type: experimental restraint type :var allowed_parameters: nuisacne parameters range :return float: Jensen–Shannon divergence """""" restraints = rest_type all_JSD = np.zeros(len(restraints)) if 'gamma' in rest_type: for i in range(len(restraints)): r1,r2,r_total = np.zeros(len(allowed_parameters[i])),np.zeros(len(allowed_parameters[i])),np.zeros(len(allowed_parameters[i])) if i == len(rest_type) - 1: # means it is gamma for j in T1: r1[j[4][i-1][1]]+=1 for j in T2: r2[j[4][i-1][1]]+=1 for j in T_total: r_total[j[4][i-1][1]]+=1 else: for j in T1: r1[j[4][i][0]]+=1 for j in T2: r2[j[4][i][0]]+=1 for j in T_total: r_total[j[4][i][0]]+=1 N1=sum(r1) N2=sum(r2) N_total = sum(r_total) H1 = -1.*r1/N1*np.log(r1/N1) H1 = sum(np.nan_to_num(H1)) H2 = -1.*r2/N2*np.log(r2/N2) H2 = sum(np.nan_to_num(H2)) H = -1.*r_total/N_total*np.log(r_total/N_total) H = sum(np.nan_to_num(H)) JSD = H-(N1/N_total)*H1-(N2/N_total)*H2 all_JSD[i] = JSD else: for i in range(len(restraints)): r1,r2,r_total = np.zeros(len(allowed_parameters[i])),np.zeros(len(allowed_parameters[i])),np.zeros(len(allowed_parameters[i])) for j in T1: r1[j[4:][0][i][0]]+=1 for j in T2: r2[j[4:][0][i][0]]+=1 for j in T_total: r_total[j[4:][0][i][0]]+=1 N1=sum(r1) N2=sum(r2) N_total = sum(r_total) H1 = -1.*r1/N1*np.log(r1/N1) H1 = sum(np.nan_to_num(H1)) H2 = -1.*r2/N2*np.log(r2/N2) H2 = sum(np.nan_to_num(H2)) H = -1.*r_total/N_total*np.log(r_total/N_total) H = sum(np.nan_to_num(H)) JSD = H-(N1/N_total)*H1-(N2/N_total)*H2 all_JSD[i] = JSD return all_JSD def plot_conv(all_JSD,all_JSDs,rest_type): """"""Plot Jensen–Shannon divergence (JSD) distribution for convergence check. :var all_JSD: JSDs for different amount of total dataset :var all_JSDs: JSDs for different amount of total dataset from bootstrapping :var rest_type: experimental restraint type :return figure: A figure of JSD and JSDs distribution """""" fold = len(all_JSD) rounds = len(all_JSDs[0]) n_rest = len(rest_type) new_JSD = [[] for i in range(n_rest)] for i in range(len(all_JSD)): for j in range(n_rest): new_JSD[j].append(all_JSD[i][j]) JSD_dist = [[] for i in range(n_rest)] JSD_std = [[] for i in range(n_rest)] for rest in range(n_rest): for f in range(fold): temp_JSD = all_JSDs[f][:,rest] JSD_dist[rest].append(np.mean(temp_JSD)) JSD_std[rest].append(np.std(temp_JSD)) plt.figure(figsize=(10,5*n_rest)) x = np.arange(100./fold,101.,fold) colors = ['red','blue','green','black','magenta','gold','navy'] for i in range(n_rest): plt.subplot(n_rest,1,i+1) plt.plot(x,new_JSD[i],'o-',color=colors[i],label=rest_type[i]) plt.hold(True) plt.plot(x,JSD_dist[i],'o',color=colors[i],label=rest_type[i]) plt.fill_between(x,np.array(JSD_dist[i])+np.array(JSD_std[i]),np.array(JSD_dist[i])-np.array(JSD_std[i]),color=colors[i],alpha=0.2) plt.xlabel('dataset (%)') plt.ylabel('JSD') plt.legend(loc='best') plt.tight_layout() plt.savefig('convergence.pdf') def plot_grid(traj, rest_type=None): """"""Plot acceptance ratio for each nuisance parameters jump during MCMC sampling. """""" if rest_type == None: rest = get_rest_type(traj) else: rest = rest_type t = np.load(traj)['arr_0'].item() grid = t['grid'] for i in range(len(grid)): plt.figure() cmap=plt.get_cmap('Greys') raw = grid[i] max_n = np.max(raw) raw[raw == 0.] = -1.0*max_n plt.pcolor(raw,cmap=cmap,vmin=-1.0*max_n,vmax=max_n,edgecolors='none') plt.colorbar() if rest[i] == ""gamma"": plt.xlabel('$\gamma$ $index$') plt.ylabel('$\gamma$ $index$') else: plt.xlabel('$\sigma_{%s}$ $index$'%rest[i]) plt.ylabel('$\sigma_{%s}$ $index$'%rest[i]) plt.xlim(0,len(raw[i])) plt.ylim(0,len(raw[i])) plt.savefig('grid_%s.pdf'%rest[i]) plt.close() def compute_distances(states, indices, outdir): """"""Function that uses MDTraj to compute distances given index pairs. Args: states(list): list of conformatonal state topology files indices(str): relative path and filename of indices for pair distances outdir(str): relative path for output directory Returns: distances(np.ndarray): computed distances """""" distances = [] if (type(indices) != np.ndarray) and (type(indices) != list): indices = np.loadtxt(indices) indices = np.array(indices).astype(int) for i in range(len(states)): d = md.compute_distances(md.load(states[i]), indices)*10. # convert nm to Å np.savetxt(outdir+'/%d.txt'%i,d) return distances def compute_chemicalshifts(states, temp=298.0, pH=5.0, outdir=""./""): """"""Chemical shifts are computed using MDTraj, which uses ShiftX2. Args: states(list): list of conformatonal state topology files temp(float): solution temperature pH(float): pH of solution outdir(str): relative path for output directory """""" states = get_files(states) for i in range(len(states)): print(f""Loading {states[i]} ..."") state = md.load(states[i], top=states[0]) shifts = md.nmr.chemical_shifts_shiftx2(state, pH, temp) out = outdir+""cs_state%d.txt""%i np.savetxt(out, shifts.mean(axis=1)) print(f""Saving {out} ..."") #out = out.replace("".txt"", "".pkl"") #shifts.to_pickle(out) def compute_nonaa_scalar_coupling(states, indices, karplus_key, outdir=""./"", top=None): """"""Compute J couplings for small molecules. :param mdtraj.Trajectory traj: Trajectory or *.pdb/*.gro files :param int indices: indices file for atoms :param list karplus_key: karplus relation for each J coupling :param mdtraj.Topology default=None top: topology file (only required if a trajectory is loaded)"""""" #ind = np.loadtxt(indices, dtype=int) if (type(indices) != np.ndarray) and (type(indices) != list): indices = np.loadtxt(indices) indices = np.array(indices).astype(int) if [type(key) for key in karplus_key if type(key)==str] == [str for i in range(len(karplus_key))]: raise TypeError(""Each karplus key must be a string. You provided: \n%s""%( [type(key) for key in karplus_key if type(key)==str])) if len(karplus_key) != len(indices): raise ValueError(""The number of indices must equale the number of karplus_key."") #states = get_files(states) nstates = len(states) for state in range(nstates): conf = md.load(states[state], indices) J = np.zeros((len(conf),len(indices))) karplus = KarplusRelation() for i in range(len(J)): for j in range(len(indices)): ri, rj, rk, rl = [conf.xyz[0,x,:] for x in indices[j]] model_angle = dihedral_angle(ri, rj, rk, rl) J[i,j] = karplus.J(angle=model_angle, key=karplus_key[j]) np.savetxt(outdir+'%d.txt'%state,J) #return J def get_J3_HN_HA(top,traj=None, frame=None, model=""Habeck"", outname = None): '''Compute J3_HN_HA for frames in a trajectories. :param mdtraj.Trajectory traj: Trajectory :param mdtraj.Topology top: topology file :param list frame: specific frame for computing :param str model: Karplus coefficient models [""Ruterjans1999"",""Bax2007"",""Bax1997"",""Habeck"" ,""Vuister"",""Pardi""] :param str outname: if not None, the output will be saved and a file name (in the format of string) is required.''' J=[] if traj is not None: if frame is None: t = md.load(traj,top=top) J = compute_J3_HN_HA(t, model = model) elif frame is not None: for i in range(len(frame)): t = md.load(traj,top=top)[frame[i]] d = compute_J3_HN_HA(t, model = model) if i == 0: J.append(d[0]) J.append(d[1]) else: J.append(d[1]) else: t = md.load(top) J = compute_J3_HN_HA(t, model = model) if outname is not None: print('saving output file...') np.save(outname, J) print('Done!') else: print('saving output file ...') np.save('J3_coupling',J) print('Done!') return J def dihedral_angle(x0, x1, x2, x3): """"""Calculate the signed dihedral angle between 4 positions. Result is in degrees. :param float x0: :param float x1: :param float x2: :param float x3: :return float phi: dihedral angle in degrees """""" #Calculate Bond Vectors b1, b2, b3 b1=x1-x0 b2=x2-x1 b3=x3-x2 #Calculate Normal Vectors c1,c2. This numbering scheme is idiotic, so care. c1=np.cross(b2,b3) c2=np.cross(b1,b2) Arg1=np.dot(b1,c1) Arg1*=np.linalg.norm(b2) Arg2=np.dot(c2,c1) phi=np.arctan2(Arg1,Arg2) # return the angle in degrees phi*=180./np.pi return(phi) def compute_nonaa_Jcoupling(traj, indices, karplus_key, top=None): """"""Compute J couplings for small molecules. :param mdtraj.Trajectory traj: Trajectory or *.pdb/*.gro files :param int indices: indices file for atoms :param list karplus_key: karplus relation for each J coupling :param mdtraj.Topology default=None top: topology file (only required if a trajectory is loaded)"""""" if (type(indices) != np.ndarray) and (type(indices) != list): indices = np.loadtxt(indices) indices = np.array(indices).astype(int) if [type(key) for key in karplus_key if type(key)==str] == [str for i in range(len(karplus_key))]: raise TypeError(""Each karplus key must be a string. You provided: \n%s""%( [type(key) for key in karplus_key if type(key)==str])) if len(karplus_key) != len(indices): raise ValueError(""The number of indices must equale the number of karplus_key."") if traj.endswith('.gro'): conf = md.load(traj) elif traj.endswith('.pdb'): conf = md.load(traj) else: if top == None: raise TypeError(""To load a trajectory file, a topology file must be provided."") conf = md.load(traj,top=top) J = np.zeros((len(conf),len(indices))) karplus = KarplusRelation() for i in range(len(J)): for j in range(len(indices)): ri, rj, rk, rl = [conf.xyz[0,x,:] for x in indices[j]] model_angle = dihedral_angle(ri, rj, rk, rl) J[i,j] = karplus.J(angle=model_angle, key=karplus_key[j]) return J def get_indices(traj, top, selection_expression=None, code_expression=None, out=None,debug=True): """"""Get atom indices from residue index list"""""" if out == None: out = 'indices.dat' # Load in the first trajectory print('Reading trajectory:' '%s'%(traj)) if not (os.path.exists(traj)): print('File not found! Exit...') exit(1) t = md.load(traj, top=top) print('done.') # Get the topology python object and set it as a variable for the eval(selection) topology = t.topology #selection = t.topology.select_expression(selection_expression) # Your new selection (sel) in a list #sel = eval(selection) if selection_expression: sel = t.topology.select(selection_expression) if code_expression: sel = eval(t.topology.select_expression(code_expression)) #sel = eval(t.topology.select_expression(selection_expression)) #print(sel) if debug: print(""selection_expression = %s""%selection_expression) print(""selection = %s""%sel) df = t.topology.to_dataframe()[0] print(df.items()) N = 0 for i in sel: print(""%s %s: atom %s""%(df.resName[i],df.resSeq[i],i)) N+=1 print(""%s atoms selected""%N) exit() # topology to dataframe table = t.topology.to_dataframe() # Get a selection for chimera atoms,chimera,chain = [],[],[] atom = 0 # Use the dataframe table from mdtraj to match the residue labels #... with their corresponding chain for ind in sel: atoms.append(t.topology.atom(int(ind))) chain.append(table[0]['chainID'][int(ind)]) # Is it chain A or chain B? if chain[atom] == 0: chimera.append(str(atoms[atom]).replace(""-"","".A@"")[3:]) elif chain[atom] == 1: chimera.append(str(atoms[atom]).replace(""-"","".B@"")[3:]) atom += 1 # Check to make sure that this is the selection you want. if debug==True: for i in range(0,len(sel)): print(t.topology.atom(int(sel[i]))) response = int(input(""Is this the correct selection? (True=1/False=0)\n"")) if response == 0: print('Exit...') exit(1) np.savetxt('%s'%out,np.array(sel),fmt='%i') np.savetxt('residues.txt',np.array(atoms),fmt='%s') #np.savetxt('residues_chimera.txt',np.array(chimera),fmt='%s') def save_object(obj, filename): """"""Saves python object as pickle file. Args: obj(object): python object filename(str): relative path for ouput >>> biceps.toolbox.save_object() """""" with open(filename, 'wb') as output: # Overwrites any existing file. pickle.dump(obj, output, pickle.HIGHEST_PROTOCOL) if __name__ == ""__main__"": import doctest doctest.testmod() ","Python" "Conformation","vvoelz/biceps","biceps/PosteriorSampler.py",".py","24123","496","# -*- coding: utf-8 -*- import numpy as np import inspect, time from .KarplusRelation import * # Returns J-coupling values from dihedral angles from .Restraint import * from .toolbox import * from tqdm import tqdm # progress bar class PosteriorSampler(object): def __init__(self, ensemble, freq_write_traj=100., freq_save_traj=100., verbose=False): """"""A class to perform posterior sampling of conformational populations. Args: ensemble(object): a :attr:`biceps.Ensemble` object freq_write_traj(int): the frequency (in steps) to write the MCMC trajectory freq_print(int): the frequency (in steps) to print status freq_save_traj(int): the frequency (in steps) to store the MCMC trajectory """""" self.lam = ensemble.lam self.ensemble = ensemble.to_list() # Allow the ensemble to pass through the class self.nreplicas = 1 self.write_traj = freq_write_traj # Step frequencies to write trajectory info self.traj_every = freq_save_traj # Frequency of storing trajectory samples self.nstates = len(self.ensemble) # Ensemble is a list of Restraint objects # The initial state of the structural ensemble we're sampling from self.state = 0 # index in the ensemble self.state = np.random.randint(low=0, high=self.nstates, size=self.nreplicas) self.E = 1.0e99 # initial energy self.accepted = 0 self.total = 0 # keep track of what we sampled in a trajectory self.traj = PosteriorSamplingTrajectory(ensemble=ensemble, sampler=self, nreplicas=self.nreplicas) # for each Restraint, calculate global reference potential parameters # ..by looking across all structures # TODO: can't this be more general?!? for i,R in enumerate(self.ensemble[0]): if R.ref == ""uniform"": self.traj.ref[i].append('Nan') pass elif R.ref == 'exponential': if hasattr(R, 'precomputed'): if not R.precomputed: self.build_exp_ref_pf(i) else: self.build_exp_ref(i) self.traj.ref[i].append(R.betas) elif R.ref == 'gaussian': if hasattr(R, 'precomputed'): if not R.precomputed: self.build_gaussian_ref_pf(i, use_global_ref_sigma=R.use_global_ref_sigma) else: self.build_gaussian_ref(i, use_global_ref_sigma=R.use_global_ref_sigma) self.traj.ref[i].append(R.ref_mean) self.traj.ref[i].append(R.ref_sigma) else: raise ValueError('Please choose a reference potential of the following:\n \ {%s,%s,%s}'%('uniform','exponential','gaussian')) # Compute ref state logZ for the free energies to normalize. self.compute_logZ() self.verbose = verbose def compute_logZ(self): """"""Compute reference state logZ for the free energies to normalize."""""" Z = 0.0 for s in self.ensemble: #Z += np.exp( -np.array(s[0].energy, dtype=np.float128) ) Z += np.exp( -np.array(s[0].energy, dtype=np.float64) ) self.logZ = np.log(Z) def build_exp_ref(self, rest_index, verbose=False): """"""Looks at each structure to find the average observables :math:``, then stores the reference potential info for each :attr:`biceps.Restraint.Restraint` of this type for each structure. ``beta_j = np.array(distributions[j]).sum()/(len(distributions[j])+1.0)`` Args: rest_index(int): restraint index """""" # collect distributions of observables r_j across all structures n_observables = self.ensemble[0][rest_index].n # the number of (model,exp) data values in this restraint distributions = [[] for j in range(n_observables)] for s in self.ensemble: # s is a list of Restraint() objects, we are considering the rest_index^th restraint for j in range(len(s[rest_index].restraints)): if verbose == True: print( s[rest_index].restraints[j]['model']) distributions[j].append( s[rest_index].restraints[j]['model'] ) if verbose == True: print('distributions',distributions) # Find the MLE average (i.e. beta_j) for each noe # calculate beta[j] for every observable r_j self.betas = np.zeros(n_observables) for j in range(n_observables): # the maximum likelihood exponential distribution fitting the data self.betas[j] = np.array(distributions[j]).sum()/(len(distributions[j])+1.0) # store the beta information in each structure and compute/store the -log P_potential for s in self.ensemble: s[rest_index].betas = self.betas s[rest_index].compute_neglog_exp_ref() def build_gaussian_ref(self, rest_index, use_global_ref_sigma=False, verbose=False): """"""Looks at all the structures to find the mean (:math:`\\mu`) and std (:math:`\\sigma`) of observables r_j then store this reference potential info for all restraints of this type for each structure. Args: rest_index(int): restraint index use_global_ref_sigma(bool): """""" #print( 'Computing parameters for Gaussian reference potentials...') # collect distributions of observables r_j across all structures n_observables = self.ensemble[0][rest_index].n # the number of (model,exp) data values in this restraint #print('n_observables = ',n_observables) distributions = [[] for j in range(n_observables)] for s in self.ensemble: # s is a list of Restraint() objects, we are considering the rest_index^th restraint for j in range(len(s[rest_index].restraints)): if verbose == True: print( s[rest_index].restraints[j]['model']) distributions[j].append( s[rest_index].restraints[j]['model'] ) if verbose == True: print('distributions',distributions) # Find the MLE mean (ref_mu_j) and std (ref_sigma_j) for each observable self.ref_mean = np.zeros(n_observables) self.ref_sigma = np.zeros(n_observables) for j in range(n_observables): self.ref_mean[j] = np.array(distributions[j]).mean() squared_diffs = [ (d - self.ref_mean[j])**2.0 for d in distributions[j] ] self.ref_sigma[j] = np.sqrt( np.array(squared_diffs).sum() / (len(distributions[j])+1.0)) #print(self.ref_sigma[j]) #print('ref_mean',self.ref_mean) #print('ref_sigma',self.ref_sigma) if use_global_ref_sigma == True: # Use the variance across all ref_sigma[j] values to calculate a single value of ref_sigma for all observables global_ref_sigma = ( np.array([self.ref_sigma[j]**(-2.0) for j in range(n_observables)]).mean() )**-0.5 for j in range(n_observables): self.ref_sigma[j] = global_ref_sigma #print(self.ref_sigma[j]) # store the ref_mean and ref_sigma information in each structure and compute/store the -log P_potential for s in self.ensemble: s[rest_index].ref_mean = self.ref_mean s[rest_index].ref_sigma = self.ref_sigma s[rest_index].compute_neglog_gaussian_ref() def build_exp_ref_pf(self,rest_index): """"""Calculate the MLE average PF values for restraint j across all structures, ``beta_PF_j = np.array(protectionfactor_distributions[j]).sum()/(len(protectionfactor_distributions[j])+1.0)`` then use this information to compute the reference prior for each structures. .. tip:: **(not required)** an additional method specific for protection factor """""" # collect distributions of observables r_j across all structures n_observables = self.ensemble[0][rest_index].n # the number of (model,exp) data values in this restraint for s in self.ensemble: # s is a list of Restraint() objects, we are considering the rest_index^th restraint s[rest_index].betas = [] # for each restraint, find the average model_protectionfactor (a 6-dim array in parameter space) across all structures for j in range(len(s[rest_index].restraints)): running_total = np.zeros(self.ensemble[0][rest_index].restraints[j]['model'].shape) for s in self.ensemble: running_total += s[rest_index].restraints[j]['model'] beta_pf_j = running_total/(len(s[rest_index].restraints)+1.0) for s in self.ensemble: s[rest_index].betas.append(beta_pf_j) # With the beta_PF_j values computed (and stored in each structure), now we can calculate the neglog reference potentials for s in self.ensemble: s[rest_index].compute_neglog_exp_ref_pf() def build_gaussian_ref_pf(self, rest_index): """"""Calculate the mean and std PF values for restraint j across all structures, then use this information to compute a gaussian reference prior for each structure. .. tip:: **(not required)** an additional method specific for protection factor """""" # collect distributions of observables r_j across all structures n_observables = self.ensemble[0][rest_index].n # the number of (model,exp) data values in this restraint #print('n_observables = ',n_observables) # Find the MLE mean (ref_mu_j) and std (ref_sigma_j) for each observable for s in self.ensemble: s[rest_index].ref_mean = [] s[rest_index].ref_sigma = [] # for each restraint, find the average model_protectionfactor (a 6-dim array in parameter space) across all structures for j in range(len(s[rest_index].restraints)): mean_PF_j = np.zeros( self.ensemble[0][rest_index].restraints[j]['model'].shape ) sigma_PF_j = np.zeros( self.ensemble[0][rest_index].restraints[j]['model'].shape ) for s in self.ensemble: mean_PF_j += s[rest_index].restraints[j]['model'] # a 6-dim array mean_PF_j = mean_PF_j/(len(s[rest_index].restraints)+1.0) for s in self.ensemble: sigma_PF_j += (s[rest_index].restraints[j]['model'] - mean_PF_j)**2.0 sigma_PF_j = np.sqrt(sigma_PF_j/(len(s[rest_index].restraints)+1.0)) for s in self.ensemble: s[rest_index].ref_mean.append(mean_PF_j) s[rest_index].ref_sigma.append(sigma_PF_j) for s in self.ensemble: s[rest_index].compute_neglog_gaussian_ref_pf() def compile_nuisance_parameters(self, verbose=False): """"""Compiles numpy arrays of allowed parameters for each nuisance parameter. :rtype np.ndarray: with shape(n_restraint,n_para) """""" # Generate empty lists for each restraint to fill with nuisance parameters nuisance_para = [ ] for R in self.ensemble[0]: keys = R.__dict__.keys() # all attributes of the Child Restraint class for j in [key for key in keys if ""allowed_"" in key]: # get the allowed parameters nuisance_para.append(np.array(getattr(R, j))) self.nuisance_para = np.array(nuisance_para, dtype=object) # np.save('compiled_nuisance_parameters.npy',self.nuisance_para) # Construct the matrix converting all values to floats for C++ if verbose == True: print(self.nuisance_para) print('Number of Restraints = ',len(self.nuisance_para)) return self.nuisance_para def neglogP(self, states, parameters, parameter_indices): """"""Return -ln P of the current configuration. Args: state(list): the new conformational state being sampled in :attr:`PosteriorSampler.sample` parameters(list): a list of the new parameters for each of the restraints parameter_indices(list): parameter indices that correspond to each restraint """""" result = 0 for state in states: s = self.ensemble[int(state)] # Current Structure (list of restraints) result += s[0].energy + self.logZ # Grab the free energy of the state and normalize for i,R in enumerate(s): result += R.compute_neglogP(parameters[i], parameter_indices[i], s[i].sse) return result def sample(self, nsteps, burn=0, print_freq=1000, verbose=False, progress=True): """"""Perform n number of steps (nsteps) of posterior sampling, where Monte Carlo moves are accepted or rejected according to Metroplis criterion. Energies are computed via :class:`neglogP`. Args: nsteps(int): the number of steps of sampling burn(int): the number of steps to burn print_freq(int): the frequency of printing to the screen verbose(bool): control over verbosity .. tip:: Set `verbose=False` when using multiprocessing. """""" # Generate a matrix of nuisance parameters allowed = self.compile_nuisance_parameters() # Store a list of nuisance parameters for each restraint self.rest_type = [] # Store a list of parameter indices for each restraint inside a list self.indices = [] # e.g., [161, 142, ...] # Loop through the restraints, and get the parameters and indices rest_index = [] #NOTE: using information from first state for i,R in enumerate(self.ensemble[self.state[0]]): keys = R.__dict__.keys() # all attributes of the Child Restraint class for j in [key for key in keys if ""index"" in key]: # get the parameter indices self.indices.append(getattr(R, j)) for j in [key.split(""_"")[-1] for key in keys if ""allowed_"" in key]: # self.rest_type.append(str(j)+""_""+str(R.__repr__).split(""_"")[-1].split()[0]) rest_index.append(i) if verbose: header = """"""Step\t\tState\tPara Indices\t\tAvg Energy\tAcceptance (%)"""""" print(header) # Create separate accepted ratio recorder list n_rest = max(rest_index)+1 sep_accepted = np.zeros(len(self.indices)+1) # all nuisance paramters + state (n_para starts from 1 not 0) step=0 start = time.time() if (not verbose) and progress: pbar = tqdm(total=nsteps+burn) while step < nsteps+burn: # Redefine based upon acceptance (Metroplis criterion) state, E = self.state.copy(), self.E indices = self.indices.copy() # e.g. [161, 142] #values = self.values # e.g. [1.2122652, 0.832136160] # All sample-space will share the same probability to be sampled RAND = 1. - 1./(n_rest + 1.) # + 1. is the term to include state-space dice = np.random.random() # rolling the dice if dice < RAND: # Take a random step in Restraint space ind = [] # Make sure the index doesn't fall out of the boundry of the allowed values for k in np.where(np.array(rest_index)==np.random.randint(n_rest))[0]: indices[k] = (indices[k]+(np.random.randint(3)-1))%len(allowed[k]) ind.append(k) else: ## Take a random step in state space state = np.random.randint(low=0, high=self.nstates, size=self.nreplicas) ind = [len(indices)] # values e.g., [1.2122652, 0.832136160, ...] values = [allowed[i][indices[i]] for i in range(len(indices))] # Convert the list of indices and values into a list of list for each restraint sep_indices = [[] for i in range(n_rest)] sep_values = [[] for i in range(n_rest)] for n,m in enumerate(rest_index): sep_indices[m].append(indices[n]) sep_values[m].append(values[n]) #print(f""sep_indices: {sep_indices}"") # Compute new ""energy"" E = self.neglogP(state, sep_values, sep_indices) # Accept or reject the MC move according to Metroplis criterion self.accept = False if E < self.E: self.accept = True else: if np.random.random() < np.exp( self.E - E ): self.accept = True # Update values based upon acceptance (Metroplis criterion) if self.accept: self.E = E self.state = state.copy() self.indices = indices.copy() self.values = values.copy() for k in ind: sep_accepted[k] += 1.0 self.accepted += 1.0 self.total += 1.0 if (step >= burn): _step = step-burn if (not verbose) and progress: pbar.update(1) # Store sampled states along trajectory for i in range(len(self.state)): self.traj.state_counts[int(self.state[i])] += 1 self.traj.state_trace.append(int(self.state[i])) # Store the counts of sampled sigma along the trajectory for i in range(len(self.indices)): self.traj.sampled_parameters[i][self.indices[i]] += 1 # Store trajectory samples temp=[[] for i in range(n_rest)] for n,m in enumerate(rest_index): temp[m].append(self.indices[n]) # Store trajectory samples if (_step%self.traj_every == 0): self.traj.trajectory.append( [int(_step), float(self.E), int(self.accept), list(self.state.copy()), list(temp.copy())]) #int(self.accept), int(self.state), list(temp.copy())]) self.traj.traces.append(self.values.copy()) if verbose: if _step%print_freq == 0: output = """"""%i\t\t%s\t%s\t\t%.3f\t\t%.2f\t%s""""""%(_step, self.state, self.indices, self.E/self.nreplicas, self.accepted/self.total*100., self.accept) print(output) step += 1 restraints = list(dict.fromkeys([r.split(""_"")[-1] for r in self.rest_type])) if not verbose: pbar.close() print('\nAccepted %s %% \n'%(self.accepted/self.total*100.)) print('\nAccepted [ ...Nuisance paramters..., state] %') print('Accepted %s %% \n'%(sep_accepted/self.total*100.)) self.traj.sep_accept.append(sep_accepted/self.total*100.) # separate accepted ratio self.traj.sep_accept.append(self.accepted/self.total*100.) # the total accepted ratio class PosteriorSamplingTrajectory(object): def __init__(self, ensemble, sampler, nreplicas): """"""A container class to store and perform operations on the trajectories of sampling runs. Args: ensemble(list): ensemble of :attr:`biceps.Restraint.Restraint` objects nreplicas(int): number of replicas """""" self.lam = ensemble.lam self.sampler = sampler self.ensemble = ensemble.to_list() # Allow the ensemble to pass through the class self.nreplicas = nreplicas self.nstates = len(self.ensemble) self.state_counts = np.ones(self.nstates) # add a pseudo-count to avoid log(0) errors # Lists for each restraint inside a list self.sampled_parameters = [] self.allowed_parameters = [] self.ref = [ [] for i in range(len(self.ensemble[0]))] # parameters of reference potentials self.model = [ [] for i in range(len(self.ensemble[0]))] # restraints model data self.sep_accept = [] # separate accepted ratio self.state_trace = [] s = self.ensemble[0] # Generate a list of the names of the parameter indices for the traj header parameter_indices = [] self.rest_type = [] for i,R in enumerate(s): keys = R.__dict__.keys() # all attributes of the Child Restraint class for j in [key for key in keys if ""allowed_"" in key]: # get the allowed parameters self.allowed_parameters.append(getattr(R, j)) self.sampled_parameters.append(np.zeros(len(getattr(R, j)))) for j in [key for key in keys if ""index"" in key]: # get the parameter indices parameter_indices.append(getattr(R, j)) for j in [key.split(""_"")[-1] for key in keys if ""allowed_"" in key]: # self.rest_type.append(str(j)+""_""+str(R.__repr__).split(""_"")[-1].split()[0]) self.trajectory_headers = [""step"", ""E"", ""accept"", ""state"", ""para_index = %s""%parameter_indices] self.trajectory = [] self.traces = [] self.results = {} def process_results(self, filename=None): """"""Process the trajectory, computing sampling statistics, ensemble-average NMR observables. Benefits of using Numpy Z compression (npz) formatting: 1) Standardized Python library (NumPy), 2) writes a compact file of several arrays into binary format and 3) significantly smaller size over many other formats. Args: filename(str): relative path and filename for MCMC trajectory .. tip:: It is possible to convert the trajectory file to a Pandas DataFrame (pickle file) with the following: :attr:`biceps.toolbox.npz_to_DataFrame` """""" if filename == None: filename = f""traj_lambda{self.lam}.npz"" # Store the name of the restraints in a list corresponding to the correct order saving = ['rest_type','trajectory_headers','trajectory','sep_accept', 'allowed_parameters','sampled_parameters','model','ref','traces','state_trace'] for rest_index in range(len(self.ensemble[0])): n_observables = self.ensemble[0][rest_index].n for n in range(n_observables): model = [] for s in range(len(self.ensemble)): model.append(self.ensemble[s][rest_index].restraints[n]['model']) self.model[rest_index].append(model) #TODO: Check to make sure that there hasn't been an update in Py3 # that will allow datatype convervation in the method `getattr()` self.results['rest_type'] = self.rest_type self.results['trajectory_headers'] = self.trajectory_headers self.results['trajectory'] = self.trajectory self.results['sep_accept'] = self.sep_accept self.results['allowed_parameters'] = self.allowed_parameters self.results['sampled_parameters'] = self.sampled_parameters self.results['model'] = self.model self.results['ref'] = self.ref self.results['traces'] = self.traces self.results['state_trace'] = self.state_trace self.write(filename, self.results) # Save Sampler object save_object(self.sampler, filename.replace("".npz"","".pkl"")) #TODO: Return a Pandas Dataframe of the results to be passed into # Analysis so time isn't wasted loading in long trajectories #return self.results #return pd.DataFrame(self.results) def write(self, filename='traj.npz', *args, **kwds): """"""Writes a compact file of several arrays into binary format. Standardized: Yes ; Binary: Yes; Human Readable: No; Args: filename(str): path and filename of output MCMC trajectory :rtype: npz (numpy compressed file) """""" np.savez_compressed(filename, *args, **kwds) ","Python" "Conformation","vvoelz/biceps","biceps/convergence.py",".py","27694","654","# -*- coding: utf-8 -*- import os import numpy as np import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt import warnings warnings.filterwarnings(""ignore"",category=DeprecationWarning) warnings.filterwarnings(""ignore"",category=RuntimeWarning) from scipy.optimize import curve_fit def single_exp_decay(x, a0, a1, tau1): """"""Function of a single exponential decay fitting. :math:`f(x) = a_{0} + a_{1}*exp(-(x/ \tau_{1}))` :param np.array x: :param float a0: :param float a1: :param float tau1: :return np.array: """""" return a0 + a1*np.exp(-(x/tau1)) def double_exp_decay(x, a0, a1, a2, tau1, tau2): """"""Function of a double exponential decay fitting. :math:`f(x) = a_{0} + a_{1}*exp(-(x/ \tau_{1})) + a_{2}*exp(-(x/ \tau_{2}))` :param np.array x: :param float a0: :param float a1: :param float a2: :param float tau1: :param float tau2: :return np.array: """""" return a0 + a1*np.exp(-(x/tau1)) + a2*np.exp(-(x/tau2)) def exponential_fit(autocorrelation, exp_function='single', v0=None, verbose=False): """"""Calls on :attr:`single_exp_decay` ('single') or :attr:`double_exp_decay` ('double') for an exponential fitting of an autocorrelation curve. See `SciPy curve fit `_ for more details. Args: autocorrelation(np.ndarray): the autocorrelation of some timeseries exp_function(str): default='single' ('single' or 'double' v0(list): Initial conditions for exponential fitting. Default for 'single' \ is v0=[0.0, 1.0, 4000.]=[a0, a1, tau1] where :math:`a_{0} + a_{1}*exp(-(x/ \tau_{1}))` and\ default for 'double' is v0=[0.0, 0.9, 0.1, 4000., 200.0]=[a0, a1, a2, tau1, tau2] where\ :math:`f(x) = a_{0} + a_{1}*exp(-(x/ \tau_{1})) + a_{2}*exp(-(x/ \tau_{2}))` Returns: yfit(np.ndarray): the y-values of the fitted curve. """""" nsteps = autocorrelation.shape[0] if exp_function == 'single': if v0 is None: v0 = [0.0, 1.0 , 4000.] # Initial guess [a0, a1, tau1] for a0 + a1*exp(-(x/tau1)) popt, pcov = curve_fit(single_exp_decay, np.arange(nsteps), autocorrelation, p0=v0, maxfev=10000) # ignore last bin, which has 0 counts yFit_data = single_exp_decay(np.arange(nsteps), popt[0], popt[1], popt[2]) if verbose: print(('Best-fit tau1 = %s +/- %s'%(popt[2],pcov[2][2]))) max_tau = popt[2] else: if v0 is None: v0 = [0.0, 0.9, 0.1, 4000., 200.0] # Initial guess [a0, a1,a2, tau1, tau2] for a0 + a1*exp(-(x/tau1)) + a2*exp(-(x/tau2)) popt, pcov = curve_fit(double_exp_decay, np.arange(nsteps), autocorrelation, p0=v0, maxfev=10000) # ignore last bin, which has 0 counts yFit_data = double_exp_decay(np.arange(nsteps), popt[0], popt[1], popt[2], popt[3], popt[4]) if verbose: print(('Best-fit tau1 = %s +/- %s'%(popt[3],pcov[3][3]))) if verbose: print(('Best-fit tau2 = %s +/- %s'%(popt[4],pcov[4][4]))) #NOTE: This may need to be fixed later max_tau = max(popt[3],popt[4]) return yFit_data,max_tau def compute_autocorrelation_curves(data, max_tau, normalize=True): """"""Calculates the autocorrelation for a list of arrays, where each array is a separate time-series. Args: data(list): list of separate timeseries maxtau(int): the upper bound of autocorrelation lag time normalize(bool): to normalize Returns: np.ndarray """""" return np.array([g(np.array(timeseries), max_tau, normalize) for timeseries in data]) def g(f, max_tau=10000, normalize=True): """"""Calculate the autocorrelaton function for a time-series f(t). Args: f(np.ndarray): a 1D numpy array containing the time series f(t) maxtau(int): the maximum autocorrelation time to consider. normalize(bool): if True, return g(tau)/g[0] Returns: np.array: a numpy array of size (max_tau+1,) containing g(tau) """""" f_zeroed = f-f.mean() T = f_zeroed.shape[0] result = np.zeros(max_tau+1) for tau in range(max_tau+1): result[tau] = np.dot(f_zeroed[0:-1-tau],f_zeroed[tau:-1])/(T-tau) if normalize: return result/result[0] else: return result def compute_autocorrelation_time(autocorrelations): """"""Computes the autocorrelation time :math:`\\tau_{auto} = \int C_{\\tau} d\\tau` Args: autocorrelations(np.ndarray): an array containing the autocorrelations for \ each time-series. Returns: np.ndarray """""" result = [sum(autocorrelations[i]) for i in range(len(autocorrelations))] return np.array(result) def get_blocks(data, nblocks=5): """"""Method used to partition data into blocks. The data is a list of arrays, where each array is a separate time-series or autocorrelation. Args: data(list): list of separate timeseries """""" # slice the data into nblocks blocks = [] for vec in data: dx = int(len(vec)/nblocks) blocks.append([vec[dx*n:dx*(n+1)] for n in range(nblocks)]) return blocks def compute_JSD(T1, T2, T_total, ind, allowed_parameters): """"""Compute JSD for a given part of trajectory. :math:`JSD = H(P_{comb}) - {\pi_{1}}{H(P_{1})} - {\pi_{2}}{H(P_{2})}`, where :math:`P_{comb}` is the combined data (:math:`P_{1} \cup P_{2}`). :math:`H` is the Shannon entropy of distribution :math:`P_{i}` and :math:`\pi_{i}` is the weight for the probability distribution :math:`P_{i}`. :math:`H(P_{i}) = \sum -\\frac{r_{i}}{N_{i}}*ln(\\frac{r_{i}}{N_{i}})`, where :math:`r_{i}` and :math:`N_{i}` represents sampled times of a specific parameter index and the total number of samples of the parameter, respectively :var T1, T2, T_total: part 1, part2 and total (part1 + part2) :var rest_type: experimental restraint type :var allowed_parameters: nuisacne parameters range :return float: Jensen–Shannon divergence """""" r1,r2,r_total = np.zeros(len(allowed_parameters)),np.zeros(len(allowed_parameters)),np.zeros(len(allowed_parameters)) for frame in T1: parameter_indices = np.concatenate(frame[4]) r1[parameter_indices[ind]]+=1 for frame in T2: parameter_indices = np.concatenate(frame[4]) r2[parameter_indices[ind]]+=1 for frame in T_total: parameter_indices = np.concatenate(frame[4]) r_total[parameter_indices[ind]]+=1 N1=sum(r1) N2=sum(r2) N_total = sum(r_total) H1 = -1.*r1/N1*np.log(r1/N1) H1 = sum(np.nan_to_num(H1)) H2 = -1.*r2/N2*np.log(r2/N2) H2 = sum(np.nan_to_num(H2)) H = -1.*r_total/N_total*np.log(r_total/N_total) H = sum(np.nan_to_num(H)) JSD = H-(N1/N_total)*H1-(N2/N_total)*H2 return JSD class Convergence(object): def __init__(self, traj=None, filename=None, outdir=""./"", verbose=False): """"""Convergence submodule for BICePs. Args: filename(str): relative path and filename to MCMC trajectory (NumPy npz file) outdir(str): relative path for output files """""" if (traj == None) and (filename == None): #raise() print(""Must provide a trajectory or a relative path to a trajectory file."") exit() self.verbose = verbose if self.verbose: print(f'Loading {filename}...') if filename: self.traj = np.load(filename, allow_pickle=True)['arr_0'].item() if traj: if type(traj) == dict: self.traj = traj else: self.traj = traj.__dict__ self.freq_save_traj = int(self.traj[""trajectory""][1][0] - self.traj[""trajectory""][0][0]) if self.verbose: print('Collecting rest_type...') self.rest_type = self.traj['rest_type'] if self.verbose: print('Collecting allowed_parameters...') self.allowed_parameters = self.traj['allowed_parameters'] if self.verbose: print('Collecting sampled parameters...') self.sampled_parameters = self.get_sampled_parameters() self.labels = self.get_labels() self.exp_function = ""single"" if outdir is None: self.outdir = os.getcwd() else: self.outdir = outdir def get_sampled_parameters(self): """"""Get sampled parameters along time (steps). :return list: A list of all nuisance paramters sampled """""" parameters = [] for i in range(len(self.rest_type)): parameters.append(np.array(self.traj['traces'])[:,i]) parameters = np.array(parameters) return parameters def get_labels(self): """"""Fetches the labels of each of the restraint types."""""" labels = [] for i in range(len(self.rest_type)): if self.rest_type[i].count('_') == 0: if self.rest_type[i] == 'gamma': labels.append('$\%s$'%self.rest_type[i]) else: labels.append('$%s$'%self.rest_type[i]) elif self.rest_type[i].count('_') == 1: labels.append(""$\%s_{%s}$""%(self.rest_type[i].split('_')[0],self.rest_type[i].split('_')[1])) elif self.rest_type[i].count('_') == 2: labels.append(""$\%s_{{%s}_{%s}}$""%(self.rest_type[i].split('_')[0],self.rest_type[i].split('_')[1],self.rest_type[i].split('_')[2])) return labels def plot_traces(self, figname=""traj_traces.png"", xlim=None): """"""Plot trajectory traces. Args: xlim(tuple): matplotlib x-axis limits """""" if self.verbose: print('Plotting traces...') total_steps = len(self.sampled_parameters[0]) x = np.arange(1,total_steps+0.1,1)*self.freq_save_traj n_rest = len(self.rest_type) plt.figure(figsize=(3*n_rest,6)) for i in range(len(self.rest_type)): plt.subplot(len(self.rest_type), 1, i+1) plt.plot(x, self.sampled_parameters[i],label=self.labels[i]) plt.ylabel(self.labels[i], fontsize=18) plt.xlabel('steps', fontsize=18) plt.legend(loc='best') plt.xticks(fontsize=14) plt.yticks(fontsize=14) if xlim: plt.xlim(left=xlim[0], right=xlim[1]) plt.tight_layout() plt.savefig(os.path.join(self.outdir,figname)) if self.verbose: print('Done!') def plot_auto_curve(self, xlim=None, figname=""autocorrelation_curve.png"", std_x=None, std_y=None): """"""Plot auto-correlation curve. This function saves a figure of auto-correlation with error bars at the 95% confidence interval (:math:`\\tau_{auto}` is rounded to the nearest integer). Args: xlim(tuple): matplotlib x-axis limits std_x(np.ndarray): std_y(np.ndarray): """""" if self.verbose: print('Plotting autocorrelation curve ...') plt.figure( figsize=(3*len(self.rest_type),6)) for i in range(len(self.autocorr)): if len(self.rest_type) == 2: plt.subplot(len(self.autocorr),1,i+1) else: plt.subplot(len(self.autocorr),2,i+1) plt.plot(np.arange(self.maxtau+1), self.autocorr[i]) j = int(round(self.tau_c[i])) plt.axvline(self.tau_c[i], color='k', linestyle=""--"") if isinstance(std_x, np.ndarray) or isinstance(std_y, np.ndarray): plt.annotate(""$\\tau_{auto} = %i \\pm %i$""%(round(self.tau_c[i]),round(std_x[i])), (self.tau_c[i], self.autocorr[i][j]), xytext=(self.tau_c[i]+10, self.autocorr[i][j]+0.05), fontsize=16) if isinstance(std_x, np.ndarray): plt.errorbar(self.tau_c[i], self.autocorr[i][j], xerr=std_x[i], ecolor='k', fmt='o', capsize=10) if isinstance(std_y, np.ndarray): #if (type(std_x) == np.ndarray) or (type(std_y) == np.ndarray): # plt.annotate(""$\\tau_{auto} = %i \\pm %i$""%(round(self.tau_c[i]),round(std_x[i])), # (self.tau_c[i], self.autocorr[i][j]), # xytext=(self.tau_c[i]+10, self.autocorr[i][j]+0.05)) # if (type(std_x) == np.ndarray): # plt.errorbar(self.tau_c[i], self.autocorr[i][j], xerr=std_x[i], # ecolor='k', fmt='o', capsize=10) # # if (type(std_y) == np.ndarray): plt.fill_between(np.arange(self.maxtau+1), self.autocorr[i]-std_y[i], self.autocorr[i]+std_y[i], color='r', alpha=0.4) else: plt.annotate(""$\\tau_{auto} = %i$""%(round(self.tau_c[i])), (self.tau_c[i], self.autocorr[i][j]), xytext=(self.tau_c[i]+10, self.autocorr[i][j]+0.05), fontsize=16) plt.xlabel('$\\tau$', fontsize=18) plt.ylabel('$C_{\\tau}$ for %s'%self.labels[i], fontsize=18) plt.xlim(left=0) plt.xticks(fontsize=14) plt.yticks(fontsize=14) if xlim: plt.xlim(left=xlim[0], right=xlim[1]) plt.tight_layout() plt.savefig(os.path.join(self.outdir,figname)) if self.verbose: print('Done!') def plot_auto_curve_with_exp_fitting(self, figname=""autocorrelation_curve_with_exp_fitting.png""): """"""Plot auto-correlation curve with an exponential fitting. :return figure: A figure of auto-correlation """""" if self.verbose: print('Plotting autocorrelation curve ...') plt.figure( figsize=(3*len(self.rest_type),6)) for i in range(len(self.autocorr)): if len(self.rest_type) == 2: plt.subplot(len(self.autocorr),1,i+1) else: plt.subplot(len(self.autocorr),2,i+1) j = int(round(self.tau_c[i])) # NOTE: Only works for single exponential plt.axvline(self.tau_c[i], color='k', linestyle=""--"") try: plt.annotate(""$\\tau_{auto} = %i$""%(round(self.tau_c[i])), (self.tau_c[i], self.autocorr[i][j]), xytext=(self.tau_c[i]+10, self.autocorr[i][j]+0.05), fontsize=16) except(IndexError) as e: continue plt.plot(np.arange(self.maxtau+1), self.autocorr[i]) plt.plot(np.arange(self.maxtau+1), self.yFits[i], 'r--') plt.xlabel('$\\tau$', fontsize=18) plt.ylabel('$C_{\\tau}$ for %s'%self.labels[i], fontsize=18) plt.xlim(left=0) plt.xticks(fontsize=14) plt.yticks(fontsize=14) plt.tight_layout() plt.savefig(os.path.join(self.outdir,figname)) if self.verbose: print('Done!') def get_autocorrelation_curves(self, method=""auto"", nblocks=5, maxtau=10000, plot_traces=False): """"""Compute autocorrelaton function for a time-series f(t), partition the data into the specified number of blocks and plot the autocorrelation curve. Saves a figure of autocorrelation curves for each restraint. Args: method(str): method for computing autocorrelation time; ""block-avg-auto"" or ""exp"" or ""auto"" nblocks(int): number of blocks to split up the trajectory maxtau(int): the upper bound of autocorrelation lag time plot_traces(bool): plot the trajectory traces? """""" sampled_parameters = self.sampled_parameters self.maxtau = maxtau # C++ #autocorr = np.array(c_conv.autocorrelation(sampled_parameters, # int(maxtau), bool(normalize))) #self.tau_c = np.array(c_conv.autocorrelation_time(autocorr)) # Python if self.verbose: print('Calculating autocorrelation ...') self.autocorr = compute_autocorrelation_curves(sampled_parameters, max_tau=self.maxtau, normalize=True) if self.verbose: print(""Done!"") if self.verbose: print('Calculating autocorrelation times...') self.tau_c = compute_autocorrelation_time(self.autocorr) if self.verbose: print(""Done!"") if method in [""block-avg-auto"",""auto""]: if method == ""auto"": nblocks = 1 blocks = get_blocks(sampled_parameters, nblocks) x,y = [],[] for i in range(len(blocks)): y.append(compute_autocorrelation_curves(blocks[i], max_tau=self.maxtau, normalize=True)) x.append(compute_autocorrelation_time(y[i])) # y.append(self.cal_auto(blocks[i])) # x.append(self.autocorrelation_time(y[i])) # x, y = np.array(x),np.array(y) self.autocorr = np.average(y, axis=1) self.tau_c = np.average(x, axis=1) # Check to see if there are any negative autocorrelation times # NOTE: Should mention something about negative autocorrelation times if any(i < 0 for i in self.tau_c): print(""NOTE: Found a negative autocorrelation time..."") # If the number of blocks is 1, then we can't get std. if nblocks == 1: std_y,std_x = None,None else: std_y = np.std(y, axis=1) std_x = np.std(x, axis=1) self.plot_auto_curve(std_x=std_x, std_y=std_y) elif method == ""exp"": from scipy.optimize import curve_fit self.yFits,self.popts = [],[] for i in range(len(self.autocorr)): yFit,popt = exponential_fit(self.autocorr[i], exp_function=self.exp_function) self.popts.append(popt) self.yFits.append(yFit) self.tau_c = np.array(self.popts) #np.max(popts) #print((""self.tau_c = %s""%self.tau_c)) self.plot_auto_curve_with_exp_fitting() else: raise KeyError(f""Method must be 'block-avg-auto' or 'exp' or 'auto'. You provided: {method}"") if plot_traces: self.plot_traces() def process(self, nblock=5, nfold=10, nround=100, savefile=True, block_avg=False, normalize=True): """"""Process the trajectory and execute :func:`compute_JSD` with :func:`plot_JSD_conv` and :func:`plot_JSD_distribution`. If :attr:`block_avg=True`, then block averaging will be executed and :func:`plot_block_avg` will be executed as well. Args: nblock(int): is the number of partitions in the time series nfold(int): is the number of partitions in the shuffled (subsampled) trajectory nround(int): is the number of rounds of bootstrapping when computing JSDs savefile(bool): block_avg(bool): use block averaging verbose(bool): verbosity """""" if block_avg: r_total = [[] for i in range(len(self.rest_type))] r_max = [[] for i in range(len(self.rest_type))] for i in range(len(self.tau_c)): tau_auto = self.tau_c[i] tau = int(1+2*tau_auto) T_new = self.traj['trajectory'][::tau] nsnaps = len(T_new) dx = int(nsnaps/nfold) for subset in range(nblock): T_total = T_new[dx*subset:dx*(subset+1)] r_grid = np.zeros(len(self.allowed_parameters[i])) for k in T_total: ind = np.concatenate(k[4])[i] r_grid[ind]+=1 r_total[i].append(r_grid) r_max[i].append(self.allowed_parameters[i][np.argmax(r_grid)]) self.plot_block_avg(nblock,r_max) all_JSD=[[] for i in range(len(self.tau_c))] # create JSD list all_JSDs=[[[] for i in range(nfold)] for j in range(len(self.tau_c))] # create JSD list of distribution if self.verbose: print('Calculating JSDs ...') for i in range(len(self.tau_c)): ind = i tau_auto = self.tau_c[i] tau = int(1+2*tau_auto) T_new = self.traj['trajectory'][::tau] nsnaps = len(T_new) if nsnaps < 2*nfold: print('Warning: not enough data left after subsampling using auto-correlation time with the given nfold') exit() dx = int(nsnaps/nfold) for subset in range(nfold): half = int(dx * (subset+1)/2) T1 = T_new[:half] # first half of the trajectory T2 = T_new[half:dx*(subset+1)] # second half of the trajectory T_total = T_new[:dx*(subset+1)] # total trajectory all_JSD[i].append(compute_JSD(T1,T2,T_total,ind,self.allowed_parameters[i])) # compute JSD for r in range(nround): # now let's mix this dataset mT1 = np.random.choice(len(T_total),int(len(T_total)/2),replace=False) # randomly pickup snapshots (index) as the first part mT2 = np.delete(np.arange(0,len(T_total),1),mT1) # take the rest (index) as the second part temp_T1, temp_T2 = [],[] for snapshot in mT1: temp_T1.append(T_total[snapshot]) # take the first part dataset from the trajectory for snapshot in mT2: temp_T2.append(T_total[snapshot]) # take the second part dataset from the trajectory all_JSDs[i][subset].append(compute_JSD(temp_T1,temp_T2,T_total,ind,self.allowed_parameters[i])) if savefile: np.save(os.path.join(self.outdir,""all_JSD.npy""), all_JSD) np.save(os.path.join(self.outdir,""all_JSDs.npy""), all_JSDs) if self.verbose: print('Done!') self.plot_JSD_distribution(np.array(all_JSD), np.array(all_JSDs), nround, nfold) self.plot_JSD_conv(np.array(all_JSD), np.array(all_JSDs)) def plot_block_avg(self, nblock, r_max, figname=""block_avg.png""): """"""Plot block average Args: nblock(int): is the number of partitions in the time series r_max(np.ndarray): maximum sampled parameters for each restraint figname(str): figure name without relative path (taken care of) """""" plt.figure(figsize=(10,5*len(self.rest_type))) x=np.arange(1.,nblock+1.,1.) colors=['red','blue','black','green'] for i in range(len(self.rest_type)): total_max = self.allowed_parameters[i][np.argmax(self.traj['sampled_parameters'][i])] plt.subplot(len(self.rest_type),1,i+1) plt.plot(x, r_max[i], 'o-', color=colors[i], label=self.labels[i]) plt.xlabel('block', fontsize=18) plt.ylabel('allowed '+self.labels[i], fontsize=18) plt.ylim(min(self.allowed_parameters[i]),max(self.allowed_parameters[i])) plt.plot(nblock-0.2,total_max,'*',ms=20,color='green',label='total max') plt.legend(loc='best', fontsize=16) plt.xticks(fontsize=14) plt.yticks(fontsize=14) plt.tight_layout() plt.savefig(os.path.join(self.outdir,figname)) def plot_JSD_conv(self, JSD, JSDs, p_limit=0.99): """"""Plot Jensen–Shannon divergence (JSD) distribution for convergence check. :var all_JSD: JSDs for different amount of total dataset :var all_JSDs: JSDs for different amount of total dataset from bootstrapping :var rest_type: experimental restraint type :param float default=0.99 p_limit: plot a red horizontal dotted line at this y-value :return figure: A figure of JSD and JSDs distribution """""" if self.verbose: print('plotting JSDs ...') for k in range(len(JSD)): plt.figure(figsize=(10,5)) for j in range(len(JSD[0])): plt.subplot(2,5,j+1) all_JSDs = np.append(JSDs[k][j],JSD[k][j]) JSDs_sorted = np.sort(all_JSDs) p = np.arange(len(all_JSDs), dtype=float) ind = np.where(JSDs_sorted==JSD[k][j])[0][0] norm = len(all_JSDs) - 1. # Red Dot plt.plot(JSDs_sorted[ind], p[ind]/norm, 'o',ms=5,color='red',label='%.3f'%(p[ind]/norm)) # plt.annotate('%.3f'%(p[ind]/norm),xy=(JSDs_sorted[ind],p[ind]/norm),color='red',fontsize=6) # Blue Curve plt.plot(JSDs_sorted, p/norm) # Horizontal Line plt.plot([0.0, JSDs_sorted[ind]], [p[ind]/norm, p[ind]/norm], 'k') # Red horizontal line plt.plot([0.0, np.max(JSDs_sorted)], [p_limit, p_limit], '--r') # Vertical Line plt.plot([JSDs_sorted[ind], JSDs_sorted[ind]], [0.0, p[ind]/norm], 'k') plt.ylim(bottom=0.0, top=1.0) plt.xlim(left=0.0) plt.xlabel('JSD') plt.ylabel('$p$') plt.xticks(fontsize=6) plt.locator_params(axis='x',nbins=5) plt.title('%d'%(10*(j+1))+'%',fontsize=10) plt.legend(loc='best',fontsize=6) plt.tight_layout() plt.savefig(os.path.join(self.outdir,'JSD_conv_%s.pdf'%self.rest_type[k])) if self.verbose: print('Done') def plot_JSD_distribution(self, all_JSD, all_JSDs, nround, nfold, figname=""JSD_distribution.png""): """"""Plots the distributions for JSD"""""" colors=['red', 'blue','black','green'] # convert shape of all_JSD from (fold,n_rest) to (n_rest,fold) n_rest = len(self.rest_type) # compute mean, std of JSDs from each fold dataset of each restraint JSD_dist = [[] for i in range(n_rest)] JSD_std = [[] for i in range(n_rest)] for rest in range(n_rest): for f in range(nfold): temp_JSD = [] for r in range(nround): temp_JSD.append(all_JSDs[rest][f][r]) JSD_dist[rest].append(np.mean(temp_JSD)) JSD_std[rest].append(np.std(temp_JSD)) plt.figure(figsize=(10,5*n_rest)) x=np.arange(int(100/nfold),101.,int(100/nfold)) # the dataset was divided into ten folds (this is the only hard coded part) for i in range(n_rest): plt.subplot(n_rest,1,i+1) plt.plot(x,all_JSD[i].transpose(),'o-',color=colors[i],label=self.labels[i]) #plt.hold(True) #plt.plot(x,JSD_dist[i],'*',color=colors[i],label=self.labels[i]) ## 2 Standard deviations from the mean #plt.fill_between(x,np.array(JSD_dist[i])+2*np.array(JSD_std[i]), # np.array(JSD_dist[i])-2*np.array(JSD_std[i]), # color=colors[i],alpha=0.2) # at 95% confidence interval bounds = np.sort(all_JSDs[i]) # remove top 50 and lower 50 lower = bounds[:, int(nround*0.05)] upper = bounds[:, int(nround*0.95)] plt.fill_between(x,lower,upper,color=colors[i],alpha=0.2) plt.xlabel('dataset (%)', size=18) plt.ylabel('JSD', size=18) plt.legend(loc='best') plt.xticks(fontsize=14) plt.yticks(fontsize=14) plt.tight_layout() plt.savefig(os.path.join(self.outdir,figname)) ","Python" "Conformation","vvoelz/biceps","docs/pip_and_conda_install_protocol.md",".md","1554","80","# Protocol for setting up `pip install` Please see: #### Tutorial for [Packing Python Projects](https://packaging.python.org/tutorials/packaging-projects/) ##### Prerequisites: ```bash pip install --user --upgrade setuptools wheel pip install --user --upgrade twine ``` -------------------------------------- 1. Register an account on [https://pypi.org](https://pypi.org/) or [https://test.pypi.org](https://test.pypi.org/) if you would like to do testing first. 2. Create a `setup.py` - main commands/controls for the project to be built. 3. Run: ``` python setup.py sdist bdist_wheel ``` - The command that is used to build the distribution archives (The `tar.gz` file is a source archive whereas the `.whl` file is a built distribution) 4. Lastly, run the following command to upload to your pypi account: ``` twine upload dist/* ``` # Protocol for setting up `conda install` Please see: #### Tutorial for [Uploading Conda Packages](https://docs.anaconda.com/anaconda-cloud/user-guide/tasks/work-with-packages/#uploading-conda-packages) ##### Prerequisites: ```bash conda install anaconda-client conda-build ``` -------------------------------------- 1. Register an account on [https://anaconda.org/](https://anaconda.org/). 2. Create a `meta.yaml` - main commands/controls for the project to be built. 3. Run `conda build` in the directory of `meta.yml` ``` conda build . ``` 4. Lastly, login to your anaconda account and upload the package ``` anaconda login anaconda upload /path/to/conda-package.tar.bz2 ``` ","Markdown" "Conformation","vvoelz/biceps","docs/make_html.py",".py","962","43"," import subprocess,os source = ""./"" outdir = ""OUT"" if os.path.exists(outdir): subprocess.Popen(f""rm -r {outdir}"", shell=True) if os.path.exists(outdir): subprocess.Popen(f""rm -r api"", shell=True) subprocess.Popen(f""sphinx-build -b html {source} {outdir}"", shell=True) # Other scripts and things:{{{ ''' NOTES from other scripts. echo ""Building biceps..."" $PYTHON setup.py install # Python command to install the script. #!/usr/bin bash printf 'This is a script to build the html files, then open up a webserver to view the docs' # Define the Project Name and the Authors of this Project Proj_Name='biceps' wd=$PWD ## Check to see if python can see your package: python -c 'import '$Proj_Name; # Set the Python path only for the build command #FIXME: PYTHONPATH=$wd/$Proj_Name make html; # Now, we want to see what we have created so far... # Open up a simple python webserver. open http://localhost:8000/ python -m SimpleHTTPServer; ''' # }}} ","Python" "Conformation","vvoelz/biceps","docs/conf.py",".py","6114","223","# -*- coding: utf-8 -*- import os, sys from datetime import datetime sys.path.insert(0, os.path.abspath('../')) import biceps # -- General configuration ------------------------------------------------ extensions = [ 'nbsphinx', # for jupyter notebooks ** 'sphinx.ext.mathjax', 'sphinx.ext.autodoc', 'sphinx.ext.doctest', 'sphinx.ext.autosummary', 'autoapi.sphinx', 'sphinxcontrib.napoleon' ] # Napoleon settings napoleon_google_docstring = True napoleon_numpy_docstring = True napoleon_include_init_with_doc = False napoleon_include_private_with_doc = False napoleon_include_special_with_doc = False napoleon_use_admonition_for_examples = False napoleon_use_admonition_for_notes = False napoleon_use_admonition_for_references = False napoleon_use_ivar = False napoleon_use_param = True napoleon_use_rtype = True napoleon_use_keyword = True napoleon_custom_sections = None ## Document Python Code autoapi_type = 'python' autoapi_dirs = ['../biceps'] # Directory of Source Code (directory of source code) autoapi_root = './api' #autodoc_default_flags = ['members', 'inherited-members', 'classes'] #autodoc_default_flags = ['members', 'inherited-members'] autodoc_default_flags = ['members'] autosummary_generate = True autodoc_member_order = 'bysource' todo_include_todos = False autoapi_modules = { 'biceps': { 'override': False, 'output': autoapi_root } } numpydoc_class_members_toctree = False #numpydoc_class_members_toctree = True # concatenate both class and __init__ docstrings when generating autodoc class # docs autoclass_content = 'both' #autoclass_content = 'class' # Execute notebooks before conversion: 'always', 'never', 'auto' (default) nbsphinx_execute = 'never' # Use this kernel instead of the one stored in the notebook metadata: nbsphinx_kernel_name = 'python3' # If True, the build process is continued even if an exception occurs: nbsphinx_allow_errors = True # List of arguments to be passed to the kernel that executes the notebooks: nbsphinx_execute_arguments = ['--InlineBackend.figure_formats={""png"", ""pdf""}'] # Controls when a cell will time out (defaults to 30; use -1 for no timeout): #nbsphinx_timeout = 60 # Default Pygments lexer for syntax highlighting in code cells: nbsphinx_codecell_lexer = 'ipython3' # Width of input/output prompts used in CSS: #nbsphinx_prompt_width = '8ex' # If window is narrower than this, input/output prompts are on separate lines: nbsphinx_responsive_width = '250px' # Add any paths that contain templates here, relative to this directory. #templates_path = ['_templates'] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # source_suffix = ['.rst', '.md', '.html'] # The master toctree document. master_doc = 'index' # General information about the project. project = u'BICePs' authors = u'Raddi R., Ge Y., Voelz V.' date = datetime.now() copyright = f""""""{date.today().year}, Temple University, {authors} """""" version = biceps.__version__ release = version # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # # This is also used if you do content translation via gettext catalogs. # Usually you set ""language"" from the command line for these cases. language = 'en' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This patterns also effect to html_static_path and html_extra_path exclude_patterns = [ 'README.md', '_build', '_templates', '**.ipynb_checkpoints', 'biceps.egg-info' ] # This is processed by Jinja2 and inserted before each notebook nbsphinx_prolog = r"""""" {% set docname = env.doc2path(env.docname, base='doc') %} .. only:: html .. role:: raw-html(raw) :format: html __ https://github.com/spatialaudio/nbsphinx/blob/ {{ env.config.release }}/{{ docname }} .. raw:: latex \vfil\penalty-1\vfilneg \vspace{\baselineskip} \textcolor{gray}{The following section was generated from \texttt{\strut{}{{ docname }}}\\[-0.5\baselineskip] \noindent\rule{\textwidth}{0.4pt}} \vspace{-2\baselineskip} """""" # This is processed by Jinja2 and inserted after each notebook nbsphinx_epilog = r"""""" .. raw:: latex \textcolor{gray}{\noindent\rule{\textwidth}{0.4pt}\\ \hbox{}\hfill End of \texttt{\strut{}{{ env.doc2path(env.docname, base='doc') }}}} \vfil\penalty-1\vfilneg """""" # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' # -- Options for HTMLHelp output --------------------------------------------- # Output file base name for HTML help builder. htmlhelp_basename = 'BICePsdoc' # -- Options for HTML output ---------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # import sphinx_rtd_theme html_theme = 'sphinx_rtd_theme' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. # html_theme_options = { 'canonical_url': '', 'analytics_id': '', 'logo_only': True, 'display_version': False, 'prev_next_buttons_location': 'bottom', 'style_external_links': True, #False, #'vcs_pageview_mode': '', # Toc options 'collapse_navigation': True, 'sticky_navigation': True, 'navigation_depth': 4, 'includehidden': True, 'titles_only': False } # Adding our Temp Logo: html_logo = 'logo.png' #html_static_path = ['_static'] html_css_files = [ '../../theme.css' ] intersphinx_mapping = {'https://docs.python.org/': None} # -- Options for Epub output ---------------------------------------------- # Bibliographic Dublin Core info. epub_title = project epub_author = authors epub_publisher = authors epub_copyright = copyright #--Adding Markdown----------------------------------- from recommonmark.parser import CommonMarkParser source_parsers = { '.md': CommonMarkParser, } ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/albocycline/albocycline.ipynb",".ipynb","100095","471","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Albocycline\n"", ""===========\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""
\n"", ""\n"", ""

Summary:

Albocycline is a macrolactone isolated from Streptomyces maizeus. This macrolactone has recently been identified as a promising lead antibiotic candidate for the treatment of both vancomycin-resistant S. aureus (VRSA) and MRSA.
\n"", ""In our previous example we showed in detail how to calculate the consistency of theoretical modeling with experiment. The user gained insight on how to run `biceps` calculations in full. In this example, we will repeat the process parallelizing lambda values with `multiprocessing`.\n"", ""\n"", ""\n"", ""\n"", ""**To convert this Jupyter Notebook into a script use the following command:**\n"", ""\n"", ""```\n"", ""$ jupyter nbconvert --to python albocycline.ipynb\n"", ""```\n"", ""\n"", ""
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 8, ""metadata"": {}, ""outputs"": [], ""source"": [ ""import numpy as np\n"", ""import pandas as pd\n"", ""import biceps\n"", ""import warnings\n"", ""warnings.filterwarnings(\""ignore\"", category=UserWarning)\n"", ""warnings.filterwarnings('ignore', category=FutureWarning)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 2, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Possible input data extensions: ['H', 'Ca', 'N', 'J', 'noe', 'pf']\n"", ""Input data: ['J', 'noe']\n"" ] } ], ""source"": [ ""####### Data and Output Directories #######\n"", ""print(f\""Possible input data extensions: {biceps.toolbox.list_possible_extensions()}\"")\n"", ""energies = np.loadtxt('albocycline/albocycline_QMenergies.dat')*627.509 # convert from hartrees to kcal/mol\n"", ""energies = energies/0.5959 # convert to reduced free energies F = f/kT\n"", ""energies -= energies.min() # set ground state to zero, just in case\n"", ""dataFiles = 'albocycline/J_NOE'\n"", ""input_data = biceps.toolbox.sort_data(dataFiles)\n"", ""print(f\""Input data: {biceps.toolbox.list_extensions(input_data)}\"")\n"", ""outdir = 'results'\n"", ""biceps.toolbox.mkdir(outdir)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 4, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""nSteps of sampling: 100000\n"" ] }, { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
refsigmagamma
0uniform(0.05, 20.0, 1.02)NaN
1exponential(0.05, 5.0, 1.02)(0.2, 5.0, 1.01)
\n"", ""
"" ], ""text/plain"": [ "" ref sigma gamma\n"", ""0 uniform (0.05, 20.0, 1.02) NaN\n"", ""1 exponential (0.05, 5.0, 1.02) (0.2, 5.0, 1.01)"" ] }, ""execution_count"": 4, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""####### Parameters #######\n"", ""\n"", ""nsteps = 100000 # for testing\n"", ""#nsteps=10000000 # for production\n"", ""\n"", ""print(f\""nSteps of sampling: {nsteps}\"")\n"", ""n_lambdas = 3\n"", ""lambda_values = np.linspace(0.0, 1.0, n_lambdas)\n"", ""parameters = [\n"", "" {\""ref\"": 'uniform', \""sigma\"": (0.05, 20.0, 1.02)},\n"", "" {\""ref\"": 'exponential', \""sigma\"": (0.05, 5.0, 1.02), \""gamma\"": (0.2, 5.0, 1.01)}\n"", "" ]\n"", ""pd.DataFrame(parameters)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 5, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Number of CPUs: 10\n"", ""Number of processes: 3\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""100%|███████████████████████████████████████████████████████████| 100000/100000 [00:01<00:00, 62547.07it/s]\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted 70.378 % \n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""\r"", ""100%|███████████████████████████████████████████████████████████| 100000/100000 [00:01<00:00, 62460.76it/s]"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted 67.006 % \n"", ""\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""\r"", ""100%|███████████████████████████████████████████████████████████| 100000/100000 [00:01<00:00, 62394.44it/s]"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted [32.549 31.386 31.386 6.443] % \n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""\n"", ""Accepted 71.999 % \n"", ""\n"", ""\n"", ""Accepted [32.549 31.725 31.725 2.732] % \n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""\n"", ""Accepted [32.643 31.537 31.537 7.819] % \n"", ""\n"" ] } ], ""source"": [ ""####### Multiprocessing Lambda values #######\n"", ""@biceps.multiprocess(iterable=lambda_values)\n"", ""def mp_lambdas(lam):\n"", "" ensemble = biceps.Ensemble(lam, energies)\n"", "" ensemble.initialize_restraints(input_data, parameters)\n"", "" sampler = biceps.PosteriorSampler(ensemble)\n"", "" sampler.sample(nsteps=nsteps, verbose=False)\n"", "" sampler.traj.process_results(f\""{outdir}/traj_lambda{lam}.npz\"")"" ] }, { ""cell_type"": ""code"", ""execution_count"": 9, ""metadata"": { ""scrolled"": false }, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""not all state sampled, these states [86] are not sampled\n"", ""not all state sampled, these states [ 9 15 48] are not sampled\n"", ""not all state sampled, these states [ 4 5 7 9 11 15 16 18 21 24 25 27 28 34 40 42 44 48 51 54 58 62 76 77\n"", "" 81 82 86 87 94 95 98] are not sampled\n"" ] }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""####### Posterior Analysis #######\n"", ""A = biceps.Analysis(outdir, nstates=len(energies))\n"", ""\n"", ""try:\n"", "" %matplotlib inline\n"", "" A.plot()\n"", ""except:\n"", "" print(ipython_warning)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
# NOTE: The following cell is for pretty notebook rendering
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 10, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"" ], ""text/plain"": [ """" ] }, ""execution_count"": 10, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from IPython.core.display import HTML\n"", ""\n"", ""def css_styling():\n"", "" styles = open(\""../../../theme.css\"", \""r\"").read()\n"", "" return HTML(styles)\n"", ""\n"", ""css_styling()"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""Python 3 (ipykernel)"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.8.13"" } }, ""nbformat"": 4, ""nbformat_minor"": 2 } ","Unknown" "Conformation","vvoelz/biceps","docs/examples/full_examples/albocycline/mp_lambdas.py",".py","1855","54","import os, sys, pickle import numpy as np import biceps ####### Data and Output Directories ####### print(f""Possible input data extensions: {biceps.toolbox.list_possible_extensions()}"") top ='albocycline/pdbs/0.pdb' energies = np.loadtxt('albocycline/albocycline_QMenergies.dat')*627.509 # convert from hartrees to kcal/mol energies = energies/0.5959 # convert to reduced free energies F = f/kT energies -= energies.min() # set ground state to zero, just in case dataFiles = 'albocycline/J_NOE' input_data = biceps.toolbox.sort_data(dataFiles) print(f""Input data: {biceps.toolbox.list_extensions(input_data)}"") ####### Parameters ####### nsteps=1000000 print(f""nSteps of sampling: {nsteps}"") maxtau = 1000 n_lambdas = 3 outdir = '%s_steps_%s_lam'%(nsteps, n_lambdas) biceps.toolbox.mkdir(outdir) lambda_values = np.linspace(0.0, 1.0, n_lambdas) parameters = [ {""ref"": 'uniform', ""sigma"": (0.05, 20.0, 1.02)}, {""ref"": 'exp', ""sigma"": (0.05, 5.0, 1.02), ""gamma"": (0.2, 5.0, 1.01)} ] ###### Multiprocessing Lambda values ####### @biceps.multiprocess(iterable=lambda_values) def mp_lambdas(lam): print(f""lambda: {lam}"") ensemble = biceps.Ensemble(lam, energies) ensemble.initialize_restraints(input_data, parameters) sampler = biceps.PosteriorSampler(ensemble) sampler.sample(nsteps=nsteps, verbose=False) sampler.traj.process_results(f""{outdir}/traj_lambda{lam}.npz"") ''' ####### Convergence Check ####### C = biceps.Convergence(trajfile=outdir+""/traj_lambda0.00.npz"") C.get_autocorrelation_curves(maxtau=maxtau) C.plot_auto_curve(fname=""auto_curve.pdf"", xlim=(0, maxtau)) C.process(nblock=5, nfold=10, nround=100, savefile=True, plot=True, block_avg=True, normalize=True) ''' ####### Posterior Analysis ####### A = biceps.Analysis(trajs=f""{outdir}/traj*.npz"", nstates=len(energies)) A.plot() ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/albocycline/test_albocycline.py",".py","354","17","### Testing script to be used with ### $ pytest -v import os, sys # Build the notebook into a script that we can test os.system('jupyter nbconvert --to python albocycline.ipynb') # ... this should output albocycline.py def test_albocycline(): """"""Tests the code in albocycline.py by importing it."""""" import albocycline test_albocycline() ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/BICePs_v2.0.ipynb",".ipynb","1213951","1782","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# BICePs v2.0: Software for Ensemble Reweighting using Bayesian Inference of Conformational Populations\n"", ""\n"", ""

\n"", ""Robert M. Radd$^{1}$, Yunhui Ge$^{2}$, Vincent A. Voelz$^{1}$\n"", ""\n"", ""\n"", ""$^{1}$Department of Chemistry, Temple University, Philadelphia, PA 19122, USA\n"", ""\n"", ""$^{2}$Department of Pharmaceutical Sciences, University of California, Irvine, CA, USA\n"", ""

\n"", ""\n"", ""https://doi.org/10.26434/chemrxiv-2022-1b24c\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""

Ensemble reweighting of cineromycin B:

\n"", ""\n"", ""We illustrate the application and results of our Bayesian reweighting approach using a dataset used during the inception of BICePs (DOI: 10.1002/jcc.23738). Cineromycin B is a 14-membered macrolide antibiotic that has become increasingly known for having activity against methicillin-resistant Staphylococcus Aureus (MRSA). Using a combination of high-resolution structural modeling and sparse restraints from experimental observables, we will reproduce our previously published results and show how we can calculate the consistency of computational models of cineromycin B compare with experiment.\n"", ""\n"", ""\n"", ""
\n"", ""\n"", ""
The line structure of the 14-membered macrocycle Cineromycin B (7-O-demethylalbocycline).\n"", ""
\n"", ""
\n"", ""\n"", ""\n"", ""To determine solution-state conformational populations of cineromycin B, we must first prepare our sparse experimental Nuclear Magnetic Resonance (NMR) observables alongside the forward model predicted observables for each configuration. In this example, our energies (prior) and forward model comes from replica exchange molecular dynamics/Quantum mechanics(QM)-refined conformational ensembles (100 states). In the next section, forward model predictions for both NOE distances & scalar coupling constants will be computed using our built-in tools. In this tutorial, we demonstrate from start to finish how to use the BICePs Python module to calculate the consistency of computational modeling with experiment. This notebook is meant as a supplemental resource to the following paper: https://doi.org/10.26434/chemrxiv-2022-1b24c.\n"", ""\n"", ""\n"", ""\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 3, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""BICePs - Bayesian Inference of Conformational Populations, Version 2.0\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""Warning on use of the timeseries module: If the inherent timescales of the system are long compared to those being analyzed, this statistical inefficiency may be an underestimate. The estimate presumes the use of many statistically independent samples. Tests should be performed to assess whether this condition is satisfied. Be cautious in the interpretation of the data.\n"" ] } ], ""source"": [ ""import biceps\n"", ""\n"", ""import numpy as np\n"", ""import pandas as pd\n"", ""import os, pickle, string\n"", ""import matplotlib.pyplot as plt\n"", ""import matplotlib.gridspec as gridspec\n"", ""import warnings\n"", ""warnings.filterwarnings(\""ignore\"", category=UserWarning)\n"", ""warnings.filterwarnings('ignore', category=FutureWarning)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""#### Preparing \\& organizing the data\n"", ""\n"", ""\n"", ""\n"", ""In order to use the algorithm, experimental and theoretical information for each state must be arranged into columns placed inside data tables. These data tables, also known as Pandas DataFrames, must be constructed for each experimental observable type e.g., NOE, J-coupling, chemical shifts, etc. For convieniency, an automated approach for data preparation along with forward model prediction tools is also included in our software. To use our built-in forward model approaches that primarily use MDTraj, simply invoke functions from `biceps.toolbox`. For chemical shift prediction for proteins, we recommend shiftx2, but please be aware that there are many software options for the various types of forward model predictions. A discussion of possible options for forward model predictions with pros and cons goes beyhond the scope of this application. Nevertheless, the user should carefully consider how they wish to perform these calculations.\n"", ""\n"", ""\n"", ""\n"", ""BICePs v2.0 supports the following experimental observables: 1) NMR nuclear Overhauser effect (NOE), 2) NMR chemical shifts, 3) J coupling constants (small molecules and amino acids) and 4) Hydrogen-deuterium exchange (HDX). The MDTraj python library\\cite{Mcgibbon:2015fva} and the SHIFTX2\\cite{Han:2011fwa} algorithm as implemented in MDTraj is normally used for computation of pairwise distances of atoms and chemical shifts in our work. For J coupling constants, our team has prepared functions in `biceps.toolbox` for both small molecules and non-natural/natural amino acids. In short, different Karplus relations are used for specific stereochemistry for small molecules and non-natural amino acids. J couplings of natural amino acids are empirically computed using different models. Six Karplus relations are provided for natural amino acids based on previous works \\cite{Hu1997DeterminationO,Pardi1984CalibrationOT,Schmidt1999,HABECK2005160,doi:10.1021/ja00070a024,doi:10.1021/ja070324o}. Please note that scalar coupling constants are also used in modeling Cineromycin B. Preparing J coupling data uses the same arguments as shown above, but uses the class-method `prep.prep_J`.\n"", ""\n"", ""\n"", ""For 100 microstates of cineromycinB, 32 forward model ensemble-averaged NOE distances (in Å) as $^{-1/6}$ were computed and averaged over all trajectories of Cineromycin B using MDTraj. For those same structures, 9 scalar coupling constants were computed using our built-in tools. To ensure proper data preparation, the user should check that the ordering of the forward model data matches with the experimental data. In addition, the restraint index should preceed each experimental observable and special care should be taken when attempting to denote equivalent restraints that should be averaged e.g., equivalent hydrogens in a methyl group all recieve the same index. "" ] }, { ""cell_type"": ""code"", ""execution_count"": 4, ""metadata"": {}, ""outputs"": [], ""source"": [ ""# Compute NOE model_data\n"", ""data_dir = \""cineromycin_B/\""\n"", ""outdir = \""_NOE/\""\n"", ""biceps.toolbox.mkdir(outdir)\n"", ""states = biceps.toolbox.get_files(data_dir+\""cineromycinB_pdbs/*.pdb\"")\n"", ""ind_noe = np.loadtxt(data_dir+'atom_indice_noe.txt')\n"", ""if (type(ind_noe) != np.ndarray) and (type(ind_noe) != list): #(list or np.ndarray):\n"", "" print(type(ind_noe))\n"", ""biceps.toolbox.compute_distances(states, ind_noe, outdir)\n"", ""model_data_NOE = np.array([np.loadtxt(file) for file in biceps.toolbox.get_files(outdir+\""*.txt\"")])\n"", ""exp_data_NOE = np.loadtxt(data_dir+\""noe_distance.txt\"")\n"", ""\n"", ""# Compute J-coupling model_data\n"", ""ind = np.load(data_dir+'ind.npy')\n"", ""ind_J = np.loadtxt(data_dir+'atom_indice_J.txt')\n"", ""outdir = \""_J/\""\n"", ""biceps.toolbox.mkdir(outdir)\n"", ""karplus_key=np.loadtxt(data_dir+'Karplus.txt', dtype=str)\n"", ""#print('Karplus relations:', karplus_key)\n"", ""biceps.toolbox.compute_nonaa_scalar_coupling(states,\n"", "" indices=ind, karplus_key=karplus_key, outdir=outdir)\n"", ""exp_data_J = np.loadtxt(data_dir+'exp_Jcoupling.txt')\n"", ""model_data_J = np.array([np.loadtxt(file) for file in biceps.toolbox.get_files(data_dir+\""J_coupling/*.txt\"")])"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""\n"", ""With standard text files for the experimental observables and forward model observables for each state, we are ready to prepare and organize the data into tables using the `biceps.Preparation` class. The number of conformational states (`nstates`) is the only required argument to initialize this class, which is used to check that the user has supplied forward model predictions for each state. Additionally, the user could also provide optional arguments to initialize the Preparation class: a system topology file `top_file` and a relative path to save output files `outdir`. By passing a topology file, relavent information is scraped from the `top_file` such as atom names and atom indices that correspond to a specific observables.\n"", ""\n"", ""Upon initialization, the class is stored as the object `prep`. Using this class object, we can call on a function that constructs Pandas DataFrames for a specific observable upon specifying the relative paths to the necessary files which includes the experimental data (`exp_data`), a relative path to grab and sort all forward model data data files numbered by state index (`model_data=\""NOE/*.txt\""`), and the array of atom indices given in the same order as the experimental observables. As a result, each `Preparation` class-method e.g., `prep.prepare_cs` (prepare chemical shift data) will save data tables with a specific file extension (`'*.noe', '*.J', '*.cs_H', '*.cs_Ha', '*.cs_N', '*.cs_Ca', '*.pf'`) denoting the observable. These extensions are required and should not be altered. \n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 5, ""metadata"": {}, ""outputs"": [], ""source"": [ ""# Now using biceps Preparation submodule\n"", ""outdir = \""J_NOE/\""\n"", ""biceps.toolbox.mkdir(outdir)\n"", ""prep = biceps.Preparation(nstates=len(states), top_file=states[0], outdir=outdir)\n"", ""prep.prepare_noe(exp_data_NOE, model_data_NOE, indices=ind_noe, verbose=False)\n"", ""prep.prepare_J(exp_data_J, model_data_J, indices=ind_J, verbose=False)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 6, ""metadata"": {}, ""outputs"": [], ""source"": [ ""input_data = prep.to_sorted_list()\n"", ""#input_data"" ] }, { ""cell_type"": ""code"", ""execution_count"": 7, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
restraint_indexatom_index1expmodel
01255.03.279128
12301.513.336870
23311.50.600845
34326.013.877749
44326.03.339372
54326.01.828765
65321.50.464738
76337.02.956672
86337.010.805575
96337.01.232210
\n"", ""
"" ], ""text/plain"": [ "" restraint_index atom_index1 exp model\n"", ""0 1 25 5.0 3.279128\n"", ""1 2 30 1.5 13.336870\n"", ""2 3 31 1.5 0.600845\n"", ""3 4 32 6.0 13.877749\n"", ""4 4 32 6.0 3.339372\n"", ""5 4 32 6.0 1.828765\n"", ""6 5 32 1.5 0.464738\n"", ""7 6 33 7.0 2.956672\n"", ""8 6 33 7.0 10.805575\n"", ""9 6 33 7.0 1.232210"" ] }, ""execution_count"": 7, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""# Let's look at J-coupling input file for state 0\n"", ""pd.read_pickle(input_data[0][0])[[\""restraint_index\"", \""atom_index1\"", \""exp\"", \""model\""]]"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""\n"", ""The `biceps.Preparation` class requires experimental data as well as correspondingly pre-computed forward model observables from simulated ensembles to convert all raw data into a tabulated format. Again, our data preparation code is for convenience, but not required to run BICePs. Apropos, users may have their own way to prepare data using excel or some program that outputs csv files. To give some extra flexibility, data tables can be stored in various formats (default is pickle), but must maintain our previously mentioned file extension protocol. Additionally, users must follow the naming convention of the column headers (order not required) as shown in the table above to achieve proper parsing of data. The required columns inside the prepared data file are `\""restraint_index\"", \""exp\"", \""model\""`.\n"", ""\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 8, ""metadata"": {}, ""outputs"": [], ""source"": [ ""####### Data and Output Directories #######\n"", ""energies = np.loadtxt('cineromycin_B/cineromycinB_QMenergies.dat')*627.509 # convert from hartrees to kcal/mol\n"", ""energies = energies/0.5959 # convert to reduced free energies F = f/kT\n"", ""energies -= energies.min() # set ground state to zero, just in case\n"", ""\n"", ""# REQUIRED: specify directory of input data (BICePs readable format)\n"", ""input_data = biceps.toolbox.sort_data('cineromycin_B/J_NOE')\n"", ""\n"", ""# REQUIRED: specify outcome directory of BICePs sampling\n"", ""outdir = 'results'\n"", ""# Make a new directory if we have to\n"", ""biceps.toolbox.mkdir(outdir)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 9, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAk4AAAMWCAYAAAAH8wnbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAACHEUlEQVR4nO3dd3gU5f7+8XtJJySBEFrovUlHQBBRka6AgApIRxEroKiAShWxnaMcu6hEEINKE76gCApRAVGko5TQSaSEQEJJJfP7g1/WhGySSXaT3Wzer+vKdQ4zz8x8djIuN88884zFMAxDAAAAyFUJZxcAAABQVBCcAAAATCI4AQAAmERwAgAAMIngBAAAYBLBCQAAwCSCEwAAgEkEJwAAAJMITgAAACYRnAAAAEwiOAEAAJhEcAIAADCJ4AQAAGASwQkAAMAkghMAAIBJno7c2fnz57VhwwZt27ZNf/75p6KionThwgXFxsbKw8NDQUFBql+/vtq3b68RI0aoXr16jjw8AABAgbIYhmE4amfvvvuunnzySVNtS5QooUmTJmn27NmOOjwAAECBctqturS0NL3yyit68803nVUCAABAnjj0Vl264OBgNWnSRGXLllXZsmXl7e2t2NhYbdu2TYcOHcrU9uWXX9aYMWMUGBhYEKUAAAA4jENv1f3111+6cuWKWrVqpRIlsnZmGYahCRMmaO7cuZmWr1ixQn369HFUGQAAAAXCoT1OjRo1kiRdu3ZNmzdv1r59+xQVFaUrV64oJSVFknTy5Mks223fvp3gBAAAXJ5Dg1Nqaqpee+01vfXWWzp//rzp7WJiYhxZBgAAQIFwaHAaOHCgli5dmuftrl696sgyAAAACoTDnqpbvXp1vkKTdH3sEwAAgKtzWHD69ttvsyxr166dIiIidPHiRRmGIcMw9P333zvqkAAAAIXKYbfqTpw4kWXZu+++q1atWmVatnXrVkcdEgAAoFA5rMfJ29s7y7Jdu3Zl+nNERIRee+01Rx0SAACgUDmsx6lVq1ZatWpVpmVjxozR0qVLVbVqVR08eFAbN25kPBMAACiyHDYB5qlTp1SvXj0lJCTk2K5bt25au3ZtpmXDhw9XWFiYI8oAAAAoMA67VVelShV98cUX8vHxybbNo48+qkmTJjnqkAAAAIXKofM49evXT9u2bdOrr76qn376STExMQoODlbLli01duxY9e7dWxs3bszXvtPS0hQdHa2AgABZLBZHlg0AAIoxwzB06dIlhYaG2nxlXEYOfVddQTp16pSqVq3q7DIAAICbOnnypKpUqZJjG4f2OBWkgIAASdc/VGBgoJOrKSISY6SVtTMv631Y8g1xTj0AALig+Ph4Va1a1Zo1clJkglP67bnAwECCk1neSVLJG5YFBki+nD8AAG5kZiiQwwaHAwAAuDuCEwAAgEkEJwAAAJMITgAAACYRnAAAAEwiOAEAAJhUZKYjAAAUnpSUFF27ds3ZZQD54uHhIS8vrwLZN8EJAGAVHx+vmJgYJSUlObsUwC4+Pj4KCQlx+NyPBCcAgKTroSkqKkqlSpVSSEiIvLy8eDcoihzDMJSSkqK4uDhFRUVJkkPDE8EJACBJiomJUalSpVSlShUCE4o0Pz8/BQQE6NSpU4qJiSE4ASi+wsPDFRsbm2V5cHCwBg0a5ISK3ENKSoqSkpIUEhJCaIJbsFgsCgoKUlRUlFJSUhw25ongBKBIiY2N1ZIlsfLzC7YuS0iI1YABTizKDaQPBC+oAbWAM6Rfz9euXSM4ASi+/PyC1abN49Y///77e06sxr3Q2wR3UhDXM/M4AQAAmERwAgDAxYSFhclisSgsLMyu/VgsFt1+++0OqQnXcasOAJCr7AbluwJHPRhw7Ngx1axZU5IUGhqqEydOyMPDI0u7PXv2qGnTppKk+vXra//+/XYfG0UHwQkAkCtbg/JdQUE8GODp6ano6GitXbtWPXv2zLL+008/laenp1JTUx17YBQJBCcAgCk3Dsp3BQXxYED79u21a9cuffbZZ1mCU3JyshYtWqSePXtq5cqVDj82XB9jnAAAyMDPz08PPPCAVq1apZiYmEzrVq5cqZiYGI0cOdLmtlevXtX06dPVoEED+fr6Kjg4WL169dLmzZttto+NjdXYsWNVoUIFlSxZUjfffLOWL1+eY327d+/WwIEDValSJXl7e6t69ep68skndf78+fx9YOQJwQkAgBuMGjXK2ruU0Weffaby5cvr7rvvzrJNUlKSOnfurBkzZsjf31/jx49X3759tXHjRnXq1EnLli3L1P7q1au6/fbb9dFHH6l27doaN26c6tevrwceeEBLliyxWdfKlSvVpk0brVq1SrfffrvGjx+vJk2a6N1339Utt9yiCxcuOO4kwCZu1QEAcIO2bduqcePG+uyzzzRu3DhJUlRUlH744QeNHz9enp5Z//p8/fXX9dtvv+nBBx/UwoULrXMIjR8/Xm3atNFDDz2kLl26KCAgwNp+z549evjhh/Xxxx9b9zNs2DB169Yty/7Pnz+voUOHqly5ctq0aZOqVatmXRceHq7Bgwdr6tSpeueddxx6LpAZPU4AANgwcuRI7d69W3/++aek61MEXLt2TaNGjbLZPiwsTF5eXnr11VczTbzYtGlTjRgxQhcuXNC3335rXb5gwQJ5e3tr5syZmfbTtWtXde7cOcv+FyxYoPj4eM2ZMydTaJKkQYMGqWXLllq8eHG+Py/MoccJAAAbhg4dqsmTJ+uzzz5Tq1atFBYWprZt26pRo0ZZ2sbHx+vIkSNq2LChqlSpkmV9+i25nTt3asiQIbp06ZKOHj2qRo0aqWLFilnad+zYUT/++GOmZb/99pv1fyMjI7Nsk5iYqJiYGMXExCgkJCS/Hxu5IDgBAGBD+fLl1bNnT4WHh6t3796KjIzUxIkTbbaNj4+XJFWoUMHm+vRwFBcXl+l/y5cvb7O9rf2kz6P13ns5P0l45coVglMB4lYdAADZGDVqlC5cuKDRo0fLz88v24k2AwMDJUlnzpyxuT59eXq79P89e/Zsju1tHWPPnj0yDCPbn+rVq+fhEyKvCE4AAGSjZ8+eqlixoqKiotS/f39reLlRYGCgatWqpcjISEVFRWVZHxERIUlq3ry5tX3NmjUVGRmp06dPZ2n/yy+/ZFnWtm1bSdKWLVvy+3HgAAQnAACy4enpqZUrV2r58uWaPXt2jm2HDx+ulJQUTZ48WYZhWJfv3btX8+fPV1BQkPr27WtdPnToUCUnJ2vq1KmZ9vPDDz9kGd8kXR+sHhAQoBdeeEH79u3Lsv7q1avWcVAoOIxxAgAgBzfffLNuvvnmXNs999xzWr16tRYuXKi///5bnTt31rlz5/TVV18pJSVFCxYssE5FkN5+2bJlmjdvnvbt26fbbrtNJ0+e1Ndff61evXpp9erVmfZfrlw5hYeH67777lOzZs3UvXt3NWjQQImJiTp+/LgiIiLUvn17ff/99w4/B/gXwQkAAAfw9fXVTz/9pNdee01fffWV3nrrLZUsWVK33XabpkyZoltvvTVTe39/f0VERGjy5Mlavny5tm/frsaNG+urr75SXFxcluAkSb169dKOHTv0xhtvaP369Vq3bp38/f1VpUoVjRw5UkOGDCmsj1tsEZwAAKYkJMQWyLvh7JGQECvJMS8erlGjRqZbbLmx1dbf318zZ87MMjdTdoKDg/XRRx/po48+yrJuxIgRNrepX7++Pvnkk3zXCPsQnAAAuQoODtaAAc6uwpZgBQc7JjgBZhCcAAC5yu4xfKC44ak6AAAAkwhOAAAAJhGcAAAATCI4AQAAmERwAgAAMIngBAAAYBLBCQAAwCSCEwAAgEkEJwAAAJMITgAAACYRnAAAAEwiOAEAUAzUqFFDNWrUcHYZRR7BCQAASceOHZPFYsnxp3nz5s4us9gKCwuTxWJRWFiYU+vwdOrRAQBwMbVr19aQIUNsrqtYsWIhV+M4P/74o7NLcAsEJwAAMqhTp46mT5/u7DIcrnbt2s4uwS1wqw4AgDx6+eWXZbFY9OSTT2ZZN336dFksFk2YMCHLso0bN2revHlq3LixfH19Va1aNU2ePFmJiYk2j7N7924NHDhQlSpVkre3t6pXr64nn3xS58+fz9Qu/TbjiBEjtH//fvXr108hISGyWCw6duyYJNtjnDLWNX/+fDVp0kR+fn6qWbOm/ve//0mSDMPQ3Llz1aBBA/n6+qpevXpauHChzXqTk5P13//+Vy1btpS/v78CAgLUsWNHrVy5MkvbESNGWOt7//331bBhQ/n6+qp69eqaMWOG0tLSMrUdOXKkJGnkyJGZbp8WNnqcAADZM9KkpPO5t3MFPmUlS+H0B0yZMkXr1q3Tu+++q65du+qee+6RJG3atEkvv/yymjZtqldffTXLdv/5z3+0ceNGPfDAA7r77ru1Zs0avfrqq9qxY4e+++67TEFg5cqVuv/+++Xh4aHevXuratWq+uuvv/Tuu+9q7dq12rp1q8qUKZNp/5GRkWrXrp0aN26s4cOHKzY2Vt7e3rl+nrffflsbN25Unz59dOedd2rp0qUaN26cSpYsqV27dumbb77R3XffrTvvvFOLFy/WsGHDVLNmTd16663WfSQlJal79+7auHGjWrRoodGjRyslJUWrV69Wnz599M477+iJJ57Icuxnn31WGzdu1N13362uXbtqxYoVmj59upKTkzV79mxJUt++fXXx4kV9++236tOnj1PHmhGcAADZSzovLSvv7CrM6XdW8i1n924iIyOzvVXXrl07de/eXSVKlNAXX3yhZs2aadSoUdq9e7dKliypIUOGyNvbW+Hh4fLx8cmy/fr167Vt2zY1btxYkjR79mz17NlTa9eu1RdffKGhQ4dKks6fP6+hQ4eqXLly2rRpk6pVq2bdR3h4uAYPHqypU6fqnXfeybT/TZs26aWXXtLMmTPz9Jl/+eUXbd++XbVq1ZIkTZw4UXXq1NHEiRNVoUIF7dmzR+XKXT+3I0aMUNu2bfXGG29kCk4zZ87Uxo0bNX36dE2dOtUaAi9duqQ777xTzzzzjPr166fQ0NBMx/7zzz+1e/duVapUSZL00ksvqW7dunrnnXc0bdo0eXt7ZwpOffv21YgRI/L0+RyJW3UAAGRw+PBhzZgxw+bP999/b21XtWpVzZs3TzExMRo2bJjGjh2rY8eO6T//+Y8aNWpkc99Dhw61hiZJ8vT01CuvvCJJ+vzzz63LFyxYoPj4eM2ZMydTaJKkQYMGqWXLllq8eHGW/VesWFEvvvhinj/zU089ZQ1N6Z/t1ltvVVxcnF544QVraJKkNm3aqFatWtq1a5d1WVpamj744APVqVMnU2iSpICAAE2dOlXJyclatmxZlmO/9NJL1tAkSSEhIerTp48uXbqkAwcO5PmzFDR6nAAAyKBbt26ZAlJO+vfvr4ceekiffPKJJKlPnz569NFHs23fsWPHLMtat24tPz8/7dy507rst99+s/5vZGRklm0SExMVExOjmJgYhYSEWJc3a9bM1K25G7Vo0SLLsvQwY+u2WKVKlbR161brnw8cOKALFy4oNDRUM2bMyNL+3LlzkqT9+/dnWdeyZcssy6pUqSJJunjxoqn6CxPBCQAAO/Tr188anB5//PEc25Yvb/u2Z/ny5RUVFWX9c2xsrCTpvffey3F/V65cyRScKlSoYKrmGwUGBmZZ5unpmeO61NTULPXu27dP+/bty7HeGwUFBWV77GvXruVSeeEjOAEAsudT9vrYoaLAp2yhHzI2NlZjxoxRqVKllJKSoieeeELbt2+Xv7+/zfZnz9o+l2fPns0UINLDyp49e3TTTTeZrscZT5lJ/9bbv39/LVmyxCk1FBaCEwAge5YSDhlw7a4efvhhnTp1SmFhYbpw4YImTJigcePGWXugbvTLL79YB4Cn27ZtmxISEtS+fXvrsrZt22rZsmXasmVLnoKTszRs2FCBgYHatm2bUlJS5OXl5fBjeHh4SHJ+LxSDwwEAyId58+Zp2bJleuCBBzR8+HCNGzdO3bp106effpptr8vChQsz3cpKTU3VlClTJEnDhw+3Lh85cqQCAgL0wgsv2Lz1dfXqVes4KFfg6empRx99VMePH9fEiROVkpKSpc3evXuz7XEzIzg4WJJ06tSpfO/DEehxAgAgg5ymI5CuTxp54MABjR8/XtWqVdOHH34oSdb3qDVt2lRjxoxR27ZtVbVq1Uzb3nXXXWrXrp0GDhyo4OBgrVmzRnv37lW3bt0yvealXLlyCg8P13333admzZqpe/fuatCggRITE3X8+HFFRESoffv2pgexF4YZM2Zo+/bt+t///qfVq1erU6dOKleunKKiorRnzx7t2rVLW7ZsyXacV25uueUW+fn56e2331Z8fLz1Sb9JkyY58mPkiuAEAEAG6dMRZGfKlCkaPHiwEhMTtXDhQpUuXdq6rmLFivrss890zz33aMiQIdqwYYNKlPj35s4zzzyje+65R3PnztXhw4dVrlw5TZo0Kcsj/JLUq1cv7dixQ2+88YbWr1+vdevWyd/fX1WqVNHIkSOzfZ+es/j4+Oi7777Tp59+qgULFmjJkiVKSkpShQoV1KhRI40dO1ZNmjTJ9/6Dg4O1ZMkSTZ8+XR988IESEhIkFX5wshiGYRTqEfMpPj5eQUFBiouLsznCHzYknss6cZ2DJogDnOW9997T6tVSmzb/Pr30++/vqVev3J9oQvYSExN19OhR1axZU76+vs4ux+1Mnz5dM2bM0IYNG3T77bc7u5xiw+x1nZeMwRgnAAAAkwhOAAAAJhGcAAAATCI4AQBQwKZPny7DMBjf5AYITgAAACYRnAAAAEwiOAEAAJhEcAIAWBWRqf0AUwrieiY4AQCsL1C19Y4xoKhKv57Tr29HIDgBAOTl5SUfHx/FxcXR6wS3YBiG4uLi5OPjIy8vL4ftl3fVAQAkSSEhIYqKitKpU6cUFBQkLy+vLO9PA1ydYRhKSUlRXFycLl++rMqVKzt0/wQnAIAkWd/RFRMTo6ioKCdXA9jHx8dHlStXdvj7bQlOAACrwMBABQYGKiUlRdeuXXN2OUC+eHh4OPT2XEYEJwBAFl5eXgX2Fw9QlDE4HAAAwCSCEwAAgEkEJwAAAJMITgAAACYRnAAAAEwiOAEAAJhEcAIAADCJ4AQAAGASwQkAAMAkghMAAIBJBCcAAACTCE4AAAAmEZwAAABMIjgBAACYRHACAAAwieAEAABgEsEJAADAJIITAACASQQnAAAAkwhOAAAAJhGcAAAATCI4AQAAmERwAgAAMIngBAAAYBLBCQAAwCSCEwAAgEkEJwAAAJMITgAAACYRnAAAAEwiOAEAAJhEcAIAADCJ4AQAAGASwQkAAMAkghMAAIBJBCcAAACTPAtqx9euXdO2bdsUHR2tFi1aqEaNGgV1KAAAgEJhV4/T2rVr1a9fPy1evDjT8ujoaLVt21bt27fXgAEDVKdOHc2YMcOuQgEAAJzNruC0YMECffvtt6pXr16m5RMmTND27dsVGBioZs2ayWKxaObMmdq0aZNdxQIAADiTXcHpjz/+UFBQkFq2bGldFhsbq+XLl6tcuXI6ePCgtm/frvDwcBmGobffftveegEAAJzGruB07tw5Va1aNdOyDRs2KDU1VYMGDVK5cuUkSQMGDFClSpW0a9cuew4HAADgVHYFp6tXr8rDwyPTsl9//VUWi0WdO3fOtLxKlSo6deqUPYcDAABwKruCU4UKFXTs2DGlpqZal61du1YlSpRQx44dM7VNSEiQv7+/PYcDAABwKruCU8eOHRUXF6eZM2fq8uXL+vTTT7V//361a9dOpUuXtrZLSUnRoUOHFBoaam+9AAAATmPXPE5TpkzRihUrNHv2bM2ePdu6/IUXXsjUbt26dUpKSlL79u3tORwA2BQdvU0REVeyLA8ODtagQYOcUBEAd2VXcGrcuLE2bNigWbNmKTIyUlWrVtX48ePVvXv3TO0WLlyooKAg9ezZ065iAcCWlJQr2rmzjC5f/ndZQkKsBgxwXk0A3JPdM4e3adNGq1atyrFNeHi4vYcBgBx5eQWqTZvHrX/+/ff3nFgNAHdl9wSYa9euNdX2hx9+0IIFC+w5HAAAgFPZFZxGjBihV155xVTbOXPmaOTIkfYcDgAAwKnsCk6SZBiGQ9sBAAC4KruDk1mnT59mHicAAFCk5Wlw+IkTJ3Ts2LFMy+Li4vTzzz9nu01CQoIiIiJ08OBBtW3bNl9FAgAAuII8Baf58+dr5syZmZbt3btXd9xxR47bpd+mGz9+fN6qAwAAcCF5Ck41atTQbbfdZv1zRESEAgMD1bx5c5vtLRaL/Pz8VKtWLT3wwAO69dZb7SoWAADAmfIUnIYPH67hw4db/1yiRAk1adJEGzZscHhhAAAArsauCTA3bNigoKAgR9UCAADg0uwKTp06dXJUHQAAAC7P7leupIuLi9ORI0d0+fLlHOdsyjhGCgAAoCixOzj9/PPPmjRpkrZu3ZprW4vFotTUVHsPCQD5Eh4ertjY2EzLgoODNWjQICdVBKCosXuMU/fu3ZWSkiIfHx/VqFFD5cuXV4kShTavJgCYFhsbqyVLYuXnFyxJSkiI1YABTi4KQJFiV3CaNm2aUlJS9OCDD+rtt99W2bJlHVUXANglOnqbIiKuZFoWERGhCxfqqlOnxyVJv//+njNKA1CE2RWctm/frtKlSyssLEweHh6OqgkA7JaSckU7d5bR5cv/LouMvCovr2TnFQWgyLMrOHl7e6tOnTqEJgAuycsrUG3aPG798/HjEU6sBoA7sGswUtu2bXXs2LEcn6IDAABwF3YFp2nTpikuLk5vvvmmo+oBAABwWXbdqgsNDdV///tfPfPMM9q8ebNGjx6t2rVry9/fP9ttqlWrZs8hkYuMj1v7Wi5pdGnn1gMAgDuxKzjVqFFDFotFhmFo5cqVWrlyZY7tmcep4GV83DrQRxp9n7MrAgDAfdgVnKpVqyaLxeKoWuAgfn7BatPmcZX0OCdpsrPLAQDAbdgVnI4dO+agMgAAAFwfU3wDAACYRHACAAAwya5bdSdOnMjzNjxVBwAAiiqHPFVnFk/VAQCAoqzAnqq7cuWKYmJiJEleXl4KDQ2151AAAABOV6BP1cXHx2vevHmaNWuWBg8erNmzZ9tzOABFQMZJWNMFBwdr0KBBTqoIABzHruCUm8DAQD3zzDNq3LixevXqpQYNGmjo0KEFeUgATpZxElZJSkiI1YABTi4KABykUJ6q6969u6pXr665c+cWxuEAOFn6JKxt2jxuDVAA4A4KbTqC0qVLa//+/YV1OAAAAIcrlOB09uxZ/f333/L19S2MwwEAABSIAg1OMTEx+u6779SjRw8lJyfrrrvuKsjDAQAAFCi7Bod7eHiYamcYhipWrKhXX33VnsMBAAA4lV3ByTCMHNf7+/urVq1a6tGjhyZOnKiQkBB7DgcAAOBUdgWntLQ0R9UBAADg8njJLwAAgEkEJwAAAJMcMnN4UlKSwsPD9cMPP+jgwYO6dOmSAgICVK9ePXXr1k0DBw6Uj4+PIw4FAMjA1ituJF5zAxQUu4PT9u3bdd999+nYsWNZBotv375dX331lWbNmqWvv/5aLVu2tPdwAIAMbnzFjcRrboCCZFdwOnXqlLp06aILFy4oJCREDz/8sBo3bqwKFSrozJkz2rdvnz755BMdOXJE3bp1086dO1W5cmVH1Y58+PSzT/XrHwckSa1bt860jn+hAkVT+itu0v3++3tOrAZwb3YFpzlz5ujChQvq16+fFi5cKD8/vyxtXnrpJQ0dOlRLly7VnDlz9O6779pzSNhp3Tpp+75zkirrzJl/l/MvVAAAcmfX4PDvvvtO/v7+CgsLsxmaJMnX11fz58+Xv7+/1qxZY8/h4AAtW46Wl1dJeXkFWl/CyotYAQAwx64ep+joaDVt2lSlSpXKsV2pUqXUsGFD7dmzx57DAYXK1qBbbmcCQPFmV3AKCAjQmYz3e3Jw5swZ+fv723M4oFDdOOiW25kAALtu1bVq1UqnTp3S4sWLc2wXHh6ukydPZhmMDLi69EG33M4EAEh2Bqcnn3xShmFo+PDheuaZZ3T06NFM648ePaqnn35aI0eOlMVi0VNPPWVXsQAAAM5kV3Dq1auXnn/+eaWkpOjtt99WnTp1VLJkSVWvXl0lS5ZUnTp1NHfuXCUnJ2vSpEnq2bOno+oGAAAodHa/cmXOnDlauXKlbrnlFlksFiUmJurkyZNKTEyUxWJRhw4dtGrVKs2ePdsR9QIAADiNQ165cvfdd+vuu+/WlStXFBkZqcuXL6tUqVKqU6cOA8KLKV4DAUewdR1FREQoOrqukyoCUNzlOTjt27dPhw8fVvny5dWuXbtM6/z9/dWsWbNMy3777TedPXtWderUUaNGjeyrthgrakGE10AUDwUdbGxdR5GRV+XlleyQ/QNAXuUpOF29elVdu3ZVTEyMNmzYYGqbtLQ0DRgwQKGhoTpw4AAv+82nohhEeA2E+yuMYHPjdXT8eITD9g0AeZWn4BQeHq5//vlHY8eOVfv27U1t0759ez388MP68MMPtXjxYg0fPjxfhYIgAtdEsAFQnORpcPiKFSvyNa3A+PHjZRiGli5dmqftAAAAXEmegtOOHTtUqVIlNWjQIE8HqVu3ripXrqwdO3bkaTsAAABXkqfgFBMTo8qVK+frQKGhoYqJicnXtgAAAK4gT8HJ19dXCQkJ+TpQQkKCvL2987UtAACAK8hTcKpUqZIOHz6spKSkPB0kKSlJhw8fVmhoaJ62AwAAcCV5Ck4dO3ZUYmKilixZkqeDfPPNN0pISFDHjh3ztB0AAIArydN0BCNGjNAnn3yi559/XrfddpuqVq2a6zYnTpzQc889J4vFwlQEACQVvQldASBdnnqc2rdvr/vuu0/R0dFq27atvvnmG6Wlpdlsm5aWpq+//lrt2rXTmTNn1L9/f3Xo0MEhRQMo2tInzly9WtafJUtibYYpAHAleX7lSlhYmKKiorR582YNHDhQ5cqVU4cOHVSzZk35+/vrypUrOnr0qDZv3qyzZ8/KMAzdcsstCgsLK4DyARRVTOgKoCjKc3Dy8/PTxo0bNX36dL3zzjs6e/asli9fLovFYm1jGIYkqVSpUnryySc1ffp0eXl5Oa5qAAAAJ8hzcJIkT09Pvfzyy3ruuee0evVqbd68WVFRUbp06ZICAgJUuXJltW/fXj179lRQUJCjawYAAHCKfAWndIGBgRo0aBCDOQEAQLFgV3BCwbD1xFFERISio+s6qSLAPUVHb1NExJUsyx35dB9PEALuheDkgtKfOPLzC7Yui4y8Ki+vZCdWBbiflJQr2rmzjC5f/ndZQkKsBgxw3DFs/ffs6GMAKDwEJxd14xNHx49HOLEawH15eQUW+NN9PEEIuI88zeMEAABQnBGcAAAATOJWHYACZWsANg87ACiqCE4ACpStAdg87ACgqCI4AShwNw7A5mEH4Dqmqyh6CE4AADgJ01UUPQQnAACciOkqihaeqgMAADCJHicAgFtjHBEcieAEAHBrjCOCIxGcAABuj3FEcBSCEyQVzlviAQAo6ghOkFQ4b4kHAKCoIzjBqjDeEg8AQFHGdAQAAAAmEZwAAABM4lYdABQRtuYjioiIUHR0XSdVBBQ/BCcAKCJszUcUGXlVXl7JTqwKKF4ITgBQhNw4H9Hx4xFOrAYofhjjBAAAYBI9TgBcgq1JWF1l/A7vOgOQjuAEwCXYmoTVVcbv8K4zAOkITgBcxo2TsLrS+B3edQZAYowTAACAafQ4AWJ+HACAOQQn2M0dQgfz4wDXucpAeFepwxlsPSghFY/PXhQQnGA3dwkdzI8DuM5AeFepwxlsPShRXD57UUBwQrby8q8eQgfgPlxlIHx+67ixt6qo9YBLWR+U4GEE10FwQrb4Vw+AoujG3qqi2AMO10VwQo74Vw9gnjuM93MXGXur6AGHIxGcAMBB3GW8H4DsEZyAYq44P71UEBjvB7g3ghNQzBXnp5cAIK8ITig0tp7So1fDNbjKU1QA4OoITk5mz2BSV36bvC03PqVHrwYAoKghODmZPYNJXflt8tnJ+JQevRoAgKKG4OQC7BlM6spvk4dzOXrQd3F51N5ZPbm2zi+3sgsXD0rADIIT4KYcPei7uDxq76ye3BvPL7eyCx8PSsAMghPgxhw96Lu4PGrvrJ7cjOeXW9lZFcbLb3lQArkhOAEAigReAwVXQHBCnhS1J/kAuBdeA+X+XH2sGcEJeVIUn+QDABQdrj7WjOCEPONJPgBAQXLlsWYEJwCAUxWXqS7gHghOAACnKi5TXcA9EJzgNIXxaDEyY3C/43AuHau4THWBoo/gBKfh0eLCx+B+x+FcAsUTwakQcR8/qxsHmq9YMVIREXuytKMXynEY3O84Rf1cFufvJHoMkV8Ep0LEffzc0QsFFJ7i/J1EjyHyi+BUyLiPnzsmuAMKT3H+TirqPYZwjhLOLgAAAKCooMcJAIBCcuO4MsZVFT0EJwBwM0z14bpuHFfGuKqih+AEAG6GhyxcW8ZxZYyrKnoITgDghsxM9cFtIiDvCE4AUAzw+D3gGAQnAFkwOaB74vF7wH4EJwBZ0DsBALYRnADYRO8EAGRFcAKAQsatUKDoIjgBQCHjVihQdBGcABdn6w32EpMZFnXcCkVeMKmp6yA4AS7O1hvsmcwQKF6Y1NR1EJwKiK1eAsYwIL9ufIP977+/58RqANdRnMaL3dhLyfeAcxCcCoitXgLGMACAYzFeDIWN4FSAbuwlYAxD/nBvH0BOiut4Mb4bnYPgBJfHvX0AyIrvRucgOKFI4N4+iht3GLvDE6EFj+/Gwkdwgtsozl/SPIzgftxh7I6tsZ7Hjm3UTTdZMl2vXKsoSghOcBvF+bF9HkZwT+4wdsfWWM+iHghRvBGcUCRldxvjwoW66tSpeHZb8zACigp3CIQovghOKJLc4TYGAKDoITg5AONLnKOw/9Vqz6O/xXn8FQC4E4KTAzC+pHiw59Hf4jz+CgDcCcHJQRhfUjzY8+ivI1+bcmPvFz2cAFA4CE5AEXRj7xc9nABQOAhOQBGVsfeLHk44G2M9UVwQnAAAdmOsJ4oLghMAwCEY64nioISzCwAAACgqCE4AAAAmcasOxU5BD2I1u397JtQEnO3G65yB4CguCE4odgp6EKvZ/dszoSbgbDde5wwER3FBcEKxVNCDWM3u354JNYHCYual2u46EJyeYdyI4AQAyFFxfqk2PcO4EcEJAJCrwn6ptiuhZxgZEZwAO2R3CyO/g2QdvT8AgGMRnAA7OPoWRnG+JQIARQHBCW6tMHpwHH0LozjfEgEAV0dwglujBwcA4EgEJ7g9enAAFDRbE99u27ZNktS6dWvrMsYsFn0EJwAA7GR74ttzkirrzBllWEaPd1FHcAIAwAFsT3xLj7e74SW/AAAAJtHjBABAHjDfWvFGcMoH3goOAMVXUXta19bAdanw37fnLgPoCU75wFvBAaB4K0pP69oauO6M9+25ywB6glMubCXk4vJWcACAe7hx4Hp+37dnb++VOwygJzjlwnZCdu00DABAQXCV3itnIjhlYKZ3SXL9NAwAQE5sDXCXzPUc3dhrtGLFSEVE7MnXvooiglMG9C4BAIoDWwPc89tz5Mh9FQVFJjgZhiFJio+PL7BjJCQkKDU1USkpCdZl166l6Nq1GG3a9KZ1WWJinKR/l934Z1dZFuhzWfGVMn/GrVvfc4naXOUcuUu9rlIHtRWP2opava5SR+HUdkHr1/+lhIR//x7btGmTLl1qZGNb/0x/36WmJmr9+vWZtr2RPfvKfltznyshoUyBZYD0/aZnjZxYDDOtXMCpU6dUtWpVZ5cBAADc1MmTJ1WlSpUc2xSZ4JSWlqbo6GgFBATIYrHYbBMfH6+qVavq5MmTCgwMLOQKXRfnxTbOi22cF9s4L7ZxXmzjvNjmqufFMAxdunRJoaGhKlEi55eqFJlbdSVKlMg1BaYLDAx0qV+Iq+C82MZ5sY3zYhvnxTbOi22cF9tc8bwEBQWZase76gAAAEwiOAEAAJjkVsHJx8dH06ZNk4+Pj7NLcSmcF9s4L7ZxXmzjvNjGebGN82KbO5yXIjM4HAAAwNncqscJAACgIBGcAAAATCI4AQAAmORywckwDP3666969tln1a5dO5UuXVre3t4KDQ1V//79tWHDhnzve8uWLerTp4/KlSsnPz8/NWrUSLNmzVJiYqIDP0HBKIjzMn36dFkslhx/9u/fXwCfxrFWrFihRx55RK1atVKlSpXk7e2t0qVLq3379po7d66Sk/P3rsGifL1Ijj8v7nK93OjFF1+01v/yyy/nax9F/VqxxZ7z4k7XyogRI3L9LPn5PRf1a8bR56UoXTMuNwHmTz/9pLvuukvS9Ukv69SpI39/fx06dEjLli3TsmXL9OKLL2rWrFl52u+iRYs0fPhwXbt2TZUrV1bVqlW1d+9eTZ06VatWrdLGjRtVsmTJgvhIDlFQ50WSqlatqmrVqtlc58rnJN2bb76pTZs2ycfHR6GhoWrWrJn++ecfbdmyRVu2bNHChQu1fv16lS5d2vQ+i/r1IhXMeZGK/vWS0d9//6033njDrn24w7VyI0ecF8m9rpW6deuqfPnyNtflNtP0jdzpmnHkeZGKyDVjuJh169YZderUMd5//30jNjbWujwpKcmYPHmyIcmQZKxatcr0Po8ePWr4+PgYkozXX3/dSEtLMwzDMI4dO2bUr1/fkGQ8/vjjDv8sjlQQ52XatGmGJGPatGkFUHHhmT9/vrFhwwYjOTk50/ItW7YYVapUMSQZjz32mOn9ucP1YhiOPy/ucr2kS0tLMzp27Gj4+/sbd955pyHJmDVrVp724S7XSkaOOC/udK0MHz7ckGTMnz/fIftzl2vG0eelKF0zLhec4uLijJSUlGzX9+jRw5Bk9O7d2/Q+H3vsMUOS0bVr1yzrNm3aZEgyvLy8jNOnT+er5sJQEOelKF2o+fX1118bkozQ0FDT27jD9ZKb/JwXd7te5s2bZ0gyXnvtNetfAnkNCO54rTjivLjTteLogOAu10xxDk4uN8YpMDBQnp7Z30Hs0qWLJOngwYOm9mcYhpYvXy5JGj16dJb17du3V4MGDZSSkqJvv/02HxUXDkefl+KiQYMGkqSrV6+aau8u10tu8npe3M25c+f0/PPPq1GjRpowYUK+9uGO14ojzguy547XTHHkcmOccpM+2MzPz89U+xMnTuiff/6RJHXo0MFmmw4dOmj//v3aunWrxowZ45hCC1lez0tGGzZs0L59+3T+/HkFBwerTZs2GjZsmCpWrOjoMgvdli1bJEktW7Y01b64XC95PS8ZucP1MmHCBMXGxmrZsmXy8vLK1z7c8VpxxHnJyB2ulXRLlizRihUrFB8fr/Lly6tDhw4aNmyY6RfDSu55zTjivGRUJK4Z53Z45U1aWprRokULQ5LxxBNPmNpm3bp1hiTDx8fHei/5RrNnzzYkGR07dnRkuYUmP+fFMP7tGrX14+fn57Au2MKWmppqnDx50njvvfeMgIAAw9/f39i6daupbd35erHnvBiG+1wv69evNyQZQ4YMsS7Lzy0pd7tWHHVeDMN9rhXD+Pcc2PopU6aM8d1335nelztdM448L4ZRtK4Zl7tVl5N58+Zpx44d8vb21vjx401tc+HCBUlS6dKlZbFYbLYpU6ZMprZFTX7OiyRVqlRJU6ZM0R9//KHz58/r6tWr2rRpk3r06KGEhASNGjVKq1atKrjCHeztt9+WxWKRp6enqlatqscff1ydO3fWb7/9pjZt2pjahzteL444L5J7XC+JiYkaO3asgoKC9Oabb9q1L3e6Vhx5XiT3uFbS1a5dW6+88op27dql+Ph4Xbp0ST/88IPatm2rCxcuqG/fvtq2bZupfbnTNePI8yIVsWvG2cnNrD///NPw9fW1Polg1oIFCwxJRtWqVbNt8+mnnxqSjNq1azui1EKV3/OSk7S0NOPee++1npPs/mXkar7++mujQ4cORps2bYwKFSoYkoygoCBjypQpRmpqqql9uOP14ojzkpOidL288MILhiTj3XffzbQ8Pz0r7nStOPK85KQoXSu5SUpKMtq0aWNIMu68805T27jTNZOd/JyXnLjiNVMkgtORI0eMSpUqGZKMwYMH5+nEpT89VKFChWzbvP/++4Yk46abbnJEuYXGnvOSmwMHDli7SXfu3Omw/Ram3377zWjWrJkhyRg7dqypbdz5ekmXn/OSm6Jwvfz111+Gt7e30bJlS+PatWuZ1uUnILjLteLo85KbonCtmLV27VpDklGiRIlM08Rkx12umdzk9bzkxtWuGZe/VXf69Gl16dJF//zzj3r16qWwsLBsuzhtSe/2vHjxogzDsNkmvUs0vW1RYO95yU29evUUHBwsSYqMjHTYfgtT27ZttWbNGvn4+Ojjjz/W8ePHc93GXa+XjPJzXnJTFK6Xxx57TKmpqfrggw/yNTHfjdzlWnH0eclNUbhWzLrlllskSWlpaTpy5Eiu7d3lmslNXs9LblztmnHp4BQbG6suXbro8OHD6tSpk7755ps8P+lRt25dSVJSUpKio6Nttkn/xaa3dXWOOC9mpO8zNTXV4fsuLKGhoWrevLnS0tK0a9euXNu74/ViS17Pixmufr3s2LFDFotFvXv3VsWKFTP9fPXVV5Kk1157TRUrVtTNN9+c6/7c5Vpx9Hkxw9WvFbMyfu+a+Szucs3kJq/nJS/7dIVrxmWD0+XLl9WzZ0/t3btXN998s1atWpWvR+2rVatmfYxx06ZNNtukL2/btm3+Cy4kjjovuYmJidHZs2clSVWqVHH4/gtT+n9oZv6Dc7frJSd5OS+5KSrXy7Vr13TmzJksP+nTeVy+fFlnzpzRuXPnct2XO10rjjwvuSkq14oZ+/bts/5/M5/Fna6ZnOT1vOTG5a4Z594ptC0xMdE61X/jxo2N8+fP27W/Rx991NRMrf/8849dxylojj4vOUl/jUtQUJCRlJRUYMcpaEePHjU8PT0NSUZkZKSpbdzleslJfs5LTor69ZLfsTzufq0UxBinon6tZDRo0CBDktGgQQPT27j7NWMY+TsvOXG1a8blglNqaqrRt29f6wj66OhoU9u99dZbRvXq1Y0HHnggy7ojR44Y3t7e1ifPbL0b6NFHH3Xo53A0R5+XvXv3Go8++qixd+/eTMsTEhKM2bNnGyVKlDAkGa+88orDPkNB2LZtmzF16lTj8OHDWdZ99913RoMGDQxJRs+ePTOtc/frxdHnxV2ul+zkFBDc/VrJSX7OiztdKz/88IMxadIk48iRI5mWX7x40XjyySetA5a//PLLTOvd/Zpx9HkpateMywWnL7/80nrS69ata3To0MHmz4ABAzJtlz55VqdOnWzu9/PPP7ee/MqVKxstWrQwvLy8DElGq1atjMuXLxfCp8s/R5+XHTt2WPdXrlw5o1WrVkarVq2MkiVLWpePHj3aJR79zMmGDRus9VasWNFo3bq10bRpU6N06dLW5TfffLNx7ty5TNu5+/Xi6PPiLtdLdnIKCO5+reQkP+fFna6V5cuXW2uuXLmycfPNNxvNmze3Bh+LxWLz3Wrufs04+rwUtWvG5V65kpSUZP3/hw4d0qFDh2y2q169ep72O2zYMNWpU0dz5szR5s2b9ddff6lWrVoaNGiQnn/+efn6+tpVd0Fz9HmpUaOGZs2apc2bN2v//v06cOCAkpOTVb58efXs2VMPPfSQunXr5pDaC1KzZs00d+5c/fjjj9q3b5/279+v5ORklS1bVrfccovuv/9+DRkyJMf3/NlS1K8XR58Xd7leCkJRv1YczZ2ulVatWumFF17Qli1bFBkZqb1798owDFWuXFkdO3bUY489lq+xSEX9mnH0eSlq14zFMLJ5JhIAAACZuOxTdQAAAK6G4AQAAGASwQkAAMAkghMAAIBJBCcAAACTCE4AAAAmEZwAAABMIjgBAACYRHACAAAwieAEAABgEsEJAADAJIITAACASQQnAEAmMTExmjBhgnr27KkZM2YoMTHR2SUBLsNiGIbh7CIAAK4hISFBTZs2VWRkpHXZnXfeqfXr18tisTixMsA10OMEALAKDw/XsWPHtGzZMl2+fFlvvPGGfvrpJ/3yyy/OLg1wCQQnAIDVkSNHVL9+fd17773y9/fX008/LU9PTx07dszZpQEugeAEoFDUqFFDFosly1/A2S2H4+zdu1ceHh4aO3Zsrm0bN26sAwcOaPny5bpy5Yr++9//KjU1VS1btszULj4+XmXKlNGtt95aUGUDLongBBSi9JBgsVi0YsWKbNvdddddslgsCgsLy7bNqlWr9MADD6hatWry9fVVcHCwWrVqpZdeeklnzpwxXUdOPzkd39W8/fbbmj59ui5evOjsUlzO888/Lw8PD02ePDnXtvfff7/uuOMO9evXT6VKldKzzz6rqVOn6qabbsrULjAwUE899ZQ2bdqkb7/9tqBKB1yOp7MLAIqr6dOnq0+fPnkecBsXF6cHHnhAa9eulSSVK1dOTZo0UXx8vHbs2KHt27dr7ty5+uSTT3T//ffnuK+6deuqfPny2a6vUKFCnmrLj9q1a8vX11deXl527eftt9/W8ePHNWLECJUuXdoxxbmBX375RWvWrNGIESNUvXr1XNt7eHioVKlS1j8HBQVpxowZNtuOHz9eb775piZPnqzevXszeBzFAsEJcAIPDw/t2rVLS5cu1YABA0xvl5ycrC5duuiPP/5QjRo19P7776t79+7Wv7BOnjyp5557TosXL9agQYPk4eGh/v37Z7u/KVOmaMSIEfZ+HLv8+OOPTj2+u3v33XclScOHDzfVfvPmzVq+fLmCgoIUHx+vuLg4nTx5UlWrVs3StkyZMrrnnnv01Vdf6aefflLnzp0dWjvgirhVBzjBoEGDJEkzZsxQXmYEmTZtmv744w9VqlRJv/zyi3r06JHpX/lVq1ZVeHi4Ro4cqbS0ND300EO53raD+zp37pxWrFih0NBQ3Xbbbaa2mThxoiRp0qRJ1rC0Z8+ebNsPHDhQkvTJJ5/YWS1QNBCcACcYNWqUatSoob179+rrr782tc3FixetvQdvvvmmqlSpkm3buXPnKiQkJNM2heH48eMaMmSIypcvr5IlS6pp06Z67733cgyH2Q0OP378uB555BHVqlVLPj4+CggIUK1atXTvvfdq8eLF1nZhYWGyWCw6fvy4JKlmzZqZxmlt3LhR0vUB0tOmTdMtt9yiSpUqydvbW5UqVVK/fv20efPmbOtL348kfffdd7rtttsUEBCgoKAg9ejRQzt27Mh229TUVM2bN0933HGHypYtK19fX9WqVUv9+/e3OS4oNTVVH374oW699VaVLl1avr6+atCggV588UXFx8dne5zsLF++XMnJyerRo4dKlMj9637p0qXasmWLKleurHHjxqlx48aScg5O3bp1k6enp1asWKGkpKQ81wgUOQaAQlO9enVDkvHLL78Y8+bNMyQZDRs2NK5du5apXefOnQ1Jxvz5863LFi1aZEgyQkJCjOTk5FyPNW7cOEOSUa9evWzryLh/e/31119G2bJlDUmGr6+v0apVK6NatWqGJOOxxx6zHvPo0aM2a8m4/OjRo0ZISIghyShZsqTRpEkTo3nz5kZwcLAhyWjWrJm17Zo1a4wOHToYPj4+hiSjdevWRocOHaw/27dvNwzj33NaunRpo2HDhkbLli2tx/Dw8DAWLVpk83NJMiQZH3zwgWGxWIxKlSoZLVu2NPz9/Q1JRqlSpYy///47y3axsbFGhw4drNtXr17daN26tVG+fHnrnzOKi4szbrvtNkOSUaJECaN69erGTTfdZHh7e1uvkzNnzuTpd/Lggw8akoyPPvoo17bJyclG3bp1DUnGvHnzDMMwjIkTJxqSjMGDB+e4bYsWLazXNeDuCE5AIcoYnFJSUoxatWoZkrL8pW0rOD3++OOGJKN3796mjrV06VLrX9oxMTE263BUcEpLSzNatmxpSDK6detmnD9/3rouPDzc8PLyMjw9PU0HpyeeeMKQZAwfPty4dOlSpvZ///23zSCQXTBL98033xi7d+/OUveKFSuMUqVKGYGBgUZ8fHyW7dLPYcmSJTOdr/j4eOvv6YEHHsiyXd++fQ1JRu3atY3ffvst07pDhw4Zr7/+eqZlAwcONCQZnTt3Ng4fPmxdHhsba/Tr18+QZAwYMMDmZ8tOzZo1DUnGtm3bcm37v//9zxrQUlNTDcMwjPnz5xuSjCZNmuS47ZgxYwxJxpw5c/JUH1AUEZyAQpQxOBnGv38x1a9f3/qXlWHYDk7pfxFPmDDB1LF27txp/Ut/165dNuvI7efChQumjrV+/XpDkuHn52ecO3cuy/qnnnrKuk8zwalbt242685JbsEpJy+++KLNAGsY/wanJ598Msu63bt3G5KMoKCgTMt///13Q5Lh4+NjHDx4MNfj79q1y9oLZSu8XblyxahataphsViMY8eOmfpMaWlp1rAaFRWVY9u4uDijXLlyhiRjxYoV1uVbt241JBleXl459nJOmzbNkGSMHTvWVG1AUcZTdYATDR06VK+88ooOHDigRYsWadiwYdm2vXTpkiTJ39/f1L4ztkvf9ka5TUfg6WnuKyJ9aoT77rtPISEhWdY/9thj+t///mdqX5Ksg5KXLFmiJk2aOOwx9xMnTujLL7/U9u3bFRMTo+TkZEnS2bNnJUm7du3S4MGDbW770EMPZVnWpEkT+fr6Ki4uTufPn1fZsmUlyTp+6d5771XdunVzrWv58uWSrs+hFBAQkGV9yZIlddddd2n+/Pn65ZdfTE0rcPHiRaWmpkqSgoODc2z76quv6ty5c2rfvr369OljXd6oUSNZLBalpKTowIEDWeZySpe+/3PnzuVaF1DUEZwAJ/Lw8NBLL72kYcOGadasWRo8eHC2YSX9L9QrV66Y2nfGdrb+MpYcNx3BwYMHJUkNGza0ub5u3bry9PS0/kWem8cff1yff/65Zs2apQULFqh79+7q2LGj7rjjDoWGhuarxs8//1xjx45VYmJitm1iY2OzXVe7dm2by8uVK6eTJ0/q8uXL1uD0999/S5LatWtnqrb0wdfLly/PdqB6+uD3qKgoU/vM+Dm9vb2zbRcVFaW3335bkvT6669nWleqVClVq1ZNx48f1549e7INTn5+fpKuvyAYcHc8VQc42eDBg1W/fn1FRkZq4cKF2barXLmyJOnw4cOm9puxXfq2BeXy5cuSrocIW0qUKGGzJyo7zZs3188//6yuXbsqKipKH330kYYMGaIqVaqoW7du1mBi1uHDh/Xwww8rMTFRzzzzjHbs2KH4+HilpaXJMAzNmzdPkpSSkpLtPrLr6Ut/Ws3I8ORg+hNwZifijIuLkyRFRkZq06ZNNn9OnTolyXw4ydjLlL5/W1588UUlJCSod+/e6tChQ5b1Zp6sSw+cefkdA0UVwQlwMg8PD02dOlWSNGvWrGx7Zdq3by/p+gSFZnpufv75Z0nXe3vSe0IKSvpM09ndqklLS9P58+fztM927dpp7dq1unDhgr7//ns9//zzqlKlin744Qd16dIlT69W+frrr5WSkqKBAwfqzTffVPPmzRUQEJBp4lBHSu/hM1tj+vmbN2+ejOtjT7P9mT59uql9+vj4KDAwUFL2PWl79uzRggULJEkrV660+dqdNWvWWNtmJ33/2QVnwJ0QnAAXMHDgQDVq1EhHjx7N9v1wPXv2lL+/v2JiYvTNN9/kuL9Lly5p0aJFkqQHHnjA0eVmUa9ePUnS/v37ba6PjIzMsTcnJ6VKlVK3bt306quvav/+/apdu7aioqL03XffZWqX0zio9Dmi0sPnjXbt2pWv2rKT3kvz22+/mWrfqFEjSdfnmnKk5s2bS1K2PXTPPvus0tLSFBgYqAoVKtj8KVOmjKScg9Nff/0lSVleBAy4I4IT4AJKlCihadOmSZJefvllmyGjdOnSevzxxyVJzzzzjPXWjS3jxo1TTEyMgoKCrNsUpK5du0qSvvnmG5s9S++//75DjlOyZEk1adJEkhQdHZ1pXU7jbNLX2ZpFff/+/Vq1apVD6kvXt29fSdKKFStM3Vq99957JUlffPFFnnvmcnLrrbdKkrZt25Zl3fr167V27Vr5+vpq9+7dOn36tM2f9evXS7o+xiq7STj/+OMPSVLHjh0dVjvgqghOgIu477771KRJEx0/flybNm2y2WbmzJlq2bKl/vnnH9122236/vvvM42tOXXqlAYPHqz58+fLYrHo448/VsWKFQu89s6dO6tFixa6evWqhg4dqgsXLljXff311/rggw9MP6EnSY8++qi++uorXb16NdPyn3/+2fpuuxt7N2rVqiVJioiIyLK/9ADx/vvva+fOndblBw8e1H333Zfj4On8aNWqle69914lJiaqR48e1mCRLjIyUm+++ab1z61bt9b999+v8+fPq0uXLllmI7927Zo2btyoBx98ME+zc6cH2l9//TXTcsMw9Nxzz0mSJkyYkONTeg0bNrSO47LVIxYZGakzZ86oQYMGNt9nB7gd58yCABRPN87jdKMlS5ZkmkfJ1gSVFy5cMO666y5rm3LlyhmtW7c26tevb1gsFuts1l9++WWuddStWzfTLNs3/sydO9f0Z9u7d691Zm8/Pz+jdevW1uPkdebwZs2aGZIMT09Po2HDhkabNm0yzT01ZMiQLMdfsGCBdf1NN91kdOrUyejUqZOxY8cOIyUlxWjXrp11lvCGDRsaN910k3Um8Jdfftk64eaN0veZ27m88XPFxsYat9xyi3X7GjVqGK1btzYqVKhgc+bwS5cuGV26dLG2r1atmtG2bVujSZMmhp+fn3V5QkJCbr8Kq7S0NKNOnTqGh4eHcfr06Sznqnz58jbnjbpR7dq1DUnGhx9+mGVd+rm7cUJPwF0RnIBClFtwSktLM5o3b55jcEq3YsUKY8CAAUaVKlUMb29vIygoyGjevLkxZcoU459//jFVR24/48aNy9PnO3LkiDF48GCjbNmyhq+vr9GkSRPjnXfeMdLS0vIUnH766Sdj3LhxRsuWLY1y5coZ3t7eRvXq1Y1u3boZK1euNNLS0mwef+7cuUbTpk0zBY0NGzYYhnF9kscnn3zSCA0NNby8vIwqVaoYDz30kBEdHW2diNSRwckwrr/G5L333jM6dOhgBAUFGb6+vkbNmjWNAQMGGKtWrcrS/tq1a8aiRYuMbt26GSEhIYaXl5dRqVIlo23btsbzzz9v/P7779nWkZ3XXnvNkGQNwQkJCdZX4dgKQrb07t3bGoBv1LhxY8PLyyvPr4MBiiqLYeTh1ewAgCIlPj5etWvXVnBwsP7++29TL/s1a8OGDbrzzjv12GOP6b333nPYfgFXxhgnAHBjgYGBevHFF3Xw4EEtXrzYofueOXOmSpUqZZ1OAygOmDkcANzco48+ap3w01Hi4+N1++2366mnnlKFChUctl/A1XGrDgAAwCRu1QEAAJhEcAIAADCJ4AQAAGASwQkAAMAkghMAAIBJBCcAAACTCE4AAAAmEZwAAABMIjgBAACYRHACAAAwieAEAABgEsEJAADAJIITAACASQQnAAAAkwhOAAAAJjk0OI0YMUIWiyXTz8aNGx15CAAAAKehxwkAAMAkghMAAIBJBCcAAACTCE4AAAAmEZwAAABMKrTg9M0336hr164qX768/Pz8VK9ePT377LOKiYkprBIAAADsUuDBKSUlRffdd5/uv/9+rVu3TufOnVNiYqIOHTqkN998Uw0bNtSff/5Z0GUAAADYrcCD0/jx47VkyZJs18fExKhr166Kjo4u6FIAAADsUuDB6a+//pLFYlG3bt306KOPqlOnTlnaxMbGasKECQVdCgAAgF08C/oAFotF3377re655x7rso8//liPPPJIpnZLly7VyZMnVbVq1YIuCQAAIF8KvMepX79+mUKTJI0ZM0Zt2rTJtOzatWv64YcfCrocAACAfCvw4NSjRw+by7t165Zl2c6dOwu4GgAAgPwr8OCU3a23KlWqZFnG1AQAAMCVFXhwslgsNpcbhmG6LQAAgCso8OB04sQJm8ujoqKyLCtbtmxBlwMAAJBvBR6cvv/+e5vLbQ0Eb968eQFXAwAAkH8FHpyWLl2q//u//8u07NNPP9XWrVszLfPw8FCXLl0KuhwAAIB8K/B5nAzDUO/evdWtWzfVrFlTf//9tzZu3Jil3b333qtq1aoVdDkAAAD5VuDBqVq1ajpx4kS2t+wkqUyZMnrrrbcKuhQAAAC7FPitug8++MDmnE3pypYtq++//97m9AQAAACupMB7nEqWLKnvvvtOCxcuVFhYmHbv3q3Lly+ratWq6t27tyZNmqRy5crlup+0tDRFR0crICCAaQsAAIDDGIahS5cuKTQ0VCVK5NynZDFsTajkgk6dOsV77AAAQIE5efJkrnfACrzHyVECAgIkXf9QgYGBTq6mCNk7J+uymyYXfh0oGK7w+3WFGlypDgBFTnx8vKpWrWrNGjkpMsEp/fZcYGAgwSkvSvlkXcb5cx+u8Pt1hRpcqQ4ARZaZoUAFPjgcAADAXRCcAAAATCI4AQAAmERwAgAAMIngBAAAYBLBCQAAwKQiMx0BAKDwpKSk6Nq1a84uA8gXDw8PeXl5Fci+CU4AAKv4+HjFxMQoKSnJ2aUAdvHx8VFISIjD534kOAEAJF0PTVFRUSpVqpRCQkLk5eXFu0FR5BiGoZSUFMXFxSkqKkqSHBqeCE4AAElSTEyMSpUqpSpVqhCYUKT5+fkpICBAp06dUkxMjEODE4PDAQBKSUlRUlKSgoKCCE1wCxaLRUFBQUpKSlJKSorD9ktwAgBYB4IX1IBawBnSr2dHPuhAcAIAWNHbBHdSENczwQkAAMAkghMAAIBJPFUHAMhVeHi4YmNjnV2GTcHBwRo0aJCzy3CosLAwjRw5UvPnz9eIESPyvR+LxaJOnTpp48aNDqutuCM4AQByFRsbqyVLYuXnF+zsUjJJSIjVgAGO2dexY8dUs2ZNSVJoaKhOnDghDw+PLO327Nmjpk2bSpLq16+v/fv3O6YAFAkEJwCAKX5+wWrT5nFnl5HJ77+/5/B9enp6Kjo6WmvXrlXPnj2zrP/000/l6emp1NRUhx8bro8xTgAAZNC+fXsFBQXps88+y7IuOTlZixYtshmoUDwQnAAAyMDPz08PPPCAVq1apZiYmEzrVq5cqZiYGI0cOdLmtlevXtX06dPVoEED+fr6Kjg4WL169dLmzZttto+NjdXYsWNVoUIFlSxZUjfffLOWL1+eY327d+/WwIEDValSJXl7e6t69ep68skndf78+fx9YOQJwQkAgBuMGjXK2ruU0Weffaby5cvr7rvvzrJNUlKSOnfurBkzZsjf31/jx49X3759tXHjRnXq1EnLli3L1P7q1au6/fbb9dFHH6l27doaN26c6tevrwceeEBLliyxWdfKlSvVpk0brVq1SrfffrvGjx+vJk2a6N1339Utt9yiCxcuOO4kwCbGOAEAcIO2bduqcePG+uyzzzRu3DhJUlRUlH744QeNHz9enp5Z//p8/fXX9dtvv+nBBx/UwoULrZMvjh8/Xm3atNFDDz2kLl26KCAgwNp+z549evjhh/Xxxx9b9zNs2DB169Yty/7Pnz+voUOHqly5ctq0aZOqVatmXRceHq7Bgwdr6tSpeueddxx6LpAZPU4AANgwcuRI7d69W3/++aek61MEXLt2TaNGjbLZPiwsTF5eXnr11VczzVjdtGlTjRgxQhcuXNC3335rXb5gwQJ5e3tr5syZmfbTtWtXde7cOcv+FyxYoPj4eM2ZMydTaJKkQYMGqWXLllq8eHG+Py/MoccJAAAbhg4dqsmTJ+uzzz5Tq1atFBYWprZt26pRo0ZZ2sbHx+vIkSNq2LChqlSpkmV9+i25nTt3asiQIbp06ZKOHj2qRo0aqWLFilnad+zYUT/++GOmZb/99pv1fyMjI7Nsk5iYqJiYGMXExCgkJCS/Hxu5IDgBAGBD+fLl1bNnT4WHh6t3796KjIzUxIkTbbaNj4+XJFWoUMHm+vRwFBcXl+l/y5cvb7O9rf2kT0D63ns5T8Fw5coVglMB4lYdAADZGDVqlC5cuKDRo0fLz88v2xnKAwMDJUlnzpyxuT59eXq79P89e/Zsju1tHWPPnj0yDCPbn+rVq+fhEyKvCE4AAGSjZ8+eqlixoqKiotS/f39reLlRYGCgatWqpcjISEVFRWVZHxERIUlq3ry5tX3NmjUVGRmp06dPZ2n/yy+/ZFnWtm1bSdKWLVvy+3HgAAQnAACy4enpqZUrV2r58uWaPXt2jm2HDx+ulJQUTZ48WYZhWJfv3btX8+fPV1BQkPr27WtdPnToUCUnJ2vq1KmZ9vPDDz9kGd8kXR+sHhAQoBdeeEH79u3Lsv7q1avWcVAoOIxxAgAgBzfffLNuvvnmXNs999xzWr16tRYuXKi///5bnTt31rlz5/TVV18pJSVFCxYssE5FkN5+2bJlmjdvnvbt26fbbrtNJ0+e1Ndff61evXpp9erVmfZfrlw5hYeH67777lOzZs3UvXt3NWjQQImJiTp+/LgiIiLUvn17ff/99w4/B/gXwQkAYEpCQmyBvBvOHgkJsZJc48XDvr6++umnn/Taa6/pq6++0ltvvaWSJUvqtttu05QpU3Trrbdmau/v76+IiAhNnjxZy5cv1/bt29W4cWN99dVXiouLyxKcJKlXr17asWOH3njjDa1fv17r1q2Tv7+/qlSpopEjR2rIkCGF9XGLLYITACBXwcHBGjDA2VXYEqzgYMcEpxo1amS6xZYbW239/f01c+bMLHMzZSc4OFgfffSRPvrooyzrRowYYXOb+vXr65NPPsl3jbAPwQkAkKvsniYDihsGhwMAAJhEcAIAADCJ4AQAAGASwQkAAMAkghMAAIBJBCcAAACTCE4AAAAmEZwAAABMIjgBAACYRHACAAAwieAEAABgEsEJAIBioEaNGqpRo4azyyjyCE4AAEg6duyYLBZLjj/Nmzd3dpnFVlhYmCwWi8LCwpxah6dTjw4AKDp2T3d2BbY1ne7Q3dWuXVtDhgyxua5ixYoOPVZh+vHHH51dglsgOAEAkEGdOnU0ffp0Z5fhcLVr13Z2CW6BW3UAAOTRyy+/LIvFoieffDLLuunTp8tisWjChAlZlm3cuFHz5s1T48aN5evrq2rVqmny5MlKTEy0eZzdu3dr4MCBqlSpkry9vVW9enU9+eSTOn/+fKZ26bcZR4wYof3796tfv34KCQmRxWLRsWPHJNke45Sxrvnz56tJkyby8/NTzZo19b///U+SZBiG5s6dqwYNGsjX11f16tXTwoULbdabnJys//73v2rZsqX8/f0VEBCgjh07auXKlVnajhgxwlrf+++/r4YNG8rX11fVq1fXjBkzlJaWlqntyJEjJUkjR47MdPu0sNHjBABAHk2ZMkXr1q3Tu+++q65du+qee+6RJG3atEkvv/yymjZtqldffTXLdv/5z3+0ceNGPfDAA7r77ru1Zs0avfrqq9qxY4e+++67TEFg5cqVuv/+++Xh4aHevXuratWq+uuvv/Tuu+9q7dq12rp1q8qUKZNp/5GRkWrXrp0aN26s4cOHKzY2Vt7e3rl+nrffflsbN25Unz59dOedd2rp0qUaN26cSpYsqV27dumbb77R3XffrTvvvFOLFy/WsGHDVLNmTd16663WfSQlJal79+7auHGjWrRoodGjRyslJUWrV69Wnz599M477+iJJ57Icuxnn31WGzdu1N13362uXbtqxYoVmj59upKTkzV79mxJUt++fXXx4kV9++236tOnj1PHmhGcAADIIDIyMttbde3atVP37t1VokQJffHFF2rWrJlGjRql3bt3q2TJkhoyZIi8vb0VHh4uHx+fLNuvX79e27ZtU+PGjSVJs2fPVs+ePbV27Vp98cUXGjp0qCTp/PnzGjp0qMqVK6dNmzapWrVq1n2Eh4dr8ODBmjp1qt55551M+9+0aZNeeuklzZw5M0+f+ZdfftH27dtVq1YtSdLEiRNVp04dTZw4URUqVNCePXtUrlw5Sdd7f9q2bas33ngjU3CaOXOmNm7cqOnTp2vq1KnWEHjp0iXdeeedeuaZZ9SvXz+FhoZmOvaff/6p3bt3q1KlSpKkl156SXXr1tU777yjadOmydvbO1Nw6tu3r0aMGJGnz+dI3KoDACCDw4cPa8aMGTZ/vv/+e2u7qlWrat68eYqJidGwYcM0duxYHTt2TP/5z3/UqFEjm/seOnSoNTRJkqenp1555RVJ0ueff25dvmDBAsXHx2vOnDmZQpMkDRo0SC1bttTixYuz7L9ixYp68cUX8/yZn3rqKWtoSv9st956q+Li4vTCCy9YQ5MktWnTRrVq1dKuXbusy9LS0vTBBx+oTp06mUKTJAUEBGjq1KlKTk7WsmXLshz7pZdesoYmSQoJCVGfPn106dIlHThwIM+fpaDR4wQAQAbdunXLFJBy0r9/fz300EP65JNPJEl9+vTRo48+mm37jh07ZlnWunVr+fn5aefOndZlv/32m/V/IyMjs2yTmJiomJgYxcTEKCQkxLq8WbNmpm7N3ahFixZZlqWHGVu3xSpVqqStW7da/3zgwAFduHBBoaGhmjFjRpb2586dkyTt378/y7qWLVtmWValShVJ0sWLF03VX5gITgAA2KFfv37W4PT444/n2LZ8+fLZLo+KirL+OTY2VpL03nvv5bi/K1euZApOFSpUMFXzjQIDA7Ms8/T0zHFdampqlnr37dunffv25VjvjYKCgrI99rVr13KpvPBxqw4AgHyKjY3VmDFjVKpUKfn4+OiJJ56wGQ7SnT17NtvlGQNEeljZs2ePDMPI9qd69eqZ9uOMp8ykf+vt379/jvXOnz/fKfU5EsEJAIB8evjhh3Xq1Cm9++67evXVV3Xw4EGNGzcu2/a//PJLlmXbtm1TQkJCpltibdu2lSRt2bLF4TUXhIYNGyowMFDbtm1TSkqKXfs6f/68NXxeuHBBZ8+e1dmzZ5WQkCDJ+b1QBCcAAPJh3rx5WrZsmR544AENHz5c48aNU7du3fTpp59qyZIlNrdZuHBhpltZqampmjJliiRp+PDh1uUjR45UQECAXnjhBZu3vq5evWodB+UKPD099eijj+r48eOaOHGizfC0d+/ebHvcMrp27ZoSEq7P4XTlihQXJ124kGrt1Tp16pRji88jxjgBAJBBTtMRSNcnjTxw4IDGjx+vatWq6cMPP5Qk63vUmjZtqjFjxqht27aqWrVqpm3vuusutWvXTgMHDlRwcLDWrFmjvXv3qlu3bple81KuXDmFh4frvvvuU7NmzdS9e3c1aNBAiYmJOn78uCIiItS+fXvTg9gLw4wZM7R9+3b973//0+rVq9WpUyeVK1dOUVFR2rNnj3bt2qUtW7ZkO84rI4vler+Or28Z+fuX15UrZ62D6N9++23Fx8dbn/SbNGlSgX6uGxGcAADIIH06guxMmTJFgwcPVmJiohYuXKjSpUtb11WsWFGfffaZ7rnnHg0ZMkQbNmxQiRL/3tx55plndM8992ju3Lk6fPiwypUrp0mTJmV5hF+SevXqpR07duiNN97Q+vXrtW7dOvn7+6tKlSoaOXJktu/TcxYfHx999913+vTTT7VgwQItWbJESUlJqlChgho1aqSxY8eqSZMm+d5/mTJltGTJEk2fPl0ffPCB9dZdYQcni2EYRqEeMZ/i4+MVFBSkuLg4myP8kY3d07Muc/ALMeFEu6dnXVbYv19XqEFynTqKqMTERB09elQ1a9aUr6+vs8txO9OnT9eMGTO0YcMG3X777c4ux6WdPXtWcXGSv/+/PVNXrpxVUFD2TyVmx+x1nZeMwRgnAAAAkwhOAAAAJhGcAAAATCI4AQBQwKZPny7DMBjf5AYITgAAACYRnAAAAEwiOAEAAJhEcAIAWBWRqf0AUwrieiY4AQDk4eEhSXa/oBVwJenXc/r17QgEJwCAvLy85OPjo7i4OHqd4BYMw1BcXJx8fHzk5eXlsP3yrjoAgCQpJCREUVFROnXqlIKCguTl5ZXl/WlAQUtJSdG1a1JqaqJ12bVrKUpJuf4KldwYhqGUlBTFxcXp8uXLqly5skPrIzgBACTJ+o6umJgYRUVFObkaFFeXLl1SQoLk7R1vXZacfEnx8dffKWeWj4+PKleu7PD32xKcAABWgYGBCgwM/P//6r/m7HJQDC1atEgREVLTpg9al+3evUidOkkPPvhgDlv+y8PDw6G35zIiOAEAsvDy8iqwv3iAnCQmJiomRrp82de6LCYmUYmJkq+vbw5bFg4GhwMAAJhEcAIAADCJ4AQAAGASwQkAAMAkghMAAIBJBCcAAACTCE4AAAAmEZwAAABMIjgBAACYRHACAAAwieAEAABgEsEJAADAJIITAACASQQnAAAAkwhOAAAAJhGcAAAATCI4AQAAmERwAgAAMIngBAAAYBLBCQAAwCSCEwAAgEkEJwAAAJMITgAAACYRnAAAAEwiOAEAAJhEcAIAADCJ4AQAAGASwQkAAMAkghMAAIBJBCcAAACTCE4AAAAmEZwAAABMIjgBAACYRHACAAAwieAEAABgkmdB7fjatWvatm2boqOj1aJFC9WoUaOgDgUAAFAo7OpxWrt2rfr166fFixdnWh4dHa22bduqffv2GjBggOrUqaMZM2bYVSgAAICz2RWcFixYoG+//Vb16tXLtHzChAnavn27AgMD1axZM1ksFs2cOVObNm2yq1gAAABnsis4/fHHHwoKClLLli2ty2JjY7V8+XKVK1dOBw8e1Pbt2xUeHi7DMPT222/bWy8AAIDT2BWczp07p6pVq2ZatmHDBqWmpmrQoEEqV66cJGnAgAGqVKmSdu3aZc/hAAAAnMqu4HT16lV5eHhkWvbrr7/KYrGoc+fOmZZXqVJFp06dsudwAAAATmVXcKpQoYKOHTum1NRU67K1a9eqRIkS6tixY6a2CQkJ8vf3t+dwAAAATmVXcOrYsaPi4uI0c+ZMXb58WZ9++qn279+vdu3aqXTp0tZ2KSkpOnTokEJDQ+2tFwAAwGnsCk5TpkyRr6+vZs+eraCgII0ZM0aS9MILL2Rqt27dOiUlJal9+/b2HA4AAMCp7ApOjRs31oYNG9SzZ0/Vq1dPnTt31v/93/+pe/fumdotXLhQQUFB6tmzp13FAgAAOJPdM4e3adNGq1atyrFNeHi4vYcBAABwOrsnwFy7dq2ptj/88IMWLFhgz+EAAACcyq7gNGLECL3yyium2s6ZM0cjR46053AAAABOZVdwkiTDMBzaDgAAwFXZHZzMOn36NPM4AQCAIi1Pg8NPnDihY8eOZVoWFxenn3/+OdttEhISFBERoYMHD6pt27b5KhIAAMAV5Ck4zZ8/XzNnzsy0bO/evbrjjjty3C79Nt348ePzVh2g609lxsbGZlkeHBysQYMGOaEiAEBxlafgVKNGDd12223WP0dERCgwMFDNmze32d5iscjPz0+1atXSAw88oFtvvdWuYlE8xcbGasmSWPn5BVuXJSTEasAAJxYFACiW8hSchg8fruHDh1v/XKJECTVp0kQbNmxweGFARn5+wWrT5nHrn3///T0nVgMAKK7smgBzw4YNCgoKclQtAAAALs2u4NSpUydH1QEAAODy7H7lSrq4uDgdOXJEly9fznHOpoxjpAAAAIoSu4PTzz//rEmTJmnr1q25trVYLEpNTbX3kAAAAE5h9xin7t27KyUlRT4+PqpRo4bKly+vEiUKbV5NAACAQmNXcJo2bZpSUlL04IMP6u2331bZsmUdVRcAAIDLsSs4bd++XaVLl1ZYWJg8PDwcVRNsYBJIAACcz67g5O3trTp16hCaCgGTQAIA4Hx2Bae2bdvqzz//lGEYslgsjqoJ2WASSAAAnMuuUdzTpk1TXFyc3nzzTUfVAwAA4LLs6nEKDQ3Vf//7Xz3zzDPavHmzRo8erdq1a8vf3z/bbapVq2bPIQEAAJzGruBUo0YNWSwWGYahlStXauXKlTm2Zx4nAABQlNkVnKpVq8bYJgAAUGzYFZyOHTvmoDIAAABcH1N8AwAAmERwAgAAMMmuW3UnTpzI8zY8VQcAAIoqhzxVZxZP1QEAgKKswJ6qu3LlimJiYiRJXl5eCg0NtedQAAAATlegT9XFx8dr3rx5mjVrlgYPHqzZs2fbczgAAACnsis45SYwMFDPPPOMGjdurF69eqlBgwYaOnRoQR4SAACgwBTKU3Xdu3dX9erVNXfu3MI4HAAAQIEotOkISpcurf379xfW4QAAAByuUILT2bNn9ffff8vX17cwDgcAAFAgCjQ4xcTE6LvvvlOPHj2UnJysu+66qyAPBwAAUKDsGhzu4eFhqp1hGKpYsaJeffVVew4HAADgVHYFJ8Mwclzv7++vWrVqqUePHpo4caJCQkLsORwAAIBT2RWc0tLSHFUHAACAy+MlvwAAACYV6ASYAAA4W3h4uGJjY7MsDw4O1qBBg5xQEYoyhwSnpKQkhYeH64cfftDBgwd16dIlBQQEqF69eurWrZsGDhwoHx8fRxwKAIA8iY2N1ZIlsfLzC7YuS0iI1YABTiwKRZbdwWn79u267777dOzYsSyDxbdv366vvvpKs2bN0tdff62WLVvaezgAAPLMzy9Ybdo8bv3z77+/58RqUJTZFZxOnTqlLl266MKFCwoJCdHDDz+sxo0bq0KFCjpz5oz27dunTz75REeOHFG3bt20c+dOVa5c2VG1AwCQL9HR2xQRcSXLcm7fITd2Bac5c+bowoUL6tevnxYuXCg/P78sbV566SUNHTpUS5cu1Zw5c/Tuu+/ac0gAAOyWknJFO3eW0eXL/y7j9h3MsCs4fffdd/L391dYWJjN0CRJvr6+mj9/vr7//nutWbPGnsMBAOAwXl6B3L5Dntk1HUF0dLQaNmyoUqVK5diuVKlSatiwof755x97DgcAAOBUdgWngIAAnTlzxlTbM2fOyN/f357DAQAAOJVdwalVq1Y6deqUFi9enGO78PBwnTx5Uq1bt7bncAAAAE5lV3B68sknZRiGhg8frmeeeUZHjx7NtP7o0aN6+umnNXLkSFksFj311FN2FQsAAOBMdgWnXr166fnnn1dKSorefvtt1alTRyVLllT16tVVsmRJ1alTR3PnzlVycrImTZqknj17OqpuAACAQmf3u+rmzJmjlStX6pZbbpHFYlFiYqJOnjypxMREWSwWdejQQatWrdLs2bMdUS8AAIDTOOSVK3fffbfuvvtuXblyRZGRkbp8+bJKlSqlOnXqMCAcAAC4jTwHp3379unw4cMqX7682rVrl2mdv7+/mjVrlmnZb7/9prNnz6pOnTpq1KiRfdUCAAA4UZ6C09WrV9W1a1fFxMRow4YNprZJS0vTgAEDFBoaqgMHDvCyXwAAUGTlaYxTeHi4/vnnH40ePVrt27c3tU379u318MMP6+TJk7lOWwAAAODK8hScVqxYka9pBcaPHy/DMLR06dI8bQcAAOBK8hScduzYoUqVKqlBgwZ5OkjdunVVuXJl7dixI0/bAQAAuJI8BaeYmBhVrlw5XwcKDQ1VTExMvrYFAABwBXkKTr6+vkpISMjXgRISEuTt7Z2vbQEAAFxBnoJTpUqVdPjwYSUlJeXpIElJSTp8+LBCQ0PztB0AAIAryVNw6tixoxITE7VkyZI8HeSbb75RQkKCOnbsmKftAAAAXEmegtOIESNkGIaef/55nTx50tQ2J06c0HPPPSeLxaLhw4fnq0gAAABXkKfg1L59e913332Kjo5W27Zt9c033ygtLc1m27S0NH399ddq166dzpw5o/79+6tDhw4OKRoAAMAZ8vzKlbCwMEVFRWnz5s0aOHCgypUrpw4dOqhmzZry9/fXlStXdPToUW3evFlnz56VYRi65ZZbFBYWVgDlwxWEh4crNjY2y/Lg4GANGjTICRUBAFAw8hyc/Pz8tHHjRk2fPl3vvPOOzp49q+XLl8tisVjbGIYhSSpVqpSefPJJTZ8+XV5eXo6rGi4lNjZWS5bEys8v2LosISFWAwY4sSgAAApAnoOTJHl6eurll1/Wc889p9WrV2vz5s2KiorSpUuXFBAQoMqVK6t9+/bq2bOngoKCHF0zXJCfX7DatHnc+ufff3/PidUAAFAw8hWc0gUGBmrQoEHcjiliuLUGAED+2BWcUDRxaw0AgPwhOBVT3FoDACDv8jQdAQAAQHFGcAIAADCJ4AQAAGASY5wAAIBT2HrKOyIiQtHRdZ1UUe4ITgAAwClsPeUdGXlVXl7JTqwqZwQnAADgNDc+5X38eIQTq8kdY5wAAABMIjgBAACYxK26DHgVCQAAyAnBKQNeRQIAAHJCcLoBryIBAADZYYwTAACASQQnAAAAkwhOAAAAJhGcAAAATCI4AQAAmERwAgAAMInpCJAtJgQFACAzghOyxYSgAABkRnBCjpgQFACAfzHGCQAAwCSCEwAAgEkEJwAAAJMY4wRJUnT0NkVEXMm0LCIiQtHRdZ1UEQAArofgBElSSsoV7dxZRpcv/7ssMvKqvLySnVcUAAAuhuAEKy+vwExP0B0/HuHEagAAcD2McQIAADCJ4AQAAGASwQkAAMAkxjjlwtbTZhLvawMAoDgiOOXC1tNmvK8NAIDiieBkwo1Pm/G+NgAAiifGOAEAAJhEcAIAADCJ4AQAAGASY5yKMJ74y114eLhiY2OzLOccAQDyg+BUhPHEX+5iY2O1ZEms/PyCrcs4RwCA/CI4FXE88Zc7P79gzhEAwCEY4wQAAGASwQkAAMAkbtXlg61B2Qw2zp2tgdqcNwCOduN3TUREhKKj6zqxIrgTglM+3Dgom8HG5tw4UJvzBqAg3PhdExl5VV5eyU6uCu6C4JRPGQdlM9jYvIwDtTlvAApKxu+a48cjnFwN3AnBCUUSc1gBAJyB4IQiiTmsAADOQHBCkcUcVgCAwsZ0BAAAACYRnAAAAEwiOAEAAJjEGCc3t2fvHiUkJGRaFhFRisngAADIB4KTm0tISNBffyXIy8vPumznTiaDAwAgPwhOxYCXl58qV26T4c9/ObEaAACKLoITAAB2svUuTolJed0RwQkAADvd+H48iUl53RXBCQAAB8j4fjyJSXndFcEJBcLWu+QiIiJ4mg8AUKQRnFAgbL1LLjKSp/kAAEUbwQkF5sZ3yR0/HuHEagAAsB/ByQXZejqD21wAADgfwckF2Xo6g9tcAAA4H8HJRd34dAa3uQAAcD6CE9yGPU/ymZm8jgnuAAAEJ7gNe57kMzN5HRPcAQAITnAr9jzJZ2byOia4A4DijeDkZm68XVX+zHFduhScwxauhScKAeRFQX9ncIseNyI4uZkbb1f1qJKiEiWuObeoPOCJQgB5UdDfGdyix40ITm4o4+2qEqffd3I1eccThQDyoqC/M7hFj4wITsgT3kEHACjOCE7IE95BBwAozghOyDPeQQcAKK4ITgAA5AFDFoo3ghMAAHnAkIXijeAEAEAeMWSh+CI4odihmx1wfUw86TicS8ciOKHYoZsdcH1MPOk4nEvHIjg5gK0ejG3btkmSWrdunWk5Cf9fzuz5oZsdcI689H4U9sST7twbzSSejkNwcgDbPRjnJFXWmTP/LiPhZ0bPD1D8uHLvB99JMIPg5CC2ezACSfi5oOcHKH5cufeD7yTkhuAEAAAcyp0HpBOcAACAQ7nyLVl7EZwAAIDDufItWXsQnAA72HoKR3KP7mgAcCR3eWqR4ATYwdZTOO7SHQ0AjuQuTy0SnAA73fgUjrt0RwOAo7nDU4slnF0AAABAUUFwAgAAMIngBAAAYBJjnAAncecJ4lD82HM9u8vTVkWJI58ItvW7d+ffH8EJcBJ3niAOxY8917O7PG1VlDjyiWBbv3t3/v0RnAAnctcJ4lA82XM9u8PTVkWNI58IvvF3786/P4ITkI0bu7LduevZkfbs3aOff8n8Bcztx+LJ0bfguKWXma1bZNu2bZMktW7d2rqsOJ+jgkBwArJxY1e2O3c9O1JCQkKmbntuPxZfjr4Fxy29zGzfIjsnqbLOnFGGZcX3HBUEghOQg4xd2e7c9exoGbvtuf1YvDn6Fhy39DKzfYuMc1SQCE5OVtyeRiiuzP6ezT7pkr6/m31/ty7z8/NTk5uaOLhyAI5k67vAVW5l2/r+cZXaXAnBycmK29MIxZXZ37PZJ13S91e6bfp2CWrUqKCqB+AoN34XuNKt7Bu/f1ypNldCcHIBxelphOLM7O/Z7JMufn7Bqly5jSQpKup3m20AuB5XvpWd8fvH1WpzFQQnwMXl/CSRl3OK+v/Cw8NV+2rm0Hb8+HFFR0c7qSIABYnhJQQnwOXl/CSRc4NTbGysko4kyMvLL8OyFKWkcKsZcEcMLyE4AUWCKz9J5OXlZ71lKEkXLx53YjUAClpxH15CcCpETN5WPDjj93zpUrSOH0+RJP2RYfLJ7J7Gy8jWhHlml0VEROjOcpfyXK/Z95q5yvv8nFGvPb8rs8c0ewxb+7txW77L8sfW94U9v9OCro3fM8GpUDF5W/HgjN/ztWspOn3aV8nJ0urd15fl9DRe7hPmmV12VZ3uvJbnes2+18xV3ufnjHrt+V2ZPabZY5j5rHyX5Y/t74v8/04LvjZ+zwSnQubKt1zgOM74PZco4aPKlduojW/OT8SYnzDP7LKsPSxmmH2vmau8z88Z9eb3d5WXY5o5hpnPyndZ/tn+vnDce+Tswd9ZWVkMwzCcXYQZcXFxKl26tE6ePKnAwMACOcbHH3+sb7+9IF/fMtZlR46skxSqWrUaZ7vMTBtnLetS+QNJASpTppy1zasrS7hEba5yjopyvZN6n5IkXbhwROm/56/3dpMkJSZeUEjIX+rQoYN1u02bNikmplGer/Gclj3S8Uym6+vChSP66JfbrO3M1mFPO0lq6btWN9qe2C3LsvwoiHrzc0yzvxezxzR7DDOf1dn/Lbjif7uOPG+F9d+zK5y37D5/nz5lNGbMGBWE+Ph4Va1aVRcvXlRQUFCObYtMcDp16pSqVq3q7DIAAICbOnnypKpUqZJjmyITnNLS0hQdHa2AgABZLJYCOUZ64izIXq2ihnNiG+fFNs6LbZyXrDgntnFebCvo82IYhi5duqTQ0FCVKFEix7ZFZoxTiRIlck2BjhIYGMgFewPOiW2cF9s4L7ZxXrLinNjGebGtIM9Lbrfo0uUcqwAAAGBFcAIAADCJ4JSBj4+Ppk2bJh8fH2eX4jI4J7ZxXmzjvNjGecmKc2Ib58U2VzovRWZwOAAAgLPR4wQAAGASwQkAAMAkghMAAIBJBCdJa9as0V133aXg4GD5+/urZcuWeuedd5SWlubs0gqdYRj69ddf9eyzz6pdu3YqXbq0vL29FRoaqv79+2vDhg3OLtFlvPjii7JYLLJYLHr55ZedXY5TXbt2TfPmzVOnTp0UEhIiX19fVa9eXX379tW3337r7PKc4uzZs5o4caIaN26skiVLytfXV7Vr19aYMWMUGRnp7PIKzNGjRzVv3jw9/PDDatasmTw9PU3/N7Jlyxb16dNH5cqVk5+fnxo1aqRZs2YpMTGxECovOPk5Jzt27NDUqVOt/015eXmpfPny6tGjh5YvX16I1Rcce66VjD755BPrd/FDDz1UQNVmYBRzc+bMMSQZkoxatWoZTZs2NUqUKGFIMnr37m1cu3bN2SUWqvXr11vPR4kSJYx69eoZLVq0MEqVKmVd/uKLLzq7TKf766+/DG9vb+s5mTVrlrNLcprY2FijXbt2hiTDYrEY9evXN1q1amVUqlTJkGT079/f2SUWuv379xvly5c3JBleXl5G/fr1jZtuusnw9fU1JBklS5Y0Nm7c6OwyC8S4ceOs/11k/Mntv5EvvvjC8PDwMCQZlStXNlq0aGF4eXkZkoybb77ZuHLlSiF9AsfL6zmJjIzM1K5mzZpGq1atjDJlyliXDR8+vMj//ZTfayWjs2fPGsHBwdZtR48eXYAVX1ese5y2bNmiKVOmqESJEvryyy91+PBh7dq1S9u3b1eFChW0cuVK/fe//3V2mYXKMAzVqVNH77//vmJiYnTgwAFt375d58+f1+TJkyVJL7/8sv7v//7PyZU6j2EYeuSRR+Tl5aU777zT2eU4VVpamnr37q3ffvtN/fr104kTJ7R//35t27ZN0dHROnnypJ566ilnl1noHn/8cZ09e1YdOnTQkSNHtH//fu3Zs0enTp1S7969dfXqVY0cOVKGGz7UHBISorvvvlszZ87Ud999p/79++e6zbFjxzR69Ghdu3ZNr7/+uk6ePKnt27fr0KFDql+/vv744w8999xzhVB9wcjrOTEMQ5UqVdJrr72m6OhoHTlyRNu2bVNMTIzeeecdWSwWff7553r//fcL6RMUjPxcKzeaMGGCLl68qF69ehVAhdko8Gjmwnr27GlIMsaMGZNl3aJFiwxJRtmyZY3k5GQnVOcccXFxRkpKSrbre/ToYe2NK67mzZtnSDJee+01Y/jw4cW6x+mDDz4wJBl33HFHkf/Xr6NcuXLF2mu9e/fuLOtjY2MNi8ViSDL++usvJ1RYuMz8N/LYY48ZkoyuXbtmWbdp0yZrz93p06cLstRCk9s5SUhIyLGHbezYsYYko2nTpgVVolPk9ft03bp1hiTj0UcfNaZNm0aPU0GLj4/X+vXrJUmjR4/Osv6+++5TYGCgzp8/X6zG9QQGBsrTM/tXGHbp0kWSdPDgwcIqyaWcO3dOzz//vBo1aqQJEyY4uxynmzt3riRp1qxZub4Ys7hITk62jo+sVatWlvVlypRRcHCwJCk1NbVQa3NFhmFYx+zY+i5u3769GjRooJSUlGIzXs7X11clS5bMdn3Xrl0lFd/vYUlKTEzUo48+qvLly+uVV14p1GMX22+6HTt2KDk5Wb6+vmrZsmWW9V5eXrr55pslSVu3bi3s8lxW+iBNPz8/J1fiHBMmTFBsbKzef/99eXl5Obscpzp06JD279+v4OBgtW/fXt9++62GDBmizp07a+DAgfrkk0+UlJTk7DILXenSpVW1alVJ0ubNm7OsP3DggM6fP6/SpUurbt26hV2eyzlx4oT++ecfSVKHDh1stklfznfxdcX9e1i6PmQkMjJSb7zxhkqXLl2oxy62wenQoUOSpGrVqmXbw5L+r8X0tsWdYRj65ptvJGX/BefOfvzxRy1atEhDhgxRp06dnF2O0/3555+SpAYNGmjo0KHq27evFi1apJ9++klfffWVHn74YTVv3lzHjx93cqWFL/2poFGjRmnp0qU6f/684uLitHbtWvXt21cWi0Wvv/66fH19nVyp86V/v/r4+Cg0NNRmG76LM/v6668lFc/vYUn6+++/9cYbb6hjx44aNmxYoR+/2AanCxcuSLrebZ6d9HXpbYu7efPmaceOHfL29tb48eOdXU6hSkxM1NixYxUUFKQ333zT2eW4hPRegj/++EOLFi3SQw89pGPHjikxMVHr169XrVq1tH//fvXv37/YTe0xbNgwLV26VCEhIRowYIBCQkJUunRpde/eXd7e3lqzZo0efvhhZ5fpEtK/X0uXLi2LxWKzDd/F//rhhx+0YsUKSdKzzz7r3GKcwPj/D+ekpaU5bXB8sQ1O6V2d3t7e2bZJf5lgQkJCodTkyrZv365x48ZJuv6v6dq1azu5osKV3i08e/ZsVahQwdnluIQrV65IklJSUtSxY0fNmzdP1atXl4+Pjzp37qxly5bJYrHozz//1OrVq51cbeEyDENHjhzR+fPn5eHhoTp16qhRo0by9vbW3r179fHHHys2NtbZZboEvovNO3HihB588EFJ0mOPPabbbrvNyRUVvk8//VS//PKLxo8fr5tuuskpNRTb4JTeRZ6cnJxtm/TxGcX5PrJ0fZKyu+++W4mJiRo8eLAmTpzo7JIKVXq3cMuWLfXoo486uxyXkfE2U3qozqhZs2a64447JEnff/99odXlCsaOHatnn31WVatWVWRkpA4dOqR9+/bp5MmT6tmzp5YvX6477rhD165dc3apTsd3sTmxsbHq0aOHYmJidPvttxe7qXKkfx/OqVKliqZNm+a0OoptcDLT9Wvmdp67O336tLp06aJ//vlHvXr1UlhYWLbd6e7qscceU2pqqj744AOeHMsg438XDRo0sNmmYcOGkq7P01Nc7Nq1S/PmzZOXl5cWL16sGjVqWNeVL19eixYtUkhIiHbv3m0dq1KcpV9HFy9ezHZeq+L+XXz58mX17NlTf/31l1q1aqWVK1dae+GKk+eee06xsbF66623VKpUKafVUWz/Fkh/muXEiRPZPhJ85MiRTG2Lm9jYWHXp0kWHDx9Wp06d9M033xTLJ8l27Nghi8Wi3r17q2LFipl+vvrqK0nSa6+9pooVK1qfxCwO6tevb/3/2X2Jpy8vTj0rmzZtkmEYqlevnvXpuowCAwPVpk0bSdK2bdsKuzyXk/79mpSUpOjoaJttivN3cVJSkvr06aOtW7eqUaNG+v777xUQEODsspxix44dkqQnnngiy3dx+tjTL7/80rqsoGQ/YY+ba9Gihby8vJSYmKjt27dbv8jSpaSk6I8//pAktW3b1hklOlX6v3D27t2rm2++WatWrSrW3eTXrl3TmTNnsl1/+fJlXb58uVg9JdWiRQv5+voqMTFRR44cUZ06dbK0Sf8Lr3LlyoVdntNcunQp1zbpPStF/R1sjlCtWjVVrFhRp0+f1qZNm3T//fdnabNp0yZJxe+7ODU1Vffff79++ukn1apVS+vWrVNISIizy3K6nL6LExISCnwsXLHtcQoMDNRdd90l6fpgsxt98803io+PV9myZXX77bcXcnXOlfFfOI0bNy7W/8KR/r2FYOtn+PDhkq5PAGkYRrG6JeXv76+ePXtKkj7//PMs60+fPq21a9dKUrF6NU16r8jBgwd18uTJLOvj4+Ot/yirV69eodbmiiwWi+69915Jtr+LN2/erP3798vLy0u9e/cu7PKcxjAMjRgxQitXrlRoaKjWr1+f7XQNxcXOnTuz/S5OH/M0evRo67KCUmyDkyS98MILslgs+uSTTxQeHm5dvmvXLj399NOSrt9TzelpD3dz7do1DRw4UD/99JNq166tdevWWWc5Bm40depUeXh4aPHixZnC08WLFzVixAglJCSoVq1auu+++5xYZeHq2rWrQkJClJKSooEDB2YK02fPntWDDz6omJgY+fr6asCAAc4r1IU8++yz8vb21g8//KA33njD+pfe8ePHNWrUKEnSQw89VKC3X1zNuHHjrOPh1q9fr5o1azq7JKQr8Je6uLiXX37Z+lblWrVqGU2bNrW+Z6pXr15Gamqqs0ssVF9++aX1fNStW9fo0KGDzZ8BAwY4u1SXUNzfVWcY199Xl/7utWrVqhmtW7c2SpYsaUgyQkJCjB07dji7xEK3Zs0aw9fX15BkeHh4GHXr1jUaNWpkeHt7G5IMT09PIywszNllFohff/3VKFu2rPXHx8fHkGSULFky0/ITJ05k2u7zzz+3fvdWrlzZaNGiheHl5WVIMlq1amVcvnzZSZ/Ifnk9J5s3b7Z+D1etWjXb7+EOHTo4+ZPZJ7/Xii2F+a66YjvGKd0LL7ygZs2a6a233tKff/6p06dPq0mTJho5cqSeeOIJeXh4OLvEQpXxFRmHDh3Kdqbe6tWrF1ZJcHFjx45V48aN9cYbb2jLli3avXu3QkND1atXL02ePLlYjW9K16NHD+3atUv/+c9/9NNPP+nEiRPWN97fdtttGj9+vM1XPbmDlJQUnT9/Psvyq1ev6urVq9Y/3/jAwLBhw1SnTh3NmTNHmzdv1l9//aVatWpp0KBBev7554v0+MG8npOM38MnT560ecvXHeT3WnE2i2EU4I1AAAAAN1KsxzgBAADkBcEJAADAJIITAACASQQnAAAAkwhOAAAAJhGcAAAATCI4AQAAmERwAgAAMIngBAAAYBLBCQAAwCSCE4AiY+PGjbJYLLr99tuzrLNYLLJYLIVfVD61a9dOISEhunz5slPrGDVqlDw9PbV//36n1gEUFQQnoAioUaOGLBaLwsLCnF0KHOCbb77R1q1b9fTTT6tUqVKZ1pn9Xd9+++2yWCyaPn26XbVMmTJFkjR58mS79gMUFwQnAG6hfv36ql+/vrPLyFVaWppeeOEFBQYG6oknnnB2OapTp47uu+8+rVixQr/99puzywFcHsEJgFvYv39/kbjdtHbtWh06dEj33nuvAgMDnV2OJGn48OGSpPfee8/JlQCuj+AEAIXo448/liQNGjTIyZX866677lJISIiWLl2qixcvOrscwKURnAA3FhUVpaefflqNGjWSv7+/goKC1KRJE02cOFGHDh3K0v7EiRN69NFHVbNmTfn4+CgkJEQ9evTQd999Z3P/I0aMyHE8zvTp022Ow8m4/PTp0xo9erRCQ0Pl6+urhg0b6s0331RqamqePmt2g8PTxwwdO3ZMv/32m3r06KEyZcrI399fHTt21E8//ZTtPs+ePatHHnnEWluDBg00Z84cpaamWscYbdy40XSNV65c0erVq+Xr66s777wzT5/PjGPHjlnPQ04/N/6+PD091a1bNyUkJGjlypUOrwtwJ57OLgBAwfjxxx/Vr18/xcfHy8vLSw0bNlRaWpqOHDmi//znPypVqlSmQLN161Z1795dFy9elL+/v5o0aaIzZ87o+++/1/fff6+XXnpJM2fOdGiN58+fV5s2bRQdHa0mTZooICBA+/fv17PPPqtNmzZp6dKlKlHCMf+++7//+z89/fTTCgwMVO3atRUZGalff/1V3bp107p167I8qXfq1Cl16NBBJ06ckJeXl2666SZduXJFU6ZM0datW/NVw5YtW5SSkqLWrVvLy8vLAZ8qM19fX3Xo0CHH46elpdlc16ZNGy1atEg///yzhg0b5vDaAHdBjxPghk6cOKH+/fsrPj5ew4YN0+nTp7Vr1y7t2bNHly5d0v/93/+pVatW1vZXr17V/fffr4sXL+r+++/XP//8o23btunkyZMKCwuTh4eHZs2alW3PU359+OGHKl26tCIjI7Vjxw4dOHBAERERCgoK0ooVK/TBBx847FhPP/20Zs6cqTNnzmjbtm06d+6cHnzwQaWmpmrSpElZ2o8dO1YnTpxQ69atdeTIEW3fvl0HDhzQzz//rIiICG3evDnPNaRvk/HcO1LFihX166+/2vzp1auX0tLSVK1aNfXq1SvLtjfffLMk6ddffy2Q2gB3QXAC3NBrr72muLg4de7cWWFhYQoODrauK1GihHr16qV77rnHuuzLL7/UiRMnVKFCBX3++ecKCAiwrhs+fLgeeeQRSdKcOXMcWmdqaqrCwsJUo0YN67LbbrtNs2bNkiS9+eabMgzDIcfq3r27Jk2aJA8PD0mSl5eX3n77bfn4+Gjr1q26cOGCte2BAwe0evVqeXl56euvv1aVKlWs6zp27Ki33npLKSkpea7h+PHjkqRKlSrl2nbkyJE53m6LiIgwfdzVq1frxRdfVMmSJbVixQqVK1cuS5v0mtJrBGAbwQlwQ99++60k6dlnnzU1KeQPP/wgSXr44Yfl6+ubZf24ceMkXe8xuXLlisPqvOWWW9SyZcssy0eNGiVfX18dO3ZMBw4ccMixHnrooSzLQkJCrKHtyJEj1uXr1q2TdH2upJo1a2bZbuDAgfLz88tzDTExMZKUKchmp27duurQoUO2P2afyDtw4IAefPBBpaWl6dNPP1WLFi1stkuvKTEx0emTcgKujDFOgJu5dOmSoqKiJF2fndqMgwcPSpIaNWpkc33dunXl7e2t5ORkHT58WE2bNnVIrQ0bNrS53N/fX1WrVtWhQ4d08OBBNWjQwO5j1a5d2+by8uXL68CBA5nCQvrA+ew+p6+vr+rWravdu3fnqYbExERJko+PT65tp0yZohEjRmS7/vbbb8+11ykuLk59+vRRXFycJk+erIEDB2bbNmMQTEhIyDIxJ4Dr6HEC3Ex8fLz1/wcFBZnaJj00lC9f3uZ6i8Vivb1z6dIlOyv8V3bHk6QKFSo49Hj+/v42l6cPPs94SzC9Vy3jLcsb5bQuO+m9OoXxyH9aWpoGDx6sAwcOqFevXnr55ZdzbB8bGyvp+u/aTI8YUFwRnAA3k/Ev9Li4OFPbpPcunD171uZ6wzB07ty5LPtPvw2Y3Tik3G7rpe/TlvRa8hNQ7JUesnK6ZZWfQJceFNNDSkGaPHmy1qxZowYNGujLL7/M9enE9JqCg4Ot48AAZEVwAtxMYGCgdTCz2Vdo1KtXT5L0119/2Vx/6NAhJScny8PDI9Mtr/SAkV0AioyMzPG4f//9t83lV69e1YkTJzLVVpjSj5ndrbikpCSb82Dlpnnz5pKy/9yOsnjxYr3++usqXbq0Vq5caWo8VPrv3taYMwD/IjgBbqhv376SpP/85z+m2nfr1k2SNG/ePOs4nIz+97//SZI6dOiQ6ZZXrVq1JEl//PFHlm1OnTqltWvX5njczZs3a+fOnVmWf/bZZ0pMTFT16tWd8v65Ll26SJI2bNhg8ymzr776SgkJCXne76233ipJ2rZtm30F5mD79u0aNWqUSpQoofDwcNWtW9fUdr///ruk608NAsgewQlwQ88++6yCgoK0bt06jR49OtOj9mlpaVqzZo3+7//+z7ps0KBBqlatms6cOaMRI0ZkukX1xRdf6KOPPpKkLPMd9ejRQ5K0YsUKrVmzxrr8n3/+sc6RlBNPT0+NGDEiUzj59ddfNXXqVEnSxIkTTT0V6Gj16tVTr169lJKSovvvv1/R0dHWdZs2bdKECRPyNYFl3bp1VbNmTR0/flynTp1yZMmSrt/e7Nu3rxISEvTaa6+pe/fuprfdtGmTJKlr164OrwtwJwQnwA1Vq1ZNS5YsUUBAgD777DNVqFBBzZs3V9OmTRUYGKhevXpl6vUoWbKkvv76awUFBemrr75SxYoVdfPNN6tatWoaOnSoUlNT9eKLL1qDUrqGDRtq9OjRSk1NVa9evVSrVi21aNFC1apV09mzZ/XYY4/lWOcjjzyi2NhY1alTRy1atFCDBg3UsWNHXbhwQffcc0+u2xekDz/8UNWqVdPvv/+uGjVqqFWrVmrQoIFuvfVW3XrrrbrlllskKc/jgUaNGiXpeq+Vo61Zs0YnT56Uh4eHVqxYYa31xp8bJzI9deqUNm/erMaNG6tt27YOrwtwJwQnoAi4du2aJMnb29v0NnfddZf27t2rJ554QtWrV9f+/ft18uRJ1a5dW88++6yGDh2aqX3btm21a9cuPfLIIwoJCdHu3bt1+fJlde3aVatXr7ZOSnmjDz/8UDNnzlTt2rUVFRWlc+fO6ZFHHtGWLVtUunTpHGsMCQnR77//rmHDhunMmTM6evSo6tevr9dee03Lli1z2OtW8qNKlSr6/fffNWbMGJUtW1b79u1TWlqaZs6cqSVLlujq1auS8j54fdSoUfL09NSiRYsKomxJ16+XTZs2Zftz5syZTO0XL14swzBsznUFIDOL4ahpeQEUmMDAQF26dEmrV69Wz549nV2O3aZPn64ZM2Zo2rRpWV4AXBSkpaUpODhYcXFxio2NVZkyZfK0/ZgxYzRv3jz98ssv1nFPzpKamqr69evr8uXLOnz4MPM3AbmgxwlwcceOHbM++p7dhJEoXMuWLVNcXJwaNWqU59AkSTNmzFDJkiUd/tLk/Fi0aJGOHDmiadOmEZoAEwhOgAtLTk7W888/L0lq3Lixzdd/oGCcOXNGr7/+us6fP59p+ffff6+xY8dKkvV/86pSpUpasGCBOnTo4PTXm1gsFs2aNUtjxoxxah1AUcErVwAXFBkZqQcffFD79+9XfHy8PDw89Oabbzq7rGIlISFBzz//vCZNmqQqVaqoYsWKOnXqlP755x9JUq9evewavN6/f3/179/fUeXm27Bhw5xdAlCk0OMEuKDLly/rjz/+UIkSJdS1a1etX78+T4+Ww37ly5fXtGnT1KZNGyUlJWnnzp26evWqOnTooA8//FArVqxghm2gGGJwOAAAgEn0OAEAAJhEcAIAADCJ4AQAAGASwQkAAMAkghMAAIBJBCcAAACTCE4AAAAmEZwAAABMIjgBAACY9P8AvWSKXfk3wsAAAAAASUVORK5CYII=\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""%matplotlib inline\n"", ""fig = plt.figure(figsize=(6,8))\n"", ""gs = gridspec.GridSpec(2, 1)\n"", ""ax1 = plt.subplot(gs[0,0])\n"", ""data1 = pd.concat([pd.read_pickle(i) for i in biceps.toolbox.get_files('cineromycin_B/J_NOE/*.noe')])\n"", ""ax1 = data1[\""model\""].plot.hist(alpha=0.5, bins=100,\n"", "" edgecolor='black', linewidth=1.2, color=\""b\"", label=\""Model\"")\n"", ""ax1.axvline(list(set(data1[\""exp\""].to_numpy())), c=\""orange\"", linewidth=3, label=\""Experiment\"")\n"", ""ax1.legend(fontsize=14)\n"", ""ax1.set_xlabel(r\""NOE distance ($\\AA$)\"", size=16)\n"", ""ax1.set_ylabel(\""Counts\"", size=16)\n"", ""ax1.axes.get_yaxis().set_ticks([])\n"", ""\n"", ""ax2 = plt.subplot(gs[1,0])\n"", ""data2 = pd.concat([pd.read_pickle(i) for i in biceps.toolbox.get_files('cineromycin_B/J_NOE/*.J')])\n"", ""ax2 = data2[\""model\""].plot.hist(alpha=0.5, bins=100,\n"", "" edgecolor='black', linewidth=1.2, color=\""b\"", label=\""Model\"")\n"", ""data2[\""exp\""].plot.hist(alpha=0.5, bins=40,\n"", "" linewidth=1.2, color=\""orange\"", label=\""Experiment\"", ax=ax2)\n"", ""ax2.set_ylim(0,100)\n"", ""ax2.axes.get_yaxis().set_ticks([])\n"", ""ax2.set_xlabel(r\""J coupling (Hz)\"", size=16)\n"", ""ax2.set_ylabel(\""Counts\"", size=16)\n"", ""ax2.legend(fontsize=14)\n"", ""\n"", ""axs = [ax1,ax2]\n"", ""for n, ax in enumerate(axs):\n"", "" ax.text(-0.05, 1.0, string.ascii_lowercase[n], transform=ax.transAxes,\n"", "" size=20, weight='bold')\n"", "" ticks = [ax.xaxis.get_minor_ticks(),\n"", "" ax.xaxis.get_major_ticks(),]\n"", "" xmarks = [ax.get_xticklabels()]\n"", "" for k in range(0,len(ticks)):\n"", "" for tick in ticks[k]:\n"", "" tick.label.set_fontsize(16)\n"", "" for k in range(0,len(xmarks)):\n"", "" for mark in xmarks[k]:\n"", "" mark.set_size(fontsize=16)\n"", "" mark.set_rotation(s=0)\n"", ""fig.tight_layout()\n"", ""fig.savefig('histogram_of_observables.pdf', dpi=600)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
\n"", ""
Histogram of (a) experimental (orange) and model data (blue) for 32 NOE distances for 100 structures. (b) For the same structures, 9 scalar coupling observables.\n"", ""
\n"", ""
\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 10, ""metadata"": {}, ""outputs"": [], ""source"": [ ""# REQUIRED: number of MCMC steps for each lambda\n"", ""nsteps = 1000000 #100000000 # 100 M steps for production\n"", ""# REQUIRED: specify how many lambdas to sample (more lambdas will provide higher \n"", ""# accuracy but slower the whole process, lambda=0.0 and 1.0 are necessary)\n"", ""n_lambdas = 2\n"", ""lambda_values = np.linspace(0.0, 1.0, n_lambdas)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""#### Constructing conformational ensembles and applying data restraints\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""We begin by constructing an ensemble using prior information from simulation $P(X)$, a collection energies for each state. In this example, energies for each state were taken from QM optimization at the B3LYP/6-3111G(2d,p)/HF/6-31G(d) level of theory. In most cases we convert the normalized population of each state into free energies through $E = -k_{b}T * \\log P$ where $k_{b}$ is the Boltzmann constant and $T$ is the temperature. Alternatively, users can describe the potential energy of conformational states based on their own preference, but it is necessary to pass BICePs reduced free energies (in units of $k_{b}T$).\n"", ""\n"", ""\n"", ""In general, the goal of this step is to construct an $\\verb|ensemble|$ object for each $lambda$-value, where each ensemble contains $\\textit{prior}$ information as well as restraint information. Please be aware that the example below is for a single $\\lambda$-value for the sake of simplicity, and that posterior sampling for each ensemble will need to be performed iteratively for at least two lambdas $\\{0.0, 1.0\\}$. As discussed in \\cite{Voelz:2014fga,Ge:2018bdb, voelz2021reconciling}, the lambda value controls how much prior information $P(x)$ is used during posterior sampling. Similar to Free Energy Perturbation (FEP) simulations, the more fine-grained spaced lambda values are employed, the more accurate the results will be. However, finer grained lambda values will increase the computational expense and may not be necessary. Unlike FEP simulations where the $\\lambda$-space plays a critical role in accuracy of results, BICePs suffers less in the \""overlap issue\"". Only when the prior distribution (computational modeling) is dramatically different from the posterior likelihood distribution (with experimental restraints), a large number of $\\lambda$-values are needed to bridge each ensemble to sample. Normally this may occur with improper modeling (i.e improper force fields) or finite sampling issue. Our previous experience shows lambda values of 0.0, 0.5, 1.0 are robust in accuracy. Nevertheless, it is still important for users to test for optimal settings for their systems and consider the balance between accuracy and efficiency.\n"", ""\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 11, ""metadata"": {}, ""outputs"": [], ""source"": [ ""####### MCMC Simulations #######\n"", ""ensemble = biceps.Ensemble(lambda_values[0], energies)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""Now that we have our $\\verb|ensemble|$ object, we want to apply data restraints and possibly adjust some of the restraint settings. However, adjusting the default settings is optional, but definitely important to achieve good sampling. We illustrate in the code block below, that the default restraint settings are readily avalible, which is a list of dictionaries, where each dictionary contains specific keyword arguments (kwargs) for each restraint type in the provided prepared data as shown here:"" ] }, { ""cell_type"": ""code"", ""execution_count"": 12, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
refsigmause_global_ref_sigmaextensionweightlog_normalgamma
0uniform[0.05, 20.0, 1.02]TrueJ1NaNNaN
1uniform[0.05, 20.0, 1.02]Truenoe1False[0.2, 10.0, 1.01]
\n"", ""
"" ], ""text/plain"": [ "" ref sigma use_global_ref_sigma extension weight \\\n"", ""0 uniform [0.05, 20.0, 1.02] True J 1 \n"", ""1 uniform [0.05, 20.0, 1.02] True noe 1 \n"", ""\n"", "" log_normal gamma \n"", ""0 NaN NaN \n"", ""1 False [0.2, 10.0, 1.01] "" ] }, ""execution_count"": 12, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""#pd.DataFrame(biceps.get_restraint_options())\n"", ""options = biceps.get_restraint_options(input_data)\n"", ""pd.DataFrame(options)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 13, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/plain"": [ ""{'ref': 'uniform',\n"", "" 'sigma': [0.05, 20.0, 1.02],\n"", "" 'use_global_ref_sigma': True,\n"", "" 'extension': 'J',\n"", "" 'weight': 1}"" ] }, ""execution_count"": 13, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""options[0]"" ] }, { ""cell_type"": ""code"", ""execution_count"": 14, ""metadata"": {}, ""outputs"": [], ""source"": [ ""df = pd.DataFrame(options)\n"", ""df.to_latex(\""restraint_options.tex\"")"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Default restraint options can be redefined. To explain the $\\verb|options|$ in greater detail, consider our system Cineromycin B with the two data restraints being J-coupling and NOE distances, respectively. We will redefine the reference potential as well as the discrete sample space for the NOE distance model parameters $\\sigma$ and $\\gamma$ (unique to NOE), but keep all default parameters for the J coupling restraint. Model parameters $\\sigma$ and $\\gamma$ reflect both uncertainty in the experimental measurements as well as conformational heterogeneity and intensities to interatomic distances, respectively.\n"", ""\n"", ""\n"", ""The implementation of reference potentials is a unique feature in BICePs compared to other Bayesian inference based approaches.\\cite{Rieping303, perez2015accelerating, beauchamp2014bayesian, fisher2010modeling, bonomi2016metainference, bonomi2016metadynamic} It functions to reweigh the informative level of the experimental restraints. Please read these works for more information regarding the theory of reference potentials\\cite{Olsson:2013gqa, Olsson:2011kl, Hamelryck:2010deb} and their implementations in BICePs\\cite{Voelz:2014fga,Ge:2018bdb, voelz2021reconciling}. A uniform reference potential treats each experimental restraint uniformly i.e., a uniform reference potential is equivalent to not having a reference potential during sampling. The options for reference potentials are the following: $\\verb|\""uniform\""|$, $\\verb|\""exponential\""|$ and $\\verb|\""gaussian\""|$. The values inside the tuple for sigma (and gamma) define its discrete sample space and follow the formalism of NumPy's method $\\verb|arange|$: a minimum of 0.05, maximum of 20.0 and incremented by $\\log(1.02)$.\n"", ""\n"", ""\n"", ""To make this change, we will set the reference potential to an exponential distribution, set the sigma-space to a smaller range of allowed sample space and alter the gamma spacing to have a larger width size.\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 15, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
refsigmause_global_ref_sigmaextensionweightlog_normalgamma
0uniform[0.05, 20.0, 1.02]TrueJ1NaNNaN
1exponential(0.05, 5.0, 1.02)Truenoe1False(0.2, 5.0, 1.02)
\n"", ""
"" ], ""text/plain"": [ "" ref sigma use_global_ref_sigma extension weight \\\n"", ""0 uniform [0.05, 20.0, 1.02] True J 1 \n"", ""1 exponential (0.05, 5.0, 1.02) True noe 1 \n"", ""\n"", "" log_normal gamma \n"", ""0 NaN NaN \n"", ""1 False (0.2, 5.0, 1.02) "" ] }, ""execution_count"": 15, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""# Change NOE reference potential from uniform to exponential\n"", ""options[1][\""ref\""] = 'exponential'\n"", ""# Change the sigma-space to a smaller range of allowed sample space\n"", ""options[1][\""sigma\""] = (0.05, 5.0, 1.02)\n"", ""# Alter gamma spacing to have larger width\n"", ""options[1][\""gamma\""] = (0.2, 5.0, 1.02)\n"", ""pd.DataFrame(options)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Using our established $\\verb|ensemble|$ object containing prior informaiton, we now would like to apply data restraints. To do this, we invoke the method $\\verb|ensemble.initialize_restraints|$ and provide the prepared data for each state as well as our restraint options. "" ] }, { ""cell_type"": ""code"", ""execution_count"": 16, ""metadata"": {}, ""outputs"": [], ""source"": [ ""ensemble.initialize_restraints(input_data, options)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""In summary, the $\\verb|biceps.Ensemble|$ class was used to construct a single ensemble for a given lambda value. Ensembles must be constructed for all lambda values, where each lambda value scales the reduced free energies of the states. Then, we apply data restraints using our prepared data along with non-default restraint options. These restraint variables are important in BICePs sampling since nuisance parameters are included in the energy calculation during sampling. We recommend a broad range of parameters for better accuracy of sampling but the sampling runtime will also increase due to a larger sampling space for a good converged sampling. Note that increasing this range may increase the sampling requirement for convergence. After filling the $\\verb|ensemble|$ container object with $\\verb|Restraint|$ objects (NOE and J) for each conformational state, the $\\verb|ensemble|$ object is ready to be passed to $\\verb|biceps.PosteriorSampler|$. \n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""#### Sampling the posterior distribution via Markov Chain Monte Carlo\n"", ""\n"", ""\n"", ""\\subsection{Sampling the posterior distribution via MCMC}\n"", ""%\\subsection{PosteriorSampler}\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""The primary objective of this step is to perform MCMC sampling of the posterior distribution, which consists of nuisance parameter space as well as conformational space . During MCMC, what is actually evaluted is an effective energy function (in $k_{b}T$). Suitably, all of the required information to perform energy evaluations is inherited from the $\\verb|ensemble|$ object. The energy function can be obtained as the negative logarithm of the posterior probability given in Eq.\\ref{eq:nuisance}:\n"", ""\n"", ""\\begin{equation}\n"", ""\\begin{split}\n"", ""-\\ln P(X_{i}, \\sigma^{\\text{NOE}}, \\sigma^{\\text{J}}, \\gamma^{\\prime} | D) = &\\left(N_{j}^{\\text{J}}+1\\right) \\ln \\sigma^{\\text{J}}+\\frac{\\chi^{2}(X_{i})}{2 (\\sigma^{\\text{J}})^{2}}+\\frac{N_{j}^{\\text{J}}}{2} \\ln 2 \\pi \\\\\n"", ""&+ \\left(N_{j}^{\\text{NOE}}+1\\right) \\ln \\sigma^{\\text{NOE}}+\\frac{\\chi^{2}(X_{i})}{2 (\\sigma^{\\text{NOE}})^{2}}+\\frac{N_{j}^{\\text{NOE}}}{2} \\ln 2 \\pi\\\\\n"", ""&+ \\sum_{j} \\left( \\ln \\beta_{j} - r_{j}^{\\text{NOE}}/\\beta_{j}\\right) + E(X_{i})/k_{b}T + \\sum_{i} \\exp\\left(-E(X_{i})/k_{b}T\\right)\n"", ""\\label{eq:neglogP}\n"", ""\\end{split}\n"", ""\\end{equation}\n"", ""\n"", ""\n"", ""The quantity $\\chi^{2}(X)$ is the sum of squared errors, computed as\n"", ""\\begin{equation}\n"", ""\\chi^{2}(X)=\\sum_{j} w_{j}\\left(r_{j}(X)-r_{j}^{\\exp }\\right)^{2}\n"", ""\\label{eq:chi2}\n"", ""\\end{equation}\n"", ""\n"", ""where $w_{j}$ is a weight parameter (for example, $w_{j}=1/3$ is the uniform weight for each hydrogen in a methyl group), where the effective number of coupling constants is $N_{j} = \\sum_{j} w_{j}$.\n"", ""\n"", ""\n"", ""The Metropolis-Hastings criterion is used to determine if a new jump is accepted or rejected in the MCMC simulation. The Metropolis-Hastings algorithm was used for MCMC sampling of the full posterior distribution over variables, $\\theta = (X_{i}, \\sigma^{\\text{NOE}}, \\sigma^{\\text{J}}, \\gamma^{\\prime})$ where $i$ is an index running over all conformations. Iteratively, candidate moves $\\theta \\rightarrow \\theta^{\\prime}$ are proposed, and either accepted or rejected by the Metropolis criterion, which accepts the move with probability min$\\left[1, P(\\theta^{\\prime})/P(\\theta) \\right]$. Overall, the result yields an estimate of the full posterior distribution $P(X, \\sigma | D)$. The most probable values of $\\sigma$ can be obtained by the marginal distribution $P(\\sigma | D) = \\int P(X, \\sigma | D) dX$, and the state populations are estimated as $P(X | D) = \\int P(X, \\sigma | D) d\\sigma$.\n"", ""\n"", ""A key advantage of MCMC sampling is that the error estimate is independent of the dimension $d$ of the parameter space to be sampled. On the other hand, this acts as a disadvantage such that convergence is slowly achieved. Therefore, MCMC sampling is not optimal for low dimensional (e.g 1D) integrals but rather a better option for high dimension task. Since BICePs is designed for working with multiple experimental observables and for some observables (i.e NOE and protection factors) more than one nuisance parameters are included in sampling, MCMC sampling is an attractive choice for such a problem.\n"", ""\n"", ""\n"", ""To initialize the class, the only requirement is the \\verb|ensemble| object.\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 17, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Step\t\tState\tPara Indices\t\tAvg Energy\tAcceptance (%)\n"", ""0\t\t[25]\t[151, 116, 81]\t\t135.228\t\t100.00\tTrue\n"", ""1000\t\t[87]\t[181, 134, 99]\t\t11.514\t\t55.64\tTrue\n"", ""2000\t\t[87]\t[207, 142, 100]\t\t5.789\t\t59.42\tTrue\n"", ""3000\t\t[87]\t[227, 135, 98]\t\t4.942\t\t62.08\tFalse\n"", ""4000\t\t[87]\t[232, 143, 98]\t\t5.517\t\t63.43\tFalse\n"", ""5000\t\t[23]\t[256, 119, 96]\t\t9.108\t\t65.47\tFalse\n"", ""6000\t\t[79]\t[229, 120, 99]\t\t7.705\t\t65.94\tTrue\n"", ""7000\t\t[87]\t[227, 143, 99]\t\t5.339\t\t66.12\tFalse\n"", ""8000\t\t[8]\t[252, 135, 99]\t\t9.481\t\t67.02\tTrue\n"", ""9000\t\t[60]\t[237, 133, 100]\t\t9.242\t\t67.95\tTrue\n"", ""\n"", ""Accepted 67.99 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [31.99 29.87 29.87 6.13] % \n"", ""\n"" ] } ], ""source"": [ ""sampler = biceps.PosteriorSampler(ensemble)\n"", ""sampler.sample(nsteps=10000, burn=0, print_freq=1000, verbose=True, progress=0)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""\n"", ""Next, the posterior distribution is sampled by invoking the $\\verb|sampler.sample|$ method from the $\\verb|sampler|$ object and specifying the number of steps to be sampled (\\mintinline{python}{nsteps}). This number is important for convergence and normally is not known a \\textit{priori}. We developed multiple statistical methods to check convergence of the outcome trajectories and more details will be discussed later. To save all the necessary information regarding MCMC sampling, we invoke $\\verb|sampler.process|$ to dump a NumPy z-compressed file ($\\verb|filename=f'traj_lambda{lam}.npz'|$) and corresponding light-weight $\\verb|sampler|$ object, where $\\verb|lam|$ is the lambda value of the ensemble.\n"", ""\n"", ""\n"", ""In Code Block \\ref{cb:Posterior} we have exhaustively sampled the posterior distribution and made full use of the information stored in the $\\verb|ensemble|$ object with the $\\verb|biceps.PosteriorSampler|$ class. \n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 18, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Number of CPUs: 10\n"", ""Number of processes: 2\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""100%|████████████████████████████████████████████████████████| 1000000/1000000 [00:21<00:00, 45618.27it/s]\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted 70.8449 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [32.7688 29.7603 29.7603 8.3158] % \n"", ""\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""100%|████████████████████████████████████████████████████████| 1000000/1000000 [00:21<00:00, 45569.64it/s]\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted 64.1479 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [32.6959 29.8973 29.8973 1.5547] % \n"", ""\n"" ] } ], ""source"": [ ""# Multiprocess trajectories for each $\\lambda$-value with a built-in decorator\n"", ""@biceps.multiprocess(iterable=lambda_values)\n"", ""def mp_lambdas(lam):\n"", "" ensemble = biceps.Ensemble(lam, energies)\n"", "" ensemble.initialize_restraints(input_data, options)\n"", "" sampler = biceps.PosteriorSampler(ensemble)\n"", "" sampler.sample(nsteps=nsteps, print_freq=1000, verbose=False)\n"", "" filename = os.path.join(outdir,'traj_lambda%2.2f.npz'%(lam))\n"", "" sampler.traj.process_results(filename)\n"", "" biceps.toolbox.save_object(sampler, filename.replace(\"".npz\"", \"".pkl\""))"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""#### Assessing the convergence of MCMC trajectories\n"", ""\n"", ""\n"", ""\n"", ""Typically, massive amounts of care is involved with setting up simulations. We stress the importance in making sure that when reweighting simulated ensembles that we do it accurately. Thus, it is essential that we attempt to objectively uncover the validity of our MCMC trajectories to ensure proper sampling & convergence. Despite there being no single clear best practice to quantify MCMC sampling quality\\cite{grossfield2018best}, we added an assortment of different approaches to test convergence inside of our $\\verb|biceps.Convergence|$ class. Here, we will find methods that suit our needs e.g., autocorrelation, block-averaging, bootstrapping, Jensen-Shannon divergence (JSD) and more. Previously, we assessed trajectory convergence by comparing populations and BICePs scores from sets of trajectories of varying number of steps. For converged results, the populations and BICePs score should be similar regardless of the trajectory length.\n"", ""\n"", ""We stress that users should check that their MCMC simulations satisfy the following items before checking convergence: 1) All states are sampled at least once over all $\\lambda$ values. The MBAR algorithm estimates conformational state populations and the states not sampled for any lambda value will be considered to have infinitely high potential energy and the corresponding predicted population will be infinite small. 2) The MCMC acceptance percentage is high. Low acceptance percentage is a sign of inefficient sampling and implies that many more MCMC steps are required to adequately sample a certain parameter space. Alternatively, one can modify the parameter space by decreasing the width and have a more fine grained sample space. Another option is to start at larger sigma values when sampling.\n"", ""\n"", ""\n"", ""\n"", ""To evaluate the convergence criteria in a more statistically rigorous manor, we added numerous tools inside the Convergence class which should provide a great deal of aid to the user. To get started, the class only requires the $\\verb|filename|$ of a biceps MCMC trajectory (including its relative path) for initialization. In this step, the trajectory is read into memory and stored as the local variable convergence object $\\verb|C|$. To view the trajectory, as shown in Figure \\ref{fig:autocorr}a, we plot the time-series of sampled nuisance parameters using $\\verb|C.plot_traces(str(figname))|$. The time-series of sampled $\\sigma_{NOE}$ implies adequate sampling with many transitions about the mean of 0.695Å. Here, we see local convergence, but let us be more statistically rigorous. "" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""To do this, we first determine the trajectory length at which sampling becomes decorrelated. Autocorrelation curves are computed for each time-series of sampled nuisance parameters.\n"", ""\n"", ""\\begin{equation}\n"", ""C\\left(\\theta_{t}, \\theta_{t+\\tau}\\right) \\equiv \\frac{\\overline{\\left(\\theta_{t}-\\overline{\\theta}\\right)\\left(\\theta_{t+\\tau}-\\overline{\\theta}\\right)}}{{s_{\\theta}}^{2}} \\Rightarrow c_{\\tau}\n"", ""\\label{eq:g}\n"", ""\\end{equation}\n"", ""\n"", ""\n"", ""where $s(\\theta)^{2}$ is the variance and $c_{\\tau}$ is independent of the lagtime $\\tau$. To find the autocorrelation time ($\\tau_{auto}$), we take integral of $C_{\\tau}$ over all lagtimes, which tells us the length at which sampling becomes decorrelated. The computed autocorrelation times for each nuisance parameter are stored in $\\verb|C|$ to be used for further convergence analysis. By default, our $\\verb|get_autocorrelation_curves|$ method uses an autocorrelation function ($\\verb|method=\""auto\""|$) with a window of length $\\verb|maxtau=10000|$ to compute the autocorrelation time. To obtain the autocorrelation time, we take the integral of the autocorrelation function over all lag-times $\\tau$ shown in Figure \\ref{fig:autocorr}b (with $\\verb|maxtau=5000|$). Three options for the argument $\\verb|method|$ are provided: block average ($\\verb|\""block-avg-auto\""|$), exponential fitting ($\\verb|\""exp\""|$) or autocorrelation function ($\\verb|\""auto\""|$). Each method varying in the level of statistical sophistication to compute the autocorrelation times of each nuisance parameter. \n"", ""\n"", ""\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 19, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""convergence = biceps.Convergence(filename=os.path.join(outdir,\""traj_lambda1.00.npz\""), outdir=outdir)\n"", ""convergence.plot_traces(figname=\""traces.pdf\"", xlim=(0, nsteps))"" ] }, { ""cell_type"": ""code"", ""execution_count"": 20, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""convergence.get_autocorrelation_curves(method=\""block-avg-auto\"", maxtau=500, nblocks=5)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""After the autocorrelation times have been stored, $\\verb|C.process|$ is called to perform a series of operations including the output of plots (Figure \\ref{fig:JSD_conv_unconv}a.) from the resulting JSD analysis. By default, there are numerous preset arguments for JSD analysis: $\\verb|nround=100|$ is the number of rounds of bootstrapping when computing JSDs, $\\verb|nfold=10|$ is the number of partitions in the shuffled (subsampled) trajectory.\n"", ""\n"", ""Jensen-Shannon divergence (JSD) is an improved method from Kullback-Leibler divergence and is a statistical way to measure the similarity between two probability distributions. In our convergence test, we are aiming to check if we use more data, will the distribution be different or similar to the less data which is a perfect situation that JSD calculation could be helpful. Given two sets data from BICePs sampling $P_1$ and $P_2$, to check if these two distribution is similar or not, we can compute the JSD as:\n"", ""\n"", ""\\begin{equation}\n"", ""JSD = H(P_{1}\\cup P_{2}) - {\\pi_1}{H(P_1)} - {\\pi_2}{H(P_2)}\n"", ""\\label{eq:JSD_def}\n"", ""\\end{equation}\n"", ""where $H$ is the Shannon entropy of distribution $P_i$ and $\\pi_i$ is the weight for the probability distribution $P_i$.\n"", ""Specifically, in BICePs the $P_i$ is the distribution of sampled parameters and ${H(P_i)}$ can be computed as:\n"", ""\n"", ""\\begin{equation}\n"", ""{H(P_i)} = \\sum -\\frac{r_i}{N_i}*\\ln{\\frac{r_i}{N_i}}\n"", ""\\end{equation}\n"", ""where $r_i$ and $N_i$ represents sampled times of a specific parameter index and the total number of samples of the parameter, respectively. $\\pi_i$ can be computed as $\\frac{N_i}{N_{total}}$ where $N_{total} = \\sum{N_i}$. Combined together we have:\n"", ""\n"", ""\\begin{equation}\n"", ""JSD = \\sum{(-\\frac{r_{total}}{N_{total}}*\\ln{\\frac{r_{total}}{N_{total}}})} - \\frac{N_i}{N_{total}}*\\sum(-\\frac{r_i}{N_i}*\\ln{\\frac{r_i}{N_i}})\n"", ""\\label{eq:JSD}\n"", ""\\end{equation}\n"", ""\n"", ""where $i = 1, 2$ in this example.\n"", ""In BICePs, we can import different amount of data into our JSD calculation. To do that, we may use $p\\%$ ($p = 10,20,...100$) data and divide the dataset ($P_{total}$) into two parts (the first half and second half) to get $P_1$ and $P_2$ in eq \\ref{eq:JSD_def} and compute the JSD value ($JSD_{single}$) using eq \\ref{eq:JSD}. Then we can randomly pick up $N_{total}/2$ points from $P_{total}$ as $P_1$ ($N_{total}$ is the total number of data after chopped) and the remaining data as $P_2$. In this way, we are mixing the data and the computed JSD ($JSD_{random}$) from this mixing data should be smaller than the computed JSD from just first versus second half data. But if the dataset is completely converged, $JSD_{single}$ and $JSD_{random}$ should be close. Repeat mixing data $N$ times, we shall get $\\Big\\{JSD_{random}\\Big\\}_N$ values and a corresponded distribution. Our null hypothesis is the computed $JSD_{single}$ is not in the distribution of $\\Big\\{JSD_{random}\\Big\\}_N$. To test if we can accept or reject the hypothesis, we rank the $JSD_{single}$ values in $\\Big\\{JSD_{random}\\Big\\}_N$ in ascending order. If it is in the top 99\\% ranked (see Figure \\ref{fig:JSD_exp}b), then we reject the hypothesis which indicates $P_1$ and $P_2$ no matter mixing the data or not are drawn from a mutual distribution and the data is converged. If the ranked $JSD_{single}$ is in the last 1\\% (Figure \\ref{fig:JSD_exp}a), the data is not converged yet.\n"", ""\n"", ""\n"", ""As an exmaple, Figure \\ref{fig:JSD_conv_unconv} shows JSD analysis on trajectories with different amount of steps (10K, 100K, 1M, 10M, 100M) with two $\\lambda$ values ($\\lambda = 0.0, 1.0$). Panel (a) shows JSD values (red dots) for a given percentage of the dataset, where the shaded region defines the 95\\% confidence interval of the distribution. Interestingly, panel (b) suggests that the 10k step trajectory has locally converged and panel (c) shows JSD values outside of the 95\\% confidence interval representing false positives suggesting that more sampling is needed. Hence, the need to analyze convergence of trajectories for various number of steps. The last two panels (d and e) clearly show convergence and suggest that 1M steps is sufficient.\n"", ""\n"", ""\n"", ""\n"", ""
\n"", ""\n"", ""
An example Jensen-Shannon Divergence (JSD) analysis. (a) The JSD between the\n"", ""first and last half of the σNOE trajectory, plotted as a function of the percentage of trajectory\n"", ""that has been sampled. The shaded region in this plot represents the 95% confidence interval\n"", ""of the JSD metric for the null distribution, calculated using a bootstrap procedure. (b-c)\n"", ""Extending the MCMC trajectories by 1M steps and 10M steps, respectively, results in the\n"", ""trajectory having complete statistical indistinguishability between the first and last halves \n"", ""
\n"", ""
\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""The convergence submodule is extremely convenient and useful for users to objectively quantify sampling quality. Still, convergence checking could get complicated. For example, a larger value of $\\verb|maxtau|$ may be necessary in cases of more slowly decorrelated time series. Occasionally, negative values of $\\tau_{auto}$ may be obtained indicating the amount of data is not enough for computing autocorrelation time. Despite there not being a one-size-fits-all approach to checking the validity of MCMC trajectories, our team decided to include a depot of methods to check convergence. By checking convergence, we can put more trust in our next step, analysis.\n"", ""\n"", ""\n"", ""\n"", ""\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""#### Analysis\n"", ""\n"", ""\n"", ""Our biceps workflow ends by predicting conformational state populations, computing the biceps score and plotting distributions. This has been made easy via the $\\verb|biceps.Analysis|$ class which automatically analyzes our MCMC trajectories. As we mentioned here \\cite{Voelz:2014fga,Ge:2018bdb, voelz2021reconciling}, BICePs uses a free energy perturbation approach in $\\lambda$ space, where sampling is done independently for multiple $\\lambda$ values. Then using MBAR we can infer the potential energy of snapshots in ensemble $j$ which is originally sampled in ensemble $i$. From this, populations can be predicted for each conformational state and the biceps score can be computed. More details can be found in this work \\cite{Shirts:2008eza}.\n"", ""\n"", ""\n"", ""From Bayesian model selection, BICePs is able to calculate a Bayes factor-like quantity that we call the BICePs score, which quantifies the support of evidence for one model over another. The quality of a model $k$ that uses a prior $P^{(k)}(X)$ from theoretical modeling can be assessed by the posterior likelihood $Z^{(k)}$ of model $k$:\n"", ""\n"", ""\\begin{equation}\n"", ""Z^{(k)} = \\int P^{(k)}(X,\\sigma | D) dX d\\sigma =\\int P^{(k)}(X) Q(X) dX.\n"", ""\\end{equation}\n"", ""\n"", ""One way to think of $Z^{(k)}$ is as an integral over the entire input space (including nuisance parameters) of the model. Another way, however, is to think of $Z^{(k)}$ as an \\textit{overlap} integral between the prior $P^{(k)}(X)$ and a likelihood function $Q(X) = \\int [Q(\\mathbf{r}(X)|D,\\sigma)/Q_{\\text{ref}}(\\mathbf{r}(X)) ] P(\\sigma) d\\sigma$. This integral reaches the maximum when $P^{(k)}(X)$ most closely matches the likelihood distribution $Q(X)$ specified by the experimental restraints.\n"", ""\n"", ""Suppose we have two models (1) and (2) with priors $P^{(1)}$ and $P^{(2)}$, and we want to know which one is more consistent with experimental measurements. In Bayesian statistics, the comparison is often made using the ratio of posterior model probabilities, $Z^{(1)}/Z^{(2)}$, also called the Bayes factor.\n"", ""\n"", ""In BICePs, we consider a free energy-like quantity, called the BICePs score:\n"", ""\\begin{equation}\n"", ""f^{(k)} = -\\ln \\frac{Z^{(k)}}{Z_0},\n"", ""\\label{eq:reference_state}\n"", ""\\end{equation}\n"", ""\n"", ""\n"", ""Not only can this be used to show that reweighted populations are more consistent with experimental data, it can also be used to rank different simulated ensembles by their accuracy in reproducing experimental observables (Ge and Voelz, 2018). Instantiating this class requires a path to glob the $\\verb|'*.npz'|$ trajectories as well as the number of states ($\\verb|nstates|$).\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 21, ""metadata"": { ""scrolled"": false }, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""not all state sampled, these states [ 1 4 5 9 11 13 14 15 16 18 22 24 25 26 27 28 29 31 34 40 41 42 48 52\n"", "" 54 55 57 62 69 73 74 76 77 81 82 95 98 99] are not sampled\n"", ""BICePs Scores = [0. 0.20294204]\n"" ] }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""############ MBAR and Figures ###########\n"", ""%matplotlib inline\n"", ""# Let's do analysis using MBAR algorithm and plot figures\n"", ""A = biceps.Analysis(outdir, nstates=len(energies))\n"", ""biceps.toolbox.save_object(A, \""analysis_object.pkl\"")\n"", ""#pops = A.P_dP[:,n_lambdas-1]\n"", ""pops, BS = A.P_dP, A.f_df\n"", ""print(f\""BICePs Scores = {BS[:,0]}\"")"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""The following analysis files will be exported to the directory where the trajectory live: (1) the predicted populations of each conformational state using PyMbar\\cite{Shirts:2008eza} ($\\verb|populations.dat|$)\n"", ""(2) the BICePs score ($\\verb|BS.dat|$). Invoking the $\\verb|plot|$ method in $\\verb|Analysis|$ produces Figure \\ref{fig:BICePs_outcome} ($\\verb|BICePs.pdf|$). This figure shows the posterior distribution of inferred state populations and sampled nuisance parameters ($\\sigma_J$, $\\sigma_{noe}$ and $\\gamma$). Our results shown in Figure \\ref{fig:BICePs_outcome} perfectly reproduce previous published work \\cite{Voelz:2014fga} which indicates reliability of the latest version.\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 22, ""metadata"": {}, ""outputs"": [], ""source"": [ ""import pickle\n"", ""with open(\""analysis_object.pkl\"", 'rb') as f:\n"", "" A = pickle.load(f)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 23, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""pops, BS = A.P_dP, A.f_df\n"", ""pops0,pops1 = pops[:,0], pops[:,len(lambda_values)-1]\n"", ""\n"", ""legend_fontsize=16\n"", ""#fig = A.plot(plottype=\""hist\"", figname=\""BICePs.pdf\"", figsize=(14,8),\n"", ""fig = A.plot(plottype=\""step\"", figname=\""BICePs_.pdf\"", figsize=(14,8),\n"", "" label_fontsize=18, legend_fontsize=legend_fontsize)\n"", ""ax = fig.axes[0]\n"", ""high_E_confs = [79, 21] #87\n"", ""for i in high_E_confs:\n"", "" #print(pops0[i], pops1[i], str(i))\n"", "" ax.text( pops0[i], pops1[i], str(i), color='r' , fontsize=legend_fontsize)\n"", ""fig.savefig(os.path.join(outdir,\""BICePs.pdf\""), dpi=600)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
\n"", ""
\n"", "" (a) A comparison of conformational state populations $p_{i}(\\text{exp})$ inferred using only experimental restraints, vs. BICePs populations $p_{i}(\\text{sim + exp})$ inferred using a combination of the simulation-based prior and experimental restraints. States on the lower right are highly compatible with experimental restraints, but are conformationally strained according the simulation model. Conformational states near the top of the graph are both reasonably compatible with experimental restraints, and highly-populated according to the simulation model. (c) The marginal posterior distribution of $\\sigma_{\\text{NOE}}$, the uncertainty parameter for NOE distance restraints. (b) The marginal posterior distribution of $\\sigma_{\\text{J}}$ , the uncertainty parameter for J-coupling constants. (d) The marginal posterior distribution of $\\gamma_{\\text{NOE}}$, the scaling parameter for the NOE distances, remains near 1.25 throughout the MCMC sampling.\n"", ""
\n"", ""
\n"", ""\n"", ""\n"", ""In panel (a) in Figure {} we can see the population of each states in the presence (y-axis) and absense (x-axis) of computational modeling prior information. You can find some states (e.g state 38, 59, 65, 90) get awarded upon including information from simulation. After mapping back to the energies of these states, we find that these correspond to some of the low energy structures. Conversely, some of the high energy states have been pentalized e.g., state 0. For futher information regarding how well our reweighted populations relate to the crystal isoforms of albocycline, the O-methylated analog of cineromycin B, please see this work\\cite{Voelz:2014fga}. Panels (b)-(d) show the distribution of nuisance parameters in the presence or absence of computational modeling information. \n"", ""\n"", ""\n"", ""The populations ($\\verb|pops|$) are stored is a NumPy array containing a row for each state ($\\verb|nstates|$=100) and four columns corresponding to our 2 lambda values (first 2 columns) and their corresponding population change (last 2 columns). Using the reweighted populations of Cineromycin B, the experimental observables $r_{j}^{\\text{exp}}$ can be compared to our ensemble-averaged back calculated observable $ = \\sum_{X} r_{j}(X)P(X)$ after BICePs reweighting. \n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""Maximum-likelihood values of nuisance parameters $\\sigma_{\\text{J}}^{*}$, $\\sigma_{\\text{NOE}}^{*}$, $\\gamma_{\\text{NOE}}^{*}$ from posterior sampling can be considered the best estimate of the uncertainty in the experimental observables. The treatment of experimental NOE distances (2.5Å for all) comes from the lack of experiemntal data. We can see from the posterior distribution of $\\gamma$ with greatest frequency about 1.25Å indicates that the estimated true NOE distance is our initial guess of 2.5Å scaled by 1.25 resulting in an experimental ensemble averaged NOE distance $3.12 \\pm 0.7Å$, as shown as the dotted black line in Figure {}.\n"", ""\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""\\section{Conclusion}\n"", ""\n"", ""We have introduced the BICePs v2.0 software package which is a Bayesian inference approach that can be used for protein structure determination, reweighting simulated ensembles, performing objective model selection, and more that exceeds the scope of this application using cineromycin B. Our algorthim is special in that it is used as a post-simulation processing step, properly accounts for differences in experimental restraints by correctly implementing reference potentials, and provides an objective metric for model selection through the BICePs score. This tool supports a range of experimental observables (NOE, Jcouplings, chemical shifts and protection factors) and will continue to grow. BICePs v2.0 is currently written in Python, but we have plans to imrpove the speed of the sampling routines with C++ and include more enhanced sampling techniques inside the algorithm. Users can install the package through pip/GitHub (\\url{https://biceps.readthedocs.io/en/latest/installation.html}). More detailed documentation and tutorials can be found at: \\url{https://biceps.readthedocs.io}. For any issues or questions, please submit the request on GitHub: \\url{https://github.com/vvoelz/biceps}.\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", "" "" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""### Data and Software Availability\n"", ""\n"", ""The BICePs v2.0 algorithm is freely available at \\url{https://github.com/vvoelz/biceps} and can be installed using: \\verb|pip install biceps|. All input files and analysis for this work can be found here: \\url{https://github.com/vvoelz/biceps/tree/master/docs/examples/full_examples/cineromycinB}. Detailed documentation and tutorials can be found here: \\url{https://biceps.readthedocs.io}. For any issues or questions, please submit the request on GitHub.\n"", ""\n"", ""\n"", ""### ACKNOWLEDGMENTS\n"", ""This research was supported in part by the National Institutes of Health through grant 1S10OD020095-01. R.R and Y.G were supported by National Institutes of Health grant 1R01GM123296. This research includes calculations carried out on Temple University’s HPC resources and thus was supported in part by the National Science Foundation through major research instrumentation grant number 1625061 and by the US Army Research Laboratory under contract number W911NF-16-2-0189.\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# SI"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Table. Maximum-likelihood values of nuisance parameters $\\sigma_{\\text{J}}^{*}$, $\\sigma_{\\text{NOE}}^{*}$, $\\gamma_{\\text{NOE}}^{*}$ from posterior sampling."" ] }, { ""cell_type"": ""code"", ""execution_count"": 24, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
sigma_Jsigma_noegamma_noe
05.4602270.7389131.365358
15.9103250.6826411.261380
\n"", ""
"" ], ""text/plain"": [ "" sigma_J sigma_noe gamma_noe\n"", ""0 5.460227 0.738913 1.365358\n"", ""1 5.910325 0.682641 1.261380"" ] }, ""execution_count"": 24, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""mlp = pd.concat([A.get_max_likelihood_parameters(model=i) for i in range(len(lambda_values))])\n"", ""mlp.reset_index(inplace=True, drop=True)\n"", ""mlp"" ] }, { ""cell_type"": ""code"", ""execution_count"": 30, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""import uncertainties as u\n"", ""\n"", ""pops_std = A.P_dP[:,-1]\n"", ""\n"", ""# NOTE: Get Prior MSM populations\n"", ""prior_pops = np.loadtxt(data_dir+\""prior_pops.txt\"")\n"", ""prior_pops /= prior_pops.sum()\n"", ""\n"", ""noe = [pd.read_pickle(i) for i in biceps.toolbox.get_files(data_dir+\""J_NOE/*.noe\"")]\n"", ""# Get the ensemble average observable\n"", ""noe_Exp = noe[0][\""exp\""].to_numpy()\n"", ""noe_model = [i[\""model\""].to_numpy() for i in noe]\n"", ""\n"", ""noe_prior = np.array([w*noe_model[i] for i,w in enumerate(prior_pops)]).sum(axis=0)\n"", ""noe_reweighted = np.array([w*noe_model[i] for i,w in enumerate(pops[:,n_lambdas-1])]).sum(axis=0)\n"", ""\n"", ""noe_prior = np.array([w*noe_model[i] for i,w in enumerate(prior_pops)]).sum(axis=0)\n"", ""noe_reweighted = np.array([u.ufloat(w, pops_std[i])*noe_model[i] for i,w in enumerate(pops[:,n_lambdas-1])]).sum(axis=0)\n"", ""\n"", ""\n"", ""\n"", ""distance_labels = [f\""{row[1]['atom_name1']}-{row[1]['atom_name2']}\"" for row in noe[0].iterrows()]\n"", ""distance_label_indices = np.array([[row[1]['atom_index1'], row[1]['atom_index2']] for row in noe[0].iterrows()])\n"", ""\n"", ""\n"", ""J = [pd.read_pickle(file) for file in biceps.toolbox.get_files(data_dir+'J_NOE/*.J')]\n"", ""# Get the ensemble average observable\n"", ""J_Exp = J[0][\""exp\""].to_numpy()\n"", ""J_model = [i[\""model\""].to_numpy() for i in J]\n"", ""\n"", ""J_prior = np.array([w*J_model[i] for i,w in enumerate(prior_pops)]).sum(axis=0)\n"", ""J_reweighted = np.array([u.ufloat(w, pops_std[i])*J_model[i] for i,w in enumerate(pops[:,n_lambdas-1])]).sum(axis=0)\n"", ""\n"", ""\n"", ""\n"", ""J_labels = [f\""{row[1]['atom_name1']}-{row[1]['atom_name2']}-{row[1]['atom_name3']}-{row[1]['atom_name4']}\"" for row in J[0].iterrows()]\n"", ""J_label_indices = np.array([[row[1]['atom_index1'], row[1]['atom_index2'], row[1]['atom_index3'], row[1]['atom_index4']] for row in J[0].iterrows()])\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""fig = plt.figure(figsize=(12,12))\n"", ""gs = gridspec.GridSpec(2, 1)\n"", ""\n"", ""\n"", ""ax1 = plt.subplot(gs[0,0])\n"", ""ax2 = plt.subplot(gs[1,0])\n"", ""data = []\n"", ""for i in range(len(noe_reweighted)):\n"", "" data.append({\""index\"":i,\n"", "" \""reweighted noe\"":noe_reweighted[i], \""prior noe\"":noe_prior[i],\n"", "" \""exp noe\"":noe_Exp[i]*mlp['gamma_noe'].to_numpy()[-1], \""label\"":distance_labels[i]\n"", "" })\n"", ""data1 = pd.DataFrame(data)\n"", ""\n"", ""_data1 = data1.sort_values([\""prior noe\""])\n"", ""_data1 = _data1.reset_index()\n"", ""#print(_data1)\n"", ""\n"", ""reweighted_vals = np.array([val.nominal_value for val in _data1[\""reweighted noe\""].to_numpy()])\n"", ""reweighted_std = np.array([val.std_dev for val in _data1[\""reweighted noe\""].to_numpy()])\n"", ""\n"", ""\n"", ""#ax1 = data1.plot.scatter(x='index', y=\""reweighted noe\"", s=5, edgecolor='black', color=\""b\"", label=\""BICePs\"")\n"", ""ax1.scatter(x=_data1[\""label\""].to_numpy(), y=_data1[\""prior noe\""].to_numpy(),\n"", "" s=45, color=\""orange\"", label=\""Prior\"", edgecolor='black',)\n"", ""ax1.scatter(x=_data1[\""label\""].to_numpy(), y=_data1[\""exp noe\""].to_numpy(),\n"", "" s=150, marker=\""_\"", color=\""k\"", label=\""Exp\"")\n"", ""#ax1.scatter(x=_data1[\""label\""].to_numpy(), y=_data1[\""reweighted noe\""].to_numpy(),\n"", ""# s=40, color=\""c\"", label=\""BICePs\"", edgecolor='black')\n"", ""\n"", ""ax1.errorbar(x=_data1['label'].to_numpy(), y=reweighted_vals,\n"", "" yerr=reweighted_std , fmt=\""o\"", capsize=5,\n"", "" markersize=5, markerfacecolor=\""c\"", label=\""BICePs\"",\n"", "" ecolor=\""k\"", markeredgecolor='black')\n"", ""\n"", ""ax1.legend(fontsize=14)\n"", ""#ax1.set_xlabel(r\""Index\"", size=16)\n"", ""ax1.set_ylabel(r\""NOE distance ($\\AA$)\"", size=16)\n"", ""\n"", ""\n"", ""data = []\n"", ""for i in range(len(J_reweighted)):\n"", "" data.append({\""index\"":i,\n"", "" \""reweighted J\"":J_reweighted[i], \""prior J\"":J_prior[i], \n"", "" \""exp J\"":J_Exp[i], \""label\"":J_labels[i]\n"", "" })\n"", ""data1 = pd.DataFrame(data)\n"", ""\n"", ""reweighted_vals = np.array([val.nominal_value for val in data1[\""reweighted J\""].to_numpy()])\n"", ""reweighted_std = np.array([val.std_dev for val in data1[\""reweighted J\""].to_numpy()])\n"", ""\n"", ""ax2.scatter(x=data1['label'].to_numpy(), y=data1[\""prior J\""].to_numpy(),\n"", "" s=45, color=\""orange\"", label=\""Prior\"", edgecolor='black',)\n"", ""ax2.scatter(x=data1['label'].to_numpy(), y=data1[\""exp J\""].to_numpy(),\n"", "" s=150, marker=\""_\"", color=\""k\"", label=\""Exp\"")\n"", ""#ax2.scatter(x=data1['label'].to_numpy(), y=data1[\""reweighted J\""].to_numpy(),\n"", ""# s=40, color=\""c\"", label=\""BICePs\"", edgecolor='black')\n"", ""ax2.errorbar(x=data1['label'].to_numpy(), y=reweighted_vals,\n"", "" yerr=reweighted_std , fmt=\""o\"", capsize=5,\n"", "" markersize=5, markerfacecolor=\""c\"", label=\""BICePs\"",\n"", "" ecolor=\""k\"", markeredgecolor='black')\n"", ""\n"", ""ax2.legend(fontsize=14)\n"", ""#ax2.set_xlabel(r\""Index\"", size=16)\n"", ""ax2.set_ylabel(r\""J-coupling (Hz)\"", size=16)\n"", ""\n"", ""ticks = [\n"", "" ax1.xaxis.get_minor_ticks(),\n"", "" ax1.xaxis.get_major_ticks(),]\n"", ""xmarks = [ax1.get_xticklabels(),\n"", "" ]\n"", ""ymarks = [ax1.get_yticklabels(),\n"", "" ]\n"", ""for k in range(0,len(ticks)):\n"", "" for tick in ticks[k]:\n"", "" tick.label.set_fontsize(16)\n"", ""for k in range(0,len(xmarks)):\n"", "" for mark in xmarks[k]:\n"", "" mark.set_size(fontsize=16)\n"", "" mark.set_rotation(s=65)\n"", ""for k in range(0,len(ymarks)):\n"", "" for mark in ymarks[k]:\n"", "" mark.set_size(fontsize=16)\n"", "" mark.set_rotation(s=0)\n"", ""\n"", ""\n"", ""ticks = [\n"", "" ax2.xaxis.get_minor_ticks(),\n"", "" ax2.xaxis.get_major_ticks(),]\n"", ""xmarks = [\n"", "" ax2.get_xticklabels(),\n"", "" \n"", "" ]\n"", ""ymarks = [\n"", "" ax2.get_yticklabels(),\n"", "" ]\n"", ""for k in range(0,len(ticks)):\n"", "" for tick in ticks[k]:\n"", "" tick.label.set_fontsize(16)\n"", ""for k in range(0,len(xmarks)):\n"", "" for mark in xmarks[k]:\n"", "" mark.set_size(fontsize=16)\n"", "" mark.set_rotation(s=70)\n"", ""for k in range(0,len(ymarks)):\n"", "" for mark in ymarks[k]:\n"", "" mark.set_size(fontsize=16)\n"", "" mark.set_rotation(s=0)\n"", ""\n"", ""\n"", ""axs = [ax1,ax2]\n"", ""for n, ax in enumerate(axs):\n"", "" ax.text(-0.1, 1.0, string.ascii_lowercase[n], transform=ax.transAxes,\n"", "" size=20, weight='bold')\n"", ""fig.tight_layout()\n"", ""fig.savefig(f\""{outdir}/reweighted_observables.pdf\"", dpi=500)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
\n"", ""
\n"", "" BICePs reweighted observables compared against experiment and prior for (a) NOE and (b) J-coupling.\n"", ""
\n"", ""
\n"", ""\n"", ""\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""\n"", ""\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""#### To quickly test MCMC convergence (w/ out knowing if you have sampled all of the states in other $\\lambda$-trajectories) "" ] }, { ""cell_type"": ""code"", ""execution_count"": 25, ""metadata"": {}, ""outputs"": [ { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""100%|█████████████████████████████████████████████████████████| 5000000/5000000 [01:42<00:00, 48737.90it/s]\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted 64.25766 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [32.70802 29.95912 29.95912 1.59052] % \n"", ""\n"", ""not all state sampled, these states [ 4 5 9 11 15 16 18 22 24 25 26 27 34 40 42 48 51 52 57 62 64 73 76 77\n"", "" 81 87 95 98 99] are not sampled\n"" ] }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA90AAAHqCAYAAAAZLi26AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAADBNUlEQVR4nOzdd3wUdf4/8NemJ7ubhBQIIRUSCCGhV6liATuKiIogJ57t9HtY7hAVPPSHnHoCKt6dBdFTOE9BUbGCEinSpJNQAiSkkp7spm39/P6YJBLSYXdndvf1fDzy0AyTzHuSfWXnM/MpKiGEABERERERERHZnIfcBRARERERERG5Kja6iYiIiIiIiOyEjW4iIiIiIiIiO2Gjm4iIiIiIiMhO2OgmIiIiIiIishM2uomIiIiIiIjshI1uIiIiIiIiIjtho5uIiIiIiIjITtjoJiIiIiIiIrITNrpdQElJCRISEpCWlta0bc+ePRg1ahQ0Gg3i4+OxevXqpn87duwYBg0aBK1Wi2nTpqG2trbp31566SU8//zzjiyfyKYOHz6Ma665BiEhIYiIiMCcOXNQWloKgLkg9/Xzzz9j1KhRCAwMREREBB577DHU1dUBYC6ILBYLJk2ahLlz5zZtYy7Inf3vf/+Dl5cXNBpN08fs2bMBMBuXTJBT27Fjh+jTp48AILZu3SqEEKK8vFyEhISIVatWCZPJJH766Seh1WrFnj17hBBCzJgxQzz11FNCr9eLsWPHin/9619CCCGys7NFamqqqKurk+t0iC5LbW2t6Nmzp1i8eLEwGAyitLRUXH/99eLGG29kLshtFRcXCz8/P7FmzRphsVhEQUGBSElJEYsXL2YuiIQQixYtEh4eHuLee+8VQvA6iujJJ58Uc+fObbGd2bh0fNLtxD788EPcfffdWLp0abPtGzZsQGhoKP70pz/By8sLkydPxqxZs/DWW28BALy8vAAAQggIIeDp6QkA+POf/4yXX34Zfn5+jj0RIhvJycnBoEGDsHjxYvj4+CA0NBQPPvggtm3bxlyQ2woPD0dxcTHmzp0LlUqFsrIy1NfXIzw8nLkgt/fzzz9jw4YNmD59etM25oLc3b59+zB8+PAW25mNS8dGtxObMmUKzpw5g5kzZzbbnp6ejtTU1GbbkpOTcfjwYQDA4sWLsX37dsTHxyM2NhZz5szBN998Ay8vL1x33XUOq5/I1vr164fvvvuu6Y88AKxfvx7Dhg1jLsitabVaAEB0dDRSU1PRs2dP/OEPf2AuyK0VFxdj3rx5WLduHQICApq2MxfkzqxWKw4cOIBvvvkGsbGxiIqKwgMPPICKigpm4zKw0e3EIiIimu4oXUiv10OtVjfbFhAQgOrqagBAUlISdu/ejdLSUqxbtw5CCDzzzDNYsWIFVq5ciaFDh+Kqq65CRkaGQ86DyB6EEHjuuefw9ddf4/XXX2cuiABkZmYiPz8fnp6euP3225kLcltWqxX33HMPnnjiCQwaNKjZvzEX5M5KSkowZMgQ3H777Th+/Dh+/fVXZGZm4p577mE2LgMb3S5IrVY3m7gAAGpra5uedFxs2bJluOeee6DT6bBs2TKkpaVh3rx5uO+++xxRLpHN6XQ63H777fj444+xbds2pKamMhdEAPz9/REZGYmXX34Z33//PXNBbmvZsmXw8/PDY4891uLfmAtyZz169MC2bdtw3333ISAgADExMXjllVfw3XffQQjBbFwiNrpdUEpKCtLT05tty8jIQEpKSot9T58+jW+++Qbz58/HsWPH0KdPHwQGBmL48OE4evSoo0omspkzZ85gxIgR0Ol0+O2335q6QTEX5K5+/fVXJCUlwWg0Nm0zGAzw8fFBcnIyc0Fu6aOPPkJaWhqCg4MRHByMdevWYd26dQgODub7Bbm1I0eO4Omnn4YQommbwWCAh4cHRo4cyWxcKkfP3Eb2gQtmLy8tLRXBwcFixYoVwmg0ip9//llotVrx888/t/i66667Tvzyyy9CCCH2798vQkNDRUlJiVizZo0YOHCgI0+B6LKVl5eLmJgYMXfuXGGxWJr9G3NB7kqv14vo6Gjx+OOPC4PBILKzs8XIkSPFww8/zFwQNbj33nubZi9nLsid5ebmCrVaLV5++WVhMpnEuXPnxOjRo8W8efOYjcvARreLuLDRLYQQ+/btE1dccYXQarWid+/eYs2aNS2+ZsOGDWLOnDnNti1cuFB069ZNJCUliV27dtm5aiLbeu211wQAERAQINRqdbMPIZgLcl/p6enimmuuEcHBwSI2NlY8++yzor6+XgjBXBAJ0bzRLQRzQe4tLS1NjBkzRmi1WhEeHi4ee+yxpuW+mI1LoxLigr4DRERERERERGQzHNNNREREREREZCdsdBMRERERERHZCRvdRERERERERHaimEZ3SUkJEhISkJaW1uY+3377bdN6u/3798emTZscVyCRDJgLopaYC6KWmAuilpgLUgpFNLp37tyJMWPG4MyZM23uk5mZienTp+PFF19EVVUVlixZgjvuuAP5+fkOrJTIcZgLopaYC6KWmAuilpgLUhLZG90ffvgh7r77bixdurTD/caPH49p06bBy8sLd9xxByZOnIh33nnHQZUSOQ5zQdQSc0HUEnNB1BJzQUrjJXcBU6ZMwaxZs+Dl5YU777yzzf3S09ORmprabFtycjIOHz7c5tcYDAYYDIamz61WK8rLyxEaGgqVSnX5xZNTEUJAr9cjMjISHh6y329qF3NBjsJcSJgLuhBzIWEu6ELMhYS5oAt1NheyN7ojIiI6tZ9er4darW62LSAgANXV1W1+zbJly7BkyZLLqo9cT25uLqKiouQuo13MBTkac8FcUEvMBXNBLTEXzAW11FEuZG90d5ZarUZtbW2zbbW1tdBqtW1+zcKFC/HEE080fV5VVYWYmBjkAghs7QuuuQZYv/73zyMigLq61r/52LHAt9/+/nl8PFBe3vq+Q4YAF07gkJIC5Oa2vm+/fsDevb9/PnIkcPJk6/tGRwPHjv3++aRJwMGDre8bEgJkZf3++fXXAzt3tr6vvz9w/vzvn99+O7B5c+v7AkBV1e//P2cO8OWXbe9bUAA0/nF76CHgv/9te98zZ1Dqq8XnB/MQseRZ3Pzbd23uesef3oE6MR69w9WY/sXbqHnubxgRH9JsH51Oh+jo6HZfM86GuWiFG+QCYWHS/z/5JPDee23ve+QIEBuLu97ZjWs+WQXP//ci7r0ivtkuzIWEubiAi+fi2vtWoSCwOxK6q/Hc7v/Cd9lSpPQKavaEirmQMBcXcJNcxIUG4G/7PoHXS/8PA3sFw8ODubgYc3EBF88FjhzBr2Y1HvjPfjyx/SNEr/oHrklufkOns7lwmkZ3SkoKDhw40GxbRkYGhg8f3ubX+Pr6wtfXt8X2QLQRCm9vIPCCf2mvi4iXV/N92+tm4+l56ft6era9r4fHpe/r1c6vXqVqvq+3d9v7Al3ftzEUPj7t7vrM5mx8llMPk0XgBYtH67+zBt8/dQ0QFyd9cvBzYFBcm/u6Utcf5qIVLp4LaLW/f+9O7pujF/D39MZVQ/sgMFDT6q7MBXPR5r4ulov5U1Ix5qphiA1VA3/ZCiTHtLkvc8FctLmvi+XiT9cMwJjJw5HQXQP8JQ0YENvmvswFc9Hmvi6WC6tag9e/zoOHbwCGR4di3Oi+be7bUS5UQgjRfmWOo1KpsHXrVkyaNKnFv504cQJDhgzBhx9+iNtuuw2ff/457r33Xhw+fBh9+7b9A7iQTqdDUFAQqgoKENjwwxZCwGAyAUJIL6oLQ3TRna9mPDwAP79L27euTjpea1Qq6U5QF/f19vaGp9EIWK1t13Fh95m6us7vW18PWCy22Tcg4Pc/NgYDYDa32OWXk8V4eO0B1Hr5AioVhsQEY86QCFzbLwxq3zbC7O//+x8bo7HVEDX9/quqmn7/zkCOXACAxWqFyWyWfq7MRct9HZyLS9rX3x9CpUK/576HMBqw9ZlrEdUtoNkuzEXrmAvXyMWmIwV45vOjMFkEFl6XhDlXxPH9grlodV9Xz4W1rh6f78vGis2nUF5jAgCMTQzDgin9kNhDy1wwF63u6+q56GjflTtzsfLnM9D6emH742MRHNzywUVnc6HoJ90ajQZvv/02Zs2ahaSkJGzcuBELFizAvHnzEBsbiw0bNnQ6EM2o1U2/yIL8fOh0OhtX7ngqlQpRUVHQaFp/itXChcHryIWBtuW+vr7N/wgBsFoFlm3LRa23H65K6o7Hr+mLlF5Bnf+eQMd3uJycI3JRXV2NvPx8KOie3CVxlVxczr6ZRXoYLVb4+fmiu7YLdTgZ5qLz3CEXwscH//rlDF75/hTg6Yubh0Zi9tXJLZ8w8f2CuWjgyrk4cV6Hv64/giN5VQA80btXIBbdmIwr+3Vv/QuYC+aigSvnoqN9X9+SiZU/S8vN/WVqv1Yb3F2hqCfd9nbxnQiz2YzMzEyEhoY61R27iwkhUFJSgtraWiQmJsKzvW4gCrfnbBlmvrMbGl8v7FhwJYIDbPeH31nv0NrbxT8Xi8WCzMxMBAQEIDw83Gm7kblSLi7VnrNlePKzw8irqMPYhFCsvX90i32Yi9YxF86rosaIv6w/jC3HiwEA88bF49nr+zcbm9oR5qJ1zIXzqTaYcc3yX1BYVQ+trxf+fHUi5oyJg49X12cfZy5ax1y4ntzyWox/ZSsA4OnrkvDQxD5t7usST7rtzdzQnUCr1cKvK3dQFCg8PBzZ2dkwmUxOHYptmSUAgCuTutu0wU2dZzKZIIRAeHg4/Ltyx1KBXCUXl+Lfv5zBy9+fgBBAVDd/PHdDstwlOTXmQvnqTRZ8dbgAKzafQmFVPXw8PbDopmTMHt322FS6PMyF8r3xUyYKq+oRExKADQ9fgXBtJ58A0iVjLpzf7rNlAIChMcHtNri7wq0b3Y2c9Q7UhVzhHL47Woh//3IWADCpb7jM1ZArvKZc4Rwuxfmqerz6w0kIAcwcHo3nbuwPrV8Hk5BQp7jCa8oVzuFCpdUGfLz7HD7efQ6l1UYAQO8wNd68ewgGRHZxeBJdEld4TbnCObTm+2PSbNELr0tig9vBXOE15QrncCm+OlwAALiiT5jNvqeyV7ZXisxMYOFC4K67pP9mZl7StzEYDLjlllswduxYvPvuu03b6+rqMHXqVIwePRrvv/9+0/acnBxMmzat6fNnn30WY8eOxcMPP3zJp6JUJ8/r8dh/D8JiFbh1SC9MG9JL7pKoM2yQjbZyodPp0KtXL0yaNAlXXXUVAGDv3r0YP348RowYgc0Ny0y4ci4u1X/35sBiFRgZH4KXbx/IBrej2TEXjaZPn47s7GwAwMcff4zRo0fjiiuuwKFDhwC4Ty72n6vA+Je3YuWWTJRWG9EzyA9PX5eErx8bxwa30tgxF8uXL8ekSZMwadIkBAUF4cCBA9i8eTNGjRqFSZMmobCwEID75AIAzBYrPj+Qh/O6egBAYo/LG49KduLg94s33ngDQ4cOxaRJk/Dqq68CcK9cdEbayWJszyyFhwqYOSLaZt+Xje6OrFkDJCUBr74KfPqp9N+kJOCDD7r8rT799FNMnToV27dvx2effYb6eukP4ffff4/x48fj119/xerVqwEA+/fvx8yZM1FZWQlAaoCfOXMGO3fuhFarxa5du2x1hopwMKcCZqvAoKgg/GPGIHh2YewdycRG2WgrFxkZGXjooYeQlpaGn376CQCwePFifPHFF/jhhx+Qk5Pj8rm4FEIIbDyUDwCYNartpZDITuycC6PRiFtvvRV79uxp2vett97Czp07sW7dOrz00ktukwuLVWDRxmOoM1nQv2cg3rhrCLb99Uo8NLFP2ytdkDzsnIsnnngCaWlpeOutt3DDDTdg6NChePXVV7FlyxYsXboUq1atcptcWK0C/9uXg6uW/4InPj0Mo9mKnkF+LVauIAWQ4f0iIyMDX375JdLS0vCXv/zFbXLRWV8eyscf//MbAODWIVGIDrFdbtjobk9mJnD//dLU9xZL8//OmwecPt2lb7d//36MGzcOHh4eSE1NxfHjxwEA/fv3h9FohMlkgnfDOnRWqxVfffVV09ceOHAAY8eOBQCMHz8eu3fvttFJKkPjbH7hWl82uJ2BDbPRVi7S09Px/fffY8KECVizZg1qampgMpkwf/583HnnnZg8ebLL5+JSZBTqcK6sFn7eHri6fw+5y3EvDsiFwWDA448/jquvvrpp36+//hqenp4wmUzw8fFxm1z8fKIYGYU6aP288PG8kbh5UCS8PXlZozgOyEWjpUuXYsmSJQCA7777DlqtFoWFhfD393ebXPxnVzYWbDiKc2W1CFH74K9T++HHxyfAz9t9xuM6BZneL06ePInHHnsM1157Lc6ePes2ueiIwWzBi5sy8OdPDsFkEbhpUCSW3ZZq02Pw3ak977/f9gL2KhXQ8FS6s/R6fdOU+2q1GtXV1QCkNfD++9//IikpCddeey0AYMSIEQgPD+/wa12F2So1u708+JJ0CjbMRluv7bi4OLzyyivYsmULPvzwQ5SXl+PgwYNYvnw5li9fjgULFrh8Li7F1hPSjM1jeofyaZ+jOSAXWq0WEyZMaLZvWFgYDAYDHnnkETz++ONuk4vDuZUAgBtSeyJUw7GqiuWAXADSEk1lZWVITEwEAHh6euLtt9/GAw88gKlTp7pNLr45KnWlv3dMLHYsuBKPTErgECMlkun94qabbsLHH3+MV199FX/961/dJhftKayqw23//BWrd2QBAO4fF4/XZw6+pBn+28MWTnuys9teOF4I6d+7QKPRoKamBgBQU1PTNK38qlWrsGzZMpw5cwZ79+7FuXPnOv21ruJIw8UTGwlOwobZaOu1PXr0aIwZMwY+Pj4YPXo0srKy0L9/f3Tv3h0pKSkoKytz+Vx0xe6zZZj13m7848dTAICxCbab/IM6yQG5aI3JZMKMGTMwa9YsDBs2zG1ycapIDwDoF6GVuRJql4Ny8e233+K2225rtv+DDz6IY8eOYcGCBW6Ri/IaIw7kVAIA7h/fGwE+vKZSLJneL/74xz9Co9Fg0KBBvI5q8OoPJ5FeoEO3AG+8N2c4nrsxuUtLTHYWG93tiYtr/y5UXFyXvt3QoUOxbds2CCFw6NAh9OvXD4B0Z0mr1cLDwwOBgYGt3mUaMmQItm/fDgDYvn07hg4d2qVjK9nh3Ep8tj8PAHDXSNtNWEB2ZMNstJWLxYsXY/PmzbBardi/fz8GDBgAs9mM0tJS5OTkIDw83KVz0RlCCPx6uhR3vL0Ld76zGztPl8HLQ4W7RkZj9hguk+RwDshFa5544glcd911mDt3LgDXfr+40LmyWgBA73BOEKVoDsrFL7/8gvHjxzd9Pn36dBiNRvj7+8PDw8MtcvHNkQJYrAKpvYJsOhaV7ECG9wshBCZOnAiTyYRTp06he/fubpGL9mQU6Jp6CL5191BcnWy/YXlsdLfnvvvavws1b16Xvt3MmTOxefNmjBw5EtOnT8ebb76JjIwMPPbYY3j11Vcxfvx4hIaGYsCAAS2+Ni4uDgkJCbjiiitQXFyMcePGXcoZKdKW40UAgOtTIzA8LkTmaqhTbJiNtnLxxBNP4O9//zvGjx+P22+/HaGhoVi6dCmuv/56zJgxA08//bRL56I9QgjsyJQa23e/twd7s8rh4+mBWaNikPaXSVh220D4enH8nsM5IBcXKyoqwnvvvYf//e9/mDRpEh577DG3yIXRbEVWqfR0pneYWuZqqF0OykVWVhaioqKa9r3zzjsxYcIE3HTTTXjhhRdcPhdWq8B/dkk9JW8ZHClzNdQhGd4vVCoVnnrqKYwbNw4PPPAAli5d6vK5aMvp4mr8ad0BXP/GdlTUmtAj0NfubRCVEG39xl2PTqdDUFAQqqqqEBgYiPr6emRlZSE+Ph5+fn6tf9EHH0gvfJVKCkHjf1evBhqeKihBp85Fof609gC+OVqIJ6/pi8euSrTbcS7+/ZPkknIBOEU2nDkX7XlxU0bT2CMfLw/cNSIaD03qg55B/l3+XsxF65gLZTuSV4mbV+1EtwBvHFh0jc3XkmUuWsdcKNeWjCLc/5/foPX1ws6FkxFoh3HczEXrmAvn8uvpUsx+fy8sDfNJ3TiwJ566th/iLvEGbmdzwcEeHZk7Fxg3TgpAdrbU3WPePCAhQebCXMPXhwuaJv0YEc+n3E6F2ZDF3qzypgb33Cvi8PCkPugR6BpvhC6BuXCIMyXSMKx+EVqbN7jJDpgLuxJC4M2t0mzXd4+OsUuDm+yAuZDFkfwqWKwCSRFarJg5GP17OuYGEhvdnZGQACxbJncVLsdiFVj05TEAwEMT+2B071CZK6IuYzYcSgiBJV+nA5DmP/jbzS2HopACMBd2l1deBwCI5trDzoO5sJsfM4pwOLcSft4e+OP43nKXQ13BXDhc43wgg6ODHdbgBjimG4B0IevsnPEcymoMqKw1QaUCnry2r9zl0EWc8TV1MVc4hwvtOF2K9AId/L098dcpSXKX45Zc4TXlCudgMFsBcMULpXCF15SznkONwYwXvpbG7943Nh5hXD5PMZz1NXUhVziHC/16phSf7MsBAExJiXDosd363crLSzp9vV7v1N3ThBAoKSmBSqWCt7fzdCkqqKwHAIRpfOHtyfs/SuHt7Q2VSoWSkhKEh4c7bTacNRdt2ZFZikfWHgAAzBgehW5qH5krci/MhXIIIfDbuXIAgNqXEwbKibmQl9FsxcNrDyC/sg69gv3x2GT7zYtDncdcKJPRbMVzXxyDEFJvwSv7dXfo8d2+0R0YGIiysjKUlZXJXc5lUalUiIqKgqen81yAHC/UAQD69eAaq0ri6emJqKgo5OXlIbuLa9ErjTPmojXfHzuPR9cdgNkqMDy2G568pu3lo8g+mAvl2HgoH7vPlsPXywN3DOcyk3JiLuS1+Mtj2HaqBP7ennjz7iHw93Ge2l0Zc6FMH+0+h7OlNQjT+OCZ6/s7/Phu3egGgMjISISFhTl99wlvb2+nC0TjmIqE7lxjVWk0Gg0SExNhMpnkLuWyOGMuLlZtMOO5jcdgtgrcPCgSr9w+EH7ezn1Ozoq5UIb3d2QDAB69MgGxoVwuTG7MhTyEENh4KB8A8MZdQzA0ppvMFdGFmAtlqTWa8c+GyQafvLYftDJMNuj2jW6VSgVfX45/kUNVnfSHKDjA+busuCJPT0+X+EPr7D7YmYXSagPiQgPwjxmD4OPFoRhyYi7kdbakGkfzq+DlocLdo2LkLocaMBeOp6s3o94kzW1wRR9ORKtEzIVybNifh7IaI2JCAnD7sChZauDVG8kms0gPAIji7LNEbTqSVwUAmDMmjg1ucntZpTUAgP49AxHKCaPIjX1+IA8A0DtMjQB2Kydq18mGNsdNg3rKNo8Ur+BIFharwLECqTExODpY3mKIFKq02oCDuZUAgJgQ3pwiqqxlDykiAPj0N6nR/Ydx8U47UReRo1Q0vHeEqOW7WctGN8kir6IW9SYrfL08EB/GMXlEF7NYBR75+ABK9AbEh6lxRQK7DxLp6qULp0B/NrrJfQkhkFcuzYszpjffG4g60piXXsH+stXARjfJ4kBOBQCgT7gGnh68Q0t0sd+yy7E3uxxqH0+8O2c4AnzcfgoOIpzXSUtNduOTbnJTBrMF8/93CHqDGT5eHogI8pO7JCLFy6uoAwBEh8jX6OZVHDmc1Srwv325AICrk3vIXA2RMp1qGH80uncoZ/gnarDnrLQ+96CoYHkLIZKBxSpw3wf7sPN0Gbw8VFg6LQUaX17KE7XHYhUorzUCALpr5btJxaSSQwkh8P++OY7dZ8vh5aHCrUN6yV0SkSIVVklP9KI5lpsIAPDT8SIcyq2Ep4cKVySEyV0OkcNt2J+HnafLoPbxxNuzh2NcInNA1JEaoxmNK0MH+svX9GWjmxwjMxN4/32sLvPH+yHDAACv3D6Q47mJ2lBrtAAA1L6clZZICIEXNmUAAO4fFy/ruDwiOQghsHLLKQDA49f0ZYObqJNMZmvT/3t5yDeymmO6yf7WrAGSkrBlQxqWdhsCAHh26/u47cgWmQsjUq66hka3vzcb3UR5FXU4V1YLb08V/u+qRLnLIXI4s1WgoKEH1PSh8qwzTOSMMourAQARgX6yziMle6O7uLgY06ZNQ3BwMMLCwjB//nyYzeZW93399dcRHx+PwMBADBw4EBs2bLikY9bU1PDDUR+HD6Nm3jzorVY8NXYWTLU63Ln/G9y/93Ng3jzg9OnLefm4LDlyQcpiMEuNbl8vNrobMRfua9eZMgBAUkQg1BzD2gxz4R4sVtH0/16enIC2I8wFNTrcsPTqkJhgWeuAkNmkSZPErFmzRE1NjThz5owYMGCAeOWVV1rs9+2334ru3buLEydOCCGEWL9+vfDw8BBZWVmdPlZVVZUAwA+ZP3JUHkIAQnh6CvH007Z6KXX6919VVeWwY14qOXLhDD8XdzJn9R4Ru2CTWLv7nF2P40y/f+bCPVmtVnHjG9tF7IJN4q2tmQ45pjP9/pkL95BfUStiF2wSCc98I6xWqyw1ONPvn7mgRn/57JCIXbBJrNh80i7fv7O/f1mfdJ8+fRppaWl45ZVXEBAQgN69e2PRokVYtWpVi32PHz8OIQSsViuEEPD09ISPjw+8vHjH29n4ioaxFUIA2dmy1qJEzIV709eb8MSnh/DLqRIAQAwnUgPAXLiz87p6HM2vgqeHCneOiJG7HEVhLtxHTsM6w921flCp+KS7PcwFXaigUhqWIff1lKyvqPT0dISEhCAyMrJpW3JyMnJyclBZWYng4OCm7XfddRfWrFmD5ORkeHp6QqVS4eOPP0ZUVNvjWgwGAwwGQ9PnOp0OAFBQUIDAwEDbnxC1tHgxsHIlnpp0P/798zsAgKaXvEoFxMXJVZliyZULkl+9yYLb/vkrMour4aEC/nRlAsYmhMpdliIwF+4rs0gajxcfpkaI2kfmapSFuXAfB3MqAQADo4LkLcQJMBd0oRqjNKxA7uX1ZD26Xq+HWt189uqAAKlJVl1d3SwURqMRgwcPxvvvv49BgwZh7dq1mDdvHpKTk5Gamtrq91+2bBmWLFnSYrtarW5xXLKThx4CVq7E0djff0dN92eFkMZ1UzNy5YLkdyi3EpnF1Qj088LquSMwIi5E7pIUg7lwX42Njf49ebP8YsyF+/j+WCEAYHRv3ojtCHNBF6qsNQEAtH7estYha/dytVqN2traZtsaP9dqtc22P/rooxgwYABGjBgBHx8f/OEPf8CYMWPwwQcftPn9Fy5ciKqqqqaP3Nxcm58DdSAxEaVvv4+c4J6/b/PwkD5WrwYSEuSrTaGYC/eVX1EHAEiNCmKD+yLMhfvaeaYUADCGjY0WmAv3kFNWi8N5VfDyUOHGgT07/gI3x1zQhYp0UvfyiCA/WeuQtdGdkpKCsrIyFBUVNW3LyMhAVFQUgoKad5/Jyclp1pUDALy9veHj03ZXM19fXwQGBjb7IMervPm25hvmzwdOngTmzpWjHMVjLtzX+YY3hsggrkF8MebCPenrTThwrgIAMC6B6xJfjLlwD0V66b0hOiQAoRpfmatRPuaCGhnMFtQ2LMEaEiDv8CRZG92JiYkYN24c5s+fD71ej6ysLLz44ouY10qX45tvvhmrVq3CgQMHYLVasX79emzduhUzZ86UoXLqisYXe5MXXuAT7nYwF+6rsEp60i333VglYi7c0y+nSmC2CvQOUyMmlJMKXoy5cA8mszQBrZeMaww7E+aCGlXVmZr+X+0r7xKssk/Nt379ejz66KOIj4+Hh4cH5syZg0WLFgEANBoN3n77bcyaNQvPP/88PD09MX36dJSXlyMxMREbN27E4MGD5T0B6lB6ASeY6Crmwj1V1EhvDpwsqnXMhfvZdFgaxzolJULmSpSLuXB9hoZGt5+3vI0GZ8JcEABkl0rDCqK6+cPLU9ZnzVAJIYSsFTiQTqdDUFAQqqqq2BXEgV74OgPvbT2O3BW3A5AmsZBjIjv+/lvHn4ty3PDGdqQX6PDW3UNxg4PG7fH33zr+XORnsQoM/NsPqDFa8PWj45DqwFmb+ftvHX8u8vjmSCH+tO4ARsaF4NOHxshWB3//rePPRbne/CkTr20+hauSumP13BF2OUZnf//yNvnJLVzYtYOIWldeY2zqFTIivpvM1RDJL7NYjxqjBWofTyRH8kKW3FfjdVSgv7yzLxM5EyEEvjiYDwC4LlX+CQjZ6Ca7M5gtHe9E5ObOlkhrEUd180d3Lcd0E508rwcAJEcGwpNjWcmNZZfVAAAigjiJGlFnHcipxNnSGvh7e2KqAoYoyT6mm1xbabUBxws5ppuoI6XVRgBAuJYXVUTA743u+DDHD0ciUoTMTOD993Gstg/g3xMDvQ0dfw0RAQC+PlwAALguNQIaX/mbvHzSTXaTXVqDW/+5E2dKahDELlFE7WrsEaL2kf+NgUhuFqvAl4ekC6Yxfbg+N7mhNWuApCTg1Vehr5J6QoX/+RGgnfWjieh3eRXSijDDY0NkrkTCqzuym5VbTiG3vA6xoQFYNSMZA1+SuyIi5TI2zE7LbrREwN+/O478yjoE+XvjuhT5x+JRczU1NfD05EzadnP6NDBvHoQQKPQJQJaXL6xWK3xNBmDePGDcOC69StQBfb00F4LWTxnNXWVUQS6p8Q7TgqlJ6B2ukbkaImWrMZgBQBFdoIjk9NGubLy7PQsAsOTmAVwmSYEiIyPlLsF9GGuB1Y9g/F1/x7D8DEClAlavBpYtk7syIkVrXJ9LKevbs3s52U3jbJvB7FpO1KHsMmktyTAN1+gm9/bBr9kAgKeu7YtpQ3rJWwyRQvz1l//A12KWWhLZ2XKXQ6RoZosVWQ0TEGr9lNEO4SMVsps6kzRG1d+HTymIOrItswQAMKZPmMyVEMnHaLbiXMMNqFuHRslcDbWloKCA6xHb0+LFwMqVqLFa0aNhU9+qIul/VCogLk6uyoicwo7TpSjRGxCi9sHIeI7pJhcmhEBptTTLZrcAPrkj6khuudTQSI0KkrkSIvn8dLwIZqtAd60vegZy6TylUqvVUKs5q7zdPPQQsHIldN7+gEkaqhdklJ7aQQhpXDcRtenrw4UAgBsH9oSPlzI6diujCnI5JXoD6k1WeKiAXt385S6HSNEMZgtMFmnwkYazl5ObslgF3tl+FgAwfVgUPBQyDo/I4RITgdWrkRUW3bRJYzECHh7SeG5OokbUphqDGT9mnAcA3DhQOfNP8OqO7CK3YRK1nkH+8Pb0gFHmeoiUTFcnTaKmUgEahcyySeRoq3ecxcGcSqh9PHHP6Fi5yyGS19y52KaKBeZOlj6fPx94+GE2uIk6sG5PDvT1ZsSHqTE8tpvc5TTh1R3ZRWGV1OiODGb3QKKONE46qPX14pJh5Lbe35ENAHj2hmT0CmYPKaIt5y94ZPHCCwC79BN1aNNRqWv5/ePjFdVjit3LyS6KddJ47u4ck0fUoXpOOkhuzmoVKNbXAwCu6t9d5mqI5He6uBqniqrlLoPI6VQ3rM/dR2HLFbPRTXZRrJca3eEaX5krIVK+shrpaUagQpa1IHK0jEIdrALw9fLg5JtEAA7lVspdApHTkSZyVuY1FRvdZBeNTyy6B7LRTdSRzCI9ACChu7LuyhI5ynfHpO6Ak5O6K2amWSI5lTQ8vCCizjuvq0dVnQmeHir0DlfWcAy+s5FdNC5/xHF5RB3Lr5TmQIgJDZC5EiJ55DVMvjk0RjmT3hDJ6VxZjdwlEDmdvVnlAICkCC38vJU1ZI+NbrKLrFLpzUJp4ymIlKiEwzHIzRnNVgCAt6dyJr0hkou+3oTtmaVyl0HkdPY0NLrHJoTJXElLbHSTzQkhUFErTWIQrmUjgqgjhoYGRwDX6CY31XijNqobe3sQPfPFMeRX1qFnEK+hiLqisKHnYIICH/qx0U02p6s3w2IVAJQ3iQGREjXmxUtBS1sQOYrJYsXZEqnR3S9CK3M1RPLKLq3B14cL4Omhwmt3DJa7HCKnktswVEmJD/3Y6CabO1MiLXEREejHJZCIOsFkaeha68VGN7mfzKJqGC1WaP28ENWN84CQe9t/rgIAMDg6GEM4xwFRp5VVG3C6WGqDDIoOlreYVrDRTTaX3dBNMD5MWbMGEilV47r27BlC7ui3c9IYvNReQVCpeOOJ3NuPGecBACPiQmSuhMi5HMmrAgD0CVcjRK28pSfZ6Caby2mYuTyWMzETdajOaEFmsbRkWEqvIJmrIXK8HQ0TRilx4hsiR6qqM+HnE8UAgGlDImWuhsi5HD+vAwAMiFTmtRQb3WRzjUu/sJsgUcfyKmphFYDWzws9Av3kLofI4RonURsYpcwLJSJHOVdWA5NFoLvWF0kRgXKXQ+RUSvVGAECkQpcrZqObbK6gYeZApb7oiZTkTMMEUpFBzAu5HyEEzlfVAwBvOpHbaxxq1D1QeZNAESldeY2UH42vMueTkr3RXVxcjGnTpiE4OBhhYWGYP38+zGZzq/v+8ssvGDVqFDQaDaKjo7Fs2TIHV0udUaSTLqAieAF1yZgL9/HloXwA7FrbGcyF68kqrYHeYIavlwfiQjkPyKVgLlzHuYbhedFcOu+yMRfuxWSxYuvJEgDAUIVOQCh7o3vmzJnQaDQoKCjA3r17sWXLFqxYsaLFfidOnMD111+PRx55BHq9Ht988w1ee+01rF+/XoaqqT2VDWt0d1PgJAbOgrlwD0IIpDW8Sdw2tJfM1Sgfc+F6dpyWxnMPjAqCj5fslyROiblwHY09BaND2Oi+XMyFe9l9tgxVdSaEaXwwqneo3OW0TsgoMzNTABD5+flN2z755BMRExPTYt9HH31U3H333c22nTx5UhQWFnb6eFVVVQKAqKqquvSiqUNDXvhRxC7YJE6e1zVtq66uFgAEAFFdXS1LXc7y+2cu3EeJvl7ELtgk4p7eJAwmiyw1OMvvn7lwTTP+/auIXbBJvLvtjNylNOMsv3/mwrX89bPDInbBJvHmT6eEEMq4drqQs/z+mQv3s3jjURG7YJN4esNhhx+7s79/WW8rp6enIyQkBJGRv8/QmJycjJycHFRWVjbbd+/evYiLi8Ndd92FsLAw9O/fH2lpaYiIiHBw1UT2xVy4j2P50vIWUd38+ZSvA8yFazp5Xpq5f1wih1dcCubCtZwukdYY7q7l8LzLwVy4n8ZeU5P6dZe5krZ5yXlwvV4Ptbr5GK6AAKlLTXV1NYKDg5u2l5eX44033sAnn3yCjz76CL/++ituvPFGhISE4Pbbb2/1+xsMBhgMhqbPdTqd7U+CWhBCyF2CU2Mu3Meus2UAgDFK7QqlIMyFazKYLQAAtY+slyNOi7lwHTUGMw7lVgIArkjge8LlYC7cS0WNsWlS2pEKXt9e1kcrarUatbW1zbY1fq7Vaptt9/X1xS233IIbbrgBXl5emDBhAmbPno1PP/20ze+/bNkyBAUFNX1ER0fb/iSohTqTdBHl763M2QOVjrlwH6canvINig6WtxAnwFy4njqjBfUmKwAgKMBb5mqcE3PhOkqrDbBYBdQ+nojiRGqXhblwL/kNcyGEa30VPZ+UrI3ulJQUlJWVoaioqGlbRkYGoqKiEBTUfL3O5OTkZneVAMBisbT7VHXhwoWoqqpq+sjNzbXtCVALtUZz00VUoD8voi4Fc+E+ssuki4D4MM7a3BHmwvUU66WVLny9PKD15ZPuS8FcuI5aY8MDCx8+sLhczIV7qaqTJnAOVni7Q9ZGd2JiIsaNG4f58+dDr9cjKysLL774IubNm9di34ceeggbN27Exx9/DCEEtm3bhrVr12L27Nltfn9fX18EBgY2+yD7OpYvdbHpEeiLIIW/+JWKuXAfxQ3L6/XkGt0dYi5cT2659HQiqps/VCqVzNU4J+bCdVisUiPP04NZuFzMhXupMUhLwakVfvNW9pl71q9fD7PZjPj4eIwaNQpTp07FokWLAAAajQZr164FAEyePBlfffUVXn/9dQQFBeEPf/gD/vGPf+Dmm2+Ws3y6yMnzUqM7tVewvIU4OebCxWVm4tun/4EaowXesKJHcZ7cFTkF5sK15FZIPT1iuDzSZWEuXIOu4WmdH4fm2QRz4T4ah7UGKLyXiOy3BHr06IHPPvus1X+rrq5u9vl1112H6667zhFl0SUq0klddCKDOfPm5WAuXNiaNah76BEsevA9IAB4aNdnCHh1LbB6NTB3rtzVKRpz4Voa1yTu1Y09PS4Hc+Ea9p+rAACk9grqYE/qDObCfdQZ2egmN9T45CIiiI1uZ1NTUwNPT2X/wXJ6p08D8+bhWGgMigQQVJaHR7avBYQVmDcPGDcOSEiQu0oihyivMQIAQtW+MldCJL/MYqkhyEY3UdeU10rvJYF+yh7WykY32dTphjeNPuEamSuhrrpwPUuys9JzwKp7kA9AD8AfAFQq6Wn3smXy1kbkII2T33DiKCIgp1x6aBHN4RZEXVJY2TA/jsJ72co+pptch8liRWaR1Oju10Pbwd5E1IwQQHa23FUQOYS+3oStJ4oBAAOj+GSP3Juu3oRj+VUAgJRI5oGoK04VScuvxocp+4Efn3STzfx0vAhGixVaPy9OjOOECgoKOAOnvS1eDKxciQ19RuLezN0AgKakqFRAXJxclRE51I/pRagxWtAnXI0xvUPlLodIVgdzKmG2CsSGBiAmlNdPRF1xpkR64JcUoewHfmx0k03UGMxY8nUGAGD26Fh4cMkLp6NWq6FWc71ou3roIWDlSvwWPwxoaHQ3JUUIaVw3kRv4rWHSqKv79+ByYeT2jGYrACBE7SNzJUTOR1cnLRmm9PyweznZxLZTJSisqkevYH88NjlR7nKIlCkxEVi9Ghk9ev++zcND+li9mpOokdto7A6YwkmjiFDfsOSRtycvy4m6wmi2wmiRblqpfZT9LJnpJptofGoxsV84J8Uhas/cubBe2LiePx84eZLLhZFbKa2WlpfkShdEQH7D8nmRzANRl1Q2zFzuoQK0fspudCu7OnIKlbVGfPpbLgBgfEKYzNUQKZvJYkV+jfX3DS+8ALBbP7kRo9mK/IqGRkYw1+gmKmu4CRWu5fJ5RF1R19BLxM/bU/FDWy/pSXd+fj7y8/NtXQs5qbV7cqCvNyMpQospAyLkLkc2zAV1xr7s8qY3CXfAXNDFsstqYLYKaH293PbJHnNBF6o2SO8JGl9lrzNsb8wFdZXZKgAAnk4wN0iXGt07d+5EfHw8YmJiEBMTgx49emDBggXQ6XT2qo+cwJmGtblvHhyp+LtM9sBcUFes+vm03CU4BHNBbamsldbnDtf6ut0kaswFtcbcMCbVx8s9R30yF3SpTje0QXp1U36vqS6l+8EHH8SAAQOwb98+HDlyBK+++ip++uknDBs2DKWlpfaqkRSupKFbVHetez6xYC6os04XV+PXM2Xw9nT9hgZzQW2pqpMa3QG+7jf/B3NBrbEI6WmdGz63AMBc0KU7mFMJABgUFSxrHZ3RpUb3mTNnsGLFCgwdOhQDBgzAnDlzsG/fPgwePBj/93//Z68aSeFK9I2Nbvcci8RcUGftPC1dPAyP6yZzJfbHXFBbMgqkp1eJ3ZW9pqo9MBfUGoNJetLt5+1+N6IA5oIu3Z6sMgDAyPgQmSvpWJca3f3798f58+ebbVOpVHjhhRfw9ddf27Qwcg6ZRfqmpV9iQwNkrkYezAV11t7scgDAyDjlvzlcLuaC2pJTXgsASOiukbkSx2MuqDV6g7TOsNrXPec3Zi7oUgghmm7iDo1V/sOMLjW6586diwceeAA5OTnNtldVVSEoiGttuqPXf8qEVQDXJvdAbKh7zsDMXFBnHc6tBAAMjg6WtQ5HYC6oLY1rqvq64fhV5oJaU6yrB+C+s5czF3QpdPVmGMzS+0lPJ5iUs0u31ObPnw8A6Nu3L2677TYMHjwYFosFH3/8MV599VV71EcKJoTAjobusg9O7CNzNfJhLqgzzBZr01qsvd3gCR9zQa2pMZix7VQJACA+zP1u1DIXdLE6owVnSqTJoOLctMcgc0GXorBKuqYKDvB2iqEZXWp0nz9/HgcPHsThw4dx6NAhfPDBB8jMzIRKpcLf//53fPPNNxg4cCAGDhyIqVOn2qtmUoginQGVtSZ4eqgwIDJQ7nJkw1xQZ5RWGyEEoFIBIQE+cpdjd8wFteabo4WoqjMhPkyNSf26y12OwzEXdLHDeZUwWQQiAv0QE+KejW7mgi5FXrnU6I5ygpnLgS42urt3744pU6ZgypQpTdvq6+tx9OhRHDp0CIcPH8ZXX32Fl156CZWVlbaulRSmca3hAG9Pp7jDZC/MBXXG/nMVAIC+3bXw8nT9brXMBbWmsRvtiLhu8HTDqZqZC7pYacMKMDGhAW63hF4j5oIuxfmG95OIQBdsdLfGz88PI0aMwIgRI2xRDzkRi1UaR+Gm7xHtYi7oYvsaJlEb3dv1J1FrC3NBunr3njCqNcyFe6uoMQIAAv28Za5EWZgL6khx4+pJgc4xF4LrP24huymtlt4owjTO8WInktOhhknUnGGGTSJ7OdswdrW3G47nJmrNyYYVYPp0ZyaIuqKx55SzLFnMRjddsvKGu7OhGtcfn0p0uRonyunf033nPyA6Xig1MBLccI1uotacLpbeG/r1YCaIOqvaYMaW40UAgN7hzjE5LRvddMl0dSYAQJA/u0QRtafaYIa+oVttD63yl7UgsoeqWlPTDP7Jbjz5JlEjIQRyyqR16911EjWiS/HRrnMorTYiLjQA16VEyF1Op7DRTZesrOFJd5A/n3QTted/+3IBALGhAQj051hWck95lVLjIkzjy5u1RADSC3QoqKqHj5cH+kbwSTdRZzX2ELl9WBS8nWRyWueokhSpaSyFk0xgQCSXj3efAwA8OKGP285OS9Q0JEnNG7VEALDpSCEA4NrkHpxIjaiTTBYrTjXMheDv4zwPMtjopkuWXyk1uiOD2F2WqC0Wq0BOufSEb3KS+61LTNQov0LqWt4zmO8ZRACQ2/DeMIwTbBJ12gtfZ+BofhU0vl64pn8PucvpNDa66ZKVNKwt2SOQF1BEbamsNcJiFQCAME46SG4su2HsalQ351hTlcje8iqkTETwOoqoUzIKdPho9zmoVMDrdw5GTKjzzIUge6O7uLgY06ZNQ3BwMMLCwjB//nyYzeZ2v+bYsWMICAhAWlqaY4qkVgkhNSS8PNld1taYC9dRpJNuTgX4eMLLScYdKRVz4dxOntcBAPpFcBI1W2IunJPJYsXx81IX2SSuamFzzIVrWr0jCwBwQ2pPXOVET7kBBTS6Z86cCY1Gg4KCAuzduxdbtmzBihUr2ty/trYWd911F+rq6hxYJV1MCIGihjHdGl+OQ7I15sI1ZBTocN8H+wAAfbkczGVjLpxbRqHU6O7PCaNsirlwTufKamA0W6H28UQsZy63OebC9Qgh8NMJaZmwOWPi5C3mEsja6D59+jTS0tLwyiuvICAgAL1798aiRYuwatWqNr/mkUcewa233urAKqk1BVX1KNIZ4OWhQmqvILnLcSnMhWvILNJj5tu7cF5Xj4TuGrx51xC5S3JqzIVzO1dWgyKdASoV16q3JebCeTXOvtynuwYeHuwxaEvMhWvKq6hDZa0J3p4qDIp2vraHrI3u9PR0hISEIDIysmlbcnIycnJyUFlZ2WL///znPzh9+jSef/55B1ZJrSnVS11mu2t94e/jKXM1roW5cH76ehMe/Gg/9AYzhsV2w4aHrkA0n2RcFubCeQkh8NzGYwCAK/qEQu3rPLPNKh1z4bwKq6TegpzjwPaYC9dUUSutgBGm8YWvl/O1PWR959Pr9VCr1c22BQRIF6bV1dUIDg5u2n7ixAk8++yz2LlzJzw9O/eDNhgMMBgMTZ/rdLrLL5oAAAazFQDg4yX7CAWXw1w4v//uzcHZ0hr0DPLD27OHISiAQzAuF3PhvPafq8D2zFL4enngxVtS5C7HpTAXzquk4eFFmIbLrtoac+GaKmpNAJx3LilZW0xqtRq1tbXNtjV+rtX+Puarvr4eM2fOxMqVKxETE9Pp779s2TIEBQU1fURHR9umcEJ5jfTHphvXW7U55sL5lTWsR3x9ak9eUNkIc+G8zjXMWj4yPgS9wzUyV+NamAvndaZE6l4eG6ruYE/qKubCNa3bcw4AMC4hTOZKLo2sje6UlBSUlZWhqKioaVtGRgaioqIQFPR7X/19+/bh1KlTmDdvHoKDg5vuUN1444145JFH2vz+CxcuRFVVVdNHbm6u3c7F3ew+Ww4A6BXMblG2xlw4v1qDBQDgy54gNsNcOK/chmWRuLyk7TEXziuzYUx33x68EWVrzIVr2nqiBABwz+hYmSu5NLJ2L09MTMS4ceMwf/58vPPOOygtLcWLL76IefPmNdtv/PjxLWYTVKlU2LRpEyZNmtTm9/f19YWvL58y2VpptQH/3ZsDALhzROfvDFLnMBfOr3GCHD7Vsx3mwnkdyasCAAyI5ARqtsZcOCeTxYqchh4gCd35PmFrzIXrsVoFjBZpaGvPIOd84Cf7Y5j169fDbDYjPj4eo0aNwtSpU7Fo0SIAgEajwdq1a2WukC6260wZDGYrkiK0GJsQKnc5Lom5cF7VBjMO5FQAAFJ6sZFhS8yF8ymvMWLH6VIAwIi4EJmrcU3MhfPJr6iD2Srg5+2BCPYAsQvmwrU09gzx8fKA2tf5JlEDZH7SDQA9evTAZ5991uq/VVdXt/l1Qgh7lUQdSC+QJowYFtsNKpVzTmagdMyF8/rlZAkMZiviw9Tox7W5bYq5cD4bD+bDaLYitVcQn3TbCXPhfBqHXER3C+B1lJ0wF67l5xPFAICxfUKdcuZyQAFPusn55JTXAAD6sOssUQt5DRdTQ6KDeTFFbi+vQuq6OTYhjHkgalBYKS0XFsl5cYg65VCu1IPwij7OOYkawEY3XYLGtSX5ZkHUUmWdtKRFoD+XCSOqM0mTCvp7O+eTCSJ7KNJJ11HsWk7UOSfO6wE499wgbHRTl1XXmwEAgX6yj04gUpzCSunJXkQQL6aITA0T3/hwJn+iJiar1IWZuSDqmNFsRW658088yLRTl9SbLChoaFQEBfBJHtHFGrvTcjk9IqBEbwAAaJx04hsiezCapZtRXp4cckHUkfzKOlgF4OftgXCt884az0Y3dUnayWLUGC2IDPJD/wjn7eJBZC/nGu7GxoWqZa6ESF4mixX7sssBAMNiOXM5UaPG7uVcu56oYznlrjHxIBvd1CWNM5dP7NcdHh7O+8Insoe8ilqU6A3w9FAhPpyNbnJv+RV1qDVa4OftgaQIzuRP1CirVJqQNrpbgMyVECnf98cKAQDJTjyeG2Cjm7pACIEjeVUAgJ4cr0rUwtaGJS2GRAdD48s5D8i9NU662TPInzdpiRpYrAKniqRJofpFOO/4VCJHqDaY8cXBfADArFGxMldzedjopk5bszMbv5wqgZeHCpOTustdDpGiCCHw0e5zAICpKREyV0Mkv8blJaND+DSPqFFmsR61RgvUPp4chkTUgb1ZZag3WREd4o8Rcd3kLueysNFNnWKxCrz240kAwDPX90dKryCZKyJSll1ny3CqqBoBPp6YMTxa7nKIZHe2RGp0x4ey0U3U6GhDj8GBUcHw8uRlOFF79mVL63OP7RPm1OO5ATa6qZPKa4yoMVqgUgFzxjh39w4ie1i7OwcAcOuQXgjiGt1ETXOAJPV07nF4RLZUUWsEwGF6RJ3RuAxrfJjz9wpho5s6pXGmzVC1D+/MErViT5Y0S/NtQ3vJXAmRMpwurgYATqJGdIHDudKT7vBA5136iMgRagxm7DhdBgCIdYEeU2w9UaecbZhpk2sPE7XOKgQAINCPT7mJLFaBkmppje5Ivm8QAQDKqg34If08AGDaYN6gJWrPx7vPobTagJiQAExO6iF3OZeNjW7qULXBjH/8II3nHhrr3JMYENlLvckCAPDx4p9VorIaAyxWAZVK6iFFRMC58lqYrQK9gv3Rn8MuiNp1JF/qFTJrVIxLXFs5/xmQ3f0r7TRyymvRK9gfj1/TV+5yiBSnWFePWqPU6A72ZwODqFgnPeUOVftySBJRA12dCQDg7encE0IROUJjXkI1rjEUg++E1C4hBDYeLAAAPH1dErvOErXipW+PAwAGRwcjKIAZIWrsWt5d6xoXS0S2sHpHFgBgZHyIzJUQKV9hlTSfVESga0w6yEY3tet0cTXyK+vg5+2Bq/s7/3gKIlsrrTZg4yHpxtQLtwyQuRoiZSislC6WunOyKCIAUo+o7Zml8FABj01OlLscIkUrrzHiXJk0n5QrTKIGsNFNHThV1Dj7bCD8fTxlroZIeRrXIo4O8cfAqGB5iyFSiBPnpeXC+vbgzOVEAKCrl7rKav28ER3iGo0IInv5375cmCwCKb0CEdXNNSbjZKOb2nW+YakwV3nBE9lafmUtACC6Gy+iiBo13oxio5tI0jjvh783H2AQdWRPlrRU2Ixh0VCpXGMOBDa6qV2iYRkkTw/XeMET2Vqp3ggACOfYVaImxXrXGotHdLmqGiaFCua8H0QdqjVIN6lc6dqKjW5q1/5zFQC4zipRW443dKONYXdBoib6ejMAINDfS+ZKiJShruFJtx+fdBN1KLthPLcrTcbJRje1qc5owU8nigEANw7sKXM1RMp0KLcSANewJ7qQyWIFwHXriRqdK5OGIjETRO0r0RtQrDfAQwUMiAySuxybYfKpTb+dK4fRbEVkkB+SewbKXQ6RIlXUSN3Lo9gbhKiJwSQ1un29+FSP6GxJNZZvPgUAmDIgQuZqiJStcSiG1s/bpSZxZqOb2vRD+nkAwJg+YS4ziQGRLQkhUNM4OY4LvTEQXY6qWhNqjFL3crUvc0H0yb5c1JksGBUfgj9cESd3OUSKVm+Srqt8XaxXiGudDdmMrt6Ezw/kAwCmD+0lczVEylRnssBolp7odQvwkbkaImX4Pr0QVgEkRWjRXcuJ1Ih0DU/uxieGwYMT0xK1q7yhB2GI2rWuq9jopladKNSj1mhBzyA/jOkTKnc5RIpUUStdSHl7qhDAJ91EAIBj+dLkgpP6dZe5EiJlqDNxEjWizqqolRrdrvYwQ/ZGd3FxMaZNm4bg4GCEhYVh/vz5MJvNre7773//G/369YNWq0Xfvn3xz3/+08HVuo/ahq6BIWofdi2XAXPhHCob3hiCA5gTR2AunIPZKi01yRtRjsFcKF/jbP5aP87m7yjMhfOqNrhmXmRvdM+cORMajQYFBQXYu3cvtmzZghUrVrTYb+PGjVi4cCE+/PBD6HQ6fPjhh3j22WexYcMGGap2fZaGiyYvT9lfIm6JuXAO6QXSE71YLhfmEMyFczCYXXM8nlIxF8rX+CDD38e1GhFKxlw4r1I9u5fb3OnTp5GWloZXXnkFAQEB6N27NxYtWoRVq1a12LegoABPP/00Ro8eDZVKhTFjxuDKK6/Etm3bZKjc9TXOHMihR47HXDiP37LLAQCjeofIXInrYy6cR+NTPT7ptj/mwjkYGub+8OONKIdgLpxbfqW0vF6ki60KI+stt/T0dISEhCAyMrJpW3JyMnJyclBZWYng4OCm7Y888kizry0uLsa2bduwfPnyNr+/wWCAwWBo+lyn09mueBcmhMCHu84BAK7geG6HYy6cR2FVPQCgd5hG5kpcH3PhPDIaeoD0CWcu7I25cA51XOXCoZgL55bdsKZ9jIv1IpT1lpter4darW62LSBA+gFXV1e3+XXnz5/Hddddh2HDhuHuu+9uc79ly5YhKCio6SM6Oto2hbu49AIdDudWwsfLA3OviJe7HLfDXDiPphk2Na7VBUqJmAvnUFlrRH5lHQBgYHSwvMW4AebCOVQ2TLqp8WX3ckdgLpzb2ZIaAEBcmLqDPZ2LrI1utVqN2traZtsaP9dqta1+ze7duzFixAj069cPX331Fby82v4DtnDhQlRVVTV95Obm2q54F/blIWmpsGv690C41lfmatwPc+E8Khob3S42w6YSMRfOIadc+p2EaXzZwHAA5kL56owWnNdJvaJiQ12rEaFUzIXzKtEbUFptgEoF9O3hWr2lZG10p6SkoKysDEVFRU3bMjIyEBUVhaCgoBb7v//++7jqqqswf/58rFu3Dr6+7TcIfX19ERgY2OyD2ieEwA/p0u/jpkE9Za7GPTEXzqNx7oMgf2+ZK3F9zIXyCSHwxk+nAQDJkfz5OQJzoXyl1VI3ZF8vD5ebGEqpmAvn9fXhAgBAvx5aBLjYxIOyNroTExMxbtw4zJ8/H3q9HllZWXjxxRcxb968Fvtu2LABDz/8MD7//HM8+eSTMlTrHk6c1yOnvBY+Xh4YnxgudzluiblwDlarQE3DOD01n+jZHXOhfF8dLsCW40Xw9lThmeuT5C7HLTAXzsODy0o6DHPhvP6zKxsAcM/oWHkLsQPZp1Fcv349zGYz4uPjMWrUKEydOhWLFi0CAGg0GqxduxYAsGTJEpjNZkyfPh0ajabp46GHHpKzfJfT+GKf3K87GxIyYi6Ur75hWSSAszQ7CnOhXOU1Riz5OgMA8OiViUiK4JMfR2EulE1XL/WI4jWVYzEXzsdotjZNonZ9quv1tpX9L0CPHj3w2WeftfpvF052cOTIEUeV5LbMFiu+OCiN575vHCdQkxNzoXyNM5erVICfNxvdjsBcKNd/9+agvMaIfj20eHhSH7nLcSvMhbKVVUtzf4Rxwk2HYi6cSGYm8P77yMsrA3rdAk8VEOyCw/Zkf9JNylFWY0S9yQpPDxWGxXaTuxwiRXt/RxYAYHxiODy5oD25ucb5DSb1C4cP1yImatL4pDvQBRsRRJdtzRogKQl49VVsPCc95R6TdQge//lQ5sJsT/Yn3aQcWaXSFP3dtb5sRBB1YHOGNEHLH8ezVwiR2SIAACqOWyVqZs/ZcgBAuIarwbi6mpoaeHqy51unnT4NzJsHIQQOhkbjnwOuhNVqxYwjPwKf7QDGjQMSEuSu0mbY6KYmu8+WAQCfchN1wGC2NK272jvctZa0ILoUtUYzAEDN+Q2ImuzLLsd/9+YAAGaNjpG5GrK3yMhIuUtwXmW5wL/vx+03/QU3ntgBeKiA1auBZcvkrsxm2AeMmpwo1AMAhsaw0U3UFiEEFm08BqPFim4B3hynRwTAYLYC4PwGRI3W7jmHu9/dDbNV4Kqk7riiT5jcJREp3ks/vAVPYQWEALKz5S7Hpvikm5oUVNUBAKJDAmSuhEi50k6V4NPf8uChAlbeOQS+XmxkkBtrmACnqiYOCIiCR1kpgN5yV0Ukq7STxXj2i2MAgBtSe+LVGQNlrogcoaCggGt2d8XixcDKldjcKxm35kp56WmUxnVDpQLi4uSrzQ7Y6KYmuoaJcLoFcLIPoracKZZmPb02OQIT+3Ite3Jja9YA99+PvVED8PNdUhfA4Y/OBqoWAnPnylsbkYzSC3QAgMlJ3bHq7iGc68BNqNVqqNVquctwHg89BKxciaweCUBDo7spKUIArayr7szY6KYmNUZp3WF2DyRqW2M3Wn+OXXULnBinDRdMgPP6gMkw11TirlO7MKjglHSh5GIT4BB1ReP7RI9APza4idqSmAisXo3d32QBv22Utnk0jHxevdrl3kPY6CYAgNUqUFEjrSUZyjGqRG06klcJAOgXoZW3EHIITozTCd+9DgAY0meE9LnK9SbAIeqK08XSHDnxYRyuR9SeczfNwK4j3/++Yf584OGHXa7BDbDRTQ3KaowwWwVUKiCMy1oQtamx2+Dg6GB5CyFSGD9TvfQ/LjgBDlFnCSFwMKcSADAgMkjeYogUrnHlpCYvvAC4aBd9NroJAJBfKU2i1kPrB29PTmpP1Jo6owXFOgMAIKqbv8zVkCNwYpw2NEyAU6zyQm+L1EtqcIm0NJIrToBD1Fmni6tRWFUPHy8PLsFK1IHyGpPcJTgMG90EANh5uhQA0JddZolaJYTAgg1HYLRYERHoh4hAP7lLIgfgxDhtaJgAp0YbAlSeBwD0qKuS/s0FJ8Ah6qzNx4sAAKPiQzhHDlE7Mgp0WPVzptxlOAwfaRIA4LtjhQCAG1N7ylwJkTL9kF6Erw4XwMtDhdfvHAwv9gghd9YwAY7B54KbTx4e0ocLToBD1Fk/HS8GAExNiZC5EiLlEkLgT+sOoMZowaj4ELnLcQheNRIAIL9C6l4+OCZY3kKIFKqxN8isUTEY1TtU5mqIFGDuXOSvXvv75/PnAydPcrkwcmtnS6RlJdm1nKht6QU6ZJXWwN/bE6/fOUTuchyC3csJQgjo680AgEA/rtFNdLH8yjp8e1TqDTI8zj3uyBJ1RAiBr85bf9/gwhPgEHVGWbUBFbXSGNWeQZz3g6gt720/CwAYlxiGoAD3aHvwSTehzmSB2SoAAFo/3ochutCZkmrM+2AfymqM6N8zENck95C7JCJF+Oy3PPyYUSR3GUSKsemIdHM2pVcggvzdoyFB1FXfHS3ExkMF8FABD0/qI3c5DsMWFqFUL8086+PpgQAfTvpBBABVtSa8/lMm/rMrG2arQKjaB+/OGcaJcYgAFFTW4YVNGXKXQaQYXx0uwP/7RsrETQMjZa6GSJksVoFXfjgJQGpwD43phpqaGpmrcgw2uglnGsYfxYepoVKpZK6GSH75lXWY9tZOlOil5cEmJ3XH4huTEdUtQObKiORnMFvw1GeHUW0wY3B0EHLlLohIZjsyS/HnTw5CCOCGgT3xh7HxcpdEpEg/HS9CVmkNgvy98cgk95pwk93LCXkNa3RHh7BBQQQAKzefQonegLjQAHx430i8P3cE4sI4VpXIbLHi//57EL+eKYO/tydevCVF7pKIZPfziWIIAUwZ0ANv3DkEPl68vCZqzb7scgDAzYMiofZ1r2e/7nW21KrGp3ndA31lroRIfmXVBmw4kAcAWD5zMIbGcAZaIkCaOO25jcfwQ3oRfLw88O6c4UjowcmiiLJKpR6DI+ND4enBHoNErdl6shhfHioAAPTtoZG5Gsdjo5t+b3Rr2egmKtIZYBVAmMaHDW6iC6zekYVP9uXCQwX88+6hGJcY5jZj8YjaklmkR9qpEgDA2AQuJ0l0sXqTBQs2HGlqcMeEBOBGN5z3gI1uNyeEwLH8KgBARKCfzNUQya+wShpuoeXyeURNqupMeOV7afKb525IxtWcxZ8I1QYz/vzJoaau5UkRgXKXRKQ4a/fk4MuG2crnjYvH49f0RYCP+zVB3e+MqZmvjxTiaH4VfL08eBFFBODrw9Kd2PGJYTJXQqQcXx7Kh9FiRWJ3Df4wNk7ucohkJ4TA/E8OIqNQhzCND567IVnukogUaffZMgDAU1P6ud3kaRdio9tN1RjMWPrtcazbkwMAuHtUDMI07F5OdDhP6vlxbXKEzJUQyc9qFXjj50y8/lMmAGnyG65yQSS9V2w5XgwfT2l+A05GS9S6w7mVAIBR8SHyFiIzNrrdUI3BjNv++StOFukBSF09/jq1n8xVEckrt7wWnx/Ib+pervHjn0dyb0II/GX9kaaJBe8ZHYMHJ/aRuSoi+WUU6PC3r9IBANenRmAI5/8galVptQHFDXNHufvwC15Vupk6owWLvjyGk0V6hGl88fqdgzE2gd1oyT2ZLVZ8eagA6/fnYVdD9ycACNP4Ij6US4SRe1u3NwcbDuTB00OFv9+WihnDo+UuiUhWxfp6vPr9Saw/kAchAB8vD8wb11vusogUa1vDJINJEVq3WyLsYrIvJFhcXIxp06YhODgYYWFhmD9/Psxmc6v7fvvtt0hNTYVarUb//v2xadMmB1frfOpNFvx6phTLN5/CHf/ehUFLfsTnB/KhUgFv3jWEDW6FYi4c453tZ/HkZ4ex62wZVCpp5tkVMwdh218nISiAE6kpDXPhOL+cKsGSrzIAAAum9mODW8GYC8d5dO1BfLZfanDfOLAntjw+EalRQXKXRa1gLpRh05FCAMC1AzhkT/ZG98yZM6HRaFBQUIC9e/diy5YtWLFiRYv9MjMzMX36dLz44ouoqqrCkiVLcMcddyA/P1+GqpVNCIG1e87hznd2YeCSH3H3u3vwxk+Z2JtdDqPFiohAPyydlooxfbi0hVIxF45xtGH89i2DI7FjwWSsvX80bh0S5ZazajoD5sIx9pwtwwP/+Q1GixU3DOyJP47nkzwlYy7sTwiBU0V6ZJVJS+S9fudgrLp7KGJCOY5bqZgL+eWU1WLryWIA0nWW2xMyyszMFABEfn5+07ZPPvlExMTEtNj32WefFddcc02zbVOnThWLFy/u9PGqqqoEAFFVVXXpRTuBdXvOidgFm5o+Rvy/zeL//ntA/HfPOZFVUi2sVqvDa6qurhYABABRXV3t8OML4Ty/f+bCMc6WVIsBi78XsQs2iV9OFjv02ErIQyNn+f0zF45hMlvE+Jd/FrELNon71uwVBpOl3f2V9Fq2JWf5/TMX9mG1WsWZYr34eHe2+NPa/WLYiz82u67KKHDM+SstX87y+2culGHxxqMidsEmMXv1nnb3U9rrvKs6+/uX9XFOeno6QkJCEBn5+92P5ORk5OTkoLKyEsHBwc32TU1Nbfb1ycnJOHz4cJvf32AwwGAwNH1eVSU91dLpdDY6A+XJKq3G8+v3wWqy4p7RsbhjRBTiQ9UXzDZrgV6vd3hdNTU1Tf+v0+lgsVgcXkPj710I4fBjdwVzYX/1JgseWL0HOp0eQ2OCkRLu7dDzV0IeLjw+wFwwF5JvjhQgu7AU3QK8sfTGPqivrUZ9O/sr6bVsS8yFxB1z8cr3J/D9sfNNkz818vX2wNDobriqfzgiA4RDfgZKyxdzIXHHXHRVqd6AtTtOwmq2YvaQ8HZ/Nkp7nXdVZ3Mha6Nbr9dDrW4+WVFAgNRVp7q6ulko2tq3urq6ze+/bNkyLFmypMX26Gj3GJu2rOFDaS78IygHvV6PoCDljsFiLhwrF0DoE/IdX+48NGIumIsL5QLo+VLXvkYpr2VbYi6YiwudBvApgAdlOLaS8sVcMBddce3Kzu+rpNd5V3WUC1kb3Wq1GrW1tc22NX6u1Wo7te/F+11o4cKFeOKJ36+mKysrERsbi5ycHNn/WOh0OkRHRyM3NxeBgfJOoe8utQghoNfrFR9od8qFnK89uV/3Sjl3rVbLXEBZuegquV/LXeEstfL9QiJ3LuR4vTj6mM50jsyFRO5cNHKm144rH7ezuZC10Z2SkoKysjIUFRWhR48eAICMjAxERUW1eNGmpKTgwIEDzbZlZGRg+PDhbX5/X19f+Pr6ttgeFBSkmDf7wMBA1tIKe9Wi9ItnwD1zIedrT+7XvRLOnblQZi66Su7Xclc4Q63MhXJyIcfrxdHHdJZzZC6Uk4tGzvLaceXjdiYXss5enpiYiHHjxmH+/PnQ6/XIysrCiy++iHnz5rXYd/bs2UhLS8Onn34Ks9mMTz/9FGlpaZg9e7YMlRPZD3NB1BJzQdQSc0HUEnNBSiT7kmHr16+H2WxGfHw8Ro0ahalTp2LRokUAAI1Gg7Vr1wIAkpKSsHHjRrz00kvo1q0bXnjhBWzYsAF9+/aVs3wiu2AuiFpiLohaYi6IWmIuSHHsO4m6stTX14vnn39e1NfXy10Ka3GCWtyFnD9zdz223MeX+9ydgTP9jFgrOYqjf39yvF54jtRVcv083em14wrHVQmh8Hn/iYiIiIiIiJyU7N3LiYiIiIiIiFwVG91EREREREREdsJGNxEREREREZGduGyj22Aw4JZbbsHYsWPx7rvvdrhdjloaTZ8+HdnZ2Q6ppb16cnNzceWVV+KKK67A3//+d1lr0ev1mDJlCkaPHo1169Y5pBZX1pU87Nq1C6NGjcKVV16JrKwshx77jTfewNChQzFp0iS8+uqrl33s9o7f6ML8OercWzu2rc+9Kzm39Xk7CzlzYc9a7ZEjW9XbyJ65o0tzuXl49tlnMXbsWDz88MM2P97HH3+M0aNH44orrsChQ4cAAOPGjcOkSZMwadIkHD161ObHbC1H9jzHa6+9FpMmTcKoUaMwcOBAm59jo46y19VzdBdyvV9cbk4ccVwAMJvNSExMvKxjdvW4e/fuxfjx4zFixAhs3rzZIcfctm0bRowYgQkTJuDcuXNdO9BlT8WmUP/5z3/EP//5T2GxWMQ111wj6urq2t0uRy0Gg0FMmzZN9OrVS2RlZdm9jo7qefLJJ0VaWpoQQojJkycLnU4nWy3//ve/xZo1a4TVahWTJk2yex2urit5uOGGG0RZWZlIT08XDzzwgEOP/eCDD4qcnJzLPmZnjt9a/hx17q0d29bn3pWc2/q8nYWcubBnrfbIka3qdUTu6NJcTh7OnTsnZs6cKYQQ4i9/+Yv49ddfbXq80aNHC7PZLLKyssSMGTOExWIRN910k13P8eIc2fscGz399NNi06ZNNj/HzmTvUs7RXcj1fnE5OXHUcYWQrts1Gs1lHbOrx50yZYooKSkRZWVl4r333nPIMW+++WaRl5cntm3bJv7yl7906Tgu+6R7//79GDduHDw8PJCamorjx4+3u12OWgwGAx5//HFcffXVdq+hM/U888wzGDduHADAYrHAy8tLtloefPBBzJ49G3q9Hlar1e51uLqu5KGurg4hISFITk5GZmamQ4998uRJPPbYY7j22mtx9uzZyz52e8dvLX+OOvfWjm3rc+9Kzm193s5CzlzYs1Z75MhW9Toid3RpLicPBw4cwNixYwEA48ePx+7du216vK+//hqenp4wmUzw8fFBVlYWzpw5g4kTJ2L+/PkQnVyI53JyZO9zBIDy8nIcOHAAN9xwg83PsTPZu5RzdBdyvV9cTk4ceb5bt27FsGHDLuuYXTnu/v37YTKZMH/+fNx5552YPHmyQ8512LBhqKqqQnV1NTQaTZeO47KNbr1e3/TDUKvVqK6ubne7HLVotVpMmDDB7sfvbD0hISHw9PTEO++8g6FDh8Lf31+2WgCgqKgIqampGD58uN3rcHVdycOFNzk6+yZvq2PfdNNN+Pjjj/Hqq6/ir3/962Ufu73jt5Y/R517a8e29bl3Jee2Pm9nIWcu7FmrPXJkq3odkTu6NJeTh0u5turK8cLCwmAwGPDII4/g8ccfh4eHB55++mn88ssv8PLywldffWXzc7w4R/Y+RwD44osvMHPmTACw+Tl2JntyXCM7C7neLy4nJ4467qpVq2w2HKGzx7VarTh48CCWL1+O5cuXY8GCBXY/ZnV1NSIjI3H11Vdj3rx5uOuuu7p0HJdtdGs0GtTU1AAAampqEBgY2O52OWqRS3v1fPzxx9i4caPDxnS3V0tkZCSys7ORlZWFkydPOqQeV9WVPKhUqqav8/C4/D8RXTn2H//4R2g0GgwaNAhlZWWXfez2jt8aR517a2x97l3Jua3P21nImQt71mqPHNmq3tbI/bMlyeXk4VKuc7pyPJPJhBkzZmDWrFkYNmwYoqKiMGPGDADA1Vdf3elrhMvJkb3PEQC++eYbTJ8+HQBsfo6tscXv0V3I9X5xOTlx1HEPHDiAiRMnXtbxLuW4/fv3R/fu3ZGSknJZ73VdOeaKFStw4sQJ7N69u8s3Nlz23W3o0KHYtm0bhBA4dOgQ+vXr1+52OWqRS1v17NmzBx9++CE2bNhw2d1SLreWN998E5s3b4ZKpYKfn1+zP2DUdV3Jg7+/P0pLS5GRkYG4uDiHHbtv376YOHEiTCYTTp06he7du1/2sds7fmscde4XE0LY/Ny7knNbn7ezkDMX9qrVXjmyVb2tkftnS5LLycOQIUOwfft2AMD27dsxdOhQmx7viSeewHXXXYe5c+cCAL7//nssWbIEALBjxw4kJyfb9Bxby5G9z1EIgcrKSgQFBdnlHFtji9+ju5Dr/eJycuKI4+bk5ODkyZOYNGkSDh06hPvvv98hx+3Xrx/MZjNKS0uRk5OD8PBwhxwzJCQEfn5+CA4ObmqQd1qXRoA7kbq6OjFt2jQxfPhw8dZbb4lXXnlFpKent9guZy2N7r33XodOpNZWPTfeeKNISUkREydOFBMnThR5eXmy1VJYWCiuuuoqMW7cOLFo0SK71+HqupKHXbt2iVGjRonRo0eLzMxMhx577dq1YuTIkWLixIk2OXZ7x290Yf4cde6tHdvW596VnNv6vJ2FnLmwZ632yJGt6m1kz9zRpbncPDzzzDNizJgx4t577xVWq9Vmxzt//rzw8/Nr+pv16KOPCrPZLO68804xYcIE8cADDwiLxWLzc2wtR/Y6RyGEKCoqErfeemvT19r6HBt1lL2unqO7kOv94nJy4qjzbTRx4sTLOmZXj7t582YxYsQIMXLkSHHw4EGHHPPzzz8XI0eOFKNHjxZbtmzp0nFUQnAAFREREREREZE9uGz3ciIiIiIiIiK5sdFNREREREREZCdsdBMRERERERHZCRvdRERERERERHbCRjcRERERERGRnbDRTURERERERGQnbHQTERERERER2Qkb3S7kgw8+QFxcHACgoqICjzzyCKKjo6FWq9GzZ0/ce++9yMvLa9p/7ty58Pb2hkajgUajgb+/P3r37o2nn34adXV1Mp0FkW0xF0QtMRdELTEXRC0xF7bBRreLmjlzJkpLS7Fv3z7U1NTg0KFDMBgMuOaaa2A2m5v2mzVrFqqrq1FdXY3a2lp88skn+OabbzB9+nQZqyeyD+aCqCXmgqgl5oKoJebi0rHR7aJ27NiBW2+9FREREQCAHj16YOXKlRg1ahQqKipa/RqVSoWRI0di/fr1+P777/Hjjz86smQiu2MuiFpiLohaYi6IWmIuLh0b3S7qrrvuwkMPPYRHHnkEn376Kc6dO4eIiAh88MEHCA8Pb/dr+/Xrh8TERPz8888OqpbIMZgLopaYC6KWmAuilpiLS8dGt4t699138dZbbyEnJwcPPPAA4uLikJCQgLVr13bq68PCwlBWVmbnKokci7kgaom5IGqJuSBqibm4dGx0uygPDw/cc8892LRpEyoqKpCeno4ZM2Zg9uzZ+Omnnzr8+uLiYnTv3t0BlRI5DnNB1BJzQdQSc0HUEnNx6djodmIfffQRXn755abPTSYTAgIC8MMPP0Cj0aC8vByANJYiOTkZy5Ytw5AhQ3Dw4MF2v+/x48dx+vRpXH311Xatn8gemAuilpgLopaYC6KWmAv7YKPbiVVXV+PNN99EYWEhdDod1q9fj+HDh2PChAno0aMH/vCHP+Do0aMwmUzQ6/VYu3YtMjMzccMNN7T6/axWK3799VfMnDkTt956K6688koHnxHR5WMuiFpiLohaYi6IWmIu7ESQ0zIajeKPf/yjCAsLExqNRtx0002isLBQCCFEQUGBeOCBB0RsbKzw9/cXQUFBYurUqWL37t1NX3/vvfcKLy8voVarhVqtFsHBwSIlJUUsXbpUmEwmuU6L6LIwF0QtMRdELTEXRC0xF/ahEkIIuRv+RERERERERK6I3cuJiIiIiIiI7ISNbiIiIiIiIiI7YaObiIiIiIiIyE7Y6CYiIiIiIiKyEza6iYiIiIiIiOyEjW4iIiIiIiIiO2Gjm4iIiIiIiMhO2OgmIiIiIiIishM2uomIiIiIiIjshI1uIiIiIiIiIjtho5uIiIiIiIjITtjoJiIiIiIiIrITNrqJiIiIiIiI7ISNbiIiIiIiIiI7YaObiIiIiIiIyE7Y6CYiIiIiIiKyEza6iYiIiIiIiOyEjW4nVl5ejjlz5iA0NBTdunXDtGnTUFhYCADYs2cPRo0aBY1Gg/j4eKxevbrp644dO4ZBgwZBq9Vi2rRpqK2tbfq3l156Cc8//7zDz4XIFtauXQuNRtPsw8fHB76+vgCYC3JfBw4cwIQJExAcHIyePXviz3/+MwwGAwDmgtzbiRMnMGXKFAQHByMmJgZLly6F1WoFwGyQ+ykpKUFCQgLS0tKatrWXAwD48MMPkZCQALVajeHDh2PXrl1N//bpp5+iV69eCAkJweLFi5t93ZQpU/Dzzz/b9XwURZDTmjRpkrj11ltFRUWF0Ol04rbbbhM33HCDKC8vFyEhIWLVqlXCZDKJn376SWi1WrFnzx4hhBAzZswQTz31lNDr9WLs2LHiX//6lxBCiOzsbJGamirq6urkPC0im8nLyxM9e/YUH330EXNBbstisYiePXuK119/XVgsFpGbmyv69esnXnjhBeaC3JperxcxMTHi/vvvF9XV1U2v67/97W/MBrmdHTt2iD59+ggAYuvWrUII0WEOtm7dKrRardixY4cwGo1i+fLlIiwsTNTU1AghhAgPDxdfffWVyMvLExqNRhw/flwIIcSnn34q7r77blnOUy580u2k9u/fj927d+ODDz5AcHAwtFot3n33Xbz88svYsGEDQkND8ac//QleXl6YPHkyZs2ahbfeegsA4OXlBQAQQkAIAU9PTwDAn//8Z7z88svw8/OT7byIbEUIgdmzZ+OGG27APffcw1yQ26qoqEBhYSGsViuEEAAADw8PBAQEMBfk1nbs2IHi4mK89dZbUKvViI2NxbPPPot//etfWL9+PbNBbuPDDz/E3XffjaVLlzbb3tF7xHvvvYc777wTY8eOhbe3Nx5//HGEhYXhf//7HwApJ43vO405qa6uxpIlS/Daa6859iRlxka3k9q7dy+Sk5Px7rvvIiEhAT179sSTTz6Jnj17Ij09Hampqc32T05OxuHDhwEAixcvxvbt2xEfH4/Y2FjMmTMH33zzDby8vHDdddfJcTpENvfxxx8jPT0dy5cvBwDmgtxWaGgoHn/8cTz55JPw9fVFdHQ0+vbti8cff5y5ILdmsVjg4+MDb2/vpm0eHh4oKirCr7/+ymyQ25gyZQrOnDmDmTNnNtve0XtER//+z3/+E0888QSGDx+O5557DomJiViyZAkefPBBRERE2PGMlIeNbidVXl6OI0eOIDMzEwcPHsShQ4eQn5+POXPmQK/XQ61WN9s/ICAA1dXVAICkpCTs3r0bpaWlWLduHYQQeOaZZ7BixQqsXLkSQ4cOxVVXXYWMjAw5To3oslmtVrz44ot49tlnodVqAYC5ILdltVrh7++PVatWoaamBseOHUNGRgaef/555oLc2tixY+Hv74+FCxeitrYW586dw6uvvgoAUKlUzAa5jYiIiKbeGxfq6D2io3+fNm0aTp8+jcLCQjz99NNIT0/Htm3bMG/ePDzwwAMYNGgQZs2ahaqqKjudmXKw0e2kGieGWrlyJbRaLXr06IGlS5fi22+/hRCi2YQeAFBbW9vU+LjYsmXLcM8990Cn02HZsmVIS0vDvHnzcN9999n9PIjsYevWrSgsLMS8efOatqnVauaC3NIXX3yBDRs24OGHH4avry8GDBiA559/Hv/85z+ZC3JrwcHB+O6777Bnzx5ER0fjjjvuwJw5cwAAnp6ezAa5vY7eI7r6HvLYY4/hjTfewJo1a5Cbm4tDhw5BrVZj2bJl9jkBBWGj20klJyfDarXCaDQ2bbNYLACAwYMHIz09vdn+GRkZSElJafF9Tp8+jW+++Qbz58/HsWPH0KdPHwQGBmL48OE4evSofU+CyE42bNiAW2+9tdnd15SUFOaC3FJOTk7TTOWNvL294ePjw1yQWzMajTCbzfj5559RVlaGPXv2wNPTE8nJyRg5ciSzQW6vo/eIrryHfPzxx0hMTMSoUaNw7NgxDBkyBCqVyn1y4vCp28gmjEajSEhIENOnTxd6vV4UFxeLyZMni1tvvVWUlpaK4OBgsWLFCmE0GsXPP/8stFqt+Pnnn1t8n+uuu0788ssvQggh9u/fL0JDQ0VJSYlYs2aNGDhwoKNPi8gmUlNTxbvvvttsG3NB7io9PV34+vqKpUuXCrPZLM6cOSNSU1PFU089xVyQW6uvrxfBwcHivffeE1arVfz222+iV69e4p133mE2yG3hgtnLO8rBli1bmj43Go1ixYoVolu3bqKsrKzZ96ysrBQpKSlN21977TVx9dVXC6PRKObOnSv+7//+z6HnKAc2up1Yfn6+mDlzpoiIiBDBwcFizpw5oqKiQgghxL59+8QVV1whtFqt6N27t1izZk2Lr9+wYYOYM2dOs20LFy4U3bp1E0lJSWLXrl0OOAsi21Or1eLbb79tsZ25IHe1efNmMWrUKBEUFCRiYmLEM888IwwGgxCCuSD39ssvv4ihQ4cKjUYjevfuLd54442mf2M2yB1d2OgWouMcfPTRR6Jfv35CrVaLkSNHit27d7f4no899ph4//33mz7X6/XipptuEoGBgWLy5MmiqKjIXqejGCohGuZxJyIiIiIiIiKb4phuIiIiIiIiIjtho5uIiIiIiIjIThTT6C4pKUFCQgLS0tLa3Ofbb79Famoq1Go1+vfvj02bNjmuQCIZMBdELTEXRC0xF0QtMRekFIpodO/cuRNjxozBmTNn2twnMzMT06dPx4svvoiqqiosWbIEd9xxB/Lz8x1YKZHjMBdELTEXRC0xF0QtMRekJLI3uj/88EPcfffdWLp0aYf7jR8/HtOmTYOXlxfuuOMOTJw4Ee+8846DKiVyHOaCqCXmgqgl5oKoJeaClEb2RveUKVNw5swZzJw5s9390tPTkZqa2mxbcnIyDh8+bM/yiGTBXBC1xFwQtcRcELXEXJDSeMldQERERKf20+v1UKvVzbYFBASgurq6za8xGAwwGAxNn1utVpSXlyM0NBQqlerSCianJYSAXq9HZGQkPDxkv9/ULuaCHIW5kDAXdCHmQsJc0IWYCwlzQRfqbC5kb3R3llqtRm1tbbNttbW10Gq1bX7NsmXLsGTJEnuXRk4mNzcXUVFRcpdhE8wF2QpzwVxQS8wFc0EtMRfMBbXUUS6cptGdkpKCAwcONNuWkZGB4cOHt/k1CxcuxBNPPNH0eVVVFWJiYpALILC1L7jmGmD9+t8/j4gA6upa/+ZjxwLffvv75/HxQHl56/sOGQJcOGtiSgqQm9v6vv36AXv3/v75yJHAyZOt7xsdDRw79vvnkyYBBw+2vm9ICJCV9fvn118P7NzZ+r7+/sD5879/fvvtwObNre8LAFVVv///nDnAl1+2vW9BAdB4R/Ghh4D//rftfc+cAcLCpP9/8kngvffa3PX6+99C72H9cV1KT1zz31XwWfZSi310Oh2io6Pb/UPqbJiLVrhJLqrqTKh97M/o+dnaNned/tC/0XfUAExO6oFJH70Ob+aiza9hLi7gxLkA0OH7xbX3rYK5VxRuHxaNe797D+pX/t5iH+ZCwlxcwMVzceLHnZizpRC1RitWHFuPSZ++DW/P5k/tmAsJc3EBF8/F7D+/i74jB2BsQjjGfbjystoXTtPonj17NpYvX45PP/0Ut912Gz7//HOkpaXh9ddfb/NrfH194evr22J7INoIhbc3EHjBv7TXRcTLq/m+7XWz8fS89H09Pdve18Pj0vf1audXr1I139fbu+19ga7v2xgKH5/299Vqf//eHez77RPXILB/ovTJl/7Na7qIK3X9YS5a4eK5+Di9DO+fysHZkhq8cLoSc9rZ99unroF3n97SJxuYC+bCdXPRlfeLhTcOxg03j4GXpwewQ81cMBeXtq+L5eJv355GvW8oxiWH4haPKHh1C25zX+aCuWhzXyfKxcGcCuQeL8XN7ey68c9XQRUfL33y2eVdR6mEEKL9yhxHpVJh69atmDRpEgBAo9Hg7bffxqxZswAAP/zwAxYsWIAzZ84gNjYWr7zyCq6//vpOf3+dToegoCBUFRQgsOGHJoSAwWQChJBeVBeG6KLuJs14eAB+fpe2b12ddLzWqFTSnaAu7uvt7Q1PoxGwWtuu48IxK3V1nd+3vh6wWGyzb0DA739sDAbAbO7yvm/8dAr/SjsLDxXw+p1DcHVyD+nn0PjHxmhsNXBNv/+qqqbfvzOQIxcAYLFaYTKbpZ8rc9FyXxlyUV5jxPDlO2GFtG9CkBeG9NRiYFQQBkYFIalnIHy9LnhzZC6Yi1b2dbVcdGbfVT9n4q2tZzA0JhgfPzYJqsaLSOaCuXDjXDRa9u1xvPNbIVKiuuG/D4yGRmVlLpgLAK6bC4sArln+C/LOV8IXVozuE4prk3tgclJ3hGou+F3Z8DpKUY1ue2vth5Kfnw+dTidzZZdPpVIhKioKGo1G7lLsasP+PDz5mTSj5Eu3puLuUTGd/lpnfbOwt9Z+LtXV1cjLy4Oz/3lwtVx89lsu/rL+CJIitFj3x9EIUXdwN7cTmIvWMReu5cp/pCGrtAbL7xiE24Z2PBaVuWgdc+GaJr26Fdlltfj3PUMxNaVnm/sxF61jLpzPpiMFeHTdQQT5e+OnJyciTNOy50JndTYXTtO93B7MZjN0Oh1CQ0Od+o+HEAIlJSXIy8tDYmIiPNvrBuLEzpRU47mN0hiTR69M6FKDmzrPYrEgLy8PAQEBCA8Pd9puZK6Yi6zSGgDA6N6hNmlwU+cxF85LX29qys5V/XvIXI1rYS5cQ16FNL54YFSwvIW4COZC2YQQ+PcvZwAAc6+Iu6wGd1e4faMbALRaLfwu7J7hhMLDw5GdnQ2TyeQyobjQgZwKPLr2AOpMFlzRJxSPX9NX7pJclslkghAC4eHh8L+wK5ITcrVcNF4YqX2d/1ycDXPhvE6c1wMAAv28EOTfwbhA6hLmwvnp602wNDyN9fJwzsah0jAXyrZubw6O5evg7+2JuVfEOey4yl5kz0E6vAOVmQksXAjcdZf038zMSzqOwWDALbfcgrFjx+Ldd99t2q7X6zFlyhSMHj0a69atAwBs27YNI0aMwIQJE3Du3DkAwLPPPouxY8fi4Ycf7vo5OLEPf83GHf/ehYKqesSHqbFi5mB48o3B7jr1mrJBNrqSC0C6WZaYmNj0ubvk4mBOBb4+UgAAmNi3u8zVuC+5c1FXV4c777wT48aNw5/+9Kem7e6ai44IIbDs2+MAgKv5lNtu5M4Fr6Mu3b/SzkAIoHe42mFP/NyF3LnQ6XTo1asXJk2ahKuuugoAsHfvXowfPx4jRozA5oaZw90pF5szirCoodfsI5P6oJsDew2y0d2RNWuApCTg1VeBTz+V/puUBHzwQZe/1aeffoqpU6di+/bt+Oyzz1BfXw8AWLduHe666y7s2rWrKSyvvfYaNm7ciKVLl+Ktt95CTk4Ozpw5g507d0Kr1WLXrl22PEvFWrcnB89/lQ6zVeCG1J746tGx6BHo3L0SXIaNstGVXADA6tWrcb5hyQl3ysXHu3MgBDBtcCRGxofIXQ61xc65ePfdd3HDDTdgx44dSEpKQl3DsjPumouOfHfsPA7kVCLAxxN/nZokdznuS4b3C15Hta/eZMGijcfwzzSpm+1fpyTBgw80HMvOucjIyMBDDz2EtLQ0/PTTTwCAxYsX44svvsAPP/yAnJwct8vF8s2nYBXAzOHReHRygkOPzUZ3ezIzgfvvl2bhs1ia/3fePOD06S59u/3792PcuHHw8PBAamoqjh+X7r4/+OCDmD17NvR6PawNM/4NGzYMVVVVqK6uhkajwYEDBzB27FgAwPjx47F7927bnqsCbT1ZjEVf/j6Ge9XdQ6D1Y9dARbBhNrqSi7q6OmzduhXDhg0DALfKRY1BGg4zLI4NbsVyQC62b9+Os2fP4sorr4RWq4W/v79b56I9FqvAaz9K69DeP743IoJ4w1YWMr1f8DqqbfUmC6b/61d8tFvqAfDIpD6YMoA9QRzKAblIT0/H999/jwkTJmDNmjWoqamByWTC/Pnzceedd2Ly5MlulwtdnQkAcNeoGIc/xWejuz3vv9/2WnoqFbB6dZe+nV6vb5r9T61Wo7q6uunfioqKkJqaiuHDhwMAIiMjcfXVV2PevHm466672v1aV7TzdCke+mg/LFaB24b0wpPX9nW5Li5OzYbZ6EouVq1a1az7k7vkotZoxm/nKgAAYZxATbkckIuKigpERkZi8+bN+Oijj1BaWuq2uejI8UIdzpTUQOPrhT+Oj5e7HPcl0/uFu19HtWfn6VKkF+ig9fPCh/eNxF+nJvEay9EckIu4uDi88sor2LJlCz788EOUl5fj4MGDWL58OZYvX44FCxa4VS52nSlDfqXUOyxUhmspNrrbk53d9hp2Qkj/3gUajQY1NdIMqjU1Nc1mTI+MjER2djaysrJw8uRJrFixAidOnMDu3bvx+OOPt/u1ruZ8VT3u//A3GMxWXN2/B/4+fSDfDJTGhtnobC4OHz6MAwcOYOLEiZ36WleydncOSqsNiA7x5+zLSuaAXAQHB2PSpEnw8vLCiBEjkJ6e7ra56MjhvEoAwJCYYPaSkpMM7xfufh3VEX291HNqUFQwJvYNl7kaN+WAXIwePRpjxoyBj48PRo8ejaysLPTv3x/du3dHSkoKysrK3CYXVqvAM18cBQDcPSoG0SEBDq+Bje72xMW1fxcqLq5L327o0KHYtm0bhBA4dOgQ+vXrBwB48803sXnzZqhUKvj5+UGlUiEkJAR+fn4IDg5GTU0NhgwZgu3btwOQuhcOHTr0Mk5M2fafq0CdyYKE7hq8NWsIfLz4MlUcG2ajs7nYvXs3Tp48iUmTJuHQoUO4//773SIXQgis3dPYBTCBeVAyB+Ri2LBh+OWXXwAAhw8fRmVlpVvmojOyG5YJ69tDK3Mlbk6G9wt3v47qSOOM/j055EI+DsjF4sWLsXnzZlitVuzfvx8DBgyA2WxGaWkpcnJyEB4e7ja5KKk2IKu0Bp4eKiy8Tp75PXj11p777mv/LtS8eV36djNnzsTmzZsxcuRITJ8+HW+++SYyMjIwY8YMvPzyyxg/fjwSEhLQt29fPPHEExg/fjymTJmC5557DnFxcUhISMAVV1yB4uJijBs3zgYnqEyNTyeSIrTw9XKN5Qlcjg2z0dlcPPjggzhw4ADS0tIwePBgvPfee26Ri2+Pnkd2WS3UPp64eVCk3OVQexyQi4cffhgbN27EyJEjMWHCBNxyyy1umYvOaFxiL4KTb8pLhvcLd7+Oas+pIj02HMgDAIzqHSpzNW7MAbl44okn8Pe//x3jx4/H7bffjtDQUCxduhTXX389ZsyYgaefftotcmE0W/Hmz9Ks8BGBfrL1fFIJ0dZv3PXodDoEBQWhqqoKgYGBqK+vR1ZWFuLj49tep/uDD6QXvkolhaDxv6tXA3PnOrL8dnXqXBROCIG0UyV44D+/wWQR+NesobgutafNvv/Fv3+SXFIuAKfIhrPn4nxVPaas3IaqOhMevTIBT03pZ/NjMBetYy6cm9FsxbD/txn6ejM+e2gMRnRxAkLmonXMhXM7nFuJ2av3QFdvRkJ3DTb+aSw0vl6d/nrmonXMhXKV1xhx/4f7cCCnEgDwwi0DMGdMnE2P0dlcdD5p7mruXGDcOCkA2dlSd49584AEx04z78oqa41Yvz8P6/bk4GxDd8BrkntgakqEzJVRu5gNu3vtx5OoqjNhYFQQ/u+qxI6/gOTHXCjChgN50NebEabxxdCYbnKXQ8yFIizffAq6ejOGxgRj9b0jutTgJjtgLuzu5e9O4EBOJbR+Xlhxx2BcnSzfvDhMW2ckJADLlsldhUt6d9tZ/OPHkzCYpSU+1D6emDakF/46hTNpOgVmw27yK+vwxcF8AMCSmwdwLLczYS5kVayvxyvfnwAAPDypDzy59rAyMBeyyymvBQD8dWoSunElDGVgLuymsKoOnx+UhlKsvncERsbLu+QqG90kq//szobBbEVShBazx8TilsG9eOeVCNLSFmarwNCYYAzhkzqiTqk2mHHfB/tQUWtCvx5azBkTK3dJRIpRVm0AAIRpfGWuhMj+vjlSCJNFYERcN9kb3AAb3QCkscTOzlnPwdjwhPsfMwYhpVeQzNXQhZz1NXUhZz6How0TCvYJ18hbCDXjzK+pRq5wDm158esMHMvXIVTtg7dnD4O3J3uIOIIrvKZc4Rw6Um+SrrkCfDhJrSO4wmvKmc8h7WQJAOC6FNvND3U53LrR7eUlnb5er3fqrsxCCJSUlEClUsHb27nWIq0zWgAAft58A1AKb29vqFQqlJSUIDw83Gmz4cy52LA/Dx/ukpYJm8A1VBWBuXAO+7LLAQAv3ZaKuDC1zNW4PubCeZgtVhgtUqOb11z2xVzIz2Sx4rdz0vvB+MQwmauRuH2jOzAwEGVlZSgrK5O7nMuiUqkQFRUFT0/n+UNarKtHtcEMAND6ufVLUVE8PT0RFRWFvLw8ZGdny13OZXHGXOjqTXjmi6MAgAcm9MZNXCZMEZgL5TOarTivqwfAHiKOwlw4j8brLYBPuu2NuZDfyfN61JusCPTzUsz7gdu3dCIjIxEWFubU3ScA6a6aswVi2XcnYBXAoOhgdNdyfJGSaDQaJCYmwmQyyV3KZXHGXBzJrYLBbEVUN388PTVJ7nLoAsyFsm07VYJaowXhWl/E8ym3wzAXzuHEeT0AIDLIj0+6HYC5kFduw6SBcWFqeChkMk23b3SrVCr4+rLB52iFVb/PzPzCzQOctuuNK/P09HTKP7TOLr2gCoB0M0opbxT0O+ZCubZlSuP3bkjtyRnLHYy5UL6DDesUD4wKlrUOd8JcOJ7VKvDffTlY9q20gkVcqHJuwLp9o5vk8e3R8wCA4bHdMCg6WN5iiBTkdHE1AKBvd63MlRA5l/yKOgBAQndldCUkUpLG+Q6Gx3E1DHJNQgj8ad0BfHdMamMMjg7GX6f2k7mq37HRTQ5Xb7Lgve1nAQC3DOZ4VaILHT+vAwD07cGGA1FnHcuvQtop6Ul3/568YUV0ISEEDuVWAgCGx8m/dBKRPZwpqcF3x87Dy0OFp69Lwh/Gxiuq1xMb3eRwn/2Wi8KqekQG+WHG8Gi5yyFSDIPZghOF0ri71CguoUfUGUIILPz8KCxWgRsG9sSwWDYqiC5UpDOgvMYITw8VkiJ4U4pc048Z0hPuobHdcP/43jJX0xIXsCSH23+uAgBw96gYTuZBdIHSaiPMVgEfTw/0CvaXuxwip7A9sxRH86sQ4OOJv900QO5yiBTnVJF0MzcuNIDXXeSSDudWYuXmTADK7UXLRjc5lBACxwqk7rMJHLNK1IyuTprlNNDfi5MLEnXS+v15AIA7hkcjnCthEDVjMFuwZmcWAKBvD153kWta8nU6jBYrpgzogbtHxshdTqvY6CaHOppfhdPF1fDx8sCY3qFyl0OkKPUmCwDwSQRRF+jqpZtVAyIDZa6ESFmMZiv+tPYgtp4sga+XB+4fHy93SUQ2V1VrwsGGOQv+puAVkdjoJof6/IC0TNjUAREICvCWuRoiZSmtNgIANL6cboOoMypqjDiSJy2zF+jP9xSiRiaLFY/99wC2HC+Cr5cH3rt3OOc7IJd0rKAKQkjDJ3oGKXdonuyN7uLiYkybNg3BwcEICwvD/PnzYTabW9339ddfR3x8PAIDAzFw4EBs2LDBwdXS5bBaBb45WggAmDZEmeMtlIK5cE+7z5YBAIbEcEmX1jAXdLFXfjiB8hoj+vXQ4sp+3eUuRxbMBV3MYhWY/79D+CG9CD6eHnhnznCMTwyXuyyHYi7cR1mN9MCiR6CfzJW0T/ZG98yZM6HRaFBQUIC9e/diy5YtWLFiRYv9vvvuO7z00kv4/vvvodPp8Pzzz+OOO+5Adna244umS5JeoEOJ3gCNrxfGJbjXH/+uYi7cU+Mkg6N782lEa5gLutjus9Law3+d2g8+XrJf0siCuaALCSGw6Mtj+OZIIbw9VXh79jBM7Ot+11zMhfuoNUg3U5TeS1DWd6jTp08jLS0Nr7zyCgICAtC7d28sWrQIq1atarHv8ePHIYSA1WqFEAKenp7w8fGBl5eyf8D0u51nSgEAo+JD3PbiqDOYC/d0MKcCGQ2TDA6KCpa3GAViLqg1RrMVABCqcc8J1JgLuthXhwuwbk8OVCpg5cwhuDLJ/XqAMBfuxWwVAKCoNblbI2vLJz09HSEhIYiM/L2rcXJyMnJyclBZWdls37vuugs9evRAcnIyvL29MWPGDHzwwQeIiopycNV0qbaeKAYAjE8Mk7kSZWMu3M/2zBLc/e4eGC1WjO4dgtjQALlLUhzmglpjtEiNbh9P97yRy1zQxX5Il9YqfmBCb9wwsKfM1ciDuXAvJXoDACBE7SNzJe2T9V1Kr9dDrVY32xYQIF1sVldXN9tuNBoxePBg7N27F7W1tXjnnXcwb948HD16tM3vbzAYoNPpmn2QPAqr6vBbQ9fZq/r3kLkaZWMu3M9f1x9BncmCCX3DsfreEYqdeVNOzAW1prFbob+Pe874z1zQxQ6cqwQAXJXkvtdazIV7OV0i/U5jFP7AQtZGt1qtRm1tbbNtjZ9rtc3XEnz00UcxYMAAjBgxAj4+PvjDH/6AMWPG4IMPPmjz+y9btgxBQUFNH9HR0TY/B+qcD3Zmw2IVGBUfgugQZYdCbsyFe6kzWlBYVQ8AePPOIVArfEySXJgLulhlrRE1RmmZvQiFT6BjL8wFXaxxCT13zQTAXLgTq1Vg1xlpEtrhCp+dX9ZGd0pKCsrKylBUVNS0LSMjA1FRUQgKCmq2b05ODgwGQ7Nt3t7e8PFpuyvBwoULUVVV1fSRm5tr2xOgTvvlVAkAYM6YOHkLcQLMhXuprJNm3fTyUCHQnw3utjAXdLG0k9L7Sq9gf7d90s1c0IWqak2obbgR5c7vJ8yF+zhXXovyGiP8vD0wJCZY7nLaJWujOzExEePGjcP8+fOh1+uRlZWFF198EfPmzWux780334xVq1bhwIEDsFqtWL9+PbZu3YqZM2e2+f19fX0RGBjY7IPkUWOUugD2DHbfO6+dxVy4FyHN/wEPDxW7lbeDuaALmSxWvLX1NADg7lExMlcjH+aCLrQnS3ri1ydcjeAAZY9vtSfmwn3klEs9GGJD1PBW+Nwest8GW79+PR599FHEx8fDw8MDc+bMwaJFiwAAGo0Gb7/9NmbNmoXnn38enp6emD59OsrLy5GYmIiNGzdi8ODB8p4AdYrBJE1248tZyzuFuXAfZovU6vZS+KybSsBcUKPXt2Qis7gaQf7euGd0rNzlyIq5oEaNDZABkUEd7On6mAv3kF9RBwDo1c1f5ko6phKi8TmL69PpdAgKCkJVVRXvSjnYkBd+REWtCT8+PgF9e2g7/gI74O+/dfy5yOvEeR2mrtyOMI0PfnvuGocfn7//1vHnolyFVXUY+/efYRXAP2cNxfWptp+hmb//1vHnomxv/JSJ5ZtP4a6RMVh2W6rNvz9//63jz0U+y388iTd+Po1Zo2Kw9Fbbv+Y7o7O/fz52JLuzWgX09VL38kA/b5mrIVKWihpp0ptAf2aDqDMKq+phFdJYbns0uImcVb1JGs/NXoXkLkqqpfH4PZxg4kCmkuyuotbYtHC90tfQI3K0shrpDSOU2SDqUL3Jgve2nwUAaP1kHyFHpCiVddJNXHedWJDcT+PqL2EaX5kr6RjfscjuThdL6+dFdfOHD+++EjVTUSPNXs4bUkTts1gF5qzei73Z5fD2VGH+1X3lLolIUfZmlQMABkVxTDe5PiEEjuZVAQCSesozdLUr2Ogmu8so1AGAbGO5iZSsRN/wpNsJ7tISyelYfhX2ZpfDz9sDa+aOxJg+oXKXRKQYBZV1OF1cDQ8VMKZ3mNzlENldYVU9ymqM8PJQIbmn8sfS87Ej2d3BnEoAwODoYFnrIFKixtlmo5xg5k0iOTWOV40M9meDm+gi205J69YPiemGoADOEUKu7+R5PQCgd7gaft7KH1LBRjfZXWMoUnuxuxPRxQ7lVgIA+rEnCFG7CqqkpWFC3Hj9YaK27DhdCgAYn8in3OQeivXSeO5ewc7x0IKNbrKrGoMZWaU1AICE7hqZqyFSloLKOmSX1cLTQ4WR8SFyl0OkaMfypaFKKbyBS9SMEAK7z0rjucf0Zi8Qcg/1JisA55k4kI1usquNh/JhtFgRFxrA7rNEF8lsmGSwT7gaWi6nR9SuU0VSr6n+TjBhDpEjZZXWoLTaAB8vDwziUD5yExW10kS0Qf7O0fuJjW6yGyEEPtiZDQC4Z3QsVCqVvAURKUxWidTojg1Vy1wJkfI19prqHc5eU0QX+jGjCAAwOCrYKca2EtlCZa20RF6I2jkeWrDRTXbzy6kSZBZXQ+PrhTtGRMtdDpHiND7pTuTQC6IO6RrWIO7GMd1ETYxmK9bszAIAzBgeJXM1RI5jMEuTa/p5OceNJja6yW5+SD8PAJg+tBcC2XWWqBmrVWBbpjTb7IBIjlEl6oizjd8jcoTfsstRpDMgTOODWwb3krscIoepNTY0up2kdwcb3WQ3+89VAACuSOBMmkQX2322DLnldQj088JV/bvLXQ6R4gkIAIAHRyoRNdl1tgwAMD4xHD5evKwn92C1CmQ3DDkK1ThH7yemk+wiv7IOp4qq4aECRsRxVmaiix3IkW5KXdW/h9PcpSWSS0WNESaL1Ohmzymi351pmBuEy7KSO3n9p0wczquCt6cKg51k8kA2uskutp2Sus0OjemGELVz3IEicqQTDevXJ/bgeG6ijpxsmLm8V7A/1L5eMldDpBzZpbUAgJ5BfjJXQuQYueW1eP2nTADA0mmpTjO5JhvdZBf5FXUAgOTIQJkrIVKeC9dUdZY7tERy2t3QhZZ5IfpdZpEeGYU6eHqoMCyum9zlEDnEeV09ACA2NMCpJmpmo5vsorxh7TzOMkvU0pkSaU1VP28PDIvlhRJRR3adkRrdYzlHCFGTjYfyAQBX9uuO7lo+6Sb3UNWwVJi/kw3NY6Ob7MJolmaZ9fXmS4zoYodzKwFIY/B8nWSpCyK5mCxWHM6rBACMjOccIUSNfjpeDAC4YWCEzJUQOc7ebKmn4KCoYHkL6SK2iMgu9PXSXSgNx94RtXCuXBqD17eHVuZKiJQvp7wW9SYr1D6e6BOulrscIkU4cV6HE+f18PZU4cp+XAGD3MeRhpuww51sSAUb3WQXueXSmO6obv4yV0KkPHVGMwBwQiiijmRmovi1VQCAHkY9VKdPy1wQkTJ8ui8PAHB1/x4I5lA+ciPnyqQHF326O8cEao3Y6Ca7aJzkoGcQG91EFztTIq0tGRHIMXhEbVqzBkhKQu73WwEAkdmngKQk4IMP5K2LSGZCCHx3rBAAcNvQKJmrIXIci1WgqKGNERXsXG0MPmYhmzOYLSivkSZS6671lbkaIuU5ll8FABjEmZgVr6amBp6eHHfvcKdPA/PmQQiBdL9AmGsqEV2WB1itwLx5wLhxQEKC3FUSyeKLg/korKqH2scT4xM5uSC5j4paI6xC+n9nW5KYjW6yudPF1QCAQD8vpwsEkSNUNMzuz3VVlS8yMlLuEmjPemDPeoQOvk76XKUCVq8Gli2Tty4iGWQU6PDMF0cBAPPG94afk83gTHQ5SqsNAIBuAd7w8nSuDtvOVS05hcO50lO8pJ6BUKlUMldDpCw1BjNMFuk2baC/t8zVEDmPXroS6X+EALKzZa2FSC4rt5xCvcmKiX3D8eerEuUuh8ihKmqkiZqd8aEen3STzW09KS1hMZ7rqRK1kFshTQASHODN2f2dQEFBAQIDA+Uuw/0sXgysXIkaqxU9GjbFV0trdUOlAuLi5KqMSDa6ehPSTko3nxZenwRPDz7YIPditkpLEvs44XKrvOIjmzJbrNh9RrowmtgvXOZqiJSnsFKaAKSXk00A4q7UajXUai5T5XAPPQSsXAlxwabuNVIvKgghjesmcjNZJTUwWqwI1/qiH5ecJDdUope6l2v9nK8JK3v38uLiYkybNg3BwcEICwvD/PnzYTabW933l19+wahRo6DRaBAdHY1lHM+lOMcL9dAbzND6eWFAZJDc5Tgt5sJ1NU4y6Ixdo+TGXLiRxERg9WqUqYObNmnNdYCHhzSem5OoNWEu3Ie5YQYpf29PDt/rAHPhmo42TETbP8L5bjrJ3uieOXMmNBoNCgoKsHfvXmzZsgUrVqxosd+JEydw/fXX45FHHoFer8c333yD1157DevXr5ehampLYZW0PnfvcA27PV0G5sJ11ZksAIAAH+frGiU35sLNzJ2L91b+/jvzf+Rh4ORJYO5c+WpSIObCfdQ3vH/4ect++a54zIXrMZqt+PpwAQBgTB8nHMIqZJSZmSkAiPz8/KZtn3zyiYiJiWmx76OPPiruvvvuZttOnjwpCgsLO328qqoqAUBUVVVdetHUrvW/5YrYBZvErHd3y11KC87y+2cuXNvq7WdF7IJN4pGP98tdihDCeX7/zIX7qaozij5PfS4ACACiurraccd2kt8/c+FefjhWKGIXbBK3rNohy/Gd5ffPXLimn48XidgFm8SI/7dZGM0Wuctp0tnfv6y3ytLT0xESEtJsSZbk5GTk5OSgsrKy2b579+5FXFwc7rrrLoSFhaF///5IS0tDREREm9/fYDBAp9M1+yD7yimXJonieNVLx1y4tqzSGgBAVAgz0hXMhfvZc7YcRotV7jIUjblwL40rX/h48Ul3e5gL13SsoWv5uIQweDvZcmGAzN3L9Xp9iwlqAgICAADV1dXNtpeXl+ONN97APffcg/Pnz+Ptt9/GU0891W73j2XLliEoKKjpIzo62vYnQc2kF0iBSOiukbkS58VcuLbGjPSP4IzYXcFcuJ8tGUVyl6B4zIV7KaiUhvBx5Yv2MReux2yx4suGruUDejnnnFGyNrrVajVqa2ubbWv8XKttPkDe19cXt9xyC2644QZ4eXlhwoQJmD17Nj799NM2v//ChQtRVVXV9JGbm2v7k6AmRrMVuxpmLh/TJ1TmapwXc+G6DGYLjuVLd8SHxATLW4yTYS7cS73Jgm+PFspdhuIxF+5lU0MmJnF1mHYxF67ns/15OF1cjRC1D24fFiV3OZdE1ltlKSkpKCsrQ1FREXr0kFbizMjIQFRUFIKCmt/FSE5OhsFgaLbNYrFACIG2+Pr6wtfX1/aFU6syi/WoMVoQ6OeF5J58inepmAvXlVUqLfcS6OeFmJAAuctxKsyFeynS1UNvMHPCqA4wF+5DX2/CkbxKAMCUAW13fSbmwhXtyy4HANwzKgZB/t4yV3NpZH03S0xMxLhx4zB//vz/396dh0dV3/sDf0/2ZCYr2QgkJJAIhIAgYkCxotUCl7aiVNFaWrxUitzll7b3dxUttWortrZKH61XrVRU8JZCW38odUOgFJWC7CQBEpYkZM8kmTWZzHJ+f5xJWBLITDIz3zPnvF/Pk+dhhknOZzK8Oed7vhssFgvOnj2Lp59+GssG2H9zxYoVePfdd7FhwwZIkoTdu3dj48aNWLJkiYDKaSDlDXIP3oTsJERw5fIhYy7Uq65dHhqYNyKB2734ibnQlm6nPJc7HOfthRJzoR3H682QJHnNnKykONHlKBpzoTJVVXAcPAwASN3xEVBVJbaeIRJ+NtuyZQtcLhcKCgpQWlqKefPmYfXq1QAAg8GAjRs3AgBuu+02bN26Fb/97W+RnJyMBx98EL/+9a/xzW9+U2T5dJHeZfxLx6YJriT8MRfqdKZVnkuWP0I/yCtpIMyFdnxwXB5GOz4M92INNeZCG0xdTgBAdjIb3L5gLlTijTeACRPgqD4LAIj/6ANgwgRg/XqxdQ2B8JUYsrKysHnz5gH/7vLFDubPn4/58+eHoizyk7nbiT3VbQAQtnMtlIS5UKfelcvHZXChwaFgLrRj21G50b14Ri7+KrgWpWMutEIe7swxUr4RkQubzYbIyMhh/xzyqq4Gli2DJEkwup1w2ToR22UDPB5g2TJg9mygsFB0lT4T3ugmdag12iFJQLohBmPYi0c0oE673FORbogRXAmRsnXYewAARVm8QUUEAD3e7cI45UK5Lt6ijALs3TUAgMjRk+THOh2wbh2wZo3AovzD5FJANJu7AXDYE9HVtFjknKTq2egmuhKbw4UO7w2qlHhmhQgAunvcAMDFBUnTsqzyqFpIEnDunNBa/MWebgqI3h681AReIBENxO2RUNloASAvNkhEA9t3rh1uj4TRqVwwiqhXZ5c8+iOF11mK1dDQgKQknt8D5qc/BdauxY6RE/DN+goAQHFns/x3Oh2Qny+utiFgo5sCYtepVgBAQTqHlhMN5GybFV1ON+KjI5kToqvoXZTzK9dwL2KiXjaH3NOtj+WcYaXS6/XQ63l+D5gVK4C1a2FMzQa8je6+cR6SJM/rDiMco0LDZu524kPvSrP3Xp8ruBoiZaro7eUemYhIbqlHNCCHy40PjjUBABZdN0pwNUTK4XBxGz3SmKIiYN06uCIv2pc7IkL+WrcurBZRA9jopgCobrHC6ZaQmRiLklHJosshUqR2qwMAkJMcL7gSIuWqMdrR5XQjMTYK1+Wlii6HSDEaOrsAgFMuSFuWLkX1v/3XhcdlZcDJk8DSpaIqGjIOL6dhqzHK2yBxyCzRldmd8tDAhBgODSS6kt697Asy9NDpOCKEqNc5XmuRRh23XPTgqaeAMB3Cz55uGrb6Dvnua25aguBKiJTL5d3uJYpDA4muqLpFbnQXci97okuc915r5fFaizREkiScbbWJLiMghnT1V19fj/r6+kDXQmGqvlPeBmlUiraHzTIXdDVOtzwfLyZSW713zAX540ybfHE1NiM8ezJ8xVyQP2wOF9pt8urlOSq+1mIu6HIWhwsWh0t0GQHhV6P7s88+Q0FBAfLy8pCXl4esrCw88sgjMJvNwaqPwsD5DjsAICdFm/OMmAvyhaVbPmnoY7Uxq4e5oKE4r/KRU8wFDUXvCJA0fQyS46MHeXX4YS7oSnr3p1cDvxrdP/jBDzBp0iTs378fR48exXPPPYdPP/0U06dPR1tbW7BqJAWrarbgs2r5s9fqImrMBQ1GkiTs1ti2eswFDUVvb15GYqzgSoKDuaCheH3PWQDA9DHqXFyQuaArOa2SoeUAoJMkSfL1xfHx8Th69CiKior6npMkCffeey+io6PxzjvvBKXIQDGbzUhOTobJZOLm9QHyfzcfweYD5zFvUjZeWTJddDlXFazPn7mgwew9Y8R9r+1FQkwk9j1+OwwK6u1mLgbGXIhx07M7UN/Zhb+uvBHT8lJhs9lgMMjzu61Wa8j2wGUuBsZchF6t0Y6vPLcTOh2w7T9uRnGOuN87czEw5iJ4Xt5VjWe3HkHdC98CENrzgK98/fz96umeOHEimpqaLnlOp9PhqaeewnvvvTe0Sims1bTLQ8sXTBkpuBJxmAsazBufyb0Ud07NUVSDO5iYCxoKl8e79kGUOhccZC7IX+UNJgDAlFHJQhvcwcRc0JX0LtasBn6d1ZYuXYrly5ejtrb2kudNJhOSk7U5tFjLup1unPbOM0o3qHMooC+YC7oao9WBTyqaAQD/elOB4GpCh7mgofCuN4gIlW4XxlyQv84aexcXVO+K/swFDaTN6sCOEy2iywgYv7pcysrKAADXXHMN7r77bkydOhVutxsbNmzAc889F4z6SMG2HDgPo60HOclxqp1n5Avmgq5m58lWeCRgUk4SirISRZcTMswFDUXvjDe1NrqZC/JXi9kBABiZrN7FapkLupwkSfj3dw6i0dSNgvQE1IkuKAD8anQ3NTXh0KFDOHLkCA4fPoz169ejqqoKOp0Ozz77LLZt24YpU6ZgypQpmDdvXrBqJoXYUyUvbvGdWWNUOxTQF8wFXc3H5fKQua9OzBJcSWgxF+Qvp9vTtzVMQkyk4GqCg7kgf7Va5Ua3mkcUMhd0uRNNFuw9047YqAi8eP91uPZx0RUNn1+N7szMTMydOxdz587te667uxvHjh3D4cOHceTIEWzduhXPPPMMOjs7A10rKUyHXV5ldnSqOrd28RVzQVfS7XRjd5W8avncSdpqdDMX5K/TrVb0uDxIjI3CKJXuRcxckL/MXU4AUOVWYb2YC7rcP88YAQClY0dgXKY6plYMe0WfuLg4zJgxAzNmzAhEPRRGTN4TQYqKTwRDxVwQIN+p7XZ6MEIfg+KR6lwAxx/MBV1Nq0Xu0RuVGo+ICHUOLx8Ic0FX02aVOzjSDDGCKwkt5kLb6jvlBdQmZKtnWp52xwTTsHXa5UZ3aoK2TgREvupddXbiyCToVDpHlShQHE55FbVYDU9XIrqY0epAjXchtewk9c7pJrqcpVueaqSPUc+OLzyz0ZCpfWsXouH6vFoeHqXlhQaJfOVweRvd0eqcz03krye2lsPe48b4rERco6GFOInOtMk3m3LT1DPViK0lGpIOWw/MXfJdKDa6ifrzeCR8flpebPDmonTB1RApn8PlBsCebiIAqG6x4P2jjYiM0OHX91yLSA1NuSCq9m5JrKabTTyz0ZC89UUNetweTMpJQv4IbS+kRjSQikYzOuxOGGKjcG1uiuhyiBTP6ebwcqJefzsm73zxlaJ0TB7NvapJO+w9LrTb5LUMctPU08bgmY2GZMeJZgDAgzcVcK4q0QAO1XYAAK7PT0V0JP+rJRpMRYMZADBCr96tkYh8tb1Svs6aV5ItuBKi0KpttwOQV+xX06r9vBIkv7k9Ek42WwAA1+WliC2GSKF6h0aNV9HKm0TB4vFIeO9oIwDgX6aMFFwNkVhGqwNHz8sLcd46PlNwNUShdaZVns9dkK4XXElgsdFNfmuzOtDt9CAyQoc8FQ37IAqk3ju1+SPUddIgCoZGczfabT2IjtThpnEjRJdDJFRvg3tchh6ZXLWcNOZwXScAYOJIdXVaCG90t7S0YOHChUhJSUF6ejrKysrgcrmu+j3Hjx9HQkICdu3aFZoi6RK9d6AyE2MRxWGzQcFchL/ePSZzUtSz8qZozIV69W6LlJuawPOKn5gL9alolKdalIziXO6hYi7CV9/0vDFpgisJLOFntsWLF8NgMKChoQH79u3D9u3b8cILL1zx9Xa7Hffffz+6urpCWCVd7L2jDQCAWeyNCBrmIry5PRLOGXt7ujkaJFCYC/VqtTgAAFns1fMbc6E+Dd6btmM4UmrImIvw1Xs+yFPZ9ZPQRnd1dTV27dqFX/3qV0hISMDYsWOxevVqvPTSS1f8npUrV+Kuu+4KYZV0uc+r5W2QvnFtjuBK1Im5CH87T7Sgx+VBfHQkRqeq66QhCnOhbr0jQzISuYiaP5gLdWrxNjqYh6FhLsKX2yP1/ftP08cIriawhDa6y8vLkZaWhpycC4234uJi1NbWorOzs9/r33rrLVRXV+OJJ57w6ec7HA6YzeZLvmj4upzyXqoZBp4MgoG5CG9uj4RnPqgEACy9KZ97qwYIc6FuR7xz+EpGJYktJMwwF+pktMqNjnSVNTpChbkIX6dbrbD3uJEQE6m6NXGENrotFgv0+kt/oQkJcq+Q1Wq95PkTJ07g8ccfxzvvvIPIyEiffv6aNWuQnJzc95WbmxuYwrWsqgp2szz3Lu7F3wJVVYILUh/mIrwdrO3AmVYbEuOisHLOONHlqAZzoW7H6+WL1imjU8QWEmaYCxWqqkJjrbxdWObGN3idNQTMRfg63yFPzStI16uu00Joo1uv18Nut1/yXO/jxMQLK9Z1d3dj8eLFWLt2LfLy8nz++atWrYLJZOr7qqurC0zhWvXGG+ieNBkWRAEAMl78DTBhArB+vdi6VIa5CG+fVrYAAG6bkInEOPXsLykac6Fe5m5n3/DyiSPZ0+0P5kJl3ngDtslT0Qh5JGHhi7/kddYQMBfhy+H0AADio327ARJOokQevKSkBEajEc3NzcjKygIAVFRUYPTo0UhOvrBi4/79+3Hq1CksW7YMy5Yt63v+61//Or773e/i5ZdfHvDnx8bGIja2/xBom83m890s8qquBpYtw9mkTLhsnYh3dsNg9w6nWbYMmD0bKCwUW6NKiMoFBcbuU60AuLdqoDEX6tVh6wEAJMREIjmeN6r8wesoFfFeZx1LHwOXrRNp9k4k8jprSHi+CF8ddicAqPNcIAk2e/Zs6b777pPMZrN05swZadKkSdITTzwx6PcBkHbu3OnXsUwmkwSAXwH6agYkCZCkyEhJevTRof0DCKHez99kMokuZVAichEOvxel67A5pDGPvC+NeeR9qdXSLbocn4TT589cqFNFg0ka88j70nVPfdzv76xWa985x2q1hqymcPr8eR2l3i+lXWcxFwMLp9+L0j334QlpzCPvS6v+crTvOVHnAV/5+vkL3zJsy5YtcLlcKCgoQGlpKebNm4fVq1cDAAwGAzZu3Ci4QhqUJAHnzomuQlWYi/B0sskCABidGo90LjQYcMyFOrV5F40aYeCiUUPBXGgAr7P8xlyEp9496sdnJQ7yyvAjdHg5AGRlZWHz5s0D/t3lix1cTJKkIR+zoaEBSUmcN+aXn/4UWLsW/zXn+3hlx2sAgL6NkHQ6ID9fVGWqJCIXNHynW+VFBgszDYIrUSfmQp1auT3SsPA6SiW811n/M2Uu/u/hDwDwOms4eL4IT5XeRrcad7IQ3ugWQa/X91vVkAaxYgWwdi3aU7P7nupbU1CS5PlGRBpXY5Qb3Wrb5oIomMxd8hy+lHj2dIcLXkcFgfc6qybzwq4XvM4iLbE5XGg0dQMACjPY001aVVQErFsH46fGC89FeGcnrFvHxT1I26qq4Fr3B2xzTQWiDJgU2SW6IqKw0TtCJDs5TnAlRAIVFcH5+jrs+af7wnO8ziIN6R31pI+JRHKC+hZSEz6nm8LI0qWwFRRdeFxWBpw8CSxdKqoiIvHeeAOYMAE7/vp3nI8yIM1uwjfuvplbvBD56MuaDgDA9WNSBVdCJNbe2QtgTEi58ASvs0hDetzydmExUepsnrKnm3zmcLnRZHddeOKppwAOL1MNbgEzBN4tXiRJwt9H5MFl68TXTnyGuJ5ubvFC5KNGkzwyZBzXQiCNO91y2VxjXmeRhth75FEeCTHqbJ6q811RUNS1d8Ht4QITapWTkyO6hPD2xSbgi03InXSb/Fink4cErlkjti4iBfN4JJj65nSrbzghkT/OtNlEl0AkjN0hd+wlxKizA0id/fcUFFaHa/AXEWnctMaT8h+4xQvRoBwuD3oXC06IZT8AaZfHI+Gj8ibRZRAJ4/AOL4+NVmfzlGc48tkp7x7EpE7cAmYIvFu87BuRh9tazwEAJrfXy3/HLV6IBmVxyL3cOh0Qp9J5fES+KG8wo9nsgIE3n0ijelzeOd2R6jwXMNnks80H6kSXQEHELWCGwLvFS0P6GMDb6O47VXCLF6JBNZu8e3QbYhGl0gstIl98droNADCjIA2VgmshEsHmHVGrV+mNJ57hyGenmq2Dv4hIS7xb6TUkZ154LiJC/uIWL0SDavAuojaS24WRxh30ruI/g6v4k0a123oAACkJMYIrCQ513kqgoOgd9kFEF1m6FC2OUcDezfLjsjLg4YfZ4CbyQbO5GwD36CZt6+px44C30T15dLLgaojEqO+Ub8LmpKjzfMBGN/nE4XKjy+kWXQaRIh1ovygb3OKFyGe9N3PVukUMkS/+5++nYbT1YFRKPBvdpFnmLnl4eapKe7o5vJx80mmXF7uJ0AkuhEhh2qwOVLdymxeioejdlzVCx5MLaZPbI+EPe84CAB5fMBGxUercLoloMF1OudGt1kU11fmuKOC6vb3c8dE8GRBd7FQzV/UnGqr959oBACWjuHMCadPZNiusDhfioyMxd1K26HKIhHG65f0jY1R644mNbvJJ79Byte6dRzRUde120SUQha3qFnmBzmtzU8QWQiTIae9IqWuyDIjkcELSsBaLvJuFIU6d043YgiKfWLrlIR+JKg0C0VD1Tr0gIv95JG/PBrcLI42q75AXj8pIVOfiUUS+sPe4UF5vAgBcl5citpgg4VmOfGLtVvfeeURD1e3kqv5EQ9HtdMNolbeISdWrc+EcoqsxWh14eVc1AGCaShsaRL6obDTD5ZGQmRiL0akJossJCja6ySemLrk3z8BGN9ElXB42uomG4kSTBS6PhJSEaORwyzDSoP/ZdRpt1h6Mz0rEstkFosshEqayUV4fpzhHvet7sNFNPjnuHfJRkM6tkIgudoYrlxMNyT/PGAEA0/NSoePq5aRBNd41QZbMGoM4LlRLGtZuk0c9jVTxDVg2usknR8/Lje6puamCKyFSlqoWrl5ONBQHajoAALPGjRBcCZEYrd6Fo1ISogVXQiRWb6M7KU69WWCjm3xS1yHfjS1IV+c8C6Kh6nFxeDnRUJz3LiA1NoMjqEh7unrcKG+QOzSmjEoRWwyRYCeazACAwkyD4EqCh41uGpTHI6HZ3A0AyE6KF1wNkbKYvYsMEpHvDtZ2oKLRe5GVkSi4GqLQq26xwumWkG6IQW4ar61I2870bZ2n3vMBG900KIvDBY+8qwtS9Ood9kHkr1aLo29IFBH57pltlQCAb00fjbwRHEFF2tPk7czISYnnmgakaR6PBKP3WioriXO6ScMs3fLK5TFREYiN4kIfRL3Wbj8FACjOUe+dWaJA83gkHK7rBAD8x22FYoshEuRcm9yzNzqVvdykbTXtdrg9EmKjIpBuUO/2kWx006BsDjcAQB/DBjdRryZTN97ZVwsAeGTeBMHVEIWPRnM3XB4JOp3cy0ekRSeb5UU41TyclsgXJ7xTjcZnJyIqUr1NU+HvrKWlBQsXLkRKSgrS09NRVlYGl2vgOZKvvPIKxo8fj8TERFxzzTV4+eWXQ1ytNvUOn03Vq/fuk9IwF8p3sLYDkgRMyknCDQVcfTkUmAt1+Oh4EwBgam4KolV8gRUqzEV4OuVtdI9nozsomIvw0btuVG6quqcaCT/bLV68GAaDAQ0NDdi3bx+2b9+OF154od/r3n33XaxatQpvvvkmzGYz3nzzTTz++OP485//LKBqbWmxyGHIMMQKrkQ7mAvl23WyBQAwLS9FbCEawlyow65TrQCAr0/JEVyJOjAX4edEkxkVDXLv3oSRSYKrUSfmInzUd8o7WWQkqrudIbTRXV1djV27duFXv/oVEhISMHbsWKxevRovvfRSv9c2NDTg0UcfxcyZM6HT6TBr1izceuut2L17t4DKtaU3DKM47ygkmAvla7f1YOuRBgDAwqmjBFejDcyFepxptQIApoxOFlxJ+GMuwo8kSVj1l2NweSR8rTgLBencMi/QmIvwcqCmAwAweZS6zwlRIg9eXl6OtLQ05ORcuNtdXFyM2tpadHZ2IiUlpe/5lStXXvK9LS0t2L17N55//vlQlatZB71hGJeh3r3zlIS5UL6fbS1Ht9OD4pFJmD4mFXa7XXRJqsdcqEeL2QEAGJms3lVqQ4W5CD9f1nTgUG0n4qMj8dSdJaLLUSXmIrzUtsvXUBNVPupDaKPbYrFAr7/0Dl9Cgjye32q1XhKKizU1NWHBggWYPn06vv3tb1/x5zscDjgcjr7HZrN5+EVrTKvFgd1VbQCA2ydmCa5GG5gLZfusug1bjzQgMkKHZ+6ezK1eQoS5UAe3R0KP2wMA3A0jAJiL8POXg+cBAN+4diSyeeMpKJiL8OH2SOjqkRdsjo0WPus5qIS+O71e36+HqPdxYuLAC0vs3bsXM2bMwPjx47F161ZERV35vsGaNWuQnJzc95Wbmxu44jXiZ1vL0ePyYMroZFyTxZ7uUGAulO2zavkm1MKpozA1N0VsMRrCXKjDl+faAQBJcVFITYgWXE34Yy7Cz/kOecoeF+AMHuYifLx/tAG2HjeS4qKQk6zuaaxCG90lJSUwGo1obm7ue66iogKjR49GcnL/cf1/+MMf8NWvfhVlZWV45513EBt79Qn3q1atgslk6vuqq6sL+HtQK0mS8JuPT2LbsUa5R+8u9uiFCnOhbKeaOR9VBOZCHXrXQrijOFvVW8OECnMRfnpc8kiPqAheUwULcxE+3vz8HADgoZvHIl7lWxMLHV5eVFSE2bNno6ysDK+99hra2trw9NNPY9myZf1e++c//xkPP/wwtm7dirlz5/r082NjYwcNDg3s59sqsW7PWQDAqvkTUKLyxQ2UhLlQtlbvav7cXzi0mIvwZ+py4t1D9QCAu6/jAoSBwFyEF6fbg2P1JgDcnzuYmIvwIEkSTjbJW+fNn5wtuJrgE36becuWLXC5XCgoKEBpaSnmzZuH1atXAwAMBgM2btwIAHjyySfhcrmwaNEiGAyGvq8VK1aILF+VDtV2YN2es9DpgKcXluD7N48VXZLmMBfK1WqR53GlG7hvfagxF+Gr3daDJev+CVuPG4WZBtw4jkNrA4W5CB8nmyywe4fSTshmozuYmAvlM3e5YPPO585NU/ce3YDgnm4AyMrKwubNmwf8O6vV2vfno0ePhqokzXv9H3IP993TRmPJzDGCq9Em5kKZHC43Gs1yT7cWThBKw1yEJ1OXE/e++gWqW6xI08dg7eKpnK4UQMxF+DjbZgMg93JHcHh5UDEXyueWpL4/x2hgupHwRjcpi8vtwY4TLQCApTfmiy2GSGHOd3RBkoCEmEiM0LOnm2gwkiThsb8cQ3WLFdlJcdjw/VIUZnJRTtKm3kXU8njTlggOl9zLrZX1DdR/W4H8cqLJgi6nG4lxUZiUo+798oj84fFI+NOX8mIpuakJ7Kkj8sG2Y43YdqwRURE6vLJkOhvcpGkNnXKjOyOR84GJ2m09AICUhGhNXFOxp5su0Wl3AgBykuM59InIy9ztRNkfD/eNArmLi0ARDUqSJLy0oxoAsPLWQm6xR5pmc7j6Vu+flpcquBoi8XoXURszQj/IK9WBjW66xKHaDgBATBQHQRD1eu3vZ7DjRAtioyLw9J0luHcG9+QkGkx5gxknmiyIj47EspsKRJdDJNTHFU0wdTmRPyIBdxRniS6HSCibw4X13u3CpmnkhixbVtRnT1UbXth+CgBw/w15gqshUo4T3ruxj8ybwAY3kY+M3qGDBel6JCdEC66GSKyzrfIiajcVpiOSIwlJw1xuD1ZsOICj501ITYjGd2fliy4pJNjopj5rt5+CRwLuvX407r+BDQuiXq1WeZuw0ancm5vIV7VGuZGRwgY3ERpM8s4XOSk8j5C2rdtzFv+oakNCTCTeePAG5I3QxsKCbHQTAKDGaMMB79Dystuv0cSCBkS+sjlcAABDHGfkEPnqg+NNAIBbrskQXAmReB3ekR/c+YK0rNHUhec/kUfV/uybkzS11gcb3YQWSze++4d9kCTghoI03oUluojD5UZdux0AkJkYJ7gaovDg9kg4UCPfyP3qxEzB1RCJ19vTnZnElctJu47UdcLh8mBCdiLumT5adDkhxUa3xjWZuvHA7/+JGqMduWnxePH+aaJLIlKUo+dNcLg8SDfEYlyGNlbYJBquP31ZB4fLg/joSBSkc5sw0jZJknCuTZ5uka+RlZqJBtLllPfmzkiM1dyoWo6V1LBaox3ffn0vznd0ITspDhuWlSIriT15RBc71SwvojZ5VJLmThBEQ/Hrj07ipZ3yVmGLZ+Ry0SjSvA67s6+xMTpVG/NXiQbS7fQAAGKjIgVXEnpsdGuUJEn48ebDON/RhfwRCXh7WSly03giILrczhOtAIBxGeytIxpMRYO5r8H9H7cV4oe3XyO4IiLxDnqnWmQkxnJLVtK0du/aBvExbHSTRvzzbDv2n+tATGQENj40E6M4j5uon08rm7G9shlRETrccz1X9CcaTG27PIR2Wl4Kfvy18YKrIRLP7ZHw3EcnAQB3TRsluBoisf5+Uu7IuC4vRWwhAvB2m0a9tvsMAOBb149mg5voCn7n7bFbNrsA47MTBVdDpHy7q9oAALkcQksEANh6pB4nmy1IiovCv80pFF0OkTBv763BvnPt0OmA2ydmiS4n5Njo1qBzbTbsONECnQ546OaxosshUqTTrVYcrO1EZIQOy24uEF0OkeI1mrqw+cs6AMCSWWMEV0MkntPtwdrtVQCAFXPGIZl71pNGVTSY8bOt5QCA//raeE1OaWWjW4MqG80AgCmjU1CQzlU0iQZyusUKACjJSeJWYUQ+eOuLGjjdEkoL0jAjP010OUTC/eXgedQY7Rihj8H3ZuWLLodImH1njXB75PPDyjnjRJcjBBvdGmTqcgIAUuJ5x5XoSo7VmwCAi94Q+cBkd+J/99UCAP51NkeGEHk8En638zQA4OE546CP5TJKpF22Hnn1/ty0BM3uBMOrSQ06VNsJACjK5GrMRAN5/R9n8OIOeT7316fkCK6GSPl+88lJdNqdKMo0aHKuHtHlDtZ2oLbdDkNsFB4o5XQL0rbj3o4MLY+wZaNbg76saQcA3FSYLrgSIuU51WzBL/5WCQD4z68W4bucm0p0VUfPd2LD3hoAwJN3TuK+3EQAPqloBgB8rThLk9sjEfVqNndj9yl51fLSAu1OPWKjW2MkSUJdRxcAoJA93UT9/G5nNSRJvlD64e1Fmh0GReSLbqcbj/75GDwScOfUHNw4jjdziYALU5RKx2q3kUEEAL/YVglbjxtTc1NwXV6q6HKEYaNbYzrtTvS4PACAzKRYwdUQKYvT7cGHx5sAAP9+WyEb3ERX4XJ78J//ewgVjWYkx0dj9deLRZdEpAhuj4Rj5+VG96ScZMHVEIljdbiw7VgjAODnC0sQoeGRUGx0a0y7vQcAkBgXhdgoDnciutjJJgscLg+S4qJQwgsloqt67qOT+LiiGTFREXjlO9ORbuCNXCIA2H+uHRaHC/qYSEzIThRdDpEwh2s74fZIGJUSj5JR2r6uYqNbY8zelcuT4rhyOdHldp5oAQBcn5+m6buxRIPptPfgzS/OAQCev/dazBo3QmxBRArRbO7G//njIQDA1yZlIyqSl9qkXQdrOwAA1+drd1h5L/5PoDF275L9+lj2chNd7pPKCwvfENGVbfxnLbqdHhSPTMKCySNFl0OkGM9+cALNZgcKMw148s5JosshEqbF0o2/HqoHAEzLTRFbjAJw00CNsXTLPd2J7OkmuoTJ7uxb+ObWCZmCqyFSrq4eN/6w5ywA4KGvFHDtA6KLnGyyAAAenTeBowpJs1rM3bjvtb0422ZDdlIcFnD7VfZ0a4nL7cGm/XUAgAzOvSO6xMG6DkgSMDZDj6ykONHlECnWJ5XNMNp6kJsWj2/wQoqoj6XbibNtNgDA6LR4wdUQifP0tkqcabNhVEo8Nv1gJjIS2e4Q3uhuaWnBwoULkZKSgvT0dJSVlcHlcg342r/97W+YPHky9Ho9Jk6ciPfffz/E1YYvt0fC4389jp0nWxEbFYGH54wTXRJdBXMRemdb5QulIm6lp1jMhTIcONcOALh9YhbnqyoAc6EM7bYe/Pz9SnQ53SjMNGB8FhdQE4m5EKe8wYT3jzYAAF5dMh1jRugFV6QMws+WixcvhsFgQENDA/bt24ft27fjhRde6Pe6qqoqLFq0CE8//TRMJhOefPJJ3HvvvaivrxdQdXixOlx46K0vsenLOuh0wG/vm4ZrObdC0ZiL0Krv7MLLu6oBAMUjtb26ppIxF+J5PBK2V8oLDt6Qz/2HlYC5EOt8hx0/21qOm57dgU1fyqMJH75lHKddCMZciNFi7sbytw5AkoD5JdmaX7H8YjpJkiRRB6+urkZRURHq6+uRkyMPUdu0aRP++7//GzU1NZe89ic/+Qn27duHjz/+uO+5+fPn44YbbsCTTz7p0/HMZjOSk5NhMpmQlJQUuDeiUO22HmzaX4cNe2tQ39mF2KgIvLB4Kv5lGIve2Gw2GAxyT6DVaoVeHz53r8Ll82cugsPl9qC+swvnjHbUGG0422ZDjdGOc0Yb6trtcLolFI9MwpaHZyEhxr/lLpiL4GMuxOt2urF2exVe+ftpJMZFYf/jtyMuOriLcorKVrh8/syFGPYeFz4ub8a7h+vxj6o2uD3ypXTJqCT825xCzFfpdVa4fP7MRehJkoSPypvxzN8qUdtuR0G6Hn95+Eak6mOG/bOVnAnA989f6EJq5eXlSEtL6wsEABQXF6O2thadnZ1ISUm55LWTJ0++5PuLi4tx5MiRUJUbNo7Xm/Dm5+fw/440oMflAQBkJsbi1SXTMS2PS/YrHXMxPCa7EwfrOnDuokZ1jdGOunY7XJ4r32PMH5GA17473e8GN4UGcyHWF6eNePyvx3DGO1/1X28qCHqDmwbHXISOy+3BZ6eNePdQPT4qb+rbDQYAbhw3AivnFOKmwhHs4VYA5iK0DtV24Jm/VWL/OXl7sOykOKx/cEZAGtxqIvTq0mKx9LtbkZCQAEC+k3FxKK70WqvVesWf73A44HA4+h6bTPLKxGazebilK9apZjPufvmLvscTRybi2zfkYf7kkYiLjhz2e7fZbH1/NpvNcLvdV3m1svS+d4GDO3zCXAzPvjNGLHvzywH/LiYqAnlp8chNS0Ce92tMmh65afHITo5HZIRrSL8H5iL4mAtx9lS3YcXbBwAA6YYYPP4vE3F7cVZIfjeissVcyJiLC7Yersdjfz3e9zg3LR5fn5yDBdeORL53zqrFYhn2cZR8PmEuZMzFBYdq27Fk3X4AQGx0BJbOyseDswtgiHYH7Peh5EwAvudCaKNbr9fDbrdf8lzv48TERJ9ee/nrLrZmzZoBh4bk5uYOteSwUwfg40FfNTQX30EMJxaLBcnJyp1jwlwE1+kg/3zmIjiYC2WoA/Ctn4s5tohsMRfMxZXUAfgcwGNBPIZSzyfMBXNxJT/xfgWLUjMBDJ4LoY3ukpISGI1GNDc3IysrCwBQUVGB0aNH9yu6pKQEBw8evOS5iooKXH/99Vf8+atWrcKPfvSjvsednZ0YM2YMamtrhf1nYTabkZubi7q6OmHzPrRagyRJsFgsig4soM1cDEQJ/04Hora6mAtZuORiMEr99zkYpdXNXMjUkovLKe3f21CF+n0wFzJRuQjl563GYwXrOD7nQhJs9uzZ0n333SeZzWbpzJkz0qRJk6Qnnnii3+sqKyuluLg4adOmTZLT6ZQ2bdokxcXFSSdPnvT5WCaTSQIgmUymAL4D/7AG5dSgZFrLxUBYl3+UWlcgMReDY93aw1z4j+9D/dSYi1B+3mo8lui8CG90NzU1Sd/61rekESNGSBkZGdKPf/xjyeVySZIkSXq9XtqwYUPfaz/88EPp2muvlQwGgzRp0iRp27Ztfh1L9C+bNSirBiXTWi4Gwrr8o9S6Aom5GBzr1h7mwn98H+qnxlyosSEcymOJzovQLcNCTQlL+rMG5dRAMqV+FqzLP0qtK1yF6++TdVMwqeVz4vugQArV5xDKz1uNxxKdl4iQH1Gg2NhYPPHEE4iNjWUNrIG8lPpZsC7/KLWucBWuv0/WTcGkls+J74MCKVSfQyg/bzUeS3ReNNXTTURERERERBRKmurpJiIiIiIiIgolNrqJiIiIiIiIgkR1jW6Hw4E777wTN910E37/+99f9fkvvvgCpaWluPXWW3H27FkhNWzYsAEzZ87EjTfeiMOHDwupAQBcLheKiooCdnx/a9i3bx9uvvlmzJgxA5988klA6yBl5GK4dQUrK8OtCwhOfoZbFzM1OKXmYjBKzY0vlJotuiBcc3G5cM7JxZgZZQhlLvz9zGtra7Fw4cKgHme4GfHnWJ988glKS0sxZ84cNDY2BvVYQAgzI2TN9CB66623pJdffllyu93SHXfcIXV1dV3x+QULFkhGo1EqLy+Xli9fLqSGmTNnSi6XSzp79qx0zz33CKlBkiTplVdekQwGQ8CO728Nc+fOlVpbWyWj0Si9/vrrAa2DlJGL4dYVrKwMty5JCk5+hlsXMzU4peYikHWHMje+UGq26IJwzcXlwjknF2NmlCGUufDnWF9++aU0c+ZM6ZZbbgnqcYabEX+Odccdd0hms1nas2eP9NhjjwX1WJIUusyorqf7wIEDmD17NiIiIjB58mRUVlZe8fmuri6kpaWhuLgYVVVVQmp47733EBkZCafTiZiYGCE1dHV1YefOnZg+fXrAju9PDQcOHIDT6URZWRnuu+8+3HbbbQGtg5SRi+HWFaysDLeuYOVnOHUxU75Rai4CWXcoc+MLpWaLLgjXXFwunHNyMWZGGUKZC3+O5fF4sHXr1qC/p+FmxJ9jffDBB0hMTERjYyPi4+ODeqxQZkZ1jW6LxQKDwQAA0Ov1sFqtV3ze4/H0fZ8UwEXc/akhPT0dDocDK1euxA9/+EMhNbz00kt4+OGHA3Zsf2vweDw4dOgQnn/+eTz//PN45JFHAl6L1ikhF8OtK1hZGW5dwcrPcOpipnyj1FwMRqm58YVSs0UXhGsuLhfOObkYM6MMocyFP8eaMWMGMjIygv6ehpsRf44VGRmJV199FcuXL8e8efOCeqxQZkZ1jW6DwQCbzQYAsNlsfZufD/S8Tqfr+76IiMD9Kvypwel04p577sEDDzwQ0Lss/tRw8OBB3HLLLQE79lBqmDhxIjIzM1FSUgKj0RjwWrROCbkYbl3Byspw6wpWfoZbFzM1OKXmYjBKzY0vlJotuiBcc3G5cM7JxZgZZQhlLvw51nCEMiP+vqcf/OAHOH78+JA6DZSaGWX9DxkA1113HXbv3g1JknD48GGMHz/+is/Hx8ejra0NFRUVyM/PF1LDj370I8yfPx9Lly4N2PH9qaG2thYnT57EnDlzcPjwYXz/+98PeQ3jx4+Hy+VCW1sbamtrh3zHjq5MCbkYbl3Byspw6gpmfoZTFzPlG6XmIpB1hzI3vlBqtuiCcM3F5cI5JxdjZpQhlLnw51ihek/DzYg/x1q0aBF6enoQHx8/pJsWSs2MTlLaeKBh6u7uxv3334/z58/jwQcfhM1mw4IFCzB27NhLnl+5ciX27t2LsrIy6HQ6vP322ygsLAxpDYsWLUJ+fj5KS0sBAJMnT8aLL74Y0hpWrlzZ9z1z5szBrl27AnJ8f2vYvn07HnvsMeh0Orz66quYOnVqwOogZeRiOHUFMyvDqSuY+RluXczU4JSai0DVHercBLL2UGeLLgjXXFwunHNyMWZGGUKZi1B95qHMiD/vafPmzfjNb36DqKgoPPfcc5g1a1bQjtUrFJlRXaObiIiIiIiISClUN7yciIiIiIiISCnY6CYiIiIiIiIKEja6iYiIiIiIiIKEjW4iIiIiIiKiIGGjm4iIiIiIiChI2OgmIiIiIiIiChI2uomIiIiIiIiChI1uFVm/fj3y8/MBAB0dHVi5ciVyc3Oh1+sxcuRIfO9738P58+f7Xr906VJER0fDYDDAYDAgPj4eY8eOxaOPPoquri5B74IosJgLov6YC6L+mAui/piLwGCjW6UWL16MtrY27N+/HzabDYcPH4bD4cAdd9wBl8vV97oHHngAVqsVVqsVdrsdf/zjH7Ft2zYsWrRIYPVEwcFcEPXHXBD1x1wQ9cdcDB0b3Sq1Z88e3HXXXcjOzgYAZGVlYe3atSgtLUVHR8eA36PT6XDDDTdgy5Yt+PDDD/Hxxx+HsmSioGMuiPpjLoj6Yy6I+mMuho6NbpW6//77sWLFCqxcuRJ/+tOfUFNTg+zsbKxfvx4ZGRlX/d7x48ejqKgIO3bsCFG1RKHBXBD1x1wQ9cdcEPXHXAwdG90q9fvf/x6/+93vUFtbi+XLlyM/Px+FhYXYuHGjT9+fnp4Oo9EY5CqJQou5IOqPuSDqj7kg6o+5GDo2ulUqIiIC3/nOd/D++++jo6MD5eXluOeee7BkyRJ8+umng35/S0sLMjMzQ1ApUegwF0T9MRdE/TEXRP0xF0PHRncYe/vtt/HLX/6y77HT6URCQgI++ugjGAwGtLe3A5DnUhQXF2PNmjWYNm0aDh06dNWfW1lZierqatx+++1BrZ8oGJgLov6YC6L+mAui/piL4GCjO4xZrVa8+OKLaGxshNlsxpYtW3D99dfjK1/5CrKysvDggw/i2LFjcDqdsFgs2LhxI6qqqrBgwYIBf57H48Hnn3+OxYsX46677sKtt94a4ndENHzMBVF/zAVRf8wFUX/MRZBIFLZ6enqkhx56SEpPT5cMBoP0jW98Q2psbJQkSZIaGhqk5cuXS2PGjJHi4+Ol5ORkad68edLevXv7vv973/ueFBUVJen1ekmv10spKSlSSUmJ9Itf/EJyOp2i3hbRsDAXRP0xF0T9MRdE/TEXwaGTJEkS3fAnIiIiIiIiUiMOLyciIiIiIiIKEja6iYiIiIiIiIKEjW4iIiIiIiKiIGGjm4iIiIiIiChI2OgmIiIiIiIiChI2uomIiIiIiIiChI1uIiIiIiIioiBho5uIiIiIiIgoSNjoJiIiIiIiIgoSNrqJiIiIiIiIgoSNbiIiIiIiIqIgYaObiIiIiIiIKEj+P/GKU4JbnE8RAAAAAElFTkSuQmCC\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA90AAAHqCAYAAAAZLi26AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAADFdElEQVR4nOzdd3wUdf4/8Ndm03c3PRBCQgIkEELoValWsIOIWBHl7HqHenfKeeJ5/pBTvifq4d1Z0RM95bCLDYSAdKRKQkmAkJDed9O2fn5/TBISUkjC7s7M7uv5eOQBGSbZ94R9ZeYz8ykaIYQAERERERERETmdj9wFEBEREREREXkqNrqJiIiIiIiIXISNbiIiIiIiIiIXYaObiIiIiIiIyEXY6CYiIiIiIiJyETa6iYiIiIiIiFyEjW4iIiIiIiIiF2Gjm4iIiIiIiMhF2OgmIiIiIiIichE2uj1EaWkpkpKSkJ6e3rxt165dmDBhAvR6Pfr374933nmn+d8OHz6MESNGwGAwYNasWairq2v+txdeeAHPPvusO8sncqqDBw/iiiuuQEREBGJiYjB//nyUlZUBYC7IO23cuBETJkxASEgIYmJi8Oijj6K+vh4AM0Fkt9sxffp0LFiwoHkbc0He6pNPPoGvry/0en3zx5133gmAubggglRv69atYuDAgQKA2LRpkxBCiIqKChERESFWrlwprFar+Omnn4TBYBC7du0SQggxd+5c8fvf/16YTCYxadIk8a9//UsIIUROTo4YNmyYqK+vl+twiC5IXV2d6NOnj1iyZIkwm82irKxMXH311eLaa69lLsgrlZSUiMDAQLFq1Spht9tFQUGBSEtLE0uWLGEmiIQQzzzzjPDx8RF33XWXEILXUOTdnnjiCbFgwYI225mLC8Mn3Sr3/vvv47bbbsPSpUtbbf/0008RGRmJhx9+GL6+vrj00ktx++234/XXXwcA+Pr6AgCEEBBCQKvVAgB+97vf4cUXX0RgYKB7D4TISXJzczFixAgsWbIE/v7+iIyMxP33348tW7YwF+SVoqOjUVJSggULFkCj0aC8vBwNDQ2Ijo5mJsjrbdy4EZ9++inmzJnTvI25IG+2Z88ejB07ts125uLCsNGtcjNmzMCJEycwb968VtszMjIwbNiwVttSU1Nx8OBBAMCSJUvw888/o3///khISMD8+fOxbt06+Pr64qqrrnJb/UTONnjwYHz33XfNv+wBYO3atRgzZgxzQV7LYDAAAOLj4zFs2DD06dMHd999NzNBXq2kpAQLFy7ERx99hODg4ObtzAV5K4fDgX379mHdunVISEhAXFwc7rvvPlRWVjIXF4iNbpWLiYlpvrPUkslkgk6na7UtODgYNTU1AICUlBTs3LkTZWVl+OijjyCEwJ/+9CesWLECr7zyCkaPHo3LLrsMmZmZbjkOIlcQQuDPf/4zvv76a7z66qvMBXm9rKws5OfnQ6vV4qabbmImyGs5HA7ccccdePzxxzFixIhW/8ZckLcqLS3FqFGjcNNNN+HIkSPYvn07srKycMcddzAXF4iNbg+l0+laTWAAAHV1dc1PO861bNky3HHHHTAajVi2bBnS09OxcOFC3HPPPe4ol8jpjEYjbrrpJqxevRpbtmzBsGHDmAvyekFBQYiNjcWLL76I77//npkgr7Vs2TIEBgbi0UcfbfNvzAV5q969e2PLli245557EBwcjH79+uGll17Cd999ByEEc3EB2Oj2UGlpacjIyGi1LTMzE2lpaW32zc7Oxrp167Bo0SIcPnwYAwcOREhICMaOHYtff/3VXSUTOc2JEycwbtw4GI1G/PLLL83doZgL8kbbt29HSkoKLBZL8zaz2Qx/f3+kpqYyE+SVPvjgA6SnpyMsLAxhYWH46KOP8NFHHyEsLIznCvJahw4dwlNPPQUhRPM2s9kMHx8fjB8/nrm4EO6euY1cBy1mLy8rKxNhYWFixYoVwmKxiI0bNwqDwSA2btzY5uuuuuoqsXnzZiGEEHv37hWRkZGitLRUrFq1SgwfPtydh0B0wSoqKkS/fv3EggULhN1ub/VvzAV5I5PJJOLj48Vjjz0mzGazyMnJEePHjxcPPvggM0HU6K677mqevZy5IG+Vl5cndDqdePHFF4XVahWnT58WEydOFAsXLmQuLhAb3R6kZaNbCCH27NkjLr74YmEwGMSAAQPEqlWr2nzNp59+KubPn99q2+LFi0V4eLhISUkRO3bscHHVRM7197//XQAQwcHBQqfTtfoQgrkg75SRkSGuuOIKERYWJhISEsTTTz8tGhoahBDMBJEQrRvdQjAX5L3S09PFRRddJAwGg4iOjhaPPvpo83JfzEXPaYRo0X+AiIiIiIiIiJyGY7qJiIiIiIiIXISNbiIiIiIiIiIXYaObiIiIiIiIyEUU0+guLS1FUlIS0tPTO9zn22+/bV5rd8iQIfjmm2/cVyCRDJgLoraYC6LWmAmitpgLUhJFNLq3bduGiy66CCdOnOhwn6ysLMyZMwfPP/88qqur8dxzz+Hmm29Gfn6+Gyslch/mgqgt5oKoNWaCqC3mgpRG9kb3+++/j9tuuw1Lly49735TpkzBrFmz4Ovri5tvvhnTpk3Dm2++6aZKidyHuSBqi7kgao2ZIGqLuSAl8pW7gBkzZuD222+Hr68vbrnllg73y8jIwLBhw1ptS01NxcGDBzv8GrPZDLPZ3Py5w+FARUUFIiMjodFoLrx4Uh0hBEwmE2JjY+HjI/s9pw65KhfMBLWHuWAuqC015ILXUOROasgEwFyQe3U1F7I3umNiYrq0n8lkgk6na7UtODgYNTU1HX7NsmXL8Nxzz11QfeSZ8vLyEBcXJ3cZHXJVLpgJ6gxzQdSWknPBayiSg5IzATAXJI/z5UL2RndX6XQ61NXVtdpWV1cHg8HQ4dcsXrwYjz/+ePPn1dXV6NevH/IAhLT3BVdcAaxde/bzmBigvr79bz5pEvDtt2c/798fqKhof99Ro4CWkzikpQF5ee3vO3gwsHv32c/HjweOHWt/3/h44PDhs59Pnw7s39/+vhERwKlTZz+/+mpg27b29w0KAoqKzn5+003A+vXt7wsA1dVn/z5/PvDllx3vW1AANP2Ce+AB4L//7XjfEyeAqCjp7088Abz9doe7XnnPShSE9AIAPL3jQ9y660vs2n8SYxMjoPU5e+fRaDQiPj6+0/eNmnQ3F8xECx6eiV+//xl77HocPFOFCe+8gtt2SzWcOVWIuIjgVvsyF8xFMw/PxdEft+GPe6pwsrQWj//8Ae7Z+zVWfbsf88b1Q7B/60siT8oFr6HaocJcjH3oP2jwDwQA/L8fXsesI5s73HfK/W+hMigUAPD0xrdx66EfO9x36d8+gS0uHvpAX1z+4T8w4vMPsO7nI5iUFIWwYP/m/TwpEwBz0S4V5sJV54v8zbsw97t8GBtszeeL7KwzSOrV+v3R1VyoptGdlpaGffv2tdqWmZmJsWPHdvg1AQEBCAgIaLM9BB0Ew88PCGnxL511E/H1bb1vZ91stNqe76vVdryvj0/P9/Xt5L9eo2m9r59fx/sC3d+3KRj+/p3vazCc/d7n2TfUoMfl01JwzbBYTNDugs8u4IqR/Tvc31O6AHU3F93NhM3HB+YW76tgjQYd/eTsGg0aerhvkEbT4QQTDo0G9T3cN1CjQUepEBoN6nq4b4CPT6e/PGtb7qvRnH/fxv39fXzQWYJqfXzO7ms0wg+AANB0yRAMNP/Mn/ziOM6E9gYATIS2+f83NbHjJwDMRWs8V8DjzhW///wYckN6ISoiDJck9UbIXuB3V43s9Gs8IRe8hmqHCnPhGxiMMIMeIUF+6KMPav//odHLt05EQGwMQoJ8kVi9HiGHOt73xXnjgcRE6ZOd0nnj1skpHe7vCZkAmIt2qTAXrjpf7KxxoEb4IybKgJtGxiNkLzA6qW+H+58vFxohhOi8OvfRaDTYtGkTpk+f3ubfjh49ilGjRuH999/HjTfeiM8++wx33XUXDh48iEGDBnXp+xuNRoSGhqK6oAAhjT9wIQTMVisghPTGahmkc+5+teLjAwQG9mzf+nrp9dqj0Uh3g7q5r5+fH7QWC+BwdFxHyy409fVd37ehAbDbnbNvcPDZXzhmM2Cz9WjfOosNn+/Lx7vbTqGgqgGzL07CCzeNkP7RYgGs1tZ1NWp+D1RXN78HlM6VuWj6eQQBrRrIGo0GsX37AlotLC22B6FjDgDmFp93Z9/Ac16/JQGgoQf72u12lOfnQ9PJr7iWqQ1E5zNLttw3AOiwgX4h+/qj8zuh7e0rADTdM0+6/234BocBAAx+wKi0BIzuF47RMToMjwlGgK+WuehGLlqeKwDA7nDAarNJv9N5rmi7rwLPFQBgttnxu48PYPOxUjT4+eO6kXF4/oY0hPqKDs8VgPpyIcc1FMBcnHffHuSioKoem46WYOPREuw+VQGbQ+Dpq1Nw2yVD4KNtPFNdYC5aCQo622jjNRTbFgrNRYeceL5o6bkNJ7FqRy4uGRyNVbePvOBcKPpJt16vxxtvvIHbb78dKSkp+OKLL/Dkk09i4cKFSEhIwKefftrlULSi0zX/0Ary82E0Gp1cuftpNBrExcVBr9d37QuCOmsSnaNlqJ25b0BA619EXdhXCIHXN2Xj7a2nUFVnBQCEhxkwe2z82X39/c9/p0vFXJGLczs6PfzQQ7j66qsVPVHK+TgcDnz77bd4/fXXu7R/w/l3aWY+/y492tfS+NHTfW/ITMfUslyMLjyGvjMvgebFTrpYeRiXnC9anCtqampwJj8fCrpP3SPecq5oYrbZ8fDa/dhwyoSA4GC8OncErh8Re3Z/niu6/42ZC5fkwmp34K2dZ7DuUCEyClpcl/oGICXGgMvHDTzb4AYuKBed4jUU2xaNlJCLbu/rpFy8vikbq3bkAgCuGxHrlFwo6km3q517J8JmsyErKwuRkZGquWPXHiEESktLUVdXh+TkZGg76wqicusOFeLhj6SuQP0ignHvlP64aUw8gvy7dsxqvEvrSk0/j4IWd2htNhvOnDmDyMhIVY/bMplMKC8vR3x8vMdkwu4Q2HmyDF8fLMSGA7mohS8c1gbkr7wDAGACoAekO+t/+AOwbFmXvi9z0dq5Pw+73Y6srCwEBwcjOjpatV0rvelcAQClJjPu/+AX7MutQoCvD965axwmJ0d1+euZi9aYC9f6vx+OYeWmbADSg7ixCeG4fEhvXJHaGwOiu9jocTFmoi22LTzPgbwqzHpdGpv+5MwUPDh9YKf7e8STblezNXYpMBgMCOzOXRQFio6ORk5ODqxWq0cHY/PxEgDALePisXT2sFaTpFHP6XS65hk8Gxoa4OPjI3U7785dS4Xx8fFBZWUl/P39VZ9vAPh4dy5eXn8cJabGZ+f+eiRUFWHO3q/xWOM+zWkQAli4UIYqPZPVaoUQAtHR0arOBOA954rjxSbcvWoP8qvqYQj0xb/vGINJSV1vcNP5MRfOk1NWi7e3ngQA/GHGYNwyLh6R+i4+rSNFYdtC3RwOgRe+PQIAuHFU3/M2uLvDqxvdTdR6d7YlTziGrjhWZAIATB8czQa3i6n9PaX2+lt6++eT+H/rpJNAWLAfrh3eB7NH9cXojV+h7s2vmhvdzWPy3nkHSEqSpVZP5gnvKU84hvPZk1OBhe/tgbHBhsTIYLx91zgk9VLGk0JP5AnvKTmP4WBeFRa+vwcNVgfGJoTjoekDPeJn6u084f/QE46hu5b/eAy7T1UgwNcHT8wY7NTvrd4Bm+6UlQUsXgzceqv0Z1ZWj76N2WzGDTfcgEmTJuGtt95q3l5fX4+ZM2di4sSJePfddwEAu3fvxpQpUzBu3Disb5xS/+mnn8akSZPw4IMPXvgxqZAQAhV10ijW0CDPHW+kGi7OhdFoxMyZMzFp0qTmXGzZsgXjxo3D1KlTcfr0aQCen4vvDxc1N7gfnD4Qu/90Of7frGEYkxABzd0LgAMHzu68aJG0DMiCBTJUSgCckovOzhW33HILJk+ejIcffhgA8Nprr2H06NGYPn06li9fDsDzM9GZw/nVuOPtXTA22DC6Xxg+f2gSG9xK4OZcrF69GhMnTsTFF1+MA42/I5WYi+wSE255cyfKaiwYGhuCf94+2isbOl7JDddQffv2xfTp03HZZZcBANavX48JEyZg+vTpKCwsBKDMXMjlpyPF+Ff6CQDAi3OGo2+Yc3vwsNF9PqtWASkpwPLlwJo10p8pKcB773X7W61ZswYzZ87Ezz//jP/9739oaJCmbvr+++8xZcoUbN++He+88w4AYMmSJfj888/xww8/IDc3F7m5uThx4gS2bdsGg8GAHTt2OPMoVeHDXbnIq6hHgK8PBvZqf7ZZchM35OLNN9/E3LlzsW3bNnz99deoq6vD3//+d3zxxRdYunQpXn/9da/Ixaaj0pCKeWPj8ccZg+Hve86v7YEtuj799a98wi0nJ+Wio0y89dZbuOaaa7B161akpKSgvr4emZmZ+PLLL5Geno4//OEPXpGJjgghdQs02xyYkhyFD38zEeE63qCVnQy5eP3117Ft2zZ89NFHeOGFFxSbi39vPol6qx3jEsPxyf0XoVeIursjUxe54RoqMzMTDzzwANLT0/HTTz8BAJYvX44NGzZg6dKlWLlypWJzIZcvDhQAAO6cmIBZozpeGqyn2OjuTFYW8JvfSNPf2+2t/1y4EMjO7ta327t3LyZPngwfHx8MGzYMR45IT6+GDBkCi8UCq9UKPz8/1NbWwmq1YtGiRbjllltw6aWXYt++fZg0aRIAYMqUKdi5c6fTD1epHA6Bt7acxHNfZwCQJjXoZeCJSTZuysWJEyea3/ODBw/GkSNHMGbMGFRXV6OmpgZ6vd4rcnGmSloyZFz/CD4BUTIn5qKjTPz88884efIkLrnkEhgMBgQFBeHYsWN49NFHceWVV+LkyZNekYmOHDpTje0nyuGv9cGyG4d1eYJNciGZcvH1119Dq9XCarXC399fkbnYl1uJLw/kAwAWXz0E+gCO+PQKbrqGysjIwPfff4+pU6di1apVAIDvvvsOBoMBhYWFCAoKUmQu5JJZYGx+yHH9yNjz7N0zbHR35t13O17EXqORxk12g8lkap52X6fToaamBoC0Dt5///tfpKSk4Morr0RlZSX279+Pl19+GS+//DKefPLJDr/W09WYbbhr1W4s/fYIrHaB60bEYsHFiXKX5d3clIuUlBRs3LgRdrsd27ZtQ0NDA2JjY3H55Zdj4cKFuPXWWz0+F0IIZJdIx9Q/ir07FM2JuejofV1ZWYnY2FisX78eH3zwAcrKynDddddh9erVWL58Of74xz96fCY6c7igGgBwcVIk4sKDZa6GAMiWi6ioKJjNZjz00EN47LHHFJeLM5V1uPf9X2C1C1yZ2huj+4XLWg+5kZuuoRITE/HSSy9hw4YNeP/991FaWgqtVos33ngD9913H2bOnKm4XMglu6QGd7yzCzVmG8YkhLssj2x0dyYnp+PF44WQ/r0b9Ho9amtrAQC1tbXN08qvXLkSy5Ytw4kTJ7B7927Y7XYMGTIEvXr1QlpaGsrLyzv8Wk/33125+DmrDIF+Pnhh9jC8dstI+HACNXm5KRf33nsvtm7ditmzZ2PAgAEIDw/HihUrcPToUezcuROPPfaYR+fC2GDFQx/uQ7HRDD+tBsm9OS5V0ZyYi47e12FhYZg+fTp8fX0xbtw4nDp1Cvfeey/0ej1GjBjh1ecKAMirqAcAJEbyBpViyJQLq9WKuXPn4vbbb8eYMWMUl4uPduWivNaCIX1CsGLeSFlrITdz0zXUxIkTcdFFF8Hf3x8TJ07EqVOnAAD3338/Dh8+jCeffFJxuZDLX77KQEWtBcP6huLdBeNcNlEzG92dSUzs/G5UYmK3vt3o0aOxZcsWCCFw4MABDB4szYqn0+lgMBjg4+ODkJAQ1NTUwGazoaysDLm5uYiOjsaoUaPw888/A5C6Uo0ePfoCDkw9jhQZAQD3ThmA2yb0Y/daJXBTLnbv3o3HHnsMX3zxBYxGIwYNGoSIiAgEBgYiLCwMtbW1HpuL6norrvvHVnx3uAh+Wg2evyENIYF+cpdFnXFiLjrKxJgxY7B582YAwMGDBzFo0CBMmzYNVqsVx48fR69evTw2E11R2ricHrvpKohMuXj88cdx1VVXYUHjpJJKy0WtWVpW6oohvaDj+9W7uOkaasmSJVi/fj0cDgf27t2LgQMHYs6cObBYLAgKCoKPj4/iciGHk6U12JpdBo0G+OftoxEa5LprLTa6O3PPPZ3fjermOrjz5s3D+vXrMX78eMyZMwf/+Mc/kJmZiUcffRTLly/HlClTEBkZiaFDh2Lp0qW4+uqrMXfuXDz11FNITExEUlISLr74YpSUlGDy5MlOOEDlEkLg7z8ew2f7pPFOQ2NDZa6ImrkpFwMHDsRvf/tbTJo0Cbfeeit8fX3x+OOPY8qUKZgxYwb+/Oc/e2wuNmQW43R5HaINAfjfAxfjlvH95C6JzseJuegoEw8++CC++OILjB8/HlOnTkVoaCh+//vfY/LkybjvvvuwdOlSj81EZ+osNvxx7UF8uu8MAHCiTSWRIRcNDQ14++238cknn2D69Ol49NFHFZeLY8XS8qchLrzAJ4Vy0zXU448/jr/97W+YMmUKbrrpJkRGRuKWW27B1KlTcd111+Gvf/2r4nIhh/25VQCAcQkRiI9w7bAk3l7rTHKyNLZi4ULp7pMQZ//swTq4gYGB+Pzzz9v9t6ZlwZpcfvnluPzyy1ttW7p0affqV7Fl3x3Fm1tOAgAeuSQJV6b2lrkiaubGXJw7k+bs2bMxe/bsVts8MReVjUvjTRwQiZHxYfIWQ13jxFx0lolvvvmm1ee33XYbbrvttlbbPDETHTE1WHHrWztxON8IjQZ49JIkXD/C+bPOUg/JlIv6+vo2+yglF0XVDdh5sgIAcNWwPjJXQ27nxmuoTZs2tfp87ty5mDt3bqttSsmFXKrqrQCA0GDX3wBjo/t8FiwAJk+WgpCTI3X7WLiQy/K40C85FXjrZ6nB/eKcYZg3jk/5FIe5cKkNR4oBAMlcX1hdmAu3stodePij/Ticb0SEzh8rbx2Fi5Oi5C6LzsVctJJbIa1IkRgZ7PR1gEklmAlFKKsx41/p0mzxw/u6vkctG91dkZQELFsmdxVeIf1YCR775ACEAG4eG8cGt5IxFy6RW16HnScr4KMBbhoTJ3c51F3Mhdt8vDsXW46XIshPi1ULxmEEe4UoF3PRrN5qBwAE+fMS3KsxE7J7Z+splNVYMLi3AfdOHeDy12PiIY0fVjtPOIbXN2Vj+Q/HAADD40Lx9DWpMlfk3dT+nlJr/d8eLgQAXDQwErF8CqIoan1PteQJx9Dk+4wiAMDvLk9mg1tGnvCecucxNE2ipg/gOvKejLlQvqbJN2eN6otAP9fn0asb3b6+0uGbTCZVz4othEBpaSk0Gg38/NQ5KUdVnQUvrz8OALhzYgL+fO0QBPjyhCQHT8mFySRNVNN0PGqx62Q5AOCKIZzHQCn8/Pyg0WhQWlqK6Oho1ebCE84VTRwOgT2nKgEAlzMrsmAueqamudGtrnMTdY2nXEN50vmiI2U1UqM7wNc984p7deJ9fX0REhKC8vJylJeXy13OBdFoNIiLi4NWq86G6p6cStgdQloeaVaa3OV4NU/KRUhIiOoa3U2TevApt3JotVrExcXhzJkzyOnmGqpKo/ZzRZOKOgssdgc0GiAh0rUzzlL7mIueMTb+jjdwGUiP5EnXUJ5yvmiPscGK7dnS/8/kZPfMBaKuq1EXiI2NRVRUlOq7UPj5+akrFFlZEO+8ix1F9XglZjx2Q5rAoE8oGxpK4Am50Gg08Pf3l7uMbjHb7MgurgEAxIQGylwNtaTX65GcnAyr1Sp3KRdEdeeKDuw+Jc3+HB8eDD8tVz+VC3PRfU3vXd5Y9VyecA0FeM75oj0Z+UZY7A7EhQdhUG+DW17T6xvdGo0GAQEBcpfhXVatAn7zG3ww6hosufx+AIC/zYpbomx4+IHLZC6OAOZCLjtOlMNktqF3SADSuDa94mi1Wo+9AFGbz/fnAwCuGc4ll+TGXHRdUXUDfjpaAgCYM5pL23kqXkMp3/48aXhS/yid217TKxvdtbW1PEHIJTsbWLgQQgjsCu0NW20VLik8jpd+fB19aiuBm44BIVwygbxTdon0lHtcYgR8fNQ7FozIlarrrEg/JjVcZo1kw4XU45M9ebA7BMYnRiDZTU/XiKi1bdllePlHaR6pSwb3ctvremWjOzY2Vu4SCAA2vg1sfBujRsxEH1M5oNVKaxZyCQXyQnUWG9b9Ks1czm6HRB377nAhrHaBlBgDBsew4ULq8fn+MwCA2yZwOVQiOZhtdvzu4wOwOQRuGBmLuycluu21ORCKZDc5Z5/0FyEAlU/GQtQTZpsdC9/7Bftzq2AI9MXNY7k+N1FHvjxQAAC4bgRvoJN6lNeYkVNeBwC4dIj7nq4R0VnfHCxEWY0ZfUID8dJNw906w7xXPukuKChASEiI3GV4pyVLIF55Bdfd/DzSP34aAJBaLXUThEYDJCbKVxuRTF7fmI0dJ8uhD/DFf+4Zj6RefHpH1B4hBHadkmacvXoYx3OTehwrlpaxTIwMRghnLieSxXeHiwAAt47v5/alib2y0a3T6aDTuW/gPLXwwAPYu+Z7nOgzuHlT8z0mIYCFC2Upi0guOWW1+NfmEwCAF+cMx6h+4TJXRKRcNoeAo3FC4Ihgda1OQN6tqk6a4T1Kzwm2iOSSVSLd/Bqb4P5rLXYvJ7eyD0zCcwuXtt7o4yN9vPMOkMRJ1Mi7/HS0BFa7wMQBEbh6WIzc5RApWp3F3vz3AD9ewpB6nCyVJsrszeUgiWRTajIDkGfuHJ6xyK3e2HIChxr8YPBv8dZbtAg4dgxYsECusohkc7xIuus6vn+kW8cWEalRRa0FAKDz1yLQj6uQkHrsyZGWKBonwxM2IpIa3BabAwDg5+v+JjAb3eQ2u09V4O+NU/Q/eU3q2X/461/5hJu8VkWd1IjoHcIuh0Tnk1chTUQVw6eFpDJZjWO6h8WFylwJkfdpsNpx/we/wOYQGBCtQ0yI+88hsje6S0pKMGvWLISFhSEqKgqLFi2CzWZrd99XX30V/fv3R0hICIYPH45PP/3UzdVST9nsDjz56SHYHQKzR/XFjaO4tmpnmAvvYW686+ruCT3UiLmg0+W1AID+UXqZK1EGZkIdLDYHCqobAAAJkZxTyNWYCzrXu9tOYV9uFUICffHW/LHQ+ri/Z6Hsje558+ZBr9ejoKAAu3fvxoYNG7BixYo2+3333Xd44YUX8P3338NoNOLZZ5/FzTffjBwuMaUK3xwqxKmyWoQH++H5WWnsRnsezIX3MFulMaqBHJ96XswFldVIPUN6sWcIAGZCLeqtZ+ci4MzlrsdcUEtWuwP/2X4aAPDMtakYGC3PTVtZr/Kys7ORnp6Ol156CcHBwRgwYACeeeYZrFy5ss2+R44cgRACDocDQghotVr4+/vD19crJ2BXnS8P5AMA7p7UH/oA/p91hrnwLnzS3TXMBQFAXqXUvTyaM0AzEypirJdmLvfTauCn5UMHV2Iu6Fw7T5ajyNiASJ0/rh8ZK1sdsr6rMjIyEBERgdjYsz+A1NRU5ObmoqqqCmFhYc3bb731VqxatQqpqanQarXQaDRYvXo14uLiOvz+ZrMZZrO5+XOj0eiS46DOFRsbsD+vCgAwOTlK3mJUwJW5YCaUp4FPuruEuSAA2JNTAQAY1S9M3kIUgNdQ6nGsccLMgdF69vRzMeaCzrXleCkA4JKUXrI+4JD1Ks9kMrVZLzs4OBgAUFNT02q7xWLByJEjsXv3btTV1eHNN9/EwoUL8euvv3b4/ZctW4bQ0NDmj/j4eOcfBHVq96kKXPPaVlTVWdE7JACpfULkLknxXJkLZkJ5ai3SOLNgfz7p7gxzQVV1FuRV1AMARnMGaF5DqchPR0sAACPjw+QtxAswF3SupvxNGxQtax2yNrp1Oh3q6upabWv63GAwtNr+yCOPYOjQoRg3bhz8/f1x991346KLLsJ7773X4fdfvHgxqqurmz/y8vKcfgzUsfIaM+a/uwtlNWakxBjwyX0XcYmXLnBlLpgJZbHZHShvHKMaHuwvczXKxlxQVol0wdw3LIjjYsFrKLWwOwTWHSoAAFw/Qr6urd6CuaCWcspqcbK0Fv5aH0wf7MWN7rS0NJSXl6O4uLh5W2ZmJuLi4hAa2npJhdzc3FbdOQDAz88P/v4dX6gGBAQgJCSk1Qe5T055HRqsDkTpA/DZQxcjMYozdnaFK3PBTChL+rFS1FnsiND5Iy48WO5yFI25oFKT9H8aG8blwgBeQ6lFQVU9jA02+Gt9MGFApNzleDzmgloqr5X+f2NCA2GQ+WatrI3u5ORkTJ48GYsWLYLJZMKpU6fw/PPPY+HChW32vf7667Fy5Urs27cPDocDa9euxaZNmzBv3jwZKqeuOFUmLe0SofNDsD8npegq5sJ7fHlQevoxZ3Rf+PtyTHdnmAuqbFzTnk+5JcyEOmSXSj004iOCZFmmyNswF9SSxSYAAL4KyJ7sLaG1a9fikUceQf/+/eHj44P58+fjmWeeAQDo9Xq88cYbuP322/Hss89Cq9Vizpw5qKioQHJyMr744guMHDlS3gOgdpltdryy4TgA4Nrh7E7VXcyFdzjYOMHgtEG95C1EJZgL79Y0njsuPEjmSpSDmVC+/acrAQDD48LkLcSLMBfUpMTUAACIMsi/4oVGCCHkLsJdjEYjQkNDUV1dze4gLrbrZDnmvbkTETp/bHvyUgSdM0lUbW0t9Hppnbyampo2k164Ct8DrfHnIZ+i6gZMXPYTNBrgwDNXIjS4Z0/vnJElvg9a489DmRa+twc/HS3BX65LxYJJ/V3+enwftMafR888uHovvjtchCXXpuKeya5/37oS3wNt8WeibL95/xdsOFKMW8bF429zhrvkNbr6HmB/RnKJ0+XSpBVDY0PaNLiJCNh8XJpNc0RcWI8b3ETewmp3YF+u9MRwBGeAJpUQQqDYKD1pMwTK3rmUyKvsOFGODUeK4eujwW+myH/Di41ucom8SqnR3S+Ck0MRtSezQFrbc8KACJkrIVK+j3fnorLOigidP4bGhp7/C4hkJoTA374/in25VdBowPctkZt9+2shAGDO6Dgk9TKcZ2/XY6ObXCK3Qmp0x4Zx7B1Re043ZiQxkrP6E3XG4RB49adsAMCiy5M56SCpwg8ZxXhj80kAwAuzhyE1ll2PidzFbLNjY+P63JekyLtUWBOeucjphBDYdbICAJDWl3d2idpzrMgEAEjqpZe5EiJlO15iQlmNGcH+Wtwyrp/c5RCdlxAC/0qXbhTdP3UAbh3P9y2RO7215STyq+oRbQjAlGQ2uslD5VXUo8jYIK1J2Z9dZ4nOZWyworBaGuc3qLf8XZ6IlOxwvjQUY3hcKJ9ykyqcqazHwTPV8NNqcO/UAXKXQ+RVhBB4e+spAMCfrxkCXYAy5lPg2Yuc7lS5tD53YlQwAv04iRrRuc40Ln0UofNHaBAnUSPqTJ3FBkDKC5EaVNdbAUjv2Si9/EsVEXmTqjorquqkDM4YGiNzNWex0U1Od6RQeioxIIrdZonas+tUOQBgQBTHcxOdT6nJDAAwBPAGFanDmUrpxmpYEG8UEblbZmM7JDY0UFEP/9joJqfbeVJqUIxj13Kidq3dewYAcO3wPjJXQqR8B/KqAABpcZwjhNRha3YpAGAiV6cgcrtt2WUAgIkDI2WupDU2usnpmu7wDonhWFWic52prENGgRE+GuD6kX3lLodI0WrMNuw6JU3MOT6RDRhSh92N79mLk6JkroTI+xQZpTlzBitszhw2usmp7A6BiloLAChm4gIiJdlyXLoDOyYhnGNUic5je3YZLDYHEiODMag3hyyR8pkarDheXAMAGJsQLnM1RN7F7hDIKZPmltL6aGSupjU2usmpvj9chIpaC8KD/TgrM1E7mu/AsicI0Xk1TYYzIFoPjUZZF1BE7Wl6zwb5aRHJSdSI3OrF749iX24VAv18cElKL7nLaYWNbnKqb38tBADcNqEfgvyVM3kBkRIIIbCnsdthtD5Q5mqIlM/mEAAAHza4SSWaGt3s7UfkXkcKjXhzy0kAwP/NHYGB0crqHcVGNzmVsUE62SjtjU6kBD8dKcGOk+Xw9/XBjaM5npvofGwOBwDAT8tGN6nD0SJp5uSkXlydgsidXt+UDQC4ZlgfXDs8VuZq2mKjm5yqwWoHAEVN0U+kFBuPlQAAbh0Xj/iIYJmrIVI2s82Oj3blAgB6h7BnCKnDiVJpPKnSJnEi8mQVtRZ8f7gIAPDQJQNlrqZ9bHSTU9WapUZ3MLuWE7VharABABvcRF3w5uaTOFpkQqTOHw9fkiR3OURdUlAlreDSNzxI5kqIvMcPGUWwOQSGxoZgaKwyl5dko5ucqsHGJ91E7XE4zo7n7h/FbodE57MlS1rr+IkrByPawAmpSB1qzdLN1ZBAP5krIfIepxpnLJ84QFlrc7fEWR7IqSw2afxdgC/v5xC19Gt+NYqMDdAH+GIS124l6lhWFszvrMIRxzjAxx+jYJS7IqIuq6qX5rZR2nJFRJ7M2Ji70CDl3uxiy4icSkgTzXKmWaJz7D1dCQCY0D+CPUGIOrJqFZCSgp++2ooaH3/EmMowaNIo4L335K6M6LwO5FVh7+lKaH00mNBfuU/ciDxNfuOwjphQ5c7/wSfd5DSlJjPKaswA2L2c6Fz786oAACPjw2Stg7qutrYWWi1/l7lNdjawcCGEEPiqTypstVW47teN0NptwMKFwOTJQBLHdpNyfXWgAABw3fA+6BfJuTuI3MHuEDhSKPWISoxU7vA9NrrJaV7flA2zzYER8WEY1JtLhhG1dCBPetI9ql+4zJVQV8XGKm/JEa+x8Q1g4xtIThwlfa7RAO+8AyxbJm9dRJ0oMkpP20bw5iqR2+w4UY6yGgvCg/0wql+Y3OV0iN3LySmEEFj3ayEA4LHLk6Fh93KiZlV1FuRVSBdjw+KUOasmkRINKc2R/iIEkJMjZylEnbLaHdh9Srq5msjJMonc5pfT0iS1l6T0gp9WuU1bPukmpzhZVotSkxm+PhpFzxxIJIdDZ6oBAHHhQYqe5INaKygoQEhIiNxleI8lSyBeeQW337AYX32+FADQv1ZqxECjARIT5auNqDNZWdj6zucow1BEwYLJqALQS+6qiLxC00ONgdHK7mXLRjc5xf/9cAwAMCkpiuO5ic7x7rZTAIApyZy1XE10Oh10Oj6xcpsHHsDGr7Zif1OXcgDNfaaEkMZ1EynNqlXAb36DU2OuAy4dignHdsMv9SZpOMSCBXJXR+TxjhZJ47kHKLyHCRvddMGOF5vw3eEi+GiAxVenyF0OkaLkltch/VgpfDTA/VMHyl0OkXIlJ+PfdzwFVDvObvNp7Cr4zjucRE0hOMFgCy0m/ysUGthqq6CrMwEOByf/I3IDm92BY0UmAEBaX2UP35O943tJSQlmzZqFsLAwREVFYdGiRbDZbO3uu3nzZkyYMAF6vR7x8fFYxglVFGF9ZjEAYPrgXkiJYVdMZ2AuPEdmodS1PK1vKMf5XSDmwrOZbXYcsJyz3MuiRcCxY3xi2AE5MhEbGwu9Xs8PvR76kSOhFwIGAH/+5Qvkr7wDPrXS+NLmyf/I7Xiu8B7ltRbYHAJaHw1iw4LkLqdTsje6582bB71ej4KCAuzevRsbNmzAihUr2ux39OhRXH311XjooYdgMpmwbt06/P3vf8fatWtlqJqaCCHw5YF8AMBlQzh+yVmYC89xsqwWAJCk8LFGasBceLYjhSZY7A6E61rMe/DXv/JJYSeYCeUJslqkv3DyP9kwF96j1CQtVRyh84fWR9mTOMvavTw7Oxvp6enIz89HcHAwBgwYgGeeeQZ//OMf8Yc//KHVvq+//jpmzZqFu+66CwAwfPhwbN++nZPcyCz9WCmOF9dA56/FdSO4vI4zMBeepcQonRB6hwaeZ0/qDHPh+Q42rmU/rG8oDslbiirIlQlOMNjCkiXAK6+g1uFA78ZNIXar9BdO/icLniu8i7FBypsaJqmV9Ul3RkYGIiIiWq2FmpqaitzcXFRVVbXad/fu3UhMTMStt96KqKgoDBkyBOnp6YiJiXFz1dSkus6Kpz//FQAwb1w/hAQq/w2vBsyFZ6kxS13amI8Lw1x4vqwSaVxeSoxB5krUQa5MNE0wyA8ddA88AB2AlgOHAhyN3Zg5+Z8seK7wLrVmOwBAF6D8acpkrdBkMrWZGTY4OBgAUFNTg7CwsObtFRUVeO211/Dxxx/jgw8+wPbt23HttdciIiICN910U7vf32w2w2w2N39uNBqdfxBebMWG4yiobkBCZDAev3KQ3OV4DFfmgplwP4dDAJAeelDPMReer7CqAQDQR+Hj8pSC11AKkJwsjdu+5x6pkQ3AXzikCQA5+Z8smAvvYqyXnnQH+so+Yvq8ZK1Qp9Ohrq6u1bamzw2G1ne6AwICcMMNN+Caa66Br68vpk6dijvvvBNr1qzp8PsvW7YMoaGhzR/x8fHOPwgvti9XWj/191cOhl4Fd5jUwpW5YCbc71S5NKY7JoTdyy8Ec+H5qhovniKD/WWuRB14DaUQCxZA7N/f/Gn8JRdz8j8ZMRfe5ZM9eQCAEfFh8hbSBbI2utPS0lBeXo7i4uLmbZmZmYiLi0NoaOtp31NTU1vdWQIAu90O0XhnsT2LFy9GdXV180deXp5zD8DL5VZIv8SSe3OCKGdyZS6YCfdyOAQyCqS74Go4ISgZc+H5ahuHYgQHcDmqruA1lHIc0UU3/33skt/xCbeMmAvv8cGOHOzOqYC/1gcLJ/eXu5zzkrXRnZycjMmTJ2PRokUwmUw4deoUnn/+eSxsZwzMAw88gC+++AKrV6+GEAJbtmzBhx9+iDvvvLPD7x8QEICQkJBWH+QcQojmLh0RfCrhVK7MBTPhXuW1FlhsDmg0QFw4u8xeCObC85lt0vrcgX5sdHcFr6GU48v9Bc1/5/tXXsyFd9hyvBTPfpUBAFh0RTJ6q6A3oewd4NeuXQubzYb+/ftjwoQJmDlzJp555hkAgF6vx4cffggAuPTSS/HVV1/h1VdfRWhoKO6++2783//9H66//no5y/dadRY7GoeqqmLyArVhLjxDWU3jUhbB/vDTyv7rVvWYC89VUWtBQVU9AE462B3MhDLsPFkudwnUAnPh+VZsOA6HAOaOicOD0wbKXU6XyN5a6t27N/73v/+1+281NTWtPr/qqqtw1VVXuaMsOo+mKfp9fTQI9uddXWdjLjxD08zlhkDZf9V6BObCc328JxdmmwNDY0OQ1ItDlrqKmVCGqnqL3CVQC8yFZys1mXGgcYnJ388YDI1KZqrloxfqkaaxd/pAX9W82YncranRzd4gRJ3LbJz74IaRsTynkKrYHQIVNVa5yyDyGntPV0IIaXlJNXQrb8JGN/VInUVaFy/Ql0+5iTpS17h+JHuDEHXOZpfGKwXwnEIqU1Zjhs3R8cRbRORcGQXVAIARcWHyFtJNbHRTj5wolbrn9OXkUEQdyi6RchIXHixzJUTKdrRIetIdH8FzCqlLfeNDCCJyj4paaThHnzD1POUG2OimHjpaZAIADI3lrI1EHdmTUwEAGNY39Dx7EnmvqjoLcsqlJSjHJkbIXA1R9zTNuk9EbpCVhdJd+wEAug0/AllZMhfUdWx0U4+YGqSxqpG6AJkrIVKmUpMZ20+UAQAuG9JL5mqIlKu88amFIdCXM5eT6hwrNsldApF3WLUK9WnD8bNVBwCY8MFKICUFeO89eevqIs7uQz1itkp3dv19ed+GqD3bT5TBIaSn3AmROrnLIVKsbdnSzakYFU2IQ9Qkp6xW7hJIAWpra6HVck4Kl8nOBhYuxPa+qTBZGhBTfgZDC45J/7ZwITB5MpCUJG+N58FGN/WIgDRpiA8nmSVq17HGIRjD49i1nKgjNrsD/9x0AgAw/6IEmash6j5jPWcuJyA2NlbuErzDmQxg5R3IB1AOoBcAaDTAO+8Ay5bJW9t58DEl9ciJxgmiovTsXk7UnlKTGQAQG8aJoYg6klNehyJjA4L9tbh5XLzc5RB1S15FHT7ekyd3GUTeTQggJ0fuKs6rR0+68/PzAQB9+/Z1ajGkDsYGKw7lS9P1T06Okrka5WAuqKWGxsl1Arx4CAYzQedzsnEljAHROq9ZLoy58BwrNhxHjdmG0f3CwKb3hVF7LgoKChASwsmFXWbJEuCVV7Dgmiew9uvlAIDmdWE0GiAxUa7Kuqxbje5t27bhjjvuQG5uLgAgKioKCxYswNNPP803mhcpM5khBGAI8FXVovSuwlxQe44USksg9YvwvuXCmAnqquONk1Al9zLIXInrMReeJ69CmnX/jokJ+FLmWtTKU3Kh0+mg03H+Fpd54AE0/ON1HEoY0bypeYSrENK4boXr1iOY+++/H0OHDsWePXtw6NAhLF++HD/99BPGjBmDsrIyV9VICpNXWQ8ACAniLLMAc0FtnS6vbV6j2xuXQGImqKsO5FUBAAbHeH6jm7nwPA2Nk8oG+Xtvj6YLxVxQlyQnI+OVt1Hv1+Jhn4+P9PHOO4qfRA3oZqP7xIkTWLFiBUaPHo2hQ4di/vz52LNnD0aOHInf/va3rqqRFOZ/v0idqC5N4TJIAHNBba3algMAmD44GhE6f3mLkQEzQV1RY7ZhS5Z0UT19cLTM1bgec+F5bA5pUlmtDxvdPcVcUFdVTL+i9YZFi4Bjx4AFC+Qop9u69VtiyJAhKCoqarVNo9Hgr3/9K77++munFkbKVGO24cfMYgDAPE56A4C5oNYarHZ8uu8MAOCeSf1lrkYezAR1xU9HimGxOTAgSofBvT3/STdz4XkcjY1uXy7l0mPMBXVVUw/CZn/9qyqecDfpVqN7wYIFuO+++5rHXTSprq5GaCiXxfEGm4+VwmJzIDEyGENj1TPWxpWYC2pp8/FSmBps6BMaiMlJ3jnRIDNB52N3CHy0S3p/XD2sDzQaz2+0MBeex2qXupf7e/GEmReKuaCu2ni0WO4SLki3JlJbtGgRAGDQoEG48cYbMXLkSNjtdqxevRrLly93RX2kME13mSYOiPSKi6SuYC6opdPltQCACf0j4OOlTz+YCTqf57/JxK5TFfD39cGNo9U5W3F3MReex9ggrdEd7N+jxYAIzAV1jRACh/ONcpdxQbr1W6KoqAj79+/HwYMHceDAAbz33nvIysqCRqPB3/72N6xbtw7Dhw/H8OHDMXPmTFfVTDKqqJXWHvbGcaodYS6oJYuNTz6YCerM/txKvLc9BwDw97kjMCBaL29BbsJceJYTpTUor7UAAKL0ATJXo17MBXVFkbEB9VY7tCp+mNGtRnevXr0wY8YMzJgxo3lbQ0MDfv31Vxw4cAAHDx7EV199hRdeeAFVVVXOrpUUoKC6AQDQJ5RLhTVhLqil/Cppdv8YL15Oj5mgzhRUSeeRsQnhuG5ErMzVuA9z4TnqLXY8uHovhAAuHhiJaAMb3T3FXFBXZBVLPW0TI4ORI28pPXbB/WECAwMxbtw4jBs3zhn1kMLllEldZ+O9cO3h7mAuvNfJUikj3vL0rquYCWrSYLUDAIL8tTJXIj/mQp3WHynG8eIaROkD8MotIwHY5S7JozAXdK6cxqF7/aN1SJe3lB7z3v6P1G21ZhtOlEp3mlL7cBI1ovbkVtQBABIieWOKqD3FJulJN58OklrlNf6enzYoGr0M3turichd6izSjS2diudPYKObuuxUWS0cAojU+aOXF3edJepIg9WOIqPUoOjH3iBEbdjsDnyxPx8AkNSLvUFInSqax3Jzfhsid6hvbHQH+qm36areysntihrHc/dmg5uoXflV9RACCPbXcrJBonZ8caAAx4trEB7sh9snJMhdDlGPNE2YGeDFE2YSuVN1vbRSQGiQn8yV9Bx/W1CXfXFAejoxrC/XTSRqT2WLmWy5pB5RW5uOlQAA5l+UqOqLJ/Jux4pMAIDYsCCZKyHyDk1LFvdRcebY6KYuqaqz4LvDRQCAuy5OlLcYIoVqGnMUzAmiiNoQQmBvTiUAYMKACJmrIeoZu0PgQF4VAGDCgEh5iyHyAg6HwMEzVQDU/eCPjW7qkv15VbA7BPpH6ZAay0nUiNrTNM4vPJhdy4nOdbKsFkXGBvj7+mB0v3C5yyHqEavdAYtd6l7OyQCJXC+nvBamBhsCfH0wqLdB7nJ6jI1u6pLjjV2p0lR8h4nIlTILjHjp+6MAOIkaUXsO51cDAIb3DUWgH3uDkDqZG8dzA4CvD4cREbna0cY2SEqfEPhp1dt0lb3ykpISzJo1C2FhYYiKisKiRYtgs9k6/ZrDhw8jODgY6enp7imSYGyQJjCI5ORQbsFcqMve0xWY++/tKKhuwIAoHR69LEnukjwSc6FuTY0VQ6B6l3xRGmbC/fIr6wEA4cF+vHmkUMyFZ2mayDkuXL3juQEFNLrnzZsHvV6PgoIC7N69Gxs2bMCKFSs63L+urg633nor6uvr3VglNXWb5cQ37sFcqEeN2YbffXwAtRY7LhoQic8fmoS4cD7pdgXmQt2aGis8jzgPM+F+J8ukCZ0SInUyV0IdYS48S3mtGQAQrVf3cA5ZG93Z2dlIT0/HSy+9hODgYAwYMADPPPMMVq5c2eHXPPTQQ5g9e7YbqyQAONN4sdRX5XeZ1IC5UJeXfzyOM5X1iAsPwpvzxyA0mA0KV2Au1G/HiXIAnHzKWZgJeWQWGAEAQ/pwfhslYi48j7Fe6qUQovJeUrI2ujMyMhAREYHY2NjmbampqcjNzUVVVVWb/f/zn/8gOzsbzz77rBurJOBs147YUDa6XY25UA9jgxUf78kFAPy/WWkwBLLB7SrMhbo1WO3NMz5PZKPbKZgJeRwplBrdqX3UO6GTJ2MuPE+tWWp061Xe6Ja1epPJBJ2udfec4GCpW2ZNTQ3CwsKatx89ehRPP/00tm3bBq22a2NozGYzzGZz8+dGo/HCi/ZCQojmRndMqLq7dqiBK3PBTDjX+oxi1FnsGNRbj2mDouUux6MxF+qWWWiExe5AlD4AiZEcfuEMvIaSx/FiqXt5Cp90KxJz4XnqrdJyrGqfQ0HWJ906nQ51dXWttjV9bjCcvYPY0NCAefPm4ZVXXkG/fv26/P2XLVuG0NDQ5o/4+HjnFO5lCqobYDLb4KfVoF8ExzC5mitzwUw4V9NcB6l9QqDRcBZbV2Iu1K26TpqMs09oILPiJLyGkkdTA4BzEygTc+F56ixS5oL91f2kW9ZGd1paGsrLy1FcXNy8LTMzE3FxcQgNPbs01Z49e3D8+HEsXLgQYWFhzXeprr32Wjz00EMdfv/Fixejurq6+SMvL89lx+LJjjSOXxoYrYe/r+xz73k8V+aCmXCuqnqp0a0LUPeJQA2YC3Urq5GeDHHmcufhNZT72R2iuatroK+6n7p5KubC81TXSzdt9Sq/1pK1+uTkZEyePBmLFi3Cm2++ibKyMjz//PNYuHBhq/2mTJnSZkZBjUaDb775BtOnT+/w+wcEBCAggN2hL1RWidSVSs0L0quJK3PBTDhXdmM2BkTrZa7E8zEX6pbRePM2JYZdcp2F11Dul1tRB7PNgQBfH04sq1DMhefJr5L+n7hk2AVau3YtbDYb+vfvjwkTJmDmzJl45plnAAB6vR4ffvihzBVSZuOkIYNj2Oh2F+ZC+RwOgV9yKgFI3cvJ9ZgL9coprwUADI7hDSpnYibcq8QozW/TNywIWh8Ok1Aq5sJzOByiuadUrxB13+yQ/Tl979698b///a/df6upqenw64QQriqJzpGRXw0ASOsbep49yVmYC+U7XFCN8loLDAG+GJsYLnc5XoG5UK/KxvkPInTqvmhSGmbCvRyNPzYfNrgVjbnwHDUWG5r+W0IC/WBvHN+tRrI/6SblK2q8s5sQwRlniZqU10iNiISoYPhp+auUqDNNE+HoAjgOltTLYncAAPz5O5/ILUwN0hwK/r4+nL2cPJvV7mi+WArhTJ1Ezcw2KRdaH/4aJeqMEALGBmkinABOPkUqVm+RGgBB/nwfE7mDsXEStRAPmISTV4vUqaZZOgH1zxpI5EzHiqQuagOjuIweUWdOltWi2GiGv9YHKZwbhFTs7NJFbHQTuUNV43KTnrBEHxvd1KmW3Tq4XBjRWSfLpEY3Jxgk6ty3hwoBABMGRHB5PVIth0Pg8/35AIBoA+cmIHKHo0XSZM69DIEyV3Lh2IqiTlU0Tn4TqfOXuRIiZWmwNo1RZSOCqCNCCKzddwYAMGtkX5mrIeq5Nb/k4eesMgT4+uCh6Ulyl0PkFb5ovNE1Y2hvmSu5cGx0U6eqGsdShAWz0U3UUlOXJ4MHjDMichWT2YbT5XUAgCs94KKJvNfavdLNo0WXD0JSLy59R+Rq1fVWHDwjraB09fA+Mldz4djopk6ZGtiwIGpPiUlaN7J3iPq7PBG5SmljTvQBvjAEqn9MHnmnYmMD9udVAQCuG6H+i38iNTh0pgoAEB8RxO7l5PmalkVi93Ki1uoaZ7HlBINEHWsaohSl5zmE1Ou1n7JgdwiMTQhHXDiXTyVyh83HSgEA4xMjZa7EOdjopk4dLzYBAHpx0hCiZkIINFil9Vq5RjdRx5qedEfwxi2plM3uwP9+kbqWP3HlYJmrIfIOQgj8mFkMALg0pZfM1TgHrxapQ7VmG748UAAAuDyVY/GImpSYzKiut0Lro0FCJJ96EHXkVFktACAxkkvrkTo12Byw2KWbrKP6hclbDJGX2H2qArkVddD5a3FJSrTc5TgFG93UoX25lagx29A3LAiTBkbJXQ6RYmw4It19HdTbgEA/rtdK1JHT5Y2Nbq5nTypVZ5aGEvloAH/2bCJyi+8OFwEArhrWB8H+njGMj789qENnKusBAIN66+Hjo5G5GiLl+GhXLgDgpjFxMldCpGxNEw5yiBKpVbFReg9H6gN4LUTkJpuOlQAArvSgnrZsdFOHiqobAAAxoUEyV0KkHEIIHCk0AgBmpsXIXA2RcpkarNh1sgIAkNzbIHM1RD3zQ4b0xG0w38NEblFWY8bp8jpoNMBFAz1jEjWAjW7qRFmNdHc3mk8oiJqV1VjgENLfw4O5BBJRR37IKEa91Y6kXnqM5lhYUiEhBD75JQ8AcNuEfjJXQ+Qd9p2uBAAMiNJ51FKTbHRTh7jUC1Fb/9mRAwAYHhfqMeOMiFyhqFoaojSmXzg0GnbLJfXJrahDqckMf60PLh/iOd1ciZTss335AICpgzxjArUmbHRTu3LKarHjZDkAoHeI+hekJ3KWppPBA9MGylwJkbKVN9641Qfy5hSp0zeHCgEAqbEh8PflJTORq5ltdvx0VJqs9uax8TJX41z8DUJt1JhtuOe9Paiqs2JY31BM87A7TUQ95XAIFBmluQ7GJITLXA2Rsh3MqwIApPYJkbcQoh4oNjZg5cZsAMBdFyfIXA2RdzhZWgurXcAQ6IuUGM+aR4GNbmrji/35OFlWiz6hgXhnwVguiUTUqMZig71xQHdokOeMMyJyhWNFJgDAiPhQmSsh6r4dJ8pRb7UjJcaAWSP7yl0OkVf4bN8ZAEBabKjHDUtio5tasdod+LBxOaSFk/ujl4Fdy4maCMfZv2u5dAxRh+otdtRa7AA4RInUqaZxfe5+EcEed/FPpETlNWa8v+M0AOD+aQNkrsb52OimVv7vx2M4UmiEIcAXs0bxzi5RS2a71IjQaABfNrqJOlReK61+4a/1gT6AY7pJfUoahxJFcjJZIrc4UVoLi82BuPAgjxzaykY3Ndt5shxvbD4JAHjppuGI0nOpMKKWGizSo+4gPy2ffBB1oqrOCgAIC/ZjVkiVTlfUAQASInUyV0LkHQ7nVwMAInX+HnneYKObAAAWmwPPfHEYAHDr+HhcNayPzBURKU+9VXrSHcR5Dog6VdfYtZxPuUmtKhtvHEXzAQSRyx0pNOLF748CAK4dHitzNa7BRjcBAL46WICskhpE6vzx1MwhcpdDpEhNY/yC/NnoJurMmUrpKSGXCyO1MtZLjW6+h4lc762fT8Jsc2D64GgsnNxf7nJcgo1uAgC8t/0UAOA3UwYgNJizMhO1p9QkjfGLNvDJB1Fn1u6VZqC9ZHAvmSsh6pmmeQmiOKabyOVOlNYCAOaNjYePh86Zw0Y3obLWgsP5RgDAvHGetRA9kTOV1lgAsLshUWdOltZg+4lyaDTA3LFxcpdD1COmBqlnU0ggH0QQuVKN2YYjhVI7JLm3Z63N3ZLsje6SkhLMmjULYWFhiIqKwqJFi2Cz2drd99///jcGDx4Mg8GAQYMG4Z///Kebq/VMp8qlu0t9QgMRoeMdXSVgLpTJ1CB1NwzhGt2yYC7U4eM9eQCASwf3Qlx4sMzVeDZmwjWEELDbBQB45IROno65UJefjhTDYnNgQJQOA6M9d+JC2Rvd8+bNg16vR0FBAXbv3o0NGzZgxYoVbfb74osvsHjxYrz//vswGo14//338fTTT+PTTz+VoWrPUlBVDwCICw+SuRJqwlwo09FCEwBmRS7MhTrsOFEOALiBy066HDPhGrtPVcBktiHIT4uYUK4zrzbMhbp80nij9toRsR59k0vWRnd2djbS09Px0ksvITg4GAMGDMAzzzyDlStXttm3oKAATz31FCZOnAiNRoOLLroIl1xyCbZs2SJD5Z6lqFoap9orhCcWJWAulEkIgV2npMbE+P4RMlfjfZgLdbA7BI4WSd0ER8WHyVuMh2MmXOfDXbkAgFmjYjkDv8owF+pSYmxoHo50s4cPR5L1N0lGRgYiIiIQG3t2avjU1FTk5uaiqqoKYWFhzdsfeuihVl9bUlKCLVu24OWXX+7w+5vNZpjN5ubPjUaj84r3IGcq+aRbSVyZC2ai506W1aLYaIa/rw9G9wuXuxyvw1yog9XugLWxW244hyu5FK+hXMPYYMUPGUUAgFvH95O5Guou5kJdTpVJQ1z7RQR7/HAkWZ90m0wm6HSt++4HB0s/8Jqamg6/rqioCFdddRXGjBmD2267rcP9li1bhtDQ0OaP+HhOEtae5u7lYWx0K4Erc8FM9Nz3h6WLsLEJ4QjkOt1ux1yog0OI5r97bidBZeA1lGv8K/0EzDYHknvpMaxvqNzlUDcxF+qyJasUgNTo9nSyNrp1Oh3q6upabWv63GBof/a6nTt3Yty4cRg8eDC++uor+Pp2/LB+8eLFqK6ubv7Iy8tzXvEepHmGTk4OpQiuzAUz0TMNVjs+auxueONoz+7+pFTMhTrYHWcb3b5aNrtdiddQzpdVbMKbW04CAP4wY7BHjy/1VMyFepTVmPHu1hwAwB0TE+Qtxg1kbXSnpaWhvLwcxcXFzdsyMzMRFxeH0NC2dxffffddXHbZZVi0aBE++ugjBAR0vmxPQEAAQkJCWn1QWzVmqdFtCOS4JSVwZS6YiZ557usM5FfVI0rvj2uH95G7HK/EXKhDQZU0R0iQnxZ+PrLP1erReA3lfD9mFsPuEJg6KBpXDo2RuxzqAeZCPbafKEe91Y6UGAOuTO0tdzkuJ+sZMTk5GZMnT8aiRYtgMplw6tQpPP/881i4cGGbfT/99FM8+OCD+Oyzz/DEE0/IUK3naloGycC1KBWBuVCWTUdL8N/dedBogJdvHsmu5TJhLtRh50lpssGxieHw8eFTQldiJpzveLG0QsXEAZwsU62YC/XIbszbqH5hXtGrRPbb0GvXroXNZkP//v0xYcIEzJw5E8888wwAQK/X48MPPwQAPPfcc7DZbJgzZw70en3zxwMPPCBn+aonhECRUXoyEaXv/O4euQ9zoRwbjkh3y28b3w9TB0XLXI13Yy6Ub09OBQBgfCIbLe7ATDhXboXUDbl/pOeuFewNmAt1yCqRxtgPjNbLXIl7yN6fuHfv3vjf//7X7r+1nPDg0KFD7irJq5SYzGiwOuCjAfpyIjXFYC6UY19uFQBgSnKUvIUQc6FwpSYzthyXJsUZk8gZ/t2BmXCu4sYlVPvwekjVmAt1aOpZkty7/bH2nkb2J90kr8wCaamDgdF6+Pvy7UDUksMhcLJUOkEP6cNxW0Sd+dPnv8LYYMOQPiF80k2qxDluiNyjwWpHTrnUs2QwG93kDU40NigGxXjHG56oOz7YeRpmmwM6fy17ghB1Iq+iDuszi6H10eDlm0fAV8vLC1IXIQTqLHYAQLA/5+4gcqXjxSbYHQJhwX7oHeIdw1t5VvRy9Y0nmBBOokbUytEiI5auOwIAeOLKwWxEEHXi0JlqAEBqnxD2CiFVMtbbYGtc8i5C5y9zNUSe7WDjOWNY31CvmEQNYKPb6xkbZy7XB/CuLlETIQSWfJkBi92By4f0wt2TEuUuiUjRCqvrAQCJUZyAitTpSJE03K6XIQABvrwmInKl40XSeO6hsW2XcfNUbHR7ubIaCwDOXE7U0qZjJdh9qgKBfj547oY0r7kLS9RTTU8I/bhMGKnU9hPScncTB0TKXAmR58sprwUA9I8KlrkS92Gj28tV1EqNbnalIjrrm4OFAIBbx/fjWG6iLjhSKD0ljIvwngso8izbsssAABcPZKObyNXKGx/69Q4JlLkS92Gj24sJIZBXKc0cGB7MRjdRk62NF19XpsbIXAmROuw+Ja3PPbE/Zy0n9amoteBAXhUAYFISl4ckcrWm4a0GL5pTio1uL3YgrwonS2sR4OuDcVzehQgAYHcIlNaYAQBJvfQyV0OkfKUmMwqrG6DRACPiw+Quh6jb1h0qgN0hMDQ2BPHsrUHkUja7o/lJd5Teex76sdHtxf639wwA4OphfRAa7D13mog6U1VngZCGpyKcuSA6r1/zqwAAA6J00AVwfWNSn68OFgAAZo/qK3MlRJ6txmzDvf/5BfVWO3T+Wq/qXs6zo5eqNduw7pA0bvWmMXEyV0OkHKYGGwBA56/lMmFEXbD3dCUAYHS/cJkrIeq+YmMDfml8D18zvI/M1RB5roKqeix8/xccKTQi0M8HL88biUA/71kpgI1uL/XS90dRXW9Fv4hgztRJ1MKWrFIAQL9ILn1E1BXHi2sAAGl9vWfpF/Ic3x8ughDAqH5h6BPKiTOJXOFAXhXu/c8vKDWZEaX3x9t3jcNILxuOxEa3F8ouMeH9HacBAEtnp0HLJV6Imv3vF2nYxbyx7AFC1BV5FdKEnP0iORaW1Gd9ZjEA4Oo0PuUmcgVjgxV3vrMLpgYbUmIMePuusYgL977zBRvdXij9mPQkb0pyFKYkR8tcDZFy2B0CR4ukpY8uG9Jb5mqI1KGsaekXg/eMzSPPcbzYBAAYx5n3iVziUF41TA029AkNxNoHL4beS+f+4IBFL7T5+NlGNxGdlV1SA6tdIMDXh+tzE3VRdb3U6OaEnKQ2tWYbSkzSahUJnLWcyCU+358PQJr3w1sb3AAb3V6n2NiAbY1rEM8cyq5URC2tzywCAFw8MBI+HHZBdF5CCFjt0nT/Ab68pCB1OXSmGgAQGxqIcJ33LF1E5C4bjxbj031noNEAd09KlLscWfEM6WV2n6qAQwDD40I5/o7oHLtzpBlsL03pJXMlROpwprIeAOCjAXT+3vsEg9Rp58lyAMAozrxP5BL/Sj8BALhnUn+MTfTuIRxsdHuZvMrGCW/YjYqojaYJoQZG62WuhEgdvjssLT05vn8Egvy9Z+kX8gw/HZUmUZs+mPPbEDlbflU99uRUQqMB7p0yQO5yZMdGtxcpMTbgzS0nAQAj4sLkLYZIYQ7kVeFUWS38tBoMjjHIXQ6R4pkarM3nlOtGxMpcDVH3ZBYYcTjfCF8fDXs3EbnA0UJpYtohMSGICeVEm2x0e5EVG46jqs6KtL4huOviRLnLIVKU97adAiA1HiL1ATJXQ6R8H+/OQ1mNBQOidLh5bLzc5RB1y9tbpRtGM9Ji+DufyAWaJinsHcJ8AWx0e5X9uVUAgN9dNgj+nPCGqFm9xY4fG9dqvWNigszVEKnDkcanGHPGxMFPy3MKqcehM1X4bJ80ozK7vRK5Rk55LQAOaW3Cs6SXKDE2ILukBgCQwq6zRK18tv8M6ix29A0Lwqj4MLnLIVKFk2XSBVUCJ+UkFamsteC3/90PALhxVF+M5O98Ipc4WmgCAAzsxXlyADa6vcaq7TmwOQTGJoQjnneciJo1WO147acsAMBvpvSHRsOlwojOJ7e8DseKpAuqlJgQmash6hqHQ+ChD/chp7wOfcOC8KdrhshdEpFHyquow56cCgDA2ATvnrW8Cdf38AINVjs+2pULALhvKrtREbWUfqwExUYz+oQG4rYJ/eQuh0jRTA1WvL7pBN7degoWuwN9w4LQP0ond1lEXfJzdhl2nCxHsL8W7y4YhyiO5SZyKovNgbe3nsRrP2WhwepAv4hg9rBtxEa3hzucX41Xf8pCdb0VfcOCcNmQ3nKXRCQ7U4MVO06U4+esMvyYWQQAuHpYHwT4cskjonNZ7Q5sP1GObw4W4IeMIhgbbACAKclR+Mv1Q6H1Ye8QUocPd54GAMwbF89VKoicrMFqx+1v78Le05UAgIsGRGLZjcPgw3MEADa6PdbuUxX4x8Ys/JxV1rztd5cn8+KIvFZ2SQ3WHSrE1uxS7Mutgt0hmv8tyE+L2aP6ylgdkbLY7A7sPlWBb34txHe/FqKyztr8b/2jdPjzNUNwaUovDscgVclqnNvmytQYmSsh8iw2uwPPfHEYe09XIiTQF3+5fihmj+rLc0QLso/pLikpwaxZsxAWFoaoqCgsWrQINput3X2//fZbDBs2DDqdDkOGDME333zj5mrV4fvDRbj5jR34OasMPhrghpGx+Pa3U7iki4owF87165lqXP3az1ix4Tj25FTC7hDoH6XD/IsS8OadY7D76cuQ1jdU7jLpPJgL12qw2vFjRhGeWHMQY5duwG1v78JHu3JRWWdFhM4ft0/oh//eOxEbHp+Gy4b05sWUAjATXddgtaOscQmjsGA/mashV2Iu3OdIoRFL12Xior9txP/2noGPBvjn7WNw4+g4niPOIfuT7nnz5qFv374oKChAUVERrr/+eqxYsQJ/+MMfWu2XlZWFOXPm4L///S+uvfZafPbZZ7j55puRlZWFvn35hKrJrpPleGLNAQDANcP64MmZKejHmWVVh7lwnhqzDY/8dx8sNgdGxofh5rHxmJIcxQkFVYi5cI2tWWX4cNdppB8rRb3V3rw9PNgPV6bG4NoRfXDRgEj4clkwxWEmum7VthyYzDb0CQ3EwGjOpuzJmAvX+/JAPt7YfBKZjUtHAtI548mZKZicHCVjZQomZJSVlSUAiPz8/OZtH3/8sejXr1+bfZ9++mlxxRVXtNo2c+ZMsWTJki6/XnV1tQAgqqure160AjkcDrE1q1Tc8sYOkfDkNyLhyW/EvDe2C4vNLndpHaqpqREABABRU1PjttdVw3vAnblQw8/jQq3ZkysSnvxGXPTCBlFVa5G7HKdzRpbU8D5gLpzvYF6luO2ts+eNppw8++VhsS27VFhlOofIdX44l9LfB7yG6pqTpTXi7lW7m9/jH+zIcfprKOU962pqeA8wF65nsdlF0p/WiYQnvxFJf1on7v/PL+KHw4XCbHX9OUOJWevqe0DWJ90ZGRmIiIhAbGxs87bU1FTk5uaiqqoKYWFhrfYdNmxYq69PTU3FwYMHO/z+ZrMZZrO5+fPq6moAgNFo7OhLVOdgXiWWfXcMh/OlY/P10eC6EX3wxJXJqK+tQb3M9XWktra2+e9GoxF2u72TvZ2n6f9eCHGePeXjylx4QybOlXm6GA5zHaYkRkJjq4fRqNRU9IwzssRceFcuSo0NWPbdEfyYWQIA8NNqMHdMHK4fGYuhsaHNXQLramtkqU+u88O5lJ4LXkN1zmJzYOWmbHywIwdWu4CfVoM7L0rENSlhTj8GpbxnXU3pmQCYC3eorrfCXCe953/8w3RENq4C0FBXgwYXv7YSs9bVXMja6DaZTNDpWi81EhwsdfmsqalpFYyO9q2p6fiiYNmyZXjuuefabI+P9+yxza81fqhFy1+M7mIymRAaqswxvK7MhbdmAgBeavzwZBeaJeaiNW/IRZMXGz+URo7zw7mUmgteQ3Xfc40frqSE96yrKTUTAHPhbgNeke+1lZa18+VC1ka3TqdDXV1dq21NnxsMhi7te+5+LS1evBiPP/548+dVVVVISEhAbm6uYn9ZdIXRaER8fDzy8vIQEhIidzkXxN3HIoSAyWRSXFBbcmUu1JAJpb6/lViXs2piLpSRCzneY3K9r9VwrErPhbdcQ6nhveItr6v0TADekwtnUuL1TU/IdRxdzYWsje60tDSUl5ejuLgYvXtL60dnZmYiLi6uzRs3LS0N+/bta7UtMzMTY8eO7fD7BwQEICAgoM320NBQVb+pmoSEhHjEcQDuPRal/1J0ZS7UlAmlvr+VWJczamIulJMLOd5jcr2vlX6sSs6Ft11DKf294i2vq+RMAN6XC2dS4vVNT8hxHF3JhaxTkSYnJ2Py5MlYtGgRTCYTTp06heeffx4LFy5ss++dd96J9PR0rFmzBjabDWvWrEF6ejruvPNOGSonch3mgqgt5oKoNWaCqC3mghTLpdO5dUFRUZG46aabRGRkpIiOjhZPPPGEsNlsQgghdDqdWL16dfO+33//vRgxYoTQ6/Vi6NChYt26dd16LU+ZYdBTjkMIzzoWZ3JXLpT481diTUIosy4l1uRKnp4LOV6Xx6pu3nAN5U3vFW97XVfxhlw4kyccgxDKPw7ZG93u1NDQIJ599lnR0NAgdykXxFOOQwjPOhY1UuLPX4k1CaHMupRYkyeQ6+cqx+vyWKmr+F7h61JbnvCz84RjEEL5x6ERQsHz/hMRERERERGpmKxjuomIiIiIiIg8GRvdRERERERERC7CRjcRERERERGRi3hco9tsNuOGG27ApEmT8NZbb3W6fceOHZgwYQIuueQSnDp1Sq6S29Wd43jttdcwevRoTJ8+HcuXL5er5A51dCxN5syZg5ycHADK/j9RMyXmojs1rV69GhMnTsTFF1+MAwcOKKImALDZbEhOTnZZPd2taffu3ZgyZQrGjRuH9evXu7QutZMrE919j+Xm5mLWrFkX9JrdfV1n5a07r7l+/XpMmDAB06dPR2FhYY9fs7uvC7gnx2rBXHS83ZnnITmywVz0nBKvoXpCrpw5mxKvH7tE7pncnO0///mP+Oc//ynsdru44oorRH19fYfbr7nmGlFeXi4yMjLEfffdJ3PlrXXnOO6//36Rm5src8Ud6+hYzGazmDVrlujbt684deqUEEIo+v9EzZSYi+7UNHHiRGGz2cSpU6fE3LlzFVGTEEL8+9//Fnq93mX1dLemGTNmiNLSUlFeXi7efvttl9aldnJlojuv+8svv4iJEyeKadOmXejhypK37rzmFVdcIYxGo9i6dav405/+5LZjFcI9OVYL5sI95yE5ssFc9JwSr6F6Qq6cOZsSrx+7wuOedO/duxeTJ0+Gj48Phg0bhiNHjnS4vb6+HhEREUhNTUVWVpbMlbfWneM4duwYHn30UVx55ZU4efKkzJW31dGxmM1mPPbYY7j88sub91Xy/4maKTEX3anp66+/hlarhdVqhb+/vyJqqq+vx6ZNmzBmzBiX1dOdmvbu3Qur1YpFixbhlltuwaWXXurSutROrkx053UdDge++uqrCz7W7r6us/LWndf87rvvYDAYUFhYiKCgILcdq7tyrBbMhXvOQ3Jkg7noOSVeQ/WEXDlzNiVeP3aFxzW6TSYT9Ho9AECn06GmpqbD7Q6Ho/nrhMJWTuvOcVx33XVYvXo1li9fjj/+8Y+y1dyRjo7FYDBg6tSprfZV8v+JmikxF92pKSoqCmazGQ899BAee+wxRdS0cuVKPPjggy6rpbs1ORwO7N+/Hy+//DJefvllPPnkky6vTc3kykR3XnfcuHGIjo6+oNfryes6K2/deU2tVos33ngD9913H2bOnNnj1+zu67orx2rBXLjnPCRHNpiLnlPiNVRPyJUzZ1Pi9WNXeFyjW6/Xo7a2FgBQW1uLkJCQDrdrNJrmr/PxUdaPojvHce+990Kv12PEiBEoLy+XreaOdHQs7VHy/4maKTEX3anJarVi7ty5uP3221165707Ne3btw/Tpk1zWS09qWnIkCHo1asX0tLSFPm7QEnkykR3XteZ5Mhbd4/1/vvvx+HDhy/4hpESc6wWzIV7zkNyZIO56DklXkP1hFw5czYlXj92hbLeDU4wevRobNmyBUIIHDhwAIMHD+5we1BQEMrKypCZmYnExER5Cz9HV49j0KBBmDZtGqxWK44fP45evXrJXHlbHR1Le5T8f6JmSsxFd2p6/PHHcdVVV2HBggUuq6c7NeXm5uLYsWOYPn06Dhw4gN/85jey1zR48GDYbDaUlZUhNzdXsXeolUKuTHTndZ1Jjrx15zXnzJkDi8WCoKCgC75QVWKO1YK5cM95SI5sMBc9p8RrqJ6QK2fOpsTrxy5xyUhxGdXX14tZs2aJsWPHitdff1289NJLIiMjo812IYTYsWOHmDBhgpg4caLIysqSufLWunMcH374oRg/fryYNm2a4o5DiI6Ppcldd93VPJGakv9P1EyJuehqTUVFRSIwMFBMmzZNTJs2TTzyyCOy19SSqycZ6U5N69evF+PGjRPjx48X+/fvd2ldaidXJuR6j8mRt+4c65o1a8SECRPEpEmTxPbt291yrC0pcbIgOTAX7jkPyZEN5qLnlHgN1ROe8h5Q4vVjV2iEUNiAAyIiIiIiIiIP4XHdy4mIiIiIiIiUgo1uIiIiIiIiIhdho5uIiIiIiIjIRdjoJiIiIiIiInIRNrqJiIiIiIiIXISNbiIiIiIiIiIXYaObiIiIiIiIyEXY6PYw7733HhITEwEAlZWVeOihhxAfHw+dToc+ffrgrrvuwpkzZ5r3X7BgAfz8/KDX66HX6xEUFIQBAwbgqaeeQn19vUxHQeQ8zARRW8wFUVvMBVFrzITzsNHtwebNm4eysjLs2bMHtbW1OHDgAMxmM6644grYbLbm/W6//XbU1NSgpqYGdXV1+Pjjj7Fu3TrMmTNHxuqJnI+ZIGqLuSBqi7kgao2ZuDBsdHuwrVu3Yvbs2YiJiQEA9O7dG6+88gomTJiAysrKdr9Go9Fg/PjxWLt2Lb7//nv8+OOP7iyZyKWYCaK2mAuitpgLotaYiQvDRrcHu/XWW/HAAw/goYcewpo1a3D69GnExMTgvffeQ3R0dKdfO3jwYCQnJ2Pjxo1uqpbI9ZgJoraYC6K2mAui1piJC8NGtwd766238PrrryM3Nxf33XcfEhMTkZSUhA8//LBLXx8VFYXy8nIXV0nkPswEUVvMBVFbzAVRa8zEhWGj24P5+PjgjjvuwDfffIPKykpkZGRg7ty5uPPOO/HTTz+d9+tLSkrQq1cvN1RK5B7MBFFbzAVRW8wFUWvMxIVho1vlPvjgA7z44ovNn1utVgQHB+OHH36AXq9HRUUFAGlMRWpqKpYtW4ZRo0Zh//79nX7fI0eOIDs7G5dffrlL6ydyNmaCqC3mgqgt5oKoNWbCddjoVrmamhr84x//QGFhIYxGI9auXYuxY8di6tSp6N27N+6++278+uuvsFqtMJlM+PDDD5GVlYVrrrmm3e/ncDiwfft2zJs3D7Nnz8Yll1zi5iMiujDMBFFbzAVRW8wFUWvMhAsJUjWLxSLuvfdeERUVJfR6vbjuuutEYWGhEEKIgoICcd9994mEhAQRFBQkQkNDxcyZM8XOnTubv/6uu+4Svr6+QqfTCZ1OJ8LCwkRaWppYunSpsFqtch0WUY8xE0RtMRdEbTEXRK0xE66jEUIIuRv+RERERERERJ6I3cuJiIiIiIiIXISNbiIiIiIiIiIXYaObiIiIiIiIyEXY6CYiIiIiIiJyETa6iYiIiIiIiFyEjW4iIiIiIiIiF2Gjm4iIiIiIiMhF2OgmIiIiIiIichE2uomIiIiIiIhchI1uIiIiIiIiIhdho5uIiIiIiIjIRdjoJiIiIiIiInIRNrqJiIiIiIiIXISNbiIiIiIiIiIXYaObiIiIiIiIyEXY6CYiIiIiIiJyETa6iYiIiIiIiFyEjW6Vq6iowPz58xEZGYnw8HDMmjULhYWFAIBdu3ZhwoQJ0Ov16N+/P955553mrzt8+DBGjBgBg8GAWbNmoa6urvnfXnjhBTz77LNuPxYiZ/jwww+h1+tbffj7+yMgIAAAc0Head++fZg6dSrCwsLQp08f/O53v4PZbAbATJD3Onr0KGbMmIGwsDD069cPS5cuhcPhAMBckPcpLS1FUlIS0tPTm7d1lgMAeP/995GUlASdToexY8dix44dzf+2Zs0a9O3bFxEREViyZEmrr5sxYwY2btzo0uNRHEGqNn36dDF79mxRWVkpjEajuPHGG8U111wjKioqREREhFi5cqWwWq3ip59+EgaDQezatUsIIcTcuXPF73//e2EymcSkSZPEv/71LyGEEDk5OWLYsGGivr5ezsMicpozZ86IPn36iA8++IC5IK9kt9tFnz59xKuvvirsdrvIy8sTgwcPFn/961+ZCfJaJpNJ9OvXT/zmN78RNTU1ze/pv/zlL8wFeZ2tW7eKgQMHCgBi06ZNQghx3hxs2rRJGAwGsXXrVmGxWMTLL78soqKiRG1trRBCiOjoaPHVV1+JM2fOCL1eL44cOSKEEGLNmjXitttuk+U45cQn3Sq2d+9e7Ny5E++99x7CwsJgMBjw1ltv4cUXX8Snn36KyMhIPPzww/D19cWll16K22+/Ha+//joAwNfXFwAghIAQAlqtFgDwu9/9Di+++CICAwNlOy4iZxFC4M4778Q111yDO+64g7kgr1RZWYnCwkI4HA4IIQAAPj4+CA4OZibIa23duhUlJSV4/fXXodPpkJCQgKeffhr/+te/sHbtWuaCvMb777+P2267DUuXLm21/Xznh7fffhu33HILJk2aBD8/Pzz22GOIiorCJ598AkDKSdM5pyknNTU1eO655/D3v//dvQepAGx0q9ju3buRmpqKt956C0lJSejTpw+eeOIJ9OnTBxkZGRg2bFir/VNTU3Hw4EEAwJIlS/Dzzz+jf//+SEhIwPz587Fu3Tr4+vriqquukuNwiJxu9erVyMjIwMsvvwwAzAV5pcjISDz22GN44oknEBAQgPj4eAwaNAiPPfYYM0Fey263w9/fH35+fs3bfHx8UFxcjO3btzMX5DVmzJiBEydOYN68ea22n+/8cL5//+c//4nHH38cY8eOxZ///GckJyfjueeew/3334+YmBgXHpEysdGtYhUVFTh06BCysrKwf/9+HDhwAPn5+Zg/fz5MJhN0Ol2r/YODg1FTUwMASElJwc6dO1FWVoaPPvoIQgj86U9/wooVK/DKK69g9OjRuOyyy5CZmSnHoRFdMIfDgeeffx5PP/00DAYDADAX5JUcDgeCgoKwcuVK1NbW4vDhw8jMzMSzzz7LTJDXmjRpEoKCgrB48WLU1dXh9OnTWL58OQBAo9EwF+Q1YmJimntvtHS+88P5/n3WrFnIzs5GYWEhnnrqKWRkZGDLli1YuHAh7rvvPowYMQK33347qqurXXRkysJGt4o1TQz1yiuvwGAwoHfv3li6dCm+/fZbCCFaTewBAHV1dc2Nj3MtW7YMd9xxB4xGI5YtW4b09HQsXLgQ99xzj8uPg8gVNm3ahMLCQixcuLB5m06nYy7I63z++ef49NNP8eCDDyIgIABDhw7Fs88+i3/+85/MBHmtsLAwfPfdd9i1axfi4+Nx8803Y/78+QAArVbLXJDXO9/5obvnj0cffRSvvfYaVq1ahby8PBw4cAA6nQ7Lli1zzQEoDBvdKpaamgqHwwGLxdK8zW63AwBGjhyJjIyMVvtnZmYiLS2tzffJzs7GunXrsGjRIhw+fBgDBw5ESEgIxo4di19//dW1B0HkIp9++ilmz57d6i5sWloac0FeJzc3t3mm8iZ+fn7w9/dnJshrWSwW2Gw2bNy4EeXl5di1axe0Wi1SU1Mxfvx45oK83vnOD905f6xevRrJycmYMGECDh8+jFGjRkGj0XhXTtw+dRs5jcViEUlJSWLOnDnCZDKJkpIScemll4rZs2eLsrIyERYWJlasWCEsFovYuHGjMBgMYuPGjW2+z1VXXSU2b94shBBi7969IjIyUpSWlopVq1aJ4cOHu/uwiJxi2LBh4q233mq1jbkgb5SRkSECAgLE0qVLhc1mEydOnBDDhg0Tv//975kJ8loNDQ0iLCxMvP3228LhcIhffvlF9O3bV7z55pvMBXkttJi9/Hw52LBhQ/PnFotFrFixQoSHh4vy8vJW37OqqkqkpaU1b//73/8uLr/8cmGxWMSCBQvEb3/7W7ceo1zY6Fa5/Px8MW/ePBETEyPCwsLE/PnzRWVlpRBCiD179oiLL75YGAwGMWDAALFq1ao2X//pp5+K+fPnt9q2ePFiER4eLlJSUsSOHTvccBREzqfT6cS3337bZjtzQd5o/fr1YsKECSI0NFT069dP/OlPfxJms1kIwUyQ99q8ebMYPXq00Ov1YsCAAeK1115r/jfmgrxRy0a3EOfPwQcffCAGDx4sdDqdGD9+vNi5c2eb7/noo4+Kd999t/lzk8kkrrvuOhESEiIuvfRSUVxc7KrDURSNEI1zuRMRERERERGRU3FMNxEREREREZGLsNFNRERERERE5CKKaXSXlpYiKSkJ6enpHe7z7bffYtiwYdDpdBgyZAi++eYb9xVIJAPmgqgt5oKoNWaCqC3mgpREEY3ubdu24aKLLsKJEyc63CcrKwtz5szB888/j+rqajz33HO4+eabkZ+f78ZKidyHuSBqi7kgao2ZIGqLuSClkb3R/f777+O2227D0qVLz7vflClTMGvWLPj6+uLmm2/GtGnT8Oabb7qpUiL3YS6I2mIuiFpjJojaYi5IiWRvdM+YMQMnTpzAvHnzOt0vIyMDw4YNa7UtNTUVBw8edGV5RLJgLojaYi6IWmMmiNpiLkiJfOUuICYmpkv7mUwm6HS6VtuCg4NRU1PT4deYzWaYzebmzx0OByoqKhAZGQmNRtOzgknVhBAwmUyIjY2Fj4/s95w65KpcMBPUHuaCuaC21JALXkORO6khEwBzQe7V1VzI3ujuKp1Oh7q6ulbb6urqYDAYOvyaZcuW4bnnnnN1aaRCeXl5iIuLk7uMC9bdXDAT1BnmgqgtT8gFr6HImTwhEwBzQc51vlyoptGdlpaGffv2tdqWmZmJsWPHdvg1ixcvxuOPP978eXV1Nfr164c8ACHtfcEVVwBr1579PCYGqK9v/5tPmgR8++3Zz/v3Byoq2t931Cig5cyJaWlAXl77+w4eDOzeffbz8eOBY8fa3zc+Hjh8+Ozn06cD+/e3v29EBHDq1NnPr74a2Lat/X2DgoCiorOf33QTsH59+/sCQHX12b/Pnw98+WXH+xYUAE13FR94APjvfzve98QJICpK+vsTTwBvv93hrlfesxKVUTGYnBSFh396H0mfrGpdVyOj0Yj4+PhOf6GqSXdzwUy04OGZ+Mcrn2J1IVBrtuPxnz/APXu/bltbI+aCuWimwFw47r8fPh9/3OGuU+5/C5VBoQCApze+jVsP/djhvhvWrIc+aSCiDf6I+/syBPz79XYzAXhWLngN1Q6V58KZ5wscOgQkJKDBasfWWx7A5RvWYNYL6/DFw5Nb7eZJmQCYi3YxF2cdOoSDPiH4f+uO4Ko1/8Q9e79G3qlCxEcEt9qtq7lQTaP7zjvvxMsvv4w1a9bgxhtvxGeffYb09HS8+uqrHX5NQEAAAgIC2mwPQQfB8PMDQlr8S2fdRHx9W+/bWTcbrbbn+2q1He/r49PzfX07+a/XaFrv6+fX8b5A9/dtCoa/f+f7GgzN3/tAcR1GdrLrK7dNwMipoxDopwWOf9O2rnN4Sheg7uaCmehkX5Vl4nz7fne0CvWhvTGwrw5XpvRByN52ajsHc9EacwHZclHtG4T1WUZ8f7gI1x0pww2d7PvkNSMRkhCLXoZApFSvR8ihjve9cVwSkJgofaIPaltXOzwhF7yGaocKc+Gq8wUMBmQ3aPDHtZmYYbQhBMAzN45FSAfZ8IRMAMxFu5iLZv+3Ix8rT+YCAG7x90cIgKGJHQ9dOF8uNEII0Xl17qPRaLBp0yZMnz4dAKDX6/HGG2/g9ttvBwD88MMPePLJJ3HixAkkJCTgpZdewtVXX93l7280GhEaGorqgoLmXyRCCJitVkAI6Y3VMkjndDlpxccHCAzs2b719dLrtUejke4GdXNfPz8/aC0WwOHouI6W41bq67u+b0MDYLc7Z9/g4LO/cMxmwGY77761ZhtGPf0NtA47gv21mDAgApOTojBpYBQSohpfOyjo7C8ciwWwWlvX1aj5PVBd3eHJRGlcmYv2MgG0yIWPj2ozAQABDgc0nf2KU2km2tvXZnfgznd24UBeNXx9NJg6Ih63XdQfFw+MhMZqlTJxbm2NmIvWOsqF3eGA1WZTdS6UfK6orLVg49ESfJ9RhE25NbA1Ho6/zYowfw3GJkZgQv8IjO8fgcG9DfDxacxCdzLUxXMFoL5cyHENBTAX591XgeeLlsprzHht+xms3nMGdodAhJ/Am7eMwNih8W32VVsmALYtADAX3dy3staC3/53P7YW1EJofDBndBwWXz4AUQE+F3QNpahGt6u190PJz8+H0WiUubILp9FoEBcXB71eL3cpTldYXY+Llm0EABz7fzMR4NvJXbfzUOMJw5U6+nl4Si5CQkLQt29fuctwOavdgSVfZuC/u3NhCPDFV49ORv+o9hsS7WEuWmvv51FTU4MzZ85A7adMpZ4rfjpSjAdW74XVfvbnO7i3AVcNi8GlKb0wNDYUWh/3Pl1jLlpjLjzH6fJabDleis3Hy7D9RBnqLFKD5orU3nj66iFI7OD8wUy0xbaFZ9l7ugKPfXIQuRV1MAT44h+3jcL0wb06/Zqu5kI13ctdwWazwWg0IjIyUtW/PIQQKC0txZkzZ5CcnAxtZ11BVOifm04AkC7ALqTBTV3jKbkwGo0oLy9H79694dtZlyeVKzE14JEP92N3jjTu6//NTutWg5vOz26348yZMwgODkZ0dLRqu1Yq+VyxNbsMVrtAXHgQ5o2Nx1XD+iCpl/dc6KkRc6EeNrsDm4+XNn+cLm/9BHVobAj+fE0qLhoYKVOFnsNTrqG8IRctmW12rFifhTe3nIBDAHHhQXh3wTgM6u28+Qs890q0C2yNXQoMBgMCW3bRUKHo6Gjk5OTAarV6VDDyKuqwetdpAMCz16fKXI138JRcCCFQXl4Om83m0Y3uxz45gN05FTAE+OLleSNxRWpvuUvyOFarFUIIREdHI6hlFz0VUuK5QgiB7BJpiZ65Y+Lx6GXJMldEXcFcqMPBvCo89dmvOFJ49smrr48GYxLCMXVQNKYNikZqn5CzwzXognjKNRTg2bloSQiBx9ccxLpDhQCAOaPj8Oz1qQgJPM9Y8m5S7iJ7bnTeu7NZWcDixcCtt0p/ZmX16HXMZjNuuOEGTJo0CW+99dZ5t+fm5mLWrFnNnz/99NOYNGkSHnzwwe4fg0pll9RACGBInxBcPDBK7nK8ity5aDJnzhzk5OQAAHbv3o0pU6Zg3LhxWN8462VHufDUTLRktTuw51QlAODDeyewwe1iXXpPOSEXHWWivr4et9xyCyZPnoyHH34YALBhwwaMGTMGl112GU41ziKrpnOFEAIvrz+On7PK4KfV4LIhnXfjI+WROxdN/vKXv+C9994DoP5cOIPN7sDz32Ri9j+34UihEaFBfrhjYj+8eecY7F9yBT65/yI8fEkS0vqGssHtAnJfQ5lMJsyYMQMTJ07ERx99BAB47bXXMHr0aEyfPh3Lly8H4H25OFe9xY7XfsrGukOF8NNq8O87RuPvN49weoMbYKP7/FatAlJSgOXLgTVrpD9TUoDGX+zdsWbNGsycORM///wz/ve//6GhoaHD7Xv37sW8efNQVVUFQGqAnzhxAtu2bYPBYMCOHTuceJDKVFBVjxe/PwoASIwMPs/e5FZuyIXFYsHs2bOxa9eu5n2XLFmCzz//HD/88ANyc3O9Mhctnamsh8XuQLC/FmmxoXKXQ07KRUeZeOutt3DNNddg69atSElJQX19PZ599lmsX78eq1atwtKlS1WViaLqBtz93h78Y2M2AOD5G9KQ1pfvY4/j4lwAQFlZWasGh5pz4Sxbs8vwztZTcAhg9qi+2PjENPy/WcNw5dAYGFzQoKBucMM11EcffYRbb70VO3bsaM5GZmYmvvzyS6Snp+MPf/iDV+YCkG727j1dicWfHcL4pRuwYsNxAMBTVw3BzLQ+LntdNro7k5UF/OY30kx8dnvrPxcuBLKzu/Xt9u7di8mTJ8PHxwfDhg3DkSNHOtzucDjw1VdfNX/tvn37MGnSJADAlClTsHPnTucdpwJlFZtww+vbcLTIhCh9AH53ObsbKoabcmE2m/HYY4/h8ssvBwDU1tbCarVi0aJFuOWWW3DppZd6XS7OVWeRurHpA3z5pEJuTsxFR5n4+eefcfLkSVxyySUwGAwICgqCv78/IiIi0K9fP5w+fVo1mfjmUAGuXLEZ6cdK4e/rgyXXpuKW8f3kLouczQ25AICXXnoJ8+fPb/5crblwJmODdH4Y3S8MK+aNRKS+7TJXJAM3XUPdf//9uPPOO2EymeBonFH82LFjePTRR3HllVfi5MmTXpmLw/nVuGLFFsz513b8d3ceTGYb4sKD8PTVQ3DPpESXvjYb3Z15992O19PTaIB33unWtzOZTM0zAOp0OtTU1HS4fdy4cYiOjj7v13qiiloL7nl/D0pNZqTEGPDlI5OQEqPeySg8jptyYTAYMHXq1Ob9KisrsX//frz88st4+eWX8eSTT3pVLtpTVC3d0Q4N4lML2TkxFx29rysrKxEbG4v169fjgw8+QFlZGYQQKCoqQmZmJnJzcxWfCbPNjme+OIxHPtoPY4MNI+JC8e1vJ+Oeyf3lLo1cwQ25yMvLg8lkwuDBg5v3VVsunO3XM9X469cZAID4CPYUVBQ3XUMBQHFxMYYNG4axY8cCAK677jqsXr0ay5cvxx//+Eevy0WD1Y5H/7sf2SU1CPLT4sbRffHRvROw5Q+X4N6pA1zend5zZxdyhpycjtexE0L6927Q6/Wora0FID21a5rVsKPt535tfn5+p/t4ij+uPYi8inr0iwjGf++diHDdeRa6J/dyUy7OFRYWhiFDhqBXr17o1asXysvLvSoX7WmasXx0v3CZKyFn5qKjTISFhWH69Onw9fXFuHHjcOrUKfztb3/DvHnzMHr0aIwePVrxmbjvP3ux+XgpAOCRS5Kw6PJk+Gp5/99juSEXy5Ytw5NPPon09PTmfdWWC2dan1mM3328H3UWO1L7hODpq4fIXRK15MZrqNjYWOTk5GDOnDk4duwY7r33Xuj1eowYMcIrr6He2nISp8pq0TskAN/9bioi3Ny+4JmuM4mJnd+NSkzs1rcbPXo0tmzZAiEEDhw40HxXtqPtLY0aNQo///wzAKmL4ejRo7v12mpRXW/FxqMlAIB/3zGGDW4lclMuzqXX62Gz2VBWVobc3FxER0d7TS46UlglPelO7s2llWTnxFx0lIkxY8Zg8+bNAICDBw9i0KBB2L59O3766Sc88MAD6NOnj6IzcehMFTYfL4W/1ger7h6H388YzAa3p3NDLvbs2YMFCxbgb3/7G/72t78hOztbVblwFiEEXt+Ujfs++AV1FjsmJ0Xhk/snoleIumfQ9jhuuob6xz/+gfXr10Oj0TTPoj5t2jRYrVYcP34cvXr18opctHTwTDUA4P6pA93e4AbY6O7cPfd0fjdq4cJufbt58+Zh/fr1GD9+PObMmYN//OMfyMzMbLO9vSUGEhMTkZSUhIsvvhglJSWYPHlyT45I8b45VACHAAZE65Aa69l33FTLTbloz9KlS3H11Vdj7ty5eOqpp7wmFx1pGtMd6Oe5S3mohhNz0VEmHnzwQXzxxRcYP348pk6ditDQUERERGDChAl4+OGH8cc//lHRmfhsn/RE5aphMbhkMGcp9wpuyMWePXuQnp6Op556Ck899RSSkpJUlQtn+SGjCMt/OAYhgPkXJWDV3eM4YZoSuekaau7cuXjxxRcxZcoUJCUlYfDgwfj973+PyZMn47777sPSpUu9IhctlZikBxWRepke6AkvUl1dLQCI6upqIYQQ9fX1IjMzU9TX13f8RatWCeHjI4RW2/rPVavcUnNXdelYFMzhcIidJ8pE2rPfi4QnvxFvbTnhktc59z3g7dr7eXhKLtSeifNpsNrExct+EglPfiO2ZZVe0PdiLlrr0blCCObiPG785zaR8OQ34ov9Z9z+2j3BXLTGXCjbQx/uFQlPfiOe+eJXl70GM9EW2xbqcCC3UiQ8+Y0YuHidKKiqc+r37mouOKb7fBYsACZPliY2yMmRun0sXAgkJclcmGfILa/DZ/vP4LN9+citqAMADI8LxYKLE+UtjDrHXMjG4RD4+lABlv9wDPlV9fD39cGwOC6zpAjMRadOlEqT9AzqbZC5EnIr5sLlsktqsD6jGABw4+g4mauh82Im3O79HTkAgOtHxKJPaJAsNbDR3RVJScCyZXJX4VHMNnurCXUAQOevxVXD+uD3V3KcnyowF27XYLVj/ju7mydQ62UIwF9vSGMXQiVhLtrVYLWjqs4KAIiV6YKHZMRcuIwQAos/OwSL3YHpg6Mxgjdh1YGZcJs6iw3fHy4CANw+MUG2OtjoJllsP1GOzcdLodEAk5OiMGd0HK4c2hvB/nxLEnVk09ES7M6pQLC/Fg9OG4iFU/ozM6QKpSYzACDA1wchQXzPEjnLkUIT9uRUwt/XB0tnD3P5skdEarM+sxh1FjsSIoMxul+YbHXwzAfpLqHaqe0Ydp4sBwDcNDoOy+eOkLkaao/a3lPnUnv97WnOzZg4PHpZsszVeB9PeE/JdQxFRmkCm94hgWwUeBjmQl4/ZEhP8KYPikbfMPYiUQo1v6eaeMIxAMDXBwsBADeMiJX1/OPVjW5fX+nwTSaTqi8ChBAoLS2FRqOBn586upnuOSV1j50wIFLmSuhcnpILk8kE4OzxqF2dxYYvDhQAAKYNipa5Gu/i5+cHjUaD0tJSREdHqzYXcp4rjhYaAQCJUTq3vi65DnOhDHsahxtN54oAiuAp11Bqz0VLZyqlOaPGJkbIWodnXI32kK+vL0JCQlBeXo7y8nK5y7kgGo0GcXFx0GqVv3SQ1e7Ar/nSWnnjEsNlrobO5Um5CAkJ8ZhG9z82ZqO63op+EcG8uHIzrVaLuLg4nDlzBjk5OXKXc0HkOlccalwfdSTHm3oM5kIZDjdeT42IZ7aUwJOuodSciyZCiOb5RIL95T0Oz7gavQCxsbGIiopSfRcKPz8/1YSi1GSG1S7g66NBfHiw3OVQOzwhFxqNBv7+Mq3F6GTfHy7Ev9JPAACenJkCrY96756rlV6vR3JyMqxWq9ylXBC5zhVNq1MM7KV3+2uT6zAX8rLZHTA22ABwgkIl8YRrKEC9uWgpo8CIImMDAnx9kNInRNZavL7RrdFoEBAQIHcZXqVpQp0ofQB82HhQJOZCWf7+43EAwG8m98c1w/vIXI330mq1qr8AkcuZynoAQFw4GwaehrmQT2mNdD3lowH0gV5/Sa8YvIZSjt2Nw1knJ0VBHyBvRrguE7ldRZ0FABCp94ynkESuVFTdgKySGmg0wCOXcg1PUh+LzYHCaqnRHR/B3k1EznIwT+paPqi3AX5capWoDbtD6m0QGiT/uHQmlNwup6wWABATEihzJUTKd/BMFQBgSEwIwoJ5o4rUp8TUAIcA/LU+iNbz6Q+Rs+RWSNdTg2MMMldCpEz2xi7+SpjUjo1ucrumZY9GxofJWwiRCpxqvEmV3JtjYUmdSpqHFPkr4sKHyFPUWewAAJ3M3WaJlMpicwAA/H3lb/LKXwF5laxiE37MLAYAXJLCGZiJzqe6XpqgKFLHJ4SkTj8fLwPAp3FEznayVLopGxvKnoNE7Wm6hgpRwJwHbHSTW72/IwdCADOG9kZaXy5vQXQ++Y0TUAX48dc1qVP68RIAwFVpnASQyFmyS2qQfkzK1rC4MHmLIVKo8sbJBpUwjxSv4sitmtZqvWFkX5krIVK+48UmfHOoAABwRWpvmash6hlT45JGcRGcuZzIGSpqLbjr3d0wNtgwIj4MFw+MlLskIkWqMUvnn5BATqRGXuZ0eeNardEcn0p0Pl8fLIBDAJcP6Y3R/cLlLoeoR6z2xjF1nF2ZyCm+O1yI/Kp6xEcE4d27xnLmcqIOFBkbAHD2cgBASUkJZs2ahbCwMERFRWHRokWw2Wzt7vvqq6+if//+CAkJwfDhw/Hpp5+6uVq6UI7GWQT9tJxMpzPMBQFAfpXUtXxMAhvcAHOhRnaHgLFxTF2wv/xj6jwNM+GdmsapTuwfiUiuCNAGc0GA1LU8s8AIABihgMmbZW90z5s3D3q9HgUFBdi9ezc2bNiAFStWtNnvu+++wwsvvIDvv/8eRqMRzz77LG6++Wbk5OS4v2jqEbtDoL5xps0gf63M1Sgbc0EAmk8WCZFc2xhgLtRo+Q/HUFlnRZCflt3LXYCZ8E5mq9R7hHN9tI+5ILtD4LE1B+EQQEqMAbFh8p9/ZE1rdnY20tPT8dJLLyE4OBgDBgzAM888g5UrV7bZ98iRIxBCwOFwQAgBrVYLf39/+PryzrlafHOoADaHgNZHg14GzrTZEeaCAKDY2IBjxSYAwPj+ETJXIz/mQn1+zirFvzefAAC8eNNwRYyp8yTMhPeqs0hPbbVcgq8N5oIA4N2tp7DleCkC/XywYt5IucsBAMj6rsrIyEBERARiY2Obt6WmpiI3NxdVVVUICwtr3n7rrbdi1apVSE1NhVarhUajwerVqxEXFydD5dRdr27IwooNxwEAs0b2hdaHJ4qOMBcEAG9sPgkhgHGJ4Yhi90HmQmWEEPi/H44BAOZflIDrR8Se5yuou5gJ71RrtuHTffkAlNFlVmmYCzI2WLFyUzYA4NnrhmJInxCZK5LI+qTbZDJBp9O12hYcLHWjrKmpabXdYrFg5MiR2L17N+rq6vDmm29i4cKF+PXXXzv8/mazGUajsdUHuV9mgbG5wf2byf3x0k3DZa5I2VyZC2ZCHYQQ+GRPLgDg0UuTZa5GGZgLdTl0phoHz1QjyE+L317G97Ar8BrKO63PLEZFrQUJkcG8mdUO5oK++7UQ1fVWDIzW4eax8XKX00zWRrdOp0NdXV2rbU2fGwyGVtsfeeQRDB06FOPGjYO/vz/uvvtuXHTRRXjvvfc6/P7Lli1DaGho80d8vHJ+8N7kTKX0fzo8LhR/vjaVT7nPw5W5YCbUod5qR23j/AecRE3CXKjLr/nS8pDj+0ewp4aL8BrKO5U1rjs8Mj4Mvpy1vA3mgqrqpIkGR8SFKarNIWta09LSUF5ejuLi4uZtmZmZiIuLQ2hoaKt9c3NzYTabW23z8/ODv3/Hi50vXrwY1dXVzR95eXnOPQDqkqwS6c4ix3F3jStzwUyoQ3mNBYC0xFKQHycdBJgLtclonARQKd36PBGvobxT06oW4cEd/995M+aCLLbGZSp9lXVTStZqkpOTMXnyZCxatAgmkwmnTp3C888/j4ULF7bZ9/rrr8fKlSuxb98+OBwOrF27Fps2bcK8efM6/P4BAQEICQlp9UHuJYTA5/ulsUdXDu0tczXq4MpcMBPqkFUiTaA2IFoHHwXdpZUTc6EuB/KqAAAj40M735F6jNdQ3sdmd2Dz8VIAwNhE9oJqD3NBFrsyG92yT8+3du1aPPLII+jfvz98fHwwf/58PPPMMwAAvV6PN954A7fffjueffZZaLVazJkzBxUVFUhOTsYXX3yBkSNHynsA1KlNx0qQXVKDYH8tZqbFyF2OajAX3i2/qgEA0C+CS4W1xFyoR255LQBgUG/DefakC8FMeJel3x7BydJa6Py1mDQwSu5yFIu58G4FjddQSusNohFCCLmLcBej0YjQ0FBUV1fzzpSb3PnOLvycVYb7pw7A4quHyF0O3wPn4M9DmZpm+79lXDz+Nsf1Ew/yfdAafx4XxmJzYNCfvwMAHFhyBcIUduHTVXwftMafh7y2nyjDbW/tAgD8+44xsjzI4HugLf5MlGfmK1twtMiEt+aPxRWpru9l29X3gLKeu5PHKTZKd5umDYqWuRIi9ThZJs2DEM8n3aRCRdXS7/0AXx+EBnFtbiJn+OFwEQBgzug49hwk6oDV7sCJUukaKiVGWT2t2Ogmlzl0pgq5FdKMkcEBso9kIFKN7MbJBwezay6pUFHjzdY+oYHQaDgnAZEz7MmpBABcPqSXzJUQKdexIhOsdgGdvxZ9w4LkLqcVNrrJJQqq6nH3qj1osDowKSkSw/tyMh2irjI12AAA4To+JST1qbdKy93peLOVyGnMNilX4Tp1DtcgcocfM6VZ6yclRSluIlo2usklPt+fj/JaC1JiDPj3HWMU98YnUjJTg7TGpD6AjW5Sn6b3b7A/l7sjcha7Q5qCyZfXU0QdOti4csa0wcob1spGN7nEr2eqAUhjjwyBbDgQdZXF5kBlndRoiTYEyFwNUfcVVjV1L1dW1z4iNau1SE+6g/3Zg4SoIw2NPa2UOJ8IG93kEk1j+hIiOREUUXfsPlUBAIjQ+SNMgScNovMprTEDAHrxphGRU1TXW1FqknLVO4S5ImpPg9WOw/nSQz+ljecG2OgmF2m60xTox+6FRN3xfUYhAGDG0BgOyyBVqqi1AODYUyJnaeoymxAZjEg9G91E7fnqQAFqLXb0DQvCyPgwuctpg41ucgmzzQEACOKYPqJu2ZZdDgC4LIUz1JI6ZRWbAACJkTqZKyHyDL82Pr0bHhcmbyFEClVdb8VLPxwFAMy/KEGRK2ew0U1OV2u2oaSxe7mes9cSdVlFrQWnymqh0QDjB0TIXQ5Rt337ayEONTYQ0vqGyFwNkWdomicntQ8zRdSerw7ko6zGggHROtw9qb/c5bSLjW5yujW/5KHWYseAKB3XGSbqhoKqegBApC4AIZyAkFRmX24lfvfxfggB3DGxHxL4pJvoggkhsDtHmutjfP9wmashUqajRVIPq5lDY+Dvq8zmrTKrItWy2R14Z+spAMA9k/tzTCpRNxRWN836HChzJUTdlJWFL/65Fla7wKWowHNDOO6UyBkKqhtQUWuBn1aDYX3D5C6HSJGKGq+f4iOUO4EzG93kVOszi3Gmsh4ROn/MGR0ndzlEqnKmsg4AEBeuvFk3iTq0ahWQkoKqI1kAgIs3fQ5t6hDgvffkrYvIA+SWN50XghX7BI9IbtbGdez9tcrNCAfcklN9e7gIADB3bBwnUSPqpiOFRgDAgGh2y1WC2tpaaLX8Pdap7Gxg4UIIIVBhtcBWWwX/hjrA4QAWLgQmTwaSkuSukki1io3sAUXUGSEEjjd2L49RcE7Y6Cansdod2HK8FABwZWpvmashUp9DjZPljOAMtYoQGxsrdwnq8t2rAID61GnS5xoN8M47wLJlMhZFpG5FjY1urntP1L5f86tRZGxAgK8PxiQod94D5T6DJ9XZml2G6norovQBGBmv3Dc9kVLVWmwAgCheXJGKDSjPl/4iBJCTI2stRGrX1AMqqZde5kqIlGnlxmwAwMy0GAT6Kbd3Gp90k9N8/6vUtfyqtBhoOYEaUbcJaUgSmB5lKCgoQEgIl+jp1JIlwCuv4GBYH0yqkBrb44qlCyBoNEBiony1EXmA7JIaAEBKDH8XEZ2r1mzD+iPFAIBHLlH2UCY2uskpHA6Bn45Kb/oZQ2NkroZIneyNE4H4KXgiEG+i0+mg03F8faceeAB45RWciU4EGhvdzYvdCSGN6yaiHms6L3CeHKK2iowNEAIwBPgiWeHLFPPKjpyixGRGWY0Fvj4ajO8fIXc5RKojhEB1vRUAL65IRZKTgXfewZnQFjdbfXykj3fe4SRqRBeg3mJHXoU0e3lokN959ibyPuU1FgBApN5f5krOj0+6ySkq66Q3fViwH5e0IOqBguoG1Fns0PpoEB+u3HUmidpYsAAVtnhg96fS54sWAQ8+yAY30QVKP1aCWosdceFBGBrL7uVE5zI2PqwIUcFNKTa6ySnqrXYAUPQEBkRKtvFoCQAgLTaEN65IdTLrWsxE8Ne/AuyWT3TBDpypAgBcMrgXNBrO9kF0rkP50qov/SKU/7CCV3bkFDa7NObIlxOoEXVbqcmMN7ecAABcO5zLVJG62B0Ch/Kq5S6DyONkF0uTqA3qzZnLic4lhMCPGdIkzlOSo2Su5vzY6CanKKiqBwD0ClHuovRESlRnsWHBqt3Iq6hHfEQQ5o6Nk7skom6x2h2w2B1yl0HkcfIqpfHcCZHsOUJ0rm3Z5ThaZEKQnxZXpip/Emc2uskpTpRKd2MHRPHEQNQdXx4oQEaBEVF6f3xwzwSEBSt/MhCilsw2NriJnK3GbENOeVOjW/ldZ4nc7YsD0ooZc8fGIVyn/GsnNrrJKTILjACAIX040QdRd2w+VgoAmH9RIhJ504pUqLLWIncJRB4n/VgJLDYHEiODVTFelcjdDjXOeTA1OVreQrqIjW5yivzG7uX92Wgg6pbjJSYAwNiEcJkrIeqZM5X1cpdA5HGyGsdzXzQwkpOoEbWjqSfI4Bhlr8/dRPZGd0lJCWbNmoWwsDBERUVh0aJFsNls7e67efNmTJgwAXq9/v+3d+fhUZV3+8DvyZ7MZCUQCFmBsARQVoOK4Npi3bCWUndaWqu8tk3btz+lvOirtsVqK9Sqb1tLRQsWK1pKsWrrgkhVQFmEACGRhISsZJk1yWSW5/fHmURDEphk5swz58z9ua5cFxlmMt+ZnDtnnvNsyM3NxZo1a0JcLQ2mo1tZvdwYz9XLg4G5iBy2LuX3mpoU/ttdyMZchKdjjVbZJUQsZkK/hOhZoFb6R3XNYS70r8vlQbdvapNWPj9JT/LSpUthMplQX1+PPXv24K233sLatWv73e/YsWP4yle+ghUrVsBms+G1117Dr3/9a2zZskVC1XSmNkfPPt3hP6dCC5iLyOFwKh8EkuO1cdKQibkIT7VtHbJLiFjMhH619H6u4rlhqJgL/Wu2OgEA8TFRSI7XyA7YQqKKigoBQNTV1fXetnnzZpGXl9fvvvfee6+45ZZb+txWXl4uGhoa/H4+i8UiAAiLxTL8oqmfU+0dIv++7SL/vu3C3uWSXc5ZaeEYCGUutPB+6NnfD9T1ZqfN7pRWhxaOA+YifH3ruT0i94dbBAABQNjtdtklBUW4Hwf8DKVvd6zfLfLv2y5e2lMju5ReWjgGmIvIsPN4s8i/b7u47PF3ZZfi9zEgtae7rKwMGRkZyM7+fF/a4uJi1NTUwGw297nvnj17UFBQgJtvvhmZmZmYMmUKduzYgdGjB18i3ul0wmq19vmi4Hvhg2oAwLxxGTBq5WpTGFMzF8xE+Ni6vw4/2LwfAPCNubmaWHlTJuYifB2u5x7dMvAzlL51unqm7fFz1VAwF5Hhk5PtAIBpY1MlV+I/qY1um80Go7HvwltJScoKjXa7vc/tbW1tePLJJ3HbbbehsbERv//97/Hf//3fZx0CsmbNGqSmpvZ+5ebmBv9FEN4+1gwAuPPCArmF6ISauWAmwsdjbxyDEMAtJXn4xY3TZZcT9piL8GTu6EaTb5gfhRY/Q+mb09fojouRPhNUU5iLyLDDt/PLvHEjJFfiP6lJNhqN6OjoOxes5/vk5L4r0cXHx+OGG27ANddcg5iYGCxYsAC33347/vrXvw7681euXAmLxdL7VVtbG/wXQTB3uAAA+SO4cnkwqJkLZiI8NFm7UG/pQnSUAf9zzRRERXFl2nNhLsJTvbkLgHYWstETfobSt2abcjFrZHK85Eq0hbnQv1PtHThQa4bBAFxZPEp2OX6TOmZl2rRpaG1tRVNTE7KysgAAR44cQU5ODlJT+w4XKC4uhtPZ92q6x+PpXd1xIPHx8YiP5x8rtdmdSqM7OYFDoIJBzVwwE+HhpG+bi9z0RCTFMTf+YC7CjxACv/pXOQBgclYyDkuuJ9LwM5S+tXcoC6mN4NSjIWEu9G9/jRkAcF5OGkYlJ8gtZgik9nQXFRVh/vz5KC0thc1mQ1VVFR555BEsX768333vvvtubN26FRs3boQQAjt37sSmTZtw++23S6icenS7vehyKUv2pySwpyMYmAv9s3YqF6pSE5kZfzEX4eeto81451gz4mKi8NNrpsguJ+IwE/rl9Yrez1YJsdyKdSiYC/072eoAAEwYaZJcydBInyiyZcsWuN1uFBYWoqSkBIsWLcLq1asBACaTCZs2bQIAXH755di2bRt+85vfIDU1Fd/85jfxq1/9Ctdff73M8iNeTZty4BvjotnTHUTMhb45fXtLxvPD1JAwF+HlcJ2ygNriGdmYmJV8jnuTGpgJfTL7LswCvDg7HMyFvvWMFswfkSS5kqGR3krKysrCyy+/POD/nbngwdVXX42rr746FGWRnyqblUb3+FEmzksNIuZC31wepdEdw8wMCXMRXurNnQCAnHRtffDRE2ZCn2ralEZFhjGOC6kNA3Ohb/WWnnNPouRKhoZJpoDYupSrselJnHNE5K8Gi7L4VFaKduYiEZ2pqkW56FqQyUU0iYLp7aNNAIALCjIkV0IUfnoWcNbaVqtsdFNA2hzKQh8pHP5E5Lcmq9LoHp3KRjdpV8/Fo1yN9TYQhTOPV+DVfXUAgEXTBt8vmihS9bQ90jTW9mCjmwJS3mQDABSN0tZiBkQydfn2XzXGcU43aVfv2gQxPI6JguXdY82oM3ciPSmWjW6iM3S5PGj0dVzkZmhrahMb3RSQE6eV4YVsdBP5r97XQ5hh5LYjpE1N1i602JWtdkal8DgmCpaezozLJo/iyuVEZ9hfY4YQylZ6WttOj41uGjavV/Qu26+1q01EMpU3WgEAk0ZzxWfSph3lzQCAGblpyDSx0U0ULN2+ESSJbHAT9dNz7lk4aSQMBm0tRstGNw3boToL2jtcMMZFYwJ7uon80uboRpNV6SFko5u06jPfKKdZeemSKyHSl9p2ZeXy0Vxok6gPIQT+dURZZPDyyaMkVzN0bHTTsO2qbAEALJg4kkOgiPxUVq/sbZw/IgmmeOm7NhINyylfw0BrW7YQhbuKJmVLq6IsXpQl+qJT7Z2oanEgNtqASyex0U0RpNE3L5W93ET+O1BjBgCcn5MmtQ6iQNSblb//2WlsdBMFixACJ04rjW5+tiLqq9KXjXGZJk12Wgyr0V1XV4e6urpg10IaU9Om9HRwr2EFc0H+6DlpFGenSK5EfcyEfrU6lCkSI5O1tZBNOGAuaDA7jp+Go9uDxNho5EXYWjnMBZ1Lg7ln1XJtXuwdUqP7P//5DwoLC5GXl4e8vDxkZWXhvvvug9VqVas+ClNCCBw8ZQYATB+bKrcYyZgLGgqHU9kuLCVBW/tLDgUzoX9Ol7LYE6cW+Y+5oHN56p1KAMBt8/IQFxMZg1GZC/JXR7cbAJAUp71ebmCIje7vfve7mDp1Kvbu3YtPP/0Ujz/+ON5++23Mnj0bLS0tatVIYajF3g1zhwsGAxeDYi5oKGxdLgCAKUGbJw1/MBP65/YKAEBsdGQ0DIKBuaBBVVSg6/5V2FfdBgBYli25nhBiLshfh+qUNXHGanQtkSGdLT/77DOsXbsWs2bNwtSpU3HHHXdg7969mDFjBr7//e+rVSOFoZ6h5aNTEiK+p4O5oKEwdyiN7vQk/fZ0MxP65vUKOF3KiI0ojW3ZIhNzQQN67jlg8mTse+mfEAYDUrrsyJ4zHdiwQXZlIcFckL92Hj8NALhCgyuXA8CQulqmTJmCxsZGFBUV9d5mMBjw8MMP44ILLgh6cRS+TtuU+XyjUzmfm7mgoWjv6AYApCfpdy4sM6FvH1W1wtHtQUpCjGbn1smgl1w4HA5ER0f2xfagqawEli+HSwismrcEbocZV5d/AIPXCyxfDsyfD0yYILtKVeklF6Q+c6fSaZE/wii5kuEZUqN72bJluOuuu/Dmm28iLy+v93aLxYLU1Mie1xtpTtuUxQxGGOMlVyIfc0H+8njF541uo34b3cyEvr1ztBkAsGjaaMTHsPHlL73kIjs7gsY+h9LmVQCAb8X7Vi03GID164E1ayQWpT695ILUZe7ohlBmNSFOo9OahtToLi0tBQBMnDgRX/3qVzFjxgx4PB5s3LgRjz/+uBr1UZg6eEqZV1GYGVmraw6EuSB/NVm74PIIxEQZkJWs3wtWzIS+VbU4AADncdu7IWEuyB/pTmWHCwgBVFdLrSUUmAvyxzvHlIu9k0cnI1Wj0/OG1OhubGzE/v37cfDgQRw4cAAbNmxARUUFDAYDHn30Ubz22ms477zzcN5552HRokVq1UwSdbk8WL31MLZ8cgoAMDs/XXJF8jEX5K+eaRkjk+MRo9Ertf5gJvTttF05jsdwetGQ6CUX9fX1SEnR/5aHIfHAA8C6dVg763qs/ngrAKC3K8NgAAoKJBUWOnrJBanrk5PtAICFk0ZKrmT4DEL0dNYPT1dXFw4dOoQDBw70Bubw4cMwm81BKjF4rFYrUlNTYbFYeMIYpm8//zHeOtqEKAPw4y9NwopLx8OgoYV0QnUMaCUXzERo7a9px43PfICxaYn4z/2Xyy6nVyiOA61kAmAuzmXRup041mjDn5dfgEuKlA9ADocDJpMyLNZut8No1Oacuy9iLvpiLlRQUQFMnow7rvt/+PPfHwUA2AEYASAqCigvD6s53fwM1R9zoT4hBJb87kN8fLIdv7xpOpbOzTv3g0LI32Mg4D1rEhISMHfuXMydOzfQH0Vhzun24J1jTQCA9cvm4rJJ2lw9MBSYCxpIg8W3FoJJv/O5B8NM6IfLo+zRHROl39EaocJcRLiiImD9ehzf1fn5bT25Wr8+rBrcocRc0Bdt2l2Dj0+2IybKgNn5GbLLGTaeMclvtW0d8ArAFB+DSydqd3gHkSzHGqwAgCmjeTWctKnZ2oVmqzK8PCmOi6gRBarr1ttRn/KFTozSUqWHe9kyWSURhQ2H042fvXYEAHDfosmYMMokuaLhC7inmyJHZ7fSu5GcEKOpIeVE4aJnf/vCkdofekuRx+Xx4u6Nn8DmdGPCKBOKs3nxiChQdqe77w0PPwzoYHoGUTAcabCiy+VFVko8vn1JoexyAsKebvLbiRZlRc2EWPZuEA3HSV+jOyedexuT9uytbsO+GjOS42Pw7B1zEKvjxQCJQqWz2yO7BKKwdaReGSE4LTtV8x1+PGOSX4QQeObdzwAAi2eMlVwNkfZ4vALHGmwAgMkcXk4aZOlwAQAmjU5GYSZ74oiCwdHtPvediCJUWb2yRbEeRlax0U1+qTN3orzJhthoA5ZdXCC7HCLNeftoEzpdHqQmxrLBQprU6VJ65BI5l5soaNjTTTQwW5cLb5YpCzjPzEuTW0wQsNFNfqlsVoaWF4wwIjVRm5vSE8kihMDvd54AANx8QR6io7Q9RIoik8M399QYx+VgiILF7Q1o514i3dq0uwaWThfGjTRi4UTt75jERjf5pb2jGwCQlZIguRIi7fnb/jp8crIdibHRWHZRgexyiIbF6VYW02RPN1Hw9GwlSUSfc3m8eP6DagDA3QvH66KzQnqju7m5GYsXL0ZaWhoyMzNRWloKt/vs81sOHz6MpKQk7NixIzRFEpwu5cNWfIz0QyYiMBf68tQ7lQCA710xAaNTeeFquJgLuVwepUcuSuOL2egJM6F9lU022SXoDnOhfbsqWtBg6UKmKQ43zMiWXU5QSG9BLV26FCaTCfX19dizZw/eeustrF27dtD7d3R04Oabb0ZnZ2cIqySXb/hTHBvdIcFc6IfL40V1qwMA8LVZOZKr0TbmQi5bl7KQWnICh5eHC2ZC+440WGWXoDvMhfYdrlMWUFswcSTiY/QxukpqC6qyshI7duzAY489hqSkJIwbNw6rV6/GU089NehjVqxYgRtvvDGEVRIAuHzDCvUwvCPcMRf6UlZvhVcAibHRyDTFyy5Hs5gL+WxdSk9RChvdYYGZ0IcTpx2yS9AV5kIf9lS3AQCm6Gi3F6mN7rKyMmRkZCA7+/NhA8XFxaipqYHZbO53/xdeeAGVlZV48MEH/fr5TqcTVqu1zxcNj1coPd1sdKtPzVwwE6G35ZNaAMCXp2YhivkZNuZCvi7f6uUJnNMdFvgZSh/sTm4ZFkzMhfY1Wrqwq7IFAPDlqaMlVxM8UhvdNpsNRmPfrXOSkpIAAHa7vc/tx44dw6pVq/Diiy8iOtq/E/6aNWuQmpra+5WbmxucwiNQk1VZ6IPDCtWnZi6YidDbUX4aAHDDTO5vHwjmQr6TrR0AgEwjR2yEA36G0j6vV8Dc6ZJdhq4wF9pX3mSDEEDRKBPyRiTJLidopDa6jUYjOjo6+tzW831ycnLvbV1dXVi6dCnWrVuHvLw8v3/+ypUrYbFYer9qa2uDU3gEOlBrBgDMyE2XW0gEUDMXzERoNdu6cKq9E1EGYE4+sxMI5kKuLpcH+2vbAQAl4zIkV0MAP0PpQaujG91uLzgIKniYC+3zePW5U4bURve0adPQ2tqKpqam3tuOHDmCnJwcpKam9t62d+9eHD9+HMuXL0daWhrS0tIAANdeey1WrFgx6M+Pj49HSkpKny8anha7smVYXoZ+rjiFKzVzwUyEVpVvrl5uRhKSE7i/fSCYC7mqWhxweQRSE2N5HggT/AylfQ0WZeGuzOQ4yZXoB3Ohfc1WJwAgLUlfuZA6VrioqAjz589HaWkp/vCHP6ClpQWPPPIIli9f3ud+l1xySb8VBQ0GA7Zv345LL700hBVHJmuXC6dtSgCSdHbVKRwxF/pR7/tAlZOeKLkS7WMu5KpqUS4gFWQaYeCWYWGBmdC+Jl/jIiuZW0kGC3OhfT3nm3ydXeCVvv/Tli1b4Ha7UVhYiJKSEixatAirV68GAJhMJmzatElyhfTbtytgd7oxbqQRk0Ynn/sBFDDmQh9abMoIkZFctTwomAt5jjUqewlPHGWSXAl9ETOhbU63b3HCWHZoBBNzoW0HT5kBANPG6msUgfRVsbKysvDyyy8P+H9nLnjwRcK3mjap7x8HGwAA9y2ajNho6ddpIgJzoQ+n2pV5ZCOT2egOBuZCnhrfXvPj2egOK8yEtrk9yu8hJpqjR4KJudCoigp0rd+AA94LgKgYzBT6WhmeLSg6p57tLCZmsZebaCj2VisLT03PSZNbCFGAvL7PonG88EoUNL3b8LGnmyLdc88Bkyfjg1ffQldUDLKtp1F04fnAhg2yKwsa6T3dFP4+PynwwxaRv3aUN+NIgxWx0QbMK+Rqz6Rtbt9qsuyRIwqeymal1zWTU5A0z+Fw+L3tGJ2hshJYvhxCCHyYmg23w4ySqv0weL3A8uXA/PnAhAmyqwwYG910Vt1uL9y+Lo6kWB4uRP564t/HAQDLLirAqBQukkPa1tHNHjmiYHJ7vHjrqLLC9kXjMvGE5HooMNnZ2bJL0IePtwIfb8WIOYuV7w0GYP16YM0amVUFBbsu6azaHMpCUNFRBiQnsNFN5A+PV+BIvTIX6c6LCuQWQxQEDt80o+R4ngeIgmHz3lpUt3YgLSkWFxeNkF0OUVjJszQq/xACqK6WWkuw8OxJZ9WzVVimKQ5RURxWSOSP6lYH3F6BuOgojEnldmGkfeYOFwBwv3miIFm/qwoAUHpFEXOlA/X19dyze7geeABYtw4OrxdZvpumt9Yq/zAYgIICWZUFFRvddFYt9p5GN+cbEfnr3WPNAIC5hemI5sUq0jghBGp9K/GP5Z7zRAHr6Hb37kV8/YyxAFxyC6KAGY1GGI1G2WVo0913A+vWodsQDQhlKtMoh1n5PyGUed06wOHldFbNti4AbHQTDcVrh5Rt9q6cknWOexKFv9q2TnS5vIiNNiCHjW6igP2nshUAkJUSjwxjnORqiCQrKgLWr8exrHG9NyW7nUBUlDKfWweLqAHs6aZzqGvvBMDeDSJ/nWx1YH+NGVEG4JrpY2SXQxSwT2raAABTs1MRyy3DiAK2eU8NAGDxjLGSKyEKE8uW4VXnWODuLwEAon/wfeCee3TT4AbY6KZz2F9rBgCMH2mSWwiRRuyrUfbmnpWXzlXLSRde3VcHALhoPBd7IgpUl8uD9ytbAAA3zc6RXA1R+PjUKj7/5uGHAZ0N1+claxpUt9uLPVVKD8clRZmSqyHShuNNyr6rk0YnS66EKHD15k68X9ECgwG4+YI82eUQad6/jzSh2+1FVko8ikaxQ4OoR6O1S3YJqmKjmwZV0WyD0+1FSkIMTwxEfjpcZwEATBnDVUxJ+yqalYtIE0clIzcjSXI1RNp22ubEg9vKAABLZufCYOBCm0QA4PUKWDr0vaAgG900qJ5e7iljUnhiIPLD8SYbdvtyMyM3TW4xREFQ0WQDAORmcF0PokA9/W4l2hzdmDImBd+7Qj9zVYkC1eJwwivOfT8tY6ObBiSEwF98C318hYtBEZ2T2+PF917cj263FwsmjsTUbPZ0k/btKD8NAJg3jvO5iQJh6XThlX2nAAArr56M+JhoyRURhY+ejj49Y6ObBmTucPXOTV08k6trEp1L5Wk7yptsSIqLxq+XnM/RIaR5Dqcbu6uUrY0umzxKcjVE2mXtcuGOP+2BrcuNghFJmD+B6+QQfdGnpyyyS1AdG900IEe3GwAQHxOF1MRYydUQhb9utxcAkJYYi5HJ3NeetG93VStcHoGc9ESMy9TXKrJEofS9F/fjYK0ZaUmxeObW2YiK4kVZoi+qanHILkF1bHTTgHoaEHExPESI/NHR7QEAJMRyyCDpw64KpZf7kqKRHLlBNEzmjm68d1yZprFxeQmKOfWIqA8hBA74tijWM7aoaEBu32oGMbwaS+QXs2/VzdQkjgwh7XN5vHjraBMA4OIJnM9NNFw9jYnCTCOmjU2VWwxRGKpu7cBpmxPxOu/o0/ero2GzdSkNiOQENiCI/NHqcAIARhg5tJy078XdNahp68AIYxwWThwpuxwizSqrtwIAzsthg5toIPXmTgBAns53yWCjmwZUZ1Y2qB9hipNcCZE27K8xAwBGpbDRTdq3eW8tAOAHVxbx4itRAMoblW33pozhsHKigbQ5ugEAaUn6bnOw0U0D+uiEMpdvZm665EqIwl91iwN/218HAPja7BzJ1RAFrme003QOhyUKSLNN6cTITtN3Lx7RcHX61sRJio+RXIm62OimAVX6tgs7P5cfuIjOZU9VGzxegbkF6ZiVxwtVpG0Nlk40WJSGQqaJIzeIhsvjFb093TnpbHQTDaRnx6REnS9Ey0Y3Dajbo6xervcAEAWDy+vbLkznQ6MoMry0txYer0BJYQZyM5Jkl0OkWQdq29He4UJqYizO46gRogG19yxEm8iebopAVt/QQlOCvgNAFAwVvpEho1MSJFdCFLjPTiv7pV5VnCW5EiJt+6xZydKM3DTERPMjN9FA9te0AwAKRhglV6Iu/gWgAZ22KisxZ7ERQXRWXS4P/lXWCAC4aDy3ViJtc3m8qGhShsOadD6/jkhtbR3KAlEjjBwFRTQQh9Pdu47UAp3vlCG90d3c3IzFixcjLS0NmZmZKC0thdvtHvC+v/vd7zBp0iQkJydj4sSJeOaZZ0JcbeTocCmLGvBDlxzMhXY8/W4l6i1dGJOagIWT9H3CkI25UN8vXz+GY402JCfE8HjWAGYivDmcyu8imaMGQ4q50I491W1weQTGpiWiMJM93apaunQpTCYT6uvrsWfPHrz11ltYu3Ztv/tt3boVK1euxPPPPw+r1Yrnn38eq1atwiuvvCKhan3r6HbD4xUAgATO6ZaCudAGr1dgwwfVAIDV1xYjKY4frNTEXKjL7fHi+Q+rAQCPf+18jEnlwk/hjpkIby12paebU/VCi7nQjkOnLACAknEZMBgMkqtRl9RGd2VlJXbs2IHHHnsMSUlJGDduHFavXo2nnnqq333r6+tx//33Y968eTAYDLjwwgtx2WWXYefOnRIq17fKZmV+6ghjHFITuT9rqDEX2nGyrQO2LjfiY6LwJc5/VRVzoT6XR8DlUS64LpiYKbkaOhdmIvx9esoMAJiazUXUQoW50BZrZ88iavpvb0i99FZWVoaMjAxkZ2f33lZcXIyamhqYzWakpaX13r5ixYo+j21ubsbOnTvxxBNPhKrciFFvVraK4aq1cjAX2lFv7gQA5GUkcZEclTEX6uvo/nz4ZSyP57DHTIS3ow1WlNVbEWUA5uRzK8lQYS60473jp/HChycB6H8RNUByo9tms8Fo7PsmJyUpDT273d4nGF/U2NiIa665BrNnz8Ytt9wy6M93Op1wOp2931ut1sCLjgBOtzKfOyGWH7pkUDMXzERwuX3TMNhAUR9zob42hzIUNi0plse0BvAzVHh77j9VAICrp4/BKC5KGzLMhTZUtThw1wsfo9vjxaKpo3FLSR66uzpll6UqqWdVo9GIjo6OPrf1fJ+cnDzgYz766CPMnTsXkyZNwrZt2xATM/h1gzVr1iA1NbX3Kzc3N3jF61jP9kdj09jTLYOauWAmgqvLt+BgPC9QqY65UF+jVRnlNCo5XnIl5A9+hgpvH/pWZF46h+9bKDEX2vDH90/A6faipDADT948MyIu9Ep9hdOmTUNrayuampp6bzty5AhycnKQmtp//suf/vQnXHHFFSgtLcWLL76I+PizfzBYuXIlLBZL71dtbW3QX4Me7fPtlze3gMOhZFAzF8xEcDX5Gilc5V99zIX6GizK8TyaC6hpAj9Dha82Rzdq25Reu/Nz0uQWE2GYi/DndHvwyr5TAIAfXjURcTH6b3ADkoeXFxUVYf78+SgtLcUf/vAHtLS04JFHHsHy5cv73feVV17BPffcg23btuHLX/6yXz8/Pj7+nOGh/lrsyrAZzumWQ81cMBPBI4TA5j3Kyfai8Vx0Sm3Mhfp6FrRJT9L/gjZ6wM9Q4Wu3r5d7YpYJqcxTSDEX4a+s3ooulxcjjHEoKcyQXU7ISL+0sGXLFrjdbhQWFqKkpASLFi3C6tWrAQAmkwmbNm0CADz00ENwu9246aabYDKZer/uvvtumeXrjhACTVal0Z2eFCe5msjFXIS5igocXflzHGmwIg5efGOES3ZFEYG5UJetS1lIjSM3tIOZCE9/P1APgBdkZWEuwtvzvq1WZ+al636bsC+SfmbNysrCyy+/POD/2e323n9/+umnoSopop1occDS6UJ8TBQmjDLJLidiMRdh7LnngG9/G29cfAtw0UwsrNiD9BmLgfXrgWXLZFena8yFuiy9Pd284KoVzET4qWy24Y2yRgDArSV5kquJTMxF+NpR3oy/H6hHlAH43uUTZJcTUtIb3RRejjYoqzAWZ6dEzBwLAhwOB6Kjo2WXEf4qK4HlyyGEwO7U0XA7zLikci/g9QLLlwPz5wMTIuskQvrR29OdwI8GRMP1t/11AIArp4xCUdbAC3cRRaqtvnzcNi8f5+emyS0mxHhmpT5OtiorPBZGwH559Lkv7mdJftr+KwBAcu405XuDQentXrNGYlFEw9PR7UZFsw0AEBcBq8gSqeXfR5QFvK47n+dVojPtrVYWa/5S8WjJlYQez6zUR88+rSNTuEgEkT9yrM3KP4QAqqul1kI0HG2Obtz87G58esqC+JgoXFLEeahEw+HxCpw47QAAzCmInAWiiPzh8Qo0WJRV/SdmRd4UVvZ0U69utxd7q9sAAGmJnNMXSerr65GSkiK7jPD3wAPAunU4lJqFC9sbAAATLb5Gt8EAFBTIq41omJ56pxIHa81IT4rFH++cyyGxRMPUYnfC7RWIMgBZ3O+eqA9blwteofw7LQLXDmGjm3o9+voxfHrKguSEGFx73hjZ5VAIGY1GGI2cUnBOd98NrFuHg3nnA75Gd+8fUSGUed1EGnOiRVlY6CdfnozZ+emSqyHSrs+alSzlZiQhhtM0iPro9nh7/x2J60ZF3iumAbU5urHhgyoAwBNfn8E9uokGUlQErF+PHRPmfn5bVJTytX49F1EjTWrvUFYtzzRFXs8DUTAdb1LWRZgwMvKGzhKdjccr8Og/jwGI3HMNG90EAHj9cAO8Aigek4KrirNkl0MUttqW3IKP8s///IbSUqC8nNuFkWa5fb0PkdjzQBRMZfXKDjBTx6ZKroQovDz+Zjle3V+H6CgDfrZ4muxypODwcoK5oxtr/30cAHDDDK62SXQ25Y02eMQXbnj4YYBD80mjhBBosHQB4P7cRIFqsjkBAHkcLUjUxz8O1gMAfnHjNCyaFplTWHlZO8KdbHXgzuf2osXejQmjTFh2cYHskojCWs+2SkR6cKq9E22ObsRGGzB5DBdQIwqEx6uMGokySC6EKIy4PN7eVcsvmzxKcjXysKc7gr267xRWbz0MR7cHyQkx+PWS8xEfEy27LKKwVdlsx6OvH5NdBlHQHKg1AwCmjEnh33+iAAghUN6oXJTlujhEn+tyeXpXLU9JiJVbjERsdEeoFz6sxgN/LwMAXFCYgSe+fj5y0nmSIBqM1yvw45cPoqPbg5LCDNTKLogoCD49ZQYAzMhNk1oHkdbVtHWgxd6NuJgonJfDOd1EPWrblF7uKAMQHcHDQDi8PAJt/7S+t8H93QXj8JfvzGODm+gcXvq4FgdrzTDFx+CXXztPdjlEQVHp2+Jo0mgOLScKxInTDgDAuEwjR40Q+bg8Xqx5/SgA4EvFoxEbwVvpsac7Aq3fpWwNdseF+bj/6skwGCL3qhORv/62vw4A8L3LJyArJUFyNUSB83oFPj1lAQBMzGKjmygQ1a1Kozt/BDsxiADA2uXCf23ah/crWhAbbcB9V0+WXZJUbHRHGCEETrUrwzxumpXDBjeRn061dQAA5hZmSK6EKDgO11vQ6uiGKT4G5+ekyS6HSNN69ujOH8HdLIjcHi9ufXY3DtVZkBgbjSdvnonCzMjOBhvdEeaNw404bXMiMTYahSMj++AnGgprlxsAkMFtlUgnqluVC0lTs1O4RzdRAN47fhov7VVW+piTny65GiL5Xj/ciEN1FqQmxmLj8hJM5zoHnNMdaX7zdgUA4DsLxkX0CoJEQyWEsvQmB4eQXlg6XQCAxDjOPyUaLo9X4Md/PQivAJbOycVVxVmySyKSqtXuxBP/Pg4A+ObFBWxw+7DRHUFO25w41miDwQB8i/txE/mts9sDR7cHAJDGnm7SASEEXtpbAwCYlceeOaLharJ2ocXuREyUAQ/dMJXT9iii2Z1u3PncHlS1ODAmNQF3Xlggu6SwwUZ3BNld1QoAmJSVzIYD0RCcbFMWyEmOj0FKAmflkPbtqzHjcJ0VCbFRuG1evuxyiDRJCIHfvfcZAGVv7oRYjhqhyPZ/OypxuM6KEcY4bPx2CdKNbG/0YKM7QgghsP1gAwBgwcSRkqsh0pa91e0AgGljU9mLQbrwj4P1AICrp41BBj8UEQ3L0+9W4oUPT8JgAH501UTZ5RBJ1eXy4MXdygiqn984DeNHmiRXFF7Y6I4And0efO8v+/FGWSMA4MtTR0uuiEg7jjfZ8PgbxwAAF40fIbkaosA53R5s8zW6rzt/jORqiLRJCIE/+rZg/d/rpuK687MlV0Qk13vHT6O9w4Xs1ARcVcy2xpk4TlLnTpy2479e3I+jDVbERBnwv9dPxWyurEnkF7fHi29t2Atrlxuz89Px7UvGyS6JKGD/PtKENkc3slLisaCII5+IhupYoxWb99TC3OFCdJQBS+fmyi6JSLp3jjYDAL40dTSiozgq8ExsdOvY3w/U4aevHoKj24NMUxyeuXU2LuAew0R+a7I5caq9EzFRBvzxjjlc5Zk0TwiBZ3eeAKCstBwTzQFvRP5wuj145ZM6vPRxLQ7WmntvX1CUybncRAD21ShT8S4pypRcSXhio1uHhBBY+1YFnvRtD1ZSmIEnb56JrJQEyZURaUuXS1mxPD4miouBkC7860gTDp6yICE2CndeVCC7HCJNEEKgdPMBvH5YmaYXE2XAlVOysHRuLtfJIYIylfWz03YAyvo31B8b3Trj8Qo8uO0wNn6kLGSw4tLx+NFVE9mbQTQMe6vaAABFWcmSKyEK3GmbE6v+dhgA8M2LCzHCFC+5IiJt+Nv+Orx+uBExUQb8v0WT8NVZOchkfoh6HW20wiuATFM8O/kGwUa3XlRUwLX+OfzYkY1txkIYADy8eBpu51YwRMPWs2r5Ag6VIo37uLoN9764Hy12JyaMMuEHVxTJLoko7NW0duDn/zyCN8uaAAD3XDoedy0YL7kqovCz72TPLi8pkisJX9K7P5ubm7F48WKkpaUhMzMTpaWlcLvdA973n//8J6ZPnw6j0YgpU6Zg+/btIa42TD33HDB5Mn54zIttxkLEeNx4cttjuP3Yu7Iro2FiLuRqtnbh1X2n8PFJpac7NyNJckUEMBfD9dLeGiz9w0dotHZh3EgjfnfbbM5B1QlmQj0b/lOFK594D2+WNSE6yoBlFxXge5fzYpUWMBeh97ZvEbVLuDjnoKT3dC9duhRjx45FfX09Ghsbcf3112Pt2rX4yU9+0ud+FRUVuOmmm/CXv/wF1157LV599VV8/etfR0VFBcaOHTuk53Q4HIiO1skHjspKYPlytMUmYWvudMBhxvrtT+CK6n3A8l3A/PnAhAmyq6QhkpGLSOZwurG7qhW7Klqxq/I0jjfZ+/z/+FHcazIcMBdDt7+mHav+dhger8ANM7Lxixunwxgv/dRPQcJMqOP1Qw34338cAaAsCrX62mJM5DQjzWAuQqvd0Y091UonxZVTRkmuJowJiSoqKgQAUVdX13vb5s2bRV5eXr/7rlq1Slx11VV9blu0aJF44IEH/H4+i8UiAOj+qwkQAhAiOlqI++8f/i9Ih3qOAYvFIruUQYUyF1p4P9Rg7ewW7xxrEmv+eVQsfnqXGL/yNZF/3/ber4L7t4trn3xfPPr6UfFxdVu/x9vt9t682e12Ca8guLRwHDAXQ+Nye8SLu0+KWQ//S+Tft12s2PiJ8Hq9qj2f3jIhRPgfB7I+Q4Xr+xEs7x5rEpP+558i/77t4sG/H1Y1Nz20kh8tHAPMReht/Kha5N+3XSxatzOgn6OVHJzJ32NA6uXusrIyZGRkIDs7u/e24uJi1NTUwGw2Iy0trc99p0+f3ufxxcXFOHjwYKjK1R4hgOpq2VXQEDEXwWftcmHPiTbsrmrF7qo2HK6zwCv63icnPRGXFGVi/oSRuGj8CK5WHmaYC/8IIfBmWSMee7McJ047AAATs0xYc9N0GAzcN1VPmIng27ynBqu2KiNDLp88Cv9zzRTmRmOYi9Dqdnvxfzs+AwB8dSZHB5yN1Ea3zWaD0Wjsc1tSkjJ30m639wnGYPe12/sOA/0ip9MJp9PZ+73FYgEAlJeXIzlZJ8OEfv5z4Jln8Ou5X8Wv97wCAHADsPb8/5gxgNU62KMjjtX3XgghznFPedTMxWCZsOr8GNm85yR+9tqxPrflpCdiTn465hRkYE5+OnK+OG/b0wWrtWvQn+dwOHr/bbVa4fF4gl5zKDEX+snFxo+q8ejr5QCAtMQYfHfheHx9bi7Q3Qlrd6dqz6u3TADhnwtZn6G0mAt/bN1fh//Zqqzuf935Y/DQ9UXocAz+/gSTVvIT7pkAmItQ27znJGoaW5FpisP1xekBvQ9aycGZ/M2F1Ea30WhER0dHn9t6vj+zUTzYfc/WeF6zZg0eeuihfrdPmjRpuCWHL1+DGwB6rzN5vcDatcoX9WGz2ZCaGp77CKqZi8EykZubG0jJmlQL4MMg/JwvXk3XOuaiL63nohbAvWuAe0P8vHrKBBC+uZD1GUrrufDHM74vGbSQn3DNBMBcyFILYPTPgvfztJCDM50rF1Ib3dOmTUNrayuampqQlZUFADhy5AhycnL6FT1t2jTs27evz21HjhzBnDlzBv35K1euxI9+9KPe781mM/Lz81FTU6PqHwur1Yrc3FzU1tYiJUXdpfP5XEMjhIDNZgvrMKuZC1mZOJtQHlesYWDMRXjkQtYxwOcdWLjnQq+foQIRDn/Lz0XLNYZ7JgDmwl9aOA4HEo51+50LNSeW+2P+/PniG9/4hrBareLEiRNi6tSp4sEHH+x3v6NHj4qEhATx0ksvCZfLJV566SWRkJAgysvL/X6uUC12EMpFFfhc+hSqXITD+8wawqeGcKf3XPB59f28atDjZ6hAsMbg0EKNZ8NcnBvrDj3p+3Rv2bIFbrcbhYWFKCkpwaJFi7B69WoAgMlkwqZNmwAAkydPxtatW/GLX/wC6enpePjhh/HKK69g4sSJMssnUgVzQdQfc0HUFzNB1B9zQeHIIEQYr4YQZFarFampqbBYLKoOSQjV8/C5KFDh8D6zhvCpgRSyfhd8Xn0/r9Zp4X1jjcGhhRrDhVbfK9YdetJ7ukMpPj4eDz74IOLj43XxPHwuClQ4vM+sIXxqIIWs3wWfV9/Pq3VaeN9YY3BoocZwodX3inWHXkT1dBMRERERERGFUkT1dBMRERERERGFEhvdRERERERERCrRTaPb6XTihhtuwMUXX4xnn332rLd/+OGHKCkpwWWXXYaqqioAwKpVq3DxxRfjnnvuUfV55s+fj0svvRSXXnopDh06FLTnAoCamhosXry493t/X1Mwnkut17Vx40bMmzcPF110EQ4cODDk1xXJQpUJNWsYynEVjBqAwHKkVg3BeB9IISsXsrIg6/iXdczz/DI84XC+ULvGUPwdDYfzjdo1Rsr5SAuZUKt2Wb9jLeQnIHJ3LAueF154QTzzzDPC4/GIq666SnR2dg56+zXXXCNaW1tFWVmZuOuuu8TJkyfF0qVLhRBC/OQnPxEffPCBKs/j8XjEddddp8pr+vjjj8W8efPEwoULhRBiSK8p0OdS83XNmzdPuN1uUVVVJZYsWTLk1xXJQpUJtWoY6nEVjBoCzZEaNQTrfSCFrFzIyoKs41/WMc/zy/CEw/lCzRpD9Xc0HM43atYYSecjLWRCjdpl/o61kJ9A6Kan+5NPPsH8+fMRFRWF6dOn4+jRo4Pe3tnZiYyMDBQXF6OiogL79u3DxRdfDAC45JJL8NFHH6nyPFVVVfjss8+wcOFClJaWQpxjDbuhPJfX68W2bdt6HzuU1xToc6n5uv7xj38gOjoaLpcLcXFxQ35dkSxUmVCrhqEeV8GoIdAcqVFDsN4HUsjKhawsyDr+ZR3zPL8MTzicL9SsMVR/R8PhfKNmjZF0PtJCJtSoXebvWAv5CYRuGt02mw0mkwkAYDQaYbfbB73d6/X2Pk4IMehjg/08UVFRuP/++/Hee+8hJiamz8ES6HPNnTsXI0eOPOdj1XguNV9XZmYmnE4nVqxYgR/+8IdDfl2RLFSZUKuGoR5Xwagh0BypUUOw3gdSyMqFrCzIOv5lHfM8vwxPOJwv1KwxVH9Hw+F8o2aNkXQ+0kIm1Khd5u9YC/kJhG4a3SaTCQ6HAwDgcDh6N0wf6HaDwdD7uKioqEEfG+znycnJwZIlSwAAV155JcrLy4P2mvx9rBrPpebrcrlcWLJkCW699VbMnj17yK8rkoUqE2rVMNTjKhg1+PvYUNYQrPeBFLJyISsLso5/Wcc8zy/DEw7nCzVrDNXf0XA436hZYySdj7SQCTVql/k71kJ+AqGbRvesWbOwc+dOCCFw4MABTJo0adDbExMT0dLSgiNHjqCgoAAzZ87E+++/DwB4//33MWvWLFWe54033sBDDz0EANi1axeKi4uD9prONJTXFOhzqfm6fvSjH+Hqq6/GsmXLhvW6IlmoMqFWDUM9roJRw5lkvA9nCtb7QApZuZCVBVnHv6xjnueX4QmH84WaNYbq72g4nG/UrDGSzkdayIQatcv8HWshPwEJyszwMNDZ2SkWL14s5syZI55++mnx2GOPibKysn63CyHEhx9+KEpKSsS8efNERUWFEEKIn/70p+LCCy8Ud955p/B6vao8j9vtFt/4xjfEggULehcrCNZr6tGzoMBQXlOgz6XW62psbBQJCQli4cKFYuHCheLee+8d8uuKZKHKhFo1DPW4CkYNPYabIzVqCNb7QApZuZCVBVnHv6xjnueX4QmH84WaNYbq72g4nG/UrDGSzkdayIQatcv8HWshP4EwCKHjVRCIiIiIiIiIJNLN8HIiIiIiIiKicMNGNxEREREREZFK2OgmIiIiIiIiUgkb3UREREREREQqYaObiIiIiIiISCVsdBMRERERERGphI1uIiIiIiIiIpWw0a0zGzZsQEFBAQCgvb0dK1asQG5uLoxGI8aMGYM777wTp06d6r3/smXLEBsbC5PJBJPJhMTERIwbNw73338/Ojs7Jb0KouBhJoj6Yy6I+mMuiPpiJoKHjW4dW7p0KVpaWrB37144HA4cOHAATqcTV111Fdxud+/9br31VtjtdtjtdnR0dGDz5s147bXXcNNNN0msnij4mAmi/pgLov6YC6K+mInAsNGtY7t27cKNN96I0aNHAwCysrKwbt06lJSUoL29fcDHGAwGXHDBBdiyZQveeOMN/Otf/wplyUSqYiaI+mMuiPpjLoj6YiYCw0a3jt188824++67sWLFCvz1r3/FyZMnMXr0aGzYsAEjR44862MnTZqEoqIivPPOOyGqlkh9zARRf8wFUX/MBVFfzERg2OjWsWeffRZPP/00ampqcNddd6GgoAATJkzApk2b/Hp8ZmYmWltbVa6SKHSYCaL+mAui/pgLor6YicCw0a1jUVFRuO2227B9+3a0t7ejrKwMS5Yswe2334633377nI9vbm7GqFGjQlApUWgwE0T9MRdE/TEXRH0xE4Fho1vj/vznP+OXv/xl7/culwtJSUl48803YTKZ0NbWBkCZU1FcXIw1a9Zg5syZ2L9//1l/7tGjR1FZWYkrr7xS1fqJgo2ZIOqPuSDqj7kg6ouZUA8b3Rpnt9vx29/+Fg0NDbBardiyZQvmzJmDBQsWICsrC9/85jdx6NAhuFwu2Gw2bNq0CRUVFbjmmmsG/HlerxcffPABli5dihtvvBGXXXZZiF8RUWCYCaL+mAui/pgLor6YCRUJ0rTu7m7xne98R2RmZgqTySSuu+460dDQIIQQor6+Xtx1110iPz9fJCYmitTUVLFo0SLx0Ucf9T7+zjvvFDExMcJoNAqj0SjS0tLEtGnTxM9//nPhcrlkvSyiYWMmiPpjLoj6Yy6I+mIm1GMQQgjZDX8iIiIiIiIiPeLwciIiIiIiIiKVsNFNREREREREpBI2uomIiIiIiIhUwkY3ERERERERkUrY6CYiIiIiIiJSCRvdRERERERERCpho5uIiIiIiIhIJWx0ExEREREREamEjW4iIiIiIiIilbDRTURERERERKQSNrqJiIiIiIiIVMJGNxEREREREZFK/j9Ii5AexVr2iAAAAABJRU5ErkJggg==\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""lam = 1.0\n"", ""nsteps=5000000\n"", ""ensemble = biceps.Ensemble(lam, energies)\n"", ""ensemble.initialize_restraints(input_data, options)\n"", ""sampler = biceps.PosteriorSampler(ensemble)\n"", ""sampler.sample(nsteps=nsteps, print_freq=1000, verbose=False)\n"", ""traj = sampler.traj\n"", ""init, frac = biceps.find_all_state_sampled_time(traj.__dict__['state_trace'], len(energies))\n"", ""convergence = biceps.Convergence(traj, outdir=outdir)\n"", ""convergence.plot_traces(figname=\""test.pdf\"", xlim=(0, nsteps))\n"", ""convergence.get_autocorrelation_curves(method=\""auto\"", maxtau=5000)\n"", ""convergence.process()"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
# NOTE: The following cell is for pretty notebook rendering
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 1, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"" ], ""text/plain"": [ """" ] }, ""execution_count"": 1, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from IPython.core.display import HTML\n"", ""def css_styling():\n"", "" styles = open(\""notebook_theme.css\"", \""r\"").read()\n"", "" return HTML(styles)\n"", ""css_styling()"" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""metadata"": {}, ""outputs"": [], ""source"": [] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""Python 3 (ipykernel)"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.8.13"" } }, ""nbformat"": 4, ""nbformat_minor"": 1 } ","Unknown" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/runme.py",".py","14090","355","import biceps import numpy as np import pandas as pd import os, pickle, string import matplotlib.pyplot as plt import matplotlib.gridspec as gridspec import warnings warnings.filterwarnings(""ignore"", category=UserWarning) warnings.filterwarnings('ignore', category=FutureWarning) import multiprocessing as mp import uncertainties as u if __name__ == ""__main__"": mp.freeze_support() # Compute NOE model_data data_dir = ""cineromycin_B/"" outdir = ""_NOE/"" biceps.toolbox.mkdir(outdir) states = biceps.toolbox.get_files(data_dir+""cineromycinB_pdbs/*.pdb"") ind_noe = data_dir+'atom_indice_noe.txt' biceps.toolbox.compute_distances(states, ind_noe, outdir) model_data_NOE = str(outdir+""*.txt"") exp_data_NOE = data_dir+""noe_distance.txt"" # Compute J-coupling model_data ind = np.load(data_dir+'ind.npy') ind_J = data_dir+'atom_indice_J.txt' outdir = ""_J/"" biceps.toolbox.mkdir(outdir) karplus_key=np.loadtxt(data_dir+'Karplus.txt', dtype=str) #print('Karplus relations:', karplus_key) biceps.toolbox.compute_nonaa_scalar_coupling(states, indices=ind, karplus_key=karplus_key, outdir=outdir) exp_data_J = data_dir+'exp_Jcoupling.txt' model_data_J = data_dir+""J_coupling/*.txt"" # Now using biceps Preparation submodule outdir = ""J_NOE/"" biceps.toolbox.mkdir(outdir) prep = biceps.Preparation(nstates=len(states), top_file=states[0], outdir=outdir) prep.prepare_noe(exp_data_NOE, model_data_NOE, indices=ind_noe, verbose=False) prep.prepare_J(exp_data_J, model_data_J, indices=ind_J, verbose=False) input_data = prep.to_sorted_list() #print(input_data) # Let's look at J-coupling input file for state 0 pd.read_pickle(input_data[0][0])[[""restraint_index"", ""atom_index1"", ""exp"", ""model""]] ####### Data and Output Directories ####### energies = np.loadtxt('cineromycin_B/cineromycinB_QMenergies.dat')*627.509 # convert from hartrees to kcal/mol energies = energies/0.5959 # convert to reduced free energies F = f/kT energies -= energies.min() # set ground state to zero, just in case # REQUIRED: specify directory of input data (BICePs readable format) input_data = biceps.toolbox.sort_data('cineromycin_B/J_NOE') # REQUIRED: specify outcome directory of BICePs sampling outdir = 'blah' # Make a new directory if we have to biceps.toolbox.mkdir(outdir) fig = plt.figure(figsize=(6,8)) gs = gridspec.GridSpec(2, 1) ax1 = plt.subplot(gs[0,0]) data1 = pd.concat([pd.read_pickle(i) for i in biceps.toolbox.get_files('cineromycin_B/J_NOE/*.noe')]) ax1 = data1[""model""].plot.hist(alpha=0.5, bins=100, edgecolor='black', linewidth=1.2, color=""b"", label=""Model"") ax1.axvline(list(set(data1[""exp""].to_numpy())), c=""orange"", linewidth=3, label=""Experiment"") ax1.legend(fontsize=14) ax1.set_xlabel(r""NOE distance ($\AA$)"", size=16) ax1.set_ylabel(""Counts"", size=16) ax1.axes.get_yaxis().set_ticks([]) ax2 = plt.subplot(gs[1,0]) data2 = pd.concat([pd.read_pickle(i) for i in biceps.toolbox.get_files('cineromycin_B/J_NOE/*.J')]) ax2 = data2[""model""].plot.hist(alpha=0.5, bins=100, edgecolor='black', linewidth=1.2, color=""b"", label=""Model"") data2[""exp""].plot.hist(alpha=0.5, bins=40, linewidth=1.2, color=""orange"", label=""Experiment"", ax=ax2) ax2.set_ylim(0,100) ax2.axes.get_yaxis().set_ticks([]) ax2.set_xlabel(r""J coupling (Hz)"", size=16) ax2.set_ylabel(""Counts"", size=16) axs = [ax1,ax2] for n, ax in enumerate(axs): ax.text(-0.05, 1.0, string.ascii_lowercase[n], transform=ax.transAxes, size=20, weight='bold') ticks = [ax.xaxis.get_minor_ticks(), ax.xaxis.get_major_ticks(),] xmarks = [ax.get_xticklabels()] for k in range(0,len(ticks)): for tick in ticks[k]: tick.label.set_fontsize(16) for k in range(0,len(xmarks)): for mark in xmarks[k]: mark.set_size(fontsize=16) mark.set_rotation(s=0) fig.tight_layout() fig.savefig(outdir+'/histogram_of_observables.pdf', dpi=600) # REQUIRED: number of MCMC steps for each lambda nsteps = 100000000 #100000000 # 100 M steps for production #nsteps = 100000 #100000000 # 100 M steps for production # REQUIRED: specify how many lambdas to sample (more lambdas will provide higher # accuracy but slower the whole process, lambda=0.0 and 1.0 are necessary) n_lambdas = 2 lambda_values = np.linspace(0.0, 1.0, n_lambdas) #pd.DataFrame(biceps.get_restraint_options()) options = biceps.get_restraint_options(input_data) pd.DataFrame(options) df = pd.DataFrame(options) df.to_latex(""restraint_options.tex"") # Change NOE reference potential from uniform to exponential options[1][""ref""] = 'exponential' # Change the sigma-space to a smaller range of allowed sample space options[1][""sigma""] = (0.05, 5.0, 1.02) # Alter gamma spacing to have larger width options[1][""gamma""] = (0.2, 5.0, 1.02) #print(options[1]) df = pd.DataFrame(options) check_convergence = 0 if check_convergence: lam = 1.0 ensemble = biceps.Ensemble(lam, energies) ensemble.initialize_restraints(input_data, options) sampler = biceps.PosteriorSampler(ensemble) sampler.sample(nsteps=nsteps, print_freq=1000, verbose=False) convergence = biceps.Convergence(sampler.traj, outdir=outdir) convergence.plot_traces(figname=""traces.pdf"", xlim=(0, sampler.traj.__dict__[""trajectory""][-1][0])) convergence.get_autocorrelation_curves(method=""block-avg"", maxtau=500, nblocks=5) init, frac = biceps.find_all_state_sampled_time(sampler.traj.__dict__['state_trace'], len(energies)) exit() # Multiprocess trajectories for each $\lambda$-value with a built-in decorator @biceps.multiprocess(iterable=lambda_values) def mp_lambdas(lam): ensemble = biceps.Ensemble(lam, energies) ensemble.initialize_restraints(input_data, options) sampler = biceps.PosteriorSampler(ensemble) sampler.sample(nsteps=nsteps, print_freq=1000, verbose=False) filename = os.path.join(outdir,'traj_lambda%2.2f.npz'%(lam)) sampler.traj.process_results(filename) biceps.toolbox.save_object(sampler, filename.replace("".npz"", "".pkl"")) ############ MBAR and Figures ########### # Let's do analysis using MBAR algorithm and plot figures A = biceps.Analysis(outdir, nstates=len(energies)) #biceps.toolbox.save_object(A, ""analysis_object.pkl"") #pops = A.P_dP[:,n_lambdas-1] pops, BS = A.P_dP, A.f_df print(f""BICePs Scores = {BS[:,0]}"") pops, BS = A.P_dP, A.f_df pops0,pops1 = pops[:,0], pops[:,len(lambda_values)-1] legend_fontsize=16 #fig = A.plot(plottype=""hist"", figname=""BICePs.pdf"", figsize=(14,8), fig = A.plot(plottype=""step"", figname=""BICePs_.pdf"", figsize=(14,8), label_fontsize=18, legend_fontsize=legend_fontsize) ax = fig.axes[0] high_E_confs = [79, 21] #87 for i in high_E_confs: #print(pops0[i], pops1[i], str(i)) ax.text( pops0[i], pops1[i], str(i), color='r' , fontsize=legend_fontsize) fig.savefig(os.path.join(outdir,""BICePs.pdf""), dpi=600) mlp = pd.concat([A.get_max_likelihood_parameters(model=i) for i in range(len(lambda_values))]) mlp.reset_index(inplace=True, drop=True) print(mlp) pops_std = A.P_dP[:,-1] # NOTE: Get Prior MSM populations prior_pops = np.loadtxt(data_dir+""prior_pops.txt"") prior_pops /= prior_pops.sum() noe = [pd.read_pickle(i) for i in biceps.toolbox.get_files(data_dir+""J_NOE/*.noe"")] # Get the ensemble average observable noe_Exp = noe[0][""exp""].to_numpy() noe_model = [i[""model""].to_numpy() for i in noe] noe_prior = np.array([w*noe_model[i] for i,w in enumerate(prior_pops)]).sum(axis=0) noe_reweighted = np.array([w*noe_model[i] for i,w in enumerate(pops[:,n_lambdas-1])]).sum(axis=0) noe_prior = np.array([w*noe_model[i] for i,w in enumerate(prior_pops)]).sum(axis=0) noe_reweighted = np.array([u.ufloat(w, pops_std[i])*noe_model[i] for i,w in enumerate(pops[:,n_lambdas-1])]).sum(axis=0) distance_labels = [f""{row[1]['atom_name1']}-{row[1]['atom_name2']}"" for row in noe[0].iterrows()] distance_label_indices = np.array([[row[1]['atom_index1'], row[1]['atom_index2']] for row in noe[0].iterrows()]) J = [pd.read_pickle(file) for file in biceps.toolbox.get_files(data_dir+'J_NOE/*.J')] # Get the ensemble average observable J_Exp = J[0][""exp""].to_numpy() J_model = [i[""model""].to_numpy() for i in J] J_prior = np.array([w*J_model[i] for i,w in enumerate(prior_pops)]).sum(axis=0) J_reweighted = np.array([u.ufloat(w, pops_std[i])*J_model[i] for i,w in enumerate(pops[:,n_lambdas-1])]).sum(axis=0) J_labels = [f""{row[1]['atom_name1']}-{row[1]['atom_name2']}-{row[1]['atom_name3']}-{row[1]['atom_name4']}"" for row in J[0].iterrows()] J_label_indices = np.array([[row[1]['atom_index1'], row[1]['atom_index2'], row[1]['atom_index3'], row[1]['atom_index4']] for row in J[0].iterrows()]) fig = plt.figure(figsize=(12,12)) gs = gridspec.GridSpec(2, 1) ax1 = plt.subplot(gs[0,0]) ax2 = plt.subplot(gs[1,0]) data = [] for i in range(len(noe_reweighted)): data.append({""index"":i, ""reweighted noe"":noe_reweighted[i], ""prior noe"":noe_prior[i], ""exp noe"":noe_Exp[i]*mlp['gamma_noe'].to_numpy()[-1], ""label"":distance_labels[i] }) data1 = pd.DataFrame(data) _data1 = data1.sort_values([""prior noe""]) _data1 = _data1.reset_index() #print(_data1) reweighted_vals = np.array([val.nominal_value for val in _data1[""reweighted noe""].to_numpy()]) reweighted_std = np.array([val.std_dev for val in _data1[""reweighted noe""].to_numpy()]) #ax1 = data1.plot.scatter(x='index', y=""reweighted noe"", s=5, edgecolor='black', color=""b"", label=""BICePs"") ax1.scatter(x=_data1[""label""].to_numpy(), y=_data1[""prior noe""].to_numpy(), s=45, color=""orange"", label=""Prior"", edgecolor='black',) ax1.scatter(x=_data1[""label""].to_numpy(), y=_data1[""exp noe""].to_numpy(), s=150, marker=""_"", color=""k"", label=""Exp"") #ax1.scatter(x=_data1[""label""].to_numpy(), y=_data1[""reweighted noe""].to_numpy(), # s=40, color=""c"", label=""BICePs"", edgecolor='black') ax1.errorbar(x=_data1['label'].to_numpy(), y=reweighted_vals, yerr=reweighted_std , fmt=""o"", capsize=5, markersize=5, markerfacecolor=""c"", label=""BICePs"", ecolor=""k"", markeredgecolor='black') ax1.legend(fontsize=14) #ax1.set_xlabel(r""Index"", size=16) ax1.set_ylabel(r""NOE distance ($\AA$)"", size=16) data = [] for i in range(len(J_reweighted)): data.append({""index"":i, ""reweighted J"":J_reweighted[i], ""prior J"":J_prior[i], ""exp J"":J_Exp[i], ""label"":J_labels[i] }) data1 = pd.DataFrame(data) reweighted_vals = np.array([val.nominal_value for val in data1[""reweighted J""].to_numpy()]) reweighted_std = np.array([val.std_dev for val in data1[""reweighted J""].to_numpy()]) ax2.scatter(x=data1['label'].to_numpy(), y=data1[""prior J""].to_numpy(), s=45, color=""orange"", label=""Prior"", edgecolor='black',) ax2.scatter(x=data1['label'].to_numpy(), y=data1[""exp J""].to_numpy(), s=150, marker=""_"", color=""k"", label=""Exp"") #ax2.scatter(x=data1['label'].to_numpy(), y=data1[""reweighted J""].to_numpy(), # s=40, color=""c"", label=""BICePs"", edgecolor='black') ax2.errorbar(x=data1['label'].to_numpy(), y=reweighted_vals, yerr=reweighted_std , fmt=""o"", capsize=5, markersize=5, markerfacecolor=""c"", label=""BICePs"", ecolor=""k"", markeredgecolor='black') ax2.legend(fontsize=14) #ax2.set_xlabel(r""Index"", size=16) ax2.set_ylabel(r""J-coupling (Hz)"", size=16) ticks = [ ax1.xaxis.get_minor_ticks(), ax1.xaxis.get_major_ticks(),] xmarks = [ax1.get_xticklabels(), ] ymarks = [ax1.get_yticklabels(), ] for k in range(0,len(ticks)): for tick in ticks[k]: tick.label.set_fontsize(16) for k in range(0,len(xmarks)): for mark in xmarks[k]: mark.set_size(fontsize=16) mark.set_rotation(s=65) for k in range(0,len(ymarks)): for mark in ymarks[k]: mark.set_size(fontsize=16) mark.set_rotation(s=0) ticks = [ ax2.xaxis.get_minor_ticks(), ax2.xaxis.get_major_ticks(),] xmarks = [ ax2.get_xticklabels(), ] ymarks = [ ax2.get_yticklabels(), ] for k in range(0,len(ticks)): for tick in ticks[k]: tick.label.set_fontsize(16) for k in range(0,len(xmarks)): for mark in xmarks[k]: mark.set_size(fontsize=16) mark.set_rotation(s=70) for k in range(0,len(ymarks)): for mark in ymarks[k]: mark.set_size(fontsize=16) mark.set_rotation(s=0) axs = [ax1,ax2] for n, ax in enumerate(axs): ax.text(-0.1, 1.0, string.ascii_lowercase[n], transform=ax.transAxes, size=20, weight='bold') fig.tight_layout() fig.savefig(f""{outdir}/reweighted_observables.pdf"", dpi=500) #lam = 1.0 #nsteps=1000000 #ensemble = biceps.Ensemble(lam, energies) #ensemble.initialize_restraints(input_data, options) #sampler = biceps.PosteriorSampler(ensemble) #sampler.sample(nsteps=nsteps, print_freq=1000, verbose=False) #traj = sampler.traj.__dict__ #C = biceps.Convergence(traj) #C.plot_traces(figname=""test.pdf"", xlim=(0, nsteps)) #C.get_autocorrelation_curves(method=""auto"", maxtau=5000) #C.process() # ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/BICePs_v2.0-manuscript_version.ipynb",".ipynb","1223630","1983","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# BICePs v2.0: Software for Ensemble Reweighting using Bayesian Inference of Conformational Populations\n"", ""\n"", ""

\n"", ""Robert M. Radd$^{1}$, Yunhui Ge$^{2}$, Vincent A. Voelz$^{1}$\n"", ""\n"", ""\n"", ""$^{1}$Department of Chemistry, Temple University, Philadelphia, PA 19122, USA\n"", ""\n"", ""$^{2}$Department of Pharmaceutical Sciences, University of California, Irvine, CA, USA\n"", ""

\n"", ""\n"", ""https://doi.org/10.26434/chemrxiv-2022-1b24c\n"", ""\n"", ""\n"", ""### Abstract\n"", ""\n"", ""\n"", ""Modeling biological systems comes with a set of challenges like inaccuracies in force fields and finite sampling. To combat limited model quality, populations can be reweighted to be more consistent with experimental data. Bayesian Inference of Conformational Populations (BICePs) version 2.0 is a free, open-source Python package that reweights theoretical predictions of conformational state populations using sparse and/or noisy experimental measurements. The algorithm now supports many experimental observables, enables convenient data preparation, and performs automatic posterior analysis, including visualization, and checks on statistical significance and sampling convergence. In this article, we provide a practical guide to reweighting theoretical ensembles using BICePs and discuss some of the prospective versions along with some of its key advantages like is it's ability to perform Bayesian model selection with the BICePs score allowing it to objectively rank different simulated ensembles by their accuracy in reproducing experimental observables.\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", """" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""### Introduction\n"", ""\n"", ""\n"", ""Having a structural ensemble of a biomolecular system with atomic level detail can facilitate research in drug discovery given the fact that the protein functions are intimately dependent on their conformations. With an accurate knowledge of the populations for different conformational states from protein dynamics, biological processes and mechanistic behavior can be understood. Many experimental techniques are able to aid, such as NMR, SAXS, cryo-EM, Hydrogen deuterium exchange, etc., which provides a range of different resolutions of ensemble-averaged observables. As a consequence, these techniques usually provide sparse and noisy structural information. Molecular simulations on the other hand, provide atomic level detail of conformations, but are limited by the accuracy of the force field and are subject to finite sampling errors. Typically, depending up on system under study, one attempts to strike a balance between the computational cost and expected level of accuracy. Due to in the insufficiencies of experimental and computational methods alone to accurately depict structural ensembles, using a combination of information to correctly reweight simulated ensembles can be of great benefit. Thus, developing rigorous approaches that are able to combine both experimental and theoretical/simulated information becomes an important topic in the field in the last decades.\\cite{Rieping303, perez2015accelerating, beauchamp2014bayesian, fisher2010modeling, bonomi2016metainference, bonomi2016metadynamic, Cicero:1995jn, SmithIII:2011ff, Atasoylu:2010bg, bonomi2017principles}"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""The Bayesian Inference of Conformational Populations (BICePs) algorithm was developed to use a combination of information from simulated ensembles and experimental measurements. BICePs uses a rigorous statistical framework that uses Bayesian inference to correctly balance theoretical modeling and experimental data to find a superior solution of conformational state populations to what would be obtained from either approach alone. Contrary to many other approaches \\cite{approaches that run during simulation}, BICePs is a post-simulation processing step that reweights discrete conformational state populations from simulated ensembles with information aquired from experiment measurements. \n"", ""\n"", ""In our most recent review article\\cite{voelz2021reconciling}, we summarize the theory of BICePs, discuss closely related methods, review the history and applications of BICePs to date, and touch on future plans for improvement. Since 2014, the BICePs algorithm has been applied to various systems such as small molecules like peptides and peptidomimetics, and even studies of larger proteins like apomyoglobin. However, there has been some difficulties for non-experienced users when attempting to apply the algorithm to their system of interest. Here, we provide a practical guide on how to implement BICePs to perform conformational reweighting on a small system when applying sparse experimental restraints. In this guide, the reader will learn how to prepare the experimental and forward model data in order to apply restraints to each configuration, choose restraint parameters, sample the posterior distribution, test for convergence, and analyze the data to plot populations, posterior distributions of uncertainties, and extract a BICePs score.\n"", ""\n"", ""In this work, we developed an improved, object-oriented version called BICePs v2.0. Our latest version includes more experimental observables (HDX) and many renovations have been done to the code structure for future developments as well as the addition of more experimental restraints to be coded into biceps with minimal labor. Furthermore, we have automated most of the daunting tasks like data preperation and convergence checking. Our algorithm has been redesigned with the simplicity to be utlized by users of all levels of programming knowledge—more effectively and efficiently. Hence, this work will serve as an introduction to the BICePs software and the workflow, show that the BICePs software is powerful, user-friendly and extensible. To begin, we briefly describe the general theory of BICePs, and then discuss the workflow of this algorithm and apply BICePs to a real system where we reproduce previously published results."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""### Methods\n"", ""\n"", ""\n"", ""\n"", ""#### Theory\n"", ""\n"", ""\n"", ""The Bayesian Inference of Conformational Populations (BICePs) algorithm was developed to use a combination of information from computational modelings and experimental measurements. BICePs uses a rigorous statistical framework based on Bayesian inference to correctly balance theoretical modeling and experimental data and find a superior solution of conformational state populations to that obtained from either one alone. Under a Bayesian formalism, the posterior probability of conformational state $X$ given experimental data $D$ is\n"", ""\n"", ""\\begin{equation}\n"", ""P(X|D) \\propto Q(D|X) P(X),\n"", ""\\label{eq:bayes1}\n"", ""\\end{equation}\n"", ""\n"", ""where $P(X)$ is the $\\textit{prior}$ conformational probability that comes from theoretical modeling and $Q(D \\mid X)$ is the $\\textit{likelihood}$ of observing the experimental data given a conformational state. By assuming the errors in the experimental observables to be normally distributed, our likelihood function takes the form of a Gaussian and the standard deviation $\\sigma$ (not known $\\textit{a priori}$) can be treated as a nuisance parameter. Since $X$ and $\\sigma$ are statistically independent, the joint prior probability $P(X, \\sigma)$ becomes the product of prior probabilities. Thus, the probablity of states and unknown parameters of the model given the data is \n"", ""\n"", ""\n"", ""\\begin{equation}\n"", ""P(X,\\sigma \\mid D) \\propto Q(D \\mid X,\\sigma) P(X) P(\\sigma),\n"", ""\\label{eq:bayes2}\n"", ""\\end{equation}\n"", ""\n"", ""where the prior on uncertainty parameters is treated as a non-informative Jeffery's prior $P(\\sigma)=1/\\sigma$ and the likelihood function \n"", ""\n"", ""\n"", ""\n"", ""\\begin{equation}\n"", ""Q(D \\mid X, \\sigma) = \\prod_{j}^{N_{d}} \\frac{1}{\\sqrt{2 \\pi \\sigma^{2}}} \\exp \\left[-\\frac{\\left(r_{j}(X)-r_{j}^{\\exp }\\right)^{2}}{ 2 \\sigma^{2}}\\right]\n"", ""\\end{equation}\n"", ""\n"", ""\n"", ""reflects how well a given conformation $X$ agrees with experimental measurements. That way, $\\sigma$ represents the uncertainty in the experimental measurements and the heterogeneity in the conformational ensemble. Markov Chain Monte Carlo (MCMC) sampling over $X$ and $\\sigma$ is employed to determine the conformational populations given the experimental restraints as $P(X|D) = \\int P(X,\\sigma | D) d\\sigma$.\n"", ""\n"", ""An advantage of the BICePs algorithm is the use of a proper reference potential to reweight experimental restraints to obtain a posterior model. Markov Chain Monte Carlo (MCMC) sampling is then performed on the posterior distribution to estimate the population of conformational states. The computed BICePs score can also be used for quantitative model selection (e.g., force field validation).\\cite{Ge:2018bdb} For more information regarding the theory of BICePs, please see these works\\cite{Voelz:2014fga,Ge:2018bdb,voelz2021reconciling}.\n"", ""\n"", ""\n"", ""\n"", ""\n"", """" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""#### The standard workflow\n"", ""\n"", ""\n"", ""\n"", ""In this section, we introduce a comprehensive workflow for population reweighting using BICePs software. First, we will describe each of the logical series of steps in the general sense, each showing a specific Python class with it's required arguments, then we will show how this workflow can be applied in detail.\n"", ""\n"", ""To begin, the `biceps` module must first be loaded into memory in order to wield all of it's functionality:\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 1, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""BICePs - Bayesian Inference of Conformational Populations, Version 2.0\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""Warning on use of the timeseries module: If the inherent timescales of the system are long compared to those being analyzed, this statistical inefficiency may be an underestimate. The estimate presumes the use of many statistically independent samples. Tests should be performed to assess whether this condition is satisfied. Be cautious in the interpretation of the data.\n"" ] } ], ""source"": [ ""import biceps\n"", ""# NOTE: \""Warning on use of the timeseries module\"" - comes from MBAR\n"", ""import numpy as np\n"", ""import pandas as pd\n"", ""import os, pickle, string\n"", ""import matplotlib.pyplot as plt\n"", ""import matplotlib.gridspec as gridspec\n"", ""import warnings\n"", ""warnings.filterwarnings(\""ignore\"", category=UserWarning)\n"", ""warnings.filterwarnings('ignore', category=FutureWarning)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""1. Prepare the `input_data` using the `biceps.Preparation` class. For each conformational state, raw experimental and corresponding forward model data from simulation is stored inside Pandas DataFrames.\n"", ""\n"", ""```python\n"", ""prep = biceps.Preparation(int(nstates), str(top_file), str(outdir))\n"", ""prep.prepare_noe(str(exp_data), str(model_data), str(indices)\n"", ""prep.prepare_J(str(exp_data), str(model_data), str(indices))\n"", ""```\n"", ""\n"", ""2. Build a thermodynamic ensemble (controlled by $\\lambda$) with energies (prior) for each conformational state. Using the ensemble object, apply data restraints to each state by invoking a method that requires the experimental and corresponding forward model data prepared from the previous step. \n"", ""\n"", ""```python\n"", ""ensemble = biceps.Ensemble(float(lam), list(energies))\n"", ""ensemble.initialize_restraints(list(input_data))\n"", ""```\n"", ""\n"", ""\n"", ""3. Form the sample-space of nuisance parameters and build reference potentials for each restraint by instantiating the `biceps.PosteriorSampler` class given the `ensemble` object. Here, we perform MCMC sampling over the posterior distribution via the Metroplis-Hastings criterion and save the trajectories in a compressed format (`'*.npz'`).\n"", ""\n"", ""```python\n"", ""sampler = biceps.PosteriorSampler(ensemble)\n"", ""sampler.sample(int(nsteps), int(burn))\n"", ""```\n"", ""\n"", ""4. Check convergence of BICePs MCMC trajectories by passing the `biceps.Convergence` class the relative directory and filename of a compressed trajectory. We recommended this step before moving onto formal analysis.\n"", ""\n"", ""```python\n"", ""C = biceps.Convergence(str(traj))\n"", ""C.plot_traces()\n"", ""C.get_autocorrelation_curves(str(method), int(maxtau))\n"", ""```\n"", ""\n"", ""5. Predict conformational state populations, visualize the full posterior distribution, and compute BICePs scores for all of the thermodynamic ensembles using the `biceps.Analysis` class. \n"", ""\n"", ""```python\n"", ""A = biceps.Analysis(str(outdir), int(nstates))\n"", ""```\n"", ""\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""\n"", ""#### Ensemble reweighting of cineromycin B\n"", ""\n"", ""We illustrate the application and results of our Bayesian reweighting approach using a dataset used during the inception of BICePs\\cite{Voelz:2014fga}. Cineromycin B is a 14-membered macrolide antibiotic that has become increasingly known for having activity against methicillin-resistant Staphylococcus Aureus (MRSA). Using a combination of high-resolution structural modeling and sparse restraints from experimental observables, we will reproduce our previously published results and show how we can calculate the consistency of computational models of cineromycin B compare with experiment.\n"", ""\n"", ""\n"", ""
\n"", ""\n"", ""
The line structure of the 14-membered macrocycle Cineromycin B (7-O-demethylalbocycline).\n"", ""
\n"", ""
\n"", ""\n"", ""\n"", ""To determine solution-state conformational populations of cineromycin B, we must first prepare our sparse experimental Nuclear Magnetic Resonance (NMR) observables alongside the forward model predicted observables for each configuration. In this example, our energies (prior) and forward model comes from replica exchange molecular dynamics/Quantum mechanics(QM)-refined conformational ensembles (100 states). In the next section, forward model predictions for both NOE distances & scalar coupling constants will be computed using our built-in tools. "" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""#### Preparing \\& organizing the data\n"", ""\n"", ""\n"", ""\n"", ""In order to use the algorithm, experimental and theoretical information for each state must be arranged into columns placed inside data tables. These data tables, also known as Pandas DataFrames, must be constructed for each experimental observable type e.g., NOE, J-coupling, chemical shifts, etc. For convieniency, an automated approach for data preparation along with forward model prediction tools is also included in our software. To use our built-in forward model approaches that primarily use MDTraj, simply invoke functions from `biceps.toolbox`. For chemical shift prediction for proteins, we recommend shiftx2, but please be aware that there are many software options for the various types of forward model predictions. A discussion of possible options for forward model predictions with pros and cons goes beyhond the scope of this application. Nevertheless, the user should carefully consider how they wish to perform these calculations.\n"", ""\n"", ""\n"", ""BICePs v2.0 supports the following experimental observables: 1) NMR nuclear Overhauser effect (NOE), 2) NMR chemical shifts, 3) J coupling constants (small molecules and amino acids) and 4) Hydrogen-deuterium exchange (HDX). The MDTraj python library\\cite{Mcgibbon:2015fva} and the SHIFTX2\\cite{Han:2011fwa} algorithm as implemented in MDTraj is normally used for computation of pairwise distances of atoms and chemical shifts in our work. For J coupling constants, our team has prepared functions in $\\verb|biceps.toolbox|$ for both small molecules and non-natural/natural amino acids. In short, different Karplus relations are used for specific stereochemistry for small molecules and non-natural amino acids. J couplings of natural amino acids are empirically computed using different models. Six Karplus relations are provided for natural amino acids based on previous works \\cite{Hu1997DeterminationO,Pardi1984CalibrationOT,Schmidt1999,HABECK2005160,doi:10.1021/ja00070a024,doi:10.1021/ja070324o}. Please note that scalar coupling constants are also used in modeling Cineromycin B. Preparing J coupling data uses the same arguments as shown above, but uses the class-method $\\verb|prep.prep_J|$.\n"", ""\n"", ""\n"", ""For 100 microstates of cineromycinB, 32 forward model ensemble-averaged NOE distances (in Å) as $^{-1/6}$ were computed and averaged over all trajectories of Cineromycin B using MDTraj. For those same structures, 9 scalar coupling constants were computed using our built-in tools. To ensure proper data preparation, the user should check that the ordering of the forward model data matches with the experimental data. In addition, the restraint index should preceed each experimental observable and special care should be taken when attempting to denote equivalent restraints that should be averaged e.g., equivalent hydrogens in a methyl group all recieve the same index. To illustrate this, please refer to Table \\ref{table}."" ] }, { ""cell_type"": ""code"", ""execution_count"": 2, ""metadata"": {}, ""outputs"": [], ""source"": [ ""# Compute NOE model_data\n"", ""data_dir = \""cineromycin_B/\""\n"", ""outdir = \""_NOE/\""\n"", ""biceps.toolbox.mkdir(outdir)\n"", ""states = biceps.toolbox.get_files(data_dir+\""cineromycinB_pdbs/*.pdb\"")\n"", ""ind_noe = np.loadtxt(data_dir+'atom_indice_noe.txt')\n"", ""if (type(ind_noe) != np.ndarray) and (type(ind_noe) != list): #(list or np.ndarray):\n"", "" print(type(ind_noe))\n"", ""biceps.toolbox.compute_distances(states, ind_noe, outdir)\n"", ""model_data_NOE = np.array([np.loadtxt(file) for file in biceps.toolbox.get_files(outdir+\""*.txt\"")])\n"", ""exp_data_NOE = np.loadtxt(data_dir+\""noe_distance.txt\"")\n"", ""\n"", ""# Compute J-coupling model_data\n"", ""ind = np.load(data_dir+'ind.npy')\n"", ""ind_J = np.loadtxt(data_dir+'atom_indice_J.txt')\n"", ""outdir = \""_J/\""\n"", ""biceps.toolbox.mkdir(outdir)\n"", ""karplus_key=np.loadtxt(data_dir+'Karplus.txt', dtype=str)\n"", ""#print('Karplus relations:', karplus_key)\n"", ""biceps.toolbox.compute_nonaa_scalar_coupling(states,\n"", "" indices=ind, karplus_key=karplus_key, outdir=outdir)\n"", ""exp_data_J = np.loadtxt(data_dir+'exp_Jcoupling.txt')\n"", ""model_data_J = np.array([np.loadtxt(file) for file in biceps.toolbox.get_files(data_dir+\""J_coupling/*.txt\"")])"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""\n"", ""With standard text files for the experimental observables and forward model observables for each state, we are ready to prepare and organize the data into tables using the `biceps.Preparation` class. The number of conformational states (`nstates`) is the only required argument to initialize this class, which is used to check that the user has supplied forward model predictions for each state. Additionally, the user could also provide optional arguments to initialize the Preparation class: a system topology file `top_file` and a relative path to save output files `outdir`. By passing a topology file, relavent information is scraped from the `top_file` such as atom names and atom indices that correspond to a specific observables.\n"", ""\n"", ""Upon initialization, the class is stored as the object `prep`. Using this class object, we can call on a function that constructs Pandas DataFrames for a specific observable upon specifying the relative paths to the necessary files which includes the experimental data (`exp_data`), a relative path to grab and sort all forward model data data files numbered by state index (`model_data=\""NOE/*.txt\""`), and the array of atom indices given in the same order as the experimental observables. As a result, each `Preparation` class-method e.g., `prep.prepare_cs` (prepare chemical shift data) will save data tables with a specific file extension (`'*.noe', '*.J', '*.cs\\_H', '*.cs\\_Ha', '*.cs\\_N', '*.cs\\_Ca', '*.pf'`) denoting the observable. These extensions are required and should not be altered. \n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 3, ""metadata"": {}, ""outputs"": [], ""source"": [ ""# Now using biceps Preparation submodule\n"", ""outdir = \""J_NOE/\""\n"", ""biceps.toolbox.mkdir(outdir)\n"", ""prep = biceps.Preparation(nstates=len(states), top_file=states[0], outdir=outdir)\n"", ""prep.prepare_noe(exp_data_NOE, model_data_NOE, indices=ind_noe, verbose=False)\n"", ""prep.prepare_J(exp_data_J, model_data_J, indices=ind_J, verbose=False)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 4, ""metadata"": {}, ""outputs"": [], ""source"": [ ""input_data = prep.to_sorted_list()\n"", ""#input_data"" ] }, { ""cell_type"": ""code"", ""execution_count"": 5, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
restraint_indexatom_index1expmodel
01255.03.279128
12301.513.336870
23311.50.600845
34326.013.877749
44326.03.339372
54326.01.828765
65321.50.464738
76337.02.956672
86337.010.805575
96337.01.232210
\n"", ""
"" ], ""text/plain"": [ "" restraint_index atom_index1 exp model\n"", ""0 1 25 5.0 3.279128\n"", ""1 2 30 1.5 13.336870\n"", ""2 3 31 1.5 0.600845\n"", ""3 4 32 6.0 13.877749\n"", ""4 4 32 6.0 3.339372\n"", ""5 4 32 6.0 1.828765\n"", ""6 5 32 1.5 0.464738\n"", ""7 6 33 7.0 2.956672\n"", ""8 6 33 7.0 10.805575\n"", ""9 6 33 7.0 1.232210"" ] }, ""execution_count"": 5, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""# Let's look at J-coupling input file for state 0\n"", ""pd.read_pickle(input_data[0][0])[[\""restraint_index\"", \""atom_index1\"", \""exp\"", \""model\""]]"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""\n"", ""\n"", ""\n"", ""The `biceps.Preparation` class requires experimental data as well as correspondingly pre-computed forward model observables from simulated ensembles to convert all raw data into a tabulated format. Again, our data preparation code is for convenience, but not required to run BICePs. Apropos, users may have their own way to prepare data using excel or some program that outputs csv files. To give some extra flexibility, data tables can be stored in various formats (default is pickle), but must maintain our previously mentioned file extension protocol. Additionally, users must follow the naming convention of the column headers (order not required) as shown in the table above (Table \\ref{tab:input_data}) to achieve proper parsing of data. The required columns inside the prepared data file are `\""restraint_index\"", \""exp\"", \""model\""`.\n"", ""\n"", ""\n"", ""\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 6, ""metadata"": {}, ""outputs"": [], ""source"": [ ""####### Data and Output Directories #######\n"", ""energies = np.loadtxt('cineromycin_B/cineromycinB_QMenergies.dat')*627.509 # convert from hartrees to kcal/mol\n"", ""energies = energies/0.5959 # convert to reduced free energies F = f/kT\n"", ""energies -= energies.min() # set ground state to zero, just in case\n"", ""\n"", ""# REQUIRED: specify directory of input data (BICePs readable format)\n"", ""input_data = biceps.toolbox.sort_data('cineromycin_B/J_NOE')\n"", ""\n"", ""# REQUIRED: specify outcome directory of BICePs sampling\n"", ""outdir = 'results'\n"", ""# Make a new directory if we have to\n"", ""biceps.toolbox.mkdir(outdir)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 7, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""%matplotlib inline\n"", ""fig = plt.figure(figsize=(6,8))\n"", ""gs = gridspec.GridSpec(2, 1)\n"", ""ax1 = plt.subplot(gs[0,0])\n"", ""data1 = pd.concat([pd.read_pickle(i) for i in biceps.toolbox.get_files('cineromycin_B/J_NOE/*.noe')])\n"", ""ax1 = data1[\""model\""].plot.hist(alpha=0.5, bins=100,\n"", "" edgecolor='black', linewidth=1.2, color=\""b\"", label=\""Model\"")\n"", ""ax1.axvline(list(set(data1[\""exp\""].to_numpy())), c=\""orange\"", linewidth=3, label=\""Experiment\"")\n"", ""ax1.legend(fontsize=14)\n"", ""ax1.set_xlabel(r\""NOE distance ($\\AA$)\"", size=16)\n"", ""ax1.set_ylabel(\""Counts\"", size=16)\n"", ""ax1.axes.get_yaxis().set_ticks([])\n"", ""\n"", ""ax2 = plt.subplot(gs[1,0])\n"", ""data2 = pd.concat([pd.read_pickle(i) for i in biceps.toolbox.get_files('cineromycin_B/J_NOE/*.J')])\n"", ""ax2 = data2[\""model\""].plot.hist(alpha=0.5, bins=100,\n"", "" edgecolor='black', linewidth=1.2, color=\""b\"", label=\""Model\"")\n"", ""data2[\""exp\""].plot.hist(alpha=0.5, bins=40,\n"", "" linewidth=1.2, color=\""orange\"", label=\""Experiment\"", ax=ax2)\n"", ""ax2.set_ylim(0,100)\n"", ""ax2.axes.get_yaxis().set_ticks([])\n"", ""ax2.set_xlabel(r\""J coupling (Hz)\"", size=16)\n"", ""ax2.set_ylabel(\""Counts\"", size=16)\n"", ""ax2.legend(fontsize=14)\n"", ""\n"", ""axs = [ax1,ax2]\n"", ""for n, ax in enumerate(axs):\n"", "" ax.text(-0.05, 1.0, string.ascii_lowercase[n], transform=ax.transAxes,\n"", "" size=20, weight='bold')\n"", "" ticks = [ax.xaxis.get_minor_ticks(),\n"", "" ax.xaxis.get_major_ticks(),]\n"", "" xmarks = [ax.get_xticklabels()]\n"", "" for k in range(0,len(ticks)):\n"", "" for tick in ticks[k]:\n"", "" tick.label.set_fontsize(16)\n"", "" for k in range(0,len(xmarks)):\n"", "" for mark in xmarks[k]:\n"", "" mark.set_size(fontsize=16)\n"", "" mark.set_rotation(s=0)\n"", ""fig.tight_layout()\n"", ""fig.savefig('histogram_of_observables.pdf', dpi=600)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
\n"", ""
Histogram of (a) experimental (orange) and model data (blue) for 32 NOE distances for 100 structures. (b) For the same structures, 9 scalar coupling observables.\n"", ""
\n"", ""
\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 8, ""metadata"": {}, ""outputs"": [], ""source"": [ ""# REQUIRED: number of MCMC steps for each lambda\n"", ""nsteps = 1000000 #100000000 # 100 M steps for production\n"", ""# REQUIRED: specify how many lambdas to sample (more lambdas will provide higher \n"", ""# accuracy but slower the whole process, lambda=0.0 and 1.0 are necessary)\n"", ""n_lambdas = 2\n"", ""lambda_values = np.linspace(0.0, 1.0, n_lambdas)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""#### Constructing conformational ensembles and applying data restraints\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""We begin by constructing an ensemble using prior information from simulation $P(X)$, a collection energies for each state. In this example, energies for each state were taken from QM optimization at the B3LYP/6-3111G(2d,p)/HF/6-31G(d) level of theory. In most cases we convert the normalized population of each state into free energies through $E = -k_{b}T * \\log P$ where $k_{b}$ is the Boltzmann constant and $T$ is the temperature. Alternatively, users can describe the potential energy of conformational states based on their own preference, but it is necessary to pass BICePs reduced free energies (in units of $k_{b}T$).\n"", ""\n"", ""\n"", ""In general, the goal of this step is to construct an $\\verb|ensemble|$ object for each $lambda$-value, where each ensemble contains $\\textit{prior}$ information as well as restraint information. Please be aware that the example below is for a single $\\lambda$-value for the sake of simplicity, and that posterior sampling for each ensemble will need to be performed iteratively for at least two lambdas $\\{0.0, 1.0\\}$. As discussed in \\cite{Voelz:2014fga,Ge:2018bdb, voelz2021reconciling}, the lambda value controls how much prior information $P(x)$ is used during posterior sampling. Similar to Free Energy Perturbation (FEP) simulations, the more fine-grained spaced lambda values are employed, the more accurate the results will be. However, finer grained lambda values will increase the computational expense and may not be necessary. Unlike FEP simulations where the $\\lambda$-space plays a critical role in accuracy of results, BICePs suffers less in the \""overlap issue\"". Only when the prior distribution (computational modeling) is dramatically different from the posterior likelihood distribution (with experimental restraints), a large number of $\\lambda$-values are needed to bridge each ensemble to sample. Normally this may occur with improper modeling (i.e improper force fields) or finite sampling issue. Our previous experience shows lambda values of 0.0, 0.5, 1.0 are robust in accuracy. Nevertheless, it is still important for users to test for optimal settings for their systems and consider the balance between accuracy and efficiency.\n"", ""\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 9, ""metadata"": {}, ""outputs"": [], ""source"": [ ""####### MCMC Simulations #######\n"", ""ensemble = biceps.Ensemble(lambda_values[0], energies)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""Now that we have our $\\verb|ensemble|$ object, we want to apply data restraints and possibly adjust some of the restraint settings. However, adjusting the default settings is optional, but definitely important to achieve good sampling. We illustrate in the code block below, that the default restraint settings are readily avalible, which is a list of dictionaries, where each dictionary contains specific keyword arguments (kwargs) for each restraint type in the provided prepared data as shown here:"" ] }, { ""cell_type"": ""code"", ""execution_count"": 10, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
refsigmause_global_ref_sigmaextensionweightfile_fmtlog_normalgamma
0uniform[0.05, 20.0, 1.02]TrueJ1pickleNaNNaN
1uniform[0.05, 20.0, 1.02]Truenoe1pickleFalse[0.2, 10.0, 1.01]
\n"", ""
"" ], ""text/plain"": [ "" ref sigma use_global_ref_sigma extension weight \\\n"", ""0 uniform [0.05, 20.0, 1.02] True J 1 \n"", ""1 uniform [0.05, 20.0, 1.02] True noe 1 \n"", ""\n"", "" file_fmt log_normal gamma \n"", ""0 pickle NaN NaN \n"", ""1 pickle False [0.2, 10.0, 1.01] "" ] }, ""execution_count"": 10, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""#pd.DataFrame(biceps.get_restraint_options())\n"", ""options = biceps.get_restraint_options(input_data)\n"", ""pd.DataFrame(options)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 11, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/plain"": [ ""{'ref': 'uniform',\n"", "" 'sigma': [0.05, 20.0, 1.02],\n"", "" 'use_global_ref_sigma': True,\n"", "" 'extension': 'J',\n"", "" 'weight': 1,\n"", "" 'file_fmt': 'pickle'}"" ] }, ""execution_count"": 11, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""options[0]"" ] }, { ""cell_type"": ""code"", ""execution_count"": 12, ""metadata"": {}, ""outputs"": [], ""source"": [ ""df = pd.DataFrame(options)\n"", ""df.to_latex(\""restraint_options.tex\"")"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Default restraint options can be redefined. To explain the $\\verb|options|$ in greater detail, consider our system Cineromycin B with the two data restraints being J-coupling and NOE distances, respectively. We will redefine the reference potential as well as the discrete sample space for the NOE distance model parameters $\\sigma$ and $\\gamma$ (unique to NOE), but keep all default parameters for the J coupling restraint. Model parameters $\\sigma$ and $\\gamma$ reflect both uncertainty in the experimental measurements as well as conformational heterogeneity and intensities to interatomic distances, respectively.\n"", ""\n"", ""\n"", ""The implementation of reference potentials is a unique feature in BICePs compared to other Bayesian inference based approaches.\\cite{Rieping303, perez2015accelerating, beauchamp2014bayesian, fisher2010modeling, bonomi2016metainference, bonomi2016metadynamic} It functions to reweigh the informative level of the experimental restraints. Please read these works for more information regarding the theory of reference potentials\\cite{Olsson:2013gqa, Olsson:2011kl, Hamelryck:2010deb} and their implementations in BICePs\\cite{Voelz:2014fga,Ge:2018bdb, voelz2021reconciling}. A uniform reference potential treats each experimental restraint uniformly i.e., a uniform reference potential is equivalent to not having a reference potential during sampling. The options for reference potentials are the following: $\\verb|\""uniform\""|$, $\\verb|\""exponential\""|$ and $\\verb|\""gaussian\""|$. The values inside the tuple for sigma (and gamma) define its discrete sample space and follow the formalism of NumPy's method $\\verb|arange|$: a minimum of 0.05, maximum of 20.0 and incremented by $\\log(1.02)$.\n"", ""\n"", ""\n"", ""To make this change, we will set the reference potential to an exponential distribution, set the sigma-space to a smaller range of allowed sample space and alter the gamma spacing to have a larger width size.\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 13, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
refsigmause_global_ref_sigmaextensionweightfile_fmtlog_normalgamma
0uniform[0.05, 20.0, 1.02]TrueJ1pickleNaNNaN
1exponential(0.05, 5.0, 1.02)Truenoe1pickleFalse(0.2, 5.0, 1.02)
\n"", ""
"" ], ""text/plain"": [ "" ref sigma use_global_ref_sigma extension weight \\\n"", ""0 uniform [0.05, 20.0, 1.02] True J 1 \n"", ""1 exponential (0.05, 5.0, 1.02) True noe 1 \n"", ""\n"", "" file_fmt log_normal gamma \n"", ""0 pickle NaN NaN \n"", ""1 pickle False (0.2, 5.0, 1.02) "" ] }, ""execution_count"": 13, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""# Change NOE reference potential from uniform to exponential\n"", ""options[1][\""ref\""] = 'exponential'\n"", ""# Change the sigma-space to a smaller range of allowed sample space\n"", ""options[1][\""sigma\""] = (0.05, 5.0, 1.02)\n"", ""# Alter gamma spacing to have larger width\n"", ""options[1][\""gamma\""] = (0.2, 5.0, 1.02)\n"", ""pd.DataFrame(options)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Using our established $\\verb|ensemble|$ object containing prior informaiton, we now would like to apply data restraints. To do this, we invoke the method $\\verb|ensemble.initialize_restraints|$ and provide the prepared data for each state as well as our restraint options. "" ] }, { ""cell_type"": ""code"", ""execution_count"": 14, ""metadata"": {}, ""outputs"": [], ""source"": [ ""ensemble.initialize_restraints(input_data, options)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""In summary, the $\\verb|biceps.Ensemble|$ class was used to construct a single ensemble for a given lambda value. Ensembles must be constructed for all lambda values, where each lambda value scales the reduced free energies of the states. Then, we apply data restraints using our prepared data along with non-default restraint options. These restraint variables are important in BICePs sampling since nuisance parameters are included in the energy calculation during sampling. We recommend a broad range of parameters for better accuracy of sampling but the sampling runtime will also increase due to a larger sampling space for a good converged sampling. Note that increasing this range may increase the sampling requirement for convergence. After filling the $\\verb|ensemble|$ container object with $\\verb|Restraint|$ objects (NOE and J) for each conformational state, the $\\verb|ensemble|$ object is ready to be passed to $\\verb|biceps.PosteriorSampler|$. \n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""#### Sampling the posterior distribution via Markov Chain Monte Carlo\n"", ""\n"", ""\n"", ""\\subsection{Sampling the posterior distribution via MCMC}\n"", ""%\\subsection{PosteriorSampler}\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""The primary objective of this step is to perform MCMC sampling of the posterior distribution, which consists of nuisance parameter space as well as conformational space . During MCMC, what is actually evaluted is an effective energy function (in $k_{b}T$). Suitably, all of the required information to perform energy evaluations is inherited from the $\\verb|ensemble|$ object. The energy function can be obtained as the negative logarithm of the posterior probability given in Eq.\\ref{eq:nuisance}:\n"", ""\n"", ""\\begin{equation}\n"", ""\\begin{split}\n"", ""-\\ln P(X_{i}, \\sigma^{\\text{NOE}}, \\sigma^{\\text{J}}, \\gamma^{\\prime} | D) = &\\left(N_{j}^{\\text{J}}+1\\right) \\ln \\sigma^{\\text{J}}+\\frac{\\chi^{2}(X_{i})}{2 (\\sigma^{\\text{J}})^{2}}+\\frac{N_{j}^{\\text{J}}}{2} \\ln 2 \\pi \\\\\n"", ""&+ \\left(N_{j}^{\\text{NOE}}+1\\right) \\ln \\sigma^{\\text{NOE}}+\\frac{\\chi^{2}(X_{i})}{2 (\\sigma^{\\text{NOE}})^{2}}+\\frac{N_{j}^{\\text{NOE}}}{2} \\ln 2 \\pi\\\\\n"", ""&+ \\sum_{j} \\left( \\ln \\beta_{j} - r_{j}^{\\text{NOE}}/\\beta_{j}\\right) + E(X_{i})/k_{b}T + \\sum_{i} \\exp\\left(-E(X_{i})/k_{b}T\\right)\n"", ""\\label{eq:neglogP}\n"", ""\\end{split}\n"", ""\\end{equation}\n"", ""\n"", ""\n"", ""The quantity $\\chi^{2}(X)$ is the sum of squared errors, computed as\n"", ""\\begin{equation}\n"", ""\\chi^{2}(X)=\\sum_{j} w_{j}\\left(r_{j}(X)-r_{j}^{\\exp }\\right)^{2}\n"", ""\\label{eq:chi2}\n"", ""\\end{equation}\n"", ""\n"", ""where $w_{j}$ is a weight parameter (for example, $w_{j}=1/3$ is the uniform weight for each hydrogen in a methyl group), where the effective number of coupling constants is $N_{j} = \\sum_{j} w_{j}$.\n"", ""\n"", ""\n"", ""The Metropolis-Hastings criterion is used to determine if a new jump is accepted or rejected in the MCMC simulation. The Metropolis-Hastings algorithm was used for MCMC sampling of the full posterior distribution over variables, $\\theta = (X_{i}, \\sigma^{\\text{NOE}}, \\sigma^{\\text{J}}, \\gamma^{\\prime})$ where $i$ is an index running over all conformations. Iteratively, candidate moves $\\theta \\rightarrow \\theta^{\\prime}$ are proposed, and either accepted or rejected by the Metropolis criterion, which accepts the move with probability min$\\left[1, P(\\theta^{\\prime})/P(\\theta) \\right]$. Overall, the result yields an estimate of the full posterior distribution $P(X, \\sigma | D)$. The most probable values of $\\sigma$ can be obtained by the marginal distribution $P(\\sigma | D) = \\int P(X, \\sigma | D) dX$, and the state populations are estimated as $P(X | D) = \\int P(X, \\sigma | D) d\\sigma$.\n"", ""\n"", ""A key advantage of MCMC sampling is that the error estimate is independent of the dimension $d$ of the parameter space to be sampled. On the other hand, this acts as a disadvantage such that convergence is slowly achieved. Therefore, MCMC sampling is not optimal for low dimensional (e.g 1D) integrals but rather a better option for high dimension task. Since BICePs is designed for working with multiple experimental observables and for some observables (i.e NOE and protection factors) more than one nuisance parameters are included in sampling, MCMC sampling is an attractive choice for such a problem.\n"", ""\n"", ""\n"", ""To initialize the class, the only requirement is the \\verb|ensemble| object.\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 15, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Step\t\tState\tPara Indices\t\tAvg Energy\tAcceptance (%)\n"", ""0\t\t[94]\t[151, 116, 81]\t\t98.053\t\t100.00\tTrue\n"", ""1000\t\t[87]\t[199, 143, 100]\t\t6.828\t\t60.24\tTrue\n"", ""2000\t\t[87]\t[229, 138, 95]\t\t5.733\t\t60.82\tTrue\n"", ""3000\t\t[87]\t[222, 140, 99]\t\t5.037\t\t64.78\tTrue\n"", ""4000\t\t[87]\t[202, 131, 101]\t\t6.413\t\t64.03\tTrue\n"", ""5000\t\t[87]\t[195, 143, 95]\t\t8.002\t\t63.41\tFalse\n"", ""6000\t\t[79]\t[218, 127, 96]\t\t6.465\t\t63.49\tTrue\n"", ""7000\t\t[79]\t[219, 135, 96]\t\t6.315\t\t63.81\tTrue\n"", ""8000\t\t[38]\t[249, 128, 88]\t\t8.595\t\t64.10\tFalse\n"", ""9000\t\t[17]\t[273, 139, 101]\t\t8.857\t\t65.54\tTrue\n"", ""\n"", ""Accepted 66.53999999999999 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [31.97 29.67 29.67 4.9 ] % \n"", ""\n"" ] } ], ""source"": [ ""sampler = biceps.PosteriorSampler(ensemble)\n"", ""sampler.sample(nsteps=10000, burn=0, print_freq=1000, verbose=True, progress=0)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""\n"", ""Next, the posterior distribution is sampled by invoking the $\\verb|sampler.sample|$ method from the $\\verb|sampler|$ object and specifying the number of steps to be sampled (\\mintinline{python}{nsteps}). This number is important for convergence and normally is not known a \\textit{priori}. We developed multiple statistical methods to check convergence of the outcome trajectories and more details will be discussed later. To save all the necessary information regarding MCMC sampling, we invoke $\\verb|sampler.process|$ to dump a NumPy z-compressed file ($\\verb|filename=f'traj_lambda{lam}.npz'|$) and corresponding light-weight $\\verb|sampler|$ object, where $\\verb|lam|$ is the lambda value of the ensemble.\n"", ""\n"", ""\n"", ""In Code Block \\ref{cb:Posterior} we have exhaustively sampled the posterior distribution and made full use of the information stored in the $\\verb|ensemble|$ object with the $\\verb|biceps.PosteriorSampler|$ class. \n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 16, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Number of CPUs: 10\n"", ""Number of processes: 2\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""100%|████████████████████████████████████████████████████████| 1000000/1000000 [00:15<00:00, 65594.31it/s]\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted 64.26859999999999 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [32.7426 29.9442 29.9442 1.5818] % \n"", ""\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""100%|████████████████████████████████████████████████████████| 1000000/1000000 [00:15<00:00, 65443.78it/s]\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted 71.7003 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [32.6684 29.9711 29.9711 9.0608] % \n"", ""\n"" ] } ], ""source"": [ ""# Multiprocess trajectories for each $\\lambda$-value with a built-in decorator\n"", ""@biceps.multiprocess(iterable=lambda_values)\n"", ""def mp_lambdas(lam):\n"", "" ensemble = biceps.Ensemble(lam, energies)\n"", "" ensemble.initialize_restraints(input_data, options)\n"", "" sampler = biceps.PosteriorSampler(ensemble)\n"", "" sampler.sample(nsteps=nsteps, print_freq=1000, verbose=False)\n"", "" filename = os.path.join(outdir,'traj_lambda%2.2f.npz'%(lam))\n"", "" sampler.traj.process_results(filename)\n"", "" biceps.toolbox.save_object(sampler, filename.replace(\"".npz\"", \"".pkl\""))"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""#### Assessing the convergence of MCMC trajectories\n"", ""\n"", ""\n"", ""\n"", ""Typically, massive amounts of care is involved with setting up simulations. We stress the importance in making sure that when reweighting simulated ensembles that we do it accurately. Thus, it is essential that we attempt to objectively uncover the validity of our MCMC trajectories to ensure proper sampling & convergence. Despite there being no single clear best practice to quantify MCMC sampling quality\\cite{grossfield2018best}, we added an assortment of different approaches to test convergence inside of our $\\verb|biceps.Convergence|$ class. Here, we will find methods that suit our needs e.g., autocorrelation, block-averaging, bootstrapping, Jensen-Shannon divergence (JSD) and more. Previously, we assessed trajectory convergence by comparing populations and BICePs scores from sets of trajectories of varying number of steps. For converged results, the populations and BICePs score should be similar regardless of the trajectory length.\n"", ""\n"", ""We stress that users should check that their MCMC simulations satisfy the following items before checking convergence: 1) All states are sampled at least once over all $\\lambda$ values. The MBAR algorithm estimates conformational state populations and the states not sampled for any lambda value will be considered to have infinitely high potential energy and the corresponding predicted population will be infinite small. 2) The MCMC acceptance percentage is high. Low acceptance percentage is a sign of inefficient sampling and implies that many more MCMC steps are required to adequately sample a certain parameter space. Alternatively, one can modify the parameter space by decreasing the width and have a more fine grained sample space. Another option is to start at larger sigma values when sampling.\n"", ""\n"", ""\n"", ""\n"", ""To evaluate the convergence criteria in a more statistically rigorous manor, we added numerous tools inside the Convergence class which should provide a great deal of aid to the user. To get started, the class only requires the $\\verb|filename|$ of a biceps MCMC trajectory (including its relative path) for initialization. In this step, the trajectory is read into memory and stored as the local variable convergence object $\\verb|C|$. To view the trajectory, as shown in Figure \\ref{fig:autocorr}a, we plot the time-series of sampled nuisance parameters using $\\verb|C.plot_traces(str(figname))|$. The time-series of sampled $\\sigma_{NOE}$ implies adequate sampling with many transitions about the mean of 0.695Å. Here, we see local convergence, but let us be more statistically rigorous. "" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""To do this, we first determine the trajectory length at which sampling becomes decorrelated. Autocorrelation curves are computed for each time-series of sampled nuisance parameters.\n"", ""\n"", ""\\begin{equation}\n"", ""C\\left(\\theta_{t}, \\theta_{t+\\tau}\\right) \\equiv \\frac{\\overline{\\left(\\theta_{t}-\\overline{\\theta}\\right)\\left(\\theta_{t+\\tau}-\\overline{\\theta}\\right)}}{{s_{\\theta}}^{2}} \\Rightarrow c_{\\tau}\n"", ""\\label{eq:g}\n"", ""\\end{equation}\n"", ""\n"", ""\n"", ""where $s(\\theta)^{2}$ is the variance and $c_{\\tau}$ is independent of the lagtime $\\tau$. To find the autocorrelation time ($\\tau_{auto}$), we take integral of $C_{\\tau}$ over all lagtimes, which tells us the length at which sampling becomes decorrelated. The computed autocorrelation times for each nuisance parameter are stored in $\\verb|C|$ to be used for further convergence analysis. By default, our $\\verb|get_autocorrelation_curves|$ method uses an autocorrelation function ($\\verb|method=\""auto\""|$) with a window of length $\\verb|maxtau=10000|$ to compute the autocorrelation time. To obtain the autocorrelation time, we take the integral of the autocorrelation function over all lag-times $\\tau$ shown in Figure \\ref{fig:autocorr}b (with $\\verb|maxtau=5000|$). Three options for the argument $\\verb|method|$ are provided: block average ($\\verb|\""block-avg-auto\""|$), exponential fitting ($\\verb|\""exp\""|$) or autocorrelation function ($\\verb|\""auto\""|$). Each method varying in the level of statistical sophistication to compute the autocorrelation times of each nuisance parameter. \n"", ""\n"", ""\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 17, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA3kAAAJOCAYAAAAK+M50AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3QU1dvHv7vZ9BBCC7333gUEpBeliFgQFJFiA34WFBELVVQQRF9QUVGqIk2adOlEpPfeAoEQEko6abvz/pHM5s7sndnZvtk8n3NyYGdnZ+7M3Ln3Pl0nCIIAgiAIgiAIgiAIwifQe7oBBEEQBEEQBEEQhPMgIY8gCIIgCIIgCMKHICGPIAiCIAiCIAjChyAhjyAIgiAIgiAIwocgIY8gCIIgCIIgCMKHICGPIAiCIAiCIAjChyAhjyAIgiAIgiAIwocgIY8gCIIgCIIgCMKHICGPIAiCIAiCIAjChyAhjyAIgiAIgiAIwocodELe7du38e2336J79+6oVKkSAgICUKZMGTz77LM4ePAg9zfJyckYM2YMKleujMDAQFSpUgVjx45Famqqm1tPEARBEARBEAShjk4QBMHTjXAnH330EaZPn47q1aujY8eOKFWqFC5fvoy1a9dCEAT88ccfGDBggHn/tLQ0tGvXDidOnED37t3RtGlTHD9+HNu2bUPLli2xd+9eBAUFaT6/yWRCbGwsihQpAp1O54pLJAiCIAiCIAjCSxEEASkpKShXrhz0ehfZ3IRCxurVq4Xdu3dbbN+7d6/g7+8vFCtWTMjIyDBvnzBhggBAGDdunGT/cePGCQCEL774wqbzx8TECADoj/7oj/7oj/7oj/7oj/7orxD/xcTE2CfQaKDQWfLU6NGjB7Zt24bDhw+jRYsWEAQBFSpUQHJyMuLi4hAaGmreNy0tDWXKlEFkZCSuXr2q+RxJSUmIiIhATEwMwsPDXXEZBEEQBEEQBEF4KcnJyahYsSISExNRtGhRl5zD4JKjFlD8/f0BAAZD7m25fPkyYmNj0aNHD4mABwChoaFo27Yttm7dipiYGFSsWFHTOUQXzfDwcBLyCIIgCIIgCKKQ4srQrUKXeEWJmzdv4p9//kHZsmXRsGFDALlCHgDUrFmT+xtxu7gfj8zMTCQnJ0v+CIIgCIIgCIIgXAUJeQCys7MxePBgZGZmYvr06fDz8wOQ61oJQNGMKlrixP14fPnllyhatKj5T6vFjyAI93HmdhLeWHIEVxOkGXOj76XhzSVHcSIm0TMNIwiCIAg3seroLYxZcQLZRpOnm0I4gUIv5JlMJrz66qvYu3cvXnvtNQwePNipxx8/fjySkpLMfzExMU49PkEQjtN7zn5sPXsXry0+Itk+etkxbDkbh37fR3moZQRBEAThHj5YeRJ/HbuNNcdue7ophBMo1DF5JpMJw4YNwx9//IGXX34Z8+bNk3wvWvCULHWi66VawGRgYCACAwOd1GKCIFzJzfvpks8xDx55qCWEOxAEATk5OTAajZ5uitvw9/c3e6sQBEHwWHX0Fl5o6fueZzfupyHqyn0836IC/P1cb/dadugmtp+7i/mvtHD5uYBCLOSZTCYMHToUixcvxsCBA7Fw4UKLOhXWYu6sxewRBFGwMPhJA6ADDIXe2cFnycrKwp07d5Cenm59Zx9Cp9OhQoUKCAsL83RTCILwUg5FP/B0E9xCh693AwBSMrLxRofqLj/f+L9OAwBm/3MJr7Uu6/LzFUohjxXwBgwYgCVLlnA1mzVr1kS5cuUQFRWFtLQ0ixIKUVFRqFq1KsXZOYGMbCOi76ehdmkqEk94DwkpmZ5uAuECTCYTrl+/Dj8/P5QrVw4BAQGFYtwRBAEJCQm4desWatasSRY9giAUEQShQIyLtxMfIcBPj1JF7PeaO3j9gVuEPJGNp+6QkOcKRBfNxYsX4/nnn8fSpUsVJzqdTocRI0ZgypQpmDp1Kr766ivzd1OnTkVqaio+/vhjdzXdpxnw8384GZOI7wc1Q69Gru/4BMHDxFQNTXqU7bmGEC4lKysLJpMJFStWREhIiKeb41ZKlSqF6OhoZGdnk5BHEIQiJgHw83IZLzkjG22/2gkAiP6ql4dbox2jm0qUFzohb8qUKVi0aBHCwsJQq1YtfP755xb79OvXD02aNAEAfPjhh1i3bh2mT5+O48ePo1mzZjh27Bi2bduGli1b4t1333XvBfgoJ/OyFy4/EkNCHuExBGbglcfnEb6H3EW/MFAQNPMEQXgekyDAD949XsQ8cM48LbhJ6BIxmkjIcwnR0dEAgNTUVEybNo27T5UqVcxCXmhoKPbs2YNJkyZh9erV2LVrF8qWLYv3338fEydORHBwsJtaXjjYeynB000gCjHsOE9rYYIgCKKwYnKz4GMPbBMLinupOyl0Qt7ChQuxcOFCm35TtGhRzJ49G7Nnz3ZNowiC8AoKwqRGEARBEK6mIEyHUiGv4Chn+zUp75bzFD5fFYIgAOQGK3f8ehd+23/d003xGkxkySMIgiCIAqH0FJDfRkfa6+4rDQ5wTzw0CXkEUUj5avMFRN9Px5S/z3m6KV5JAZjfCIIgCMIluClszCEkljwnHccduCsGkIQ8wuOkZuZ4ugmFkszs/ALQ/7eDXwuyMOOuwGiCsJX//vsPXbp0QYkSJaDT6SR/ycnJnm4el2WHbuKFnw4gKZ2y1hJEQaAgWPJ2XYw3/9+R9p6Nde+46a5bS0Ie4XEW/Rvt6SYUSlgZ5pvtlzzXEC8lx2TydBMINyIIAtKzctz+Z6tG9+TJk+jYsSOaNm2Kffv2YcuWLShevDi6dOmC5cuXIzw83EV3yDHG/3Uah64/wNxdpFAiiIKAUACmwG//yR9PHBGc7qW6viYuO9a7S3wudIlXCO8jg7EoAYDJJECvp4Ao1+P9WjpPkm2k+1OYeJRtRL0JW91+3nNTeiAkQPtU/Pbbb6N///6YOXMmAKBevXoYOHAgjh49ihdeeAEzZsxAWloaJk+e7KomO0RqptH6TgRBeJyCYMljycwxIcjfe2t/mmRJYtwBWfIIj6OXZbg4cuOhh1pSuCBvRHVMdIMIL+Pu3bvYv38/Ro4cKdkeGhpqTh1++vRpNGzY0BPNIwjChyhoQt6uC/HWd/Ig7q7FB5Alj/AC/GRWO7llj3ANnhhwChJGuj+FimB/P5yb0sMj59XK0aNHYTKZ0LhxY4vtLVq0AJAr5H366adObSNBeCOCIGDc6lOoUjIUIzvW8HRzCjzyNUFB03Oej0tGP9hXmqBmZJiTW2MJez9/3X8NQx8r7fJzkpBHeJz0LKlQVzw0wEMtKVwUsPHb7RS0CY5wDJ1OZ5PbpCcw5cWJpqWloUiRIgCAU6dOYe/evfj888+Rk5ODGzduoEYNWvASvs+xmw+x4sgtACAhzwnIk40JBWyV8NOeaxj/ZF27fuuOK2XvZ3KGexIOkrsm4XFyjNLoXoMfxeO5AxJi1GFdVVpWKebBlhBELq1atUJwcDDGjh2LCxcuYOPGjejbty9GjRqF1q1b4/Lly6hWrRr8/Lw3LoXUS4SzkCuICceQrwkKkzOLO1xTPXE/vVttSRRKKHW9eyB3TXUoJo/wNkqVKoUVK1bg/fffR6NGjVCpUiWMHj0aY8aMAQCcOXOG4vEIgrALuaBT0GLyHMINlyq/ne5Yg5GQR3gdJOQR3gDbDalLEt5C79690bt3b+53lHSFKEwUJhnEHcjXXt4+7+04f9dpx3KHQCs/R0a262tUkLsm4XHkrxYJee7BkTGtMFgB2QG5MFwvUfA5ceIEmjdv7ulmWIHc8QnCG7Gw5HnBWkxt7h2+6IjTzuOOS5Wf4pEbkgySkEd4HSTkuQf5gD5vz1VNv9t3OQEtp+1wqhbNG2EnOOqRhLcTFxeHs2fPom3btp5uCkG4Bbb60sO0LM81xEcwyQxLntZtzthyAe2m78J9NxQq94Ql71GW65OvkJBHeBz5u0VCnnuQ3/evNl/Q9LvBvx7CvdRMp2rRvBFy1yQKCj/88AOefPJJ/PDDD/D39/d0cwgPkJKR7ekmeJTfoq57ugkFHm+Lyfth91XcTnyEBVHRLj+XOy5VkAnRGTlkySMKAfJsmlSfzD14egD3diT3h+4V4cWMHDkSx48fR48e7q/zR3ie+fuuoeGkbVhxOMbTTfEYOaSJcxj52stb1gjuWBO6IyRDXpLikRuyw5KQR3icBuWLSj6TJc89eONdPhmT6BbXDC3cY9pBXZIgnENWjuuTDRQ2Pt94HgDw4epTHm6Je2HX5d4QP1bQkd9Db7mlmW5IUOKOS5Xfz4wsSrxCFEJII+cevC2ZyNEbD/H091EYsuCQp5sCAJi84Zz5/wWtKCxBeCurj93ydBMIH4SUw45jWSfPO+6pO1xx3VMnT3qOdHLXJBxFEAQsO3QTZ24nebopisg7/o+7r1IQtRvwkvHbzJ6L8QCAM7eTPdwSS7ztXhEEQRR22MQrFObhOJbumh5qiJ0Ma1vV7t/eTc50uTVYfnij0fU3mIQ8H2f7ubsY/9dp9J6z39NNUUQ+Nh+6/gDvrzzpmcYUIrxt/NbpvDe1ekGb7AiCIHwdCpt2LpbumgXrpgb5OybSrD8Z66SW8JF7BLlDMUFCno9zOT7V002wCs/KuPNCvAdaUrjwtgFc78VCnjvcVjp8vQtVPtqIbCPFLLkLb3FHcieF8ZoJ34fcNR1Hvibw5qGCN4452gXO33GtF5G8ye4Yi0nI83EC/Lz/Ec/fT6mPPYG3DeB675XxXH6vjCYBN+6nAwDm7Ljs2pMR5jID6enpHm6J+8nKynWF9/Pz83BLfAcSMDwPxfI7jrwfe5simIXXNEdj5/UuXoRYFpt36ekAAAbXn4LwJP5+XrxyVqFkWICnm+DzeNvw7cWGPJcnXmEH/9ikDJeei8gVcCIiIhAfn+sxEBIS4tXuws7CZDIhISEBISEhMBho+ncGF+KS0f+HfzGqUw2M6lTD080ptCw7dBNfPNOgULzHrsIy8Ypn2qEFngDqaHv3XEzAuJ51HDuICrGJ0rndHUI0jfI+jr/B+y15PPy82azjK3jZCH432TtKJ/BwtZKY1aCSVcA9lClTBgDMgl5hQa/Xo1KlSrQYdhKT1p9FepYRX2+96DYh7+iNByhTNBjlI4Ldcj5vRT5SpmTmIDzI3yNt8QWW/ndD8tmbLXm8eDZHE6ecc7G75uQNZyWfScgjHMafcdcUBKHATOzevOD3FbxNllgim2C8CVf7zrOHJyHPPeh0OpQtWxaRkZHIzs72dHPcRkBAAPT6gqn8I3Ljhp798QAAIPqrXh5ujWeRL+ov301F88rFPNSags2Bq/ex8N9oyTZvFvL47prezalb0vwT7pjrScjzcdiYvGyjgABDwRDyCNfjzfK+tykkriakufT47GRKQp578fPzo/g0osBw+pb3lkNyN3Ih5MztJBLy7GTZoZsW27x5KuIJoM4SSteduI1jNx5iQp/6LvUqc8f9JSHPxzEwMXmZOUYEFBD3TYrJcz2eEqIEQUBmjglB/soLa5MAeFs4aXxyBiLDg1xybHZyqhEZ5pJzEARR8AkOyB83TSbB5ckivBlSiDmPh+mWtYlzvDjTM+/RO8vw+M6fJwAAzSoXw9NNyjvnoBxcXZcPoOyaPo+BccvJzPHeF1ZOvXJFPd0En8dTa4Nxq0+hzmdbcDVBubxHjjvSTqnAc898lG102fnYyy1b1DWCJEF4ijtJjzzdBJ8hIiQ/5izxUeFxM+bx+pKjks9e5PzhE2w+E+fpJijCT7ziXKFJFPZchTvcYUnIK0QUJCHPTwesOByDs7HkmuIqPFWXbsWRWwCAX/ZeU9zn6I2HWHfitruaZAFPQ+xKpRs72Ge5UHsqCAJWHonh1qYkCFfx56EYTzfB7VyIS8bywzedvvD0Y8ZtVyqeCiJ1y4Z7ugkFlnY1Slpsk8fouRNr743AmSYdnaM71Crl2AFsxOiGKEJy1/Rx2BclqwAJebsuJmDXxQQAFFzuKjyt9FRzFx30y0EAQKXiIWhayf0xFtzMXS7UurHHTs9y3cJtz6UEjF11CgC9VwThSnp+uw8AEBJgQJ/G5Zx2XLYenDvcvQoSXpwnxOvxtozm1ro215LnoNBUp0wRh36vBu9dFchdk3AUtg95c6YkNbrM2o34FKod5mw8ZckT0XL66/dcm/BECZ63qCtfH/Y93XjqjsvOc/musossQbiKgjnzOIezsc5Ny84qoFw9p0/beA69/m8fMgqIxdCXY/TikjLQeeZuzN+n7AFz5nYSOny9y645hNeXhrWtavNxnIW1Z8lPvGL7eUqE5ud/cGXv4SmOD15/4MIz5kJCno/DvgiuTgPvKq4mpGHuziuebobPcDc5A5tP38Gth+kebYcWxaGn5mzegOzKKYB9T0+70JXS4G3ZbIjCQQGde5yBsw0kJis1NR0RdHZeuItJ68+aj/HLvus4G5uM9Sdi7T6mO0nPyvF0E1zGdzsu49q9NHy+8bziPqP+OIYb99Mx6o9jNh+fFyXgyfnCmgKDn3jF9r7P/sKVa2Tee7n9nOtrtJK7po9jkmj9PNgQB8n24ixPBY2u3+xBSobnJ0OdBodRT1mfjUbPxeS5EoMf6fUIz1IksHAtO5ztMSFx1+SMG0sORONVOy0wwxYeAZCb3OXdrrXM27M9nAhLKxPXn0WXuqU93QwXYX2OcMTiauQ8Y0+6A7N9O8jfct7iJ15x7Dyu9dbxzL2kGd/LSc/KQd+5+zFr20W7fs/2q4LqrlmYyMg2ot/3UZi+5YLLzqEm4LnT2qtJw+1FljzXxuS57NASgpmyFQXJsp+Qkome3+7Fb/uve7ophB0ICv93Bm8vO47XFh/x2v7sbK94k0ldcbszL5bdEZYfjsGeS/nH8dJba8Gth87J4ppjNGHATwdQ5aON+N+y4045piPEJWVgmYbkRVoUp0rw9OieNAzY565phyWP+YkrL3cP5718skEZF54xFxLyvJz1J2Jx6lYS5tjpriix5BUMZVyh5u9Td3AiJhE/7r7qkfPbEj9icNAPiU28oqQxTPOQ+w03u6YL3x93aUwDmTqZOQXItP/j7qu4EJeCKX+f83RTCDtwVdhARrYR60/GYvu5u05b4DsbZ9cjzZG5a6ZkSMsoJKRkOnwOvU6HIb8dMn/2VgHamRy98QD7LucuxC/EpZjjpTacjEVqpmc9X4YvOqxpP0emZHcrNq1hPfGK5TZ7mitIvN1cd71v/W7pQhsaqFwr2FmQkOeFOGtAFQRBslh1NPOQZykcsURyt1R3T6695+x32/nZtQ8/Bs5zgfTOjnWxBju59KjvOncjVjDP4bikeisFe+zybgRBsC+WxYbfuMPb3luTbvg5WcgzyRal41afkn5v531gn6e8yd55Z52HIAh49scDGPzrIdxLzfS68BCtpTIcUShwsz96Ushj2sOzUPLaa0/Xl1jy3Hy52W6Yg0nI8zJG/3EMnWftMftWs2ltbZ3ERv1xzJwuHSg4LheFGfYZLTt0E40nb8Pxmw890paJ686gzZc7kZiexf0+yN8xLRQbq6LUt90xCPLPaznJu7JAO3v5rlxf6JnxpKDE2QCAP8USuoRHWUZUHb8JVcdvQlyS9gzGSw5Eo8mU7ZrrLUoseTa3UttxvTUcYfMZ52bL/W7HZfP/TSZg02lpwWp7FSLs7ZPLCr5eqoG9vPjkTMk9BoDJ68+6uUVStHrNOKJP4Fvy7D+eo+y+pJ6UhPe6O5p4xd24Q5lAM6eX8fepO7h+Lw3/Xr0HQKqZuRyfYv7/wqjr2HxaffKQD/7eOglqwcPZ/j3C+L9OIzkjx0JT6y4WHbiBuOQM/HHoJvd7RzNvsb9WGuxcPQiejEnEzK2W8a6iSxQ7ubqrTh4vAN5ZsIH52QWobqa31XDyRv69cg//t+OyTQvyrWfz54h5e7S7iH+27iySHmVLlIhqWGtT9L00TN9yAfdSbXM1lJYIsumnToM3LOQw49aFuBTsvui8LHrXEvLLyuziHNdeiyY7BsmTxRTclYM2jDIX2N2y+KmVR2+5u0kStCbvcUjI41rG3PfkT8QkospHG3Eoz032veUnzd/xFBf8OnnaiU/OwFebL0hccS/dTVH5hfPJISGv8OKnz3007OQoLjgvxqVg0oZzXB9fNXxcGecT8AYzsS94Cqk7Q/6HxPRszt7a0WuwUtszCAqCgOv30jQtdp/+Pgpzd1nGu4rnLRJkQLWSoXnbXPcCsffVntPEp2QgOcP685i9/ZL5/wUpJs/R+M/CwKD5B/HN9ktYd/K25t+wi0J7skBq/YVJMoZYfv/MD1H4cfdVfLDypOWXqsf1vCWPd9/+PCxNkvHqAm0xVbbyDfM+i9jr/cA+I3lR6AKsH9YE23dc6bFhL+5QcvGFPJef1ky/76MAAC/8dMCyHdykMI4JpSN/P2ah2Pr36n2nu6g+TMvCgzS+N1QWuWsWLthFqb/4UjPvtrjYv5tsX2Fwb7XkaRnA/jjItyYVBjy9vJUIILJR/2ys/TXd2OtSEjjsiTFY9G80Os3cjU/WnrGzZfkLJYOf3uwq6MqYH1aWtdWSl5Sejcem7UCjSdus7nuHccnLKkCWPIOHFR0FieuMpccarIBij0es1tfT2tzzME9hdCTaNtf0q/Gp5v8vOXDDpt86i5AAS7f1K0y73M3NB/bVP2WfUf1yRSXfeefKwXmwY7s3rpO0KrliHtiffIg3v3lLwh2thc9tmaKP3OCPNc6c5rONJjSduh3Npm5X/N7VeHzmHDNmDBYvXoxTp04hJ8fztbs8SRbzwP3zsuCVDg8yb9tx/i6e/j4KVxPyJxBbFmquel9/P3gDz/74Lx4qaCusUTTY38ktIpyJmkvUJisuw2qwApySlaxGZJjNx520ITcD4zIFN1MtiNpcf73ObHF0peVLokm2Ubt30QYXk7e71DT/Pz7FPmWRJ6Ai7spsPHXHrAUHbOunrJCnt8NaoNX6pzUBmK0tYN3qlvznGSGP1ze9NQmMGuz64J/zd2XfFbzrsQWjRJHpwYYo4OwMrTxstYxN3nAWby096pa+kWMS8PtB6fvNO68z2uJMIT/5kbp3jTuSn3m8Kum3335r7sD+/v6oW7cumjRpYv5r3LgxIiIiPNtIN5GZnT+6iJobtsN9vvE8gNw4IpF/zt/FUw3LWhyL19n/OX8XzSsXc1ZzzXyyJtdi8t2Oy5jUt77Nvy+IE6ISY1eexMqjt7Drg46omufmZwu8LFKevjtqLlGOTIipmfkDoJKLjKe0qqwlT3wXlTKAOgPePV5xJAblI4LRtkZJ1d/a8v6wVoe4JMdTrbsL1tovCIJbFj0FhVF/SN32bRlOd1zIX8zb5a5phyUvI1tl0LCxCd4gfFy6m690Tc/KQUiAwaVjhatgn9GpW1IPjc1n4jCifTV3N8ltmLzckqfF28nR+C5+Rmnl/RdERQMAzt1JtrD8uoJP1pzBS60qmz/z3rFzd7SXgFLCmetRa2OqO4Q8j1vyTp8+jSVLluCDDz5Ax44dERcXh0WLFuG9995D586dUaJECVSpUgX9+vXDxIkTsW7dOty/f9/TzXYJ60/Fmv8vvtTWJjGlDsnb/OPuqy7NkpVgY9C8iNimgp5cITbxkTlAu9PM3XYdwxtvgdSSJ+0/tx7a5xoEAEv/y7e0KfVj+XZBEHAlPsWl/Xj/5XvmCdPgpzP3S6NLY/Ly/59jEnAuNhkfrjqFl+Yf1PBb7e1i76c3xp4oISn94ENKIU+SkW3EX8duSz7bitZFinzcOK+wGLN1+POGnnD9Xr577MytuTFyvLHixn3tbrSeQE24OXrjoaaYX3fCmwNaVimGjGyjzfda4q7pJeNL7lyXihyjSdOYt/wIv1h6XFIGkqxYlAD73TU9paQXp69gfz9EFgkEIE1KpIa8tiTLQ4Vs4vZgTQmW5Wvumr/99huOHTuG7Oz8G1y/fn0MGjQI06dPx5YtW3Dnzh3cuXMHW7ZswVdffYUXX3wRYWFh2LhxI6ZOnYr+/fujTJky6Nu3L86fP+/O5rucz5gYIvHdsrYO81dwY1J68VI9VFxaDVEjU9CFPEcTkQB8zY+ntdVqMXnOuGZAeeEu3/7D7qvo+s1eTFhvf7ydNS7dTTGf11+vN/dLVwoX8kXGnSTtsRUSIdxKG9mFnKfKU9gDK+R5Ww0rb0NrlsyRssRd9izWtGrO5ceOU4grt9VCG+BlpTX+u5argOaNFR2+3o1jHiqHowVrjz8lw7vWDqwlp0Weh1K2UcDTc6PQ4evdOMF4PNlyrPUnY1X2dB+rjt5C12/2YOTvxyTeW0qcuW35Lj5My0LrL3eg8WTr8dq2ZNf859xd7nZ3IrYtPNiA+BTbDAwNVeLX23y506F2sUTfV1eCu6OMkVtHyBEjRqBly5ZYtmyZ6n6lS5dG9+7dMXbsWPz+++84c+YMUlNTceTIEfzyyy94+eWXsXfvXjz22GM4edK2bFwAsHTpUrzxxhto0aIFAgMDodPpsHDhQsX9k5OTMWbMGFSuXBmBgYGoUqUKxo4di9RU1wVXix3YmtuHUuZFpZfTleZhe0U0cXBRCy6uWDzYzqO7D7nAHXXlns3H4K1xLsSluF0LzAoLgkSIcOy4GxQmUKV+KZ94vs4rd8BaAZWw16PPaBLMGjaJJc9dMXkmQdOkzvuttfGClY8KkrDkxyzms3MKjnDqzey8IE2/36C861yu5K+OUoFwW/V8VUvZ7hLvSsR3UWn+Xe2mVPwrDvOtOmpYUya2/WonVipYizwBOx6/2rYKgFzvBDFG+a9j2u81O6/JM6N6il/2XQMAbHNAoDofp919kZ07nm1WAYCy4M/Gv/JCTNyB2Fy5YvytpUc90Bo++y4lcLeL45zPl1C4e/cubt26pSnhSmBgIJo1a4Zhw4ZhwYIFuHLlCsqWLYtPP/3U5vN++umn+Pnnn3Hjxg2ULWsZz8aSlpaGDh06YPbs2ahTpw7ee+891K5dGzNnzkTnzp2RkeGa5AXiJGFt4A0P4odVanV/8wbEa/2yf0PFfSoX967JnId8ga3F1U6Okg/35LxkIu5iOxN4n/go331BvnixNSHG/5Yd525Xch10pL/arXQQBLPQ6e+mmDy2Vo/RJOD/duaXdbDqsq1iaZUjteR5RshLzsjGBytP2qQEkdRULEBupgUJez0Gqny0Ed9zypCwyMcNJa+Nh+nZGLPihOZ6ed42n4nX2agCX2B21zv3oR21VbXcSq11Ed0Bay0NMuTGGrPKQlvcj70xhtIZwpMtx1h3IlcBO/7JOmhQPhyAsrLCG7yuxLbpdTqM7lTDvH3zmTjV98zWcc4RTyqlfiVm7HaHN41HhLx58+YhMjIS5cqVQ+XKlREcHIzmzZtjwoQJuHlTW0a8kiVL4o033sD+/fttPv/8+fMRHR2NhIQEvPnmm6r7zpgxAydOnMC4ceOwdetWfPXVV9i6dSvGjRuHw4cPY/bs2TafXwvi+GVt4FX6XqlzOSOoOCUjG0v/u4EEG03kSogTdetqJXDp8ye5+6hlZPMWVh1xXEurZH1yVrr7Cev4bo69ZMl73liSrw0rw2R4lfcrZ1mGlRZrn6qUQbDmmmgt6Flp8DaaBLOGzV9iyXPdAu3nvdck52f579oD1d8qWV15sMf2VAmFWVsvYtXRWzYpQdjL0hIzs/dSAvYqaFEJPo7IH6KFXQl2DAHU382/jt3GxHVnNZ3X24S8G3nuWQYFN1I2SYu34Y0JR9Rg4x4D/XPvNxvjZEvX0DKmPEzLwtL/buC+nbkHbEVt+nJF3KD4Lm08fcf8fip1iVO3Es3/v+4CL6MVGizGZiFPDzSvIk0o+EhFwOe5tarhyGuh9JgC8rLnu2MO9oiQd/DgQdy7dw+CIEAQBBiNRhw/fhzTpk1DjRo1MHbsWGRmWn+RHn/8cdSvb3s2x65du6Jy5cpW9xMEAfPnz0dYWBg+++wzyXefffYZwsLCMH/+fJvPrwXxJbY28Cp9rzQI7HHCwufjNWfw6dozeHXBIclC2Z6Md4IgmF8EvU6HAIMeRQItrZMFYf656yShl4czhNyjNx5gMaeW1Oq3HsdjVYubP8tr35UMCzT/X96vnKGZzsox4fjNRMXvF0Zd5wpkG06px05Yi6FTE54ycnInCZ0uX8hzpqvzg7Qs/LL3Gi7nuRYF++dnvZQvXNMy1T0d2N2tu2tK3UI9wT473JjZ52+t3WmZOXjlt0N45bdDSPfCGGRvxZXWjDCZx4m1qYItE6SG1ndSEAScuZ1kV3IZW8jMW7QZFcZFW+LE3I0rhbyHaVlOrx3I9tcgf0tL3sU47aVltCgLmk7djk/XnsHrS9zjDqj2PHjvqnyOvJucIXnPtAqG91Iyze6ESm1gE7m8vew4TsYkOvXd+lCDxZhdN8qVRo+ylNvygJNYRRS6eDjyViiFIAWYa+/6qJAnCAIGDBiApUuXYvPmzVi0aBGGDRuGEiVKICcnB9988w26d+9uNeatTZs2dlnytHL58mXExsaibdu2CA2VuguGhoaibdu2uHbtGmJinOPD3b1eafP/tVrybHXLPHvb/uLVIpvzaqOdjU3GSgetV78zRc7FxXT5Ypbxd9bcA9ReandRRMF1Fsjt82wbldqr9NycMf8qaZGbVy4mcbsctvCw5Ht2US1vXjCnELBWOtUuBQB4f+VJTFyfq7kvVSQQY3vUluw3acM5bD0bZ/F7uWCYYzTZpBlTKuSu0wGT1ue6xx66/oBbzsRRmk3djmmbzqPb7L2IT85A9/plzN/JJ3B/lQkIkPYZm9w1PWDJu5eaqTkDGovcnVUNVijef9l2gbIwwBt/XJlVUH5sa+fS+qppVVSsPXEbvefst8uFXg2lcdwTCpSudUtb30kFVypSm07djq7f7HFqbLno4q/TAYF5YyQb43TahrWOLQqOowpFtJ2NmtWXX+5Aui0hJVPirKn1Gk1Cfs1MpTnPIMsF8fT3URaJnFyNKNTmCnnS79JV1oMLo65bbGOVrHIcmfe/2X6Ju93n3TW//fZbLFu2DIMGDUKPHj0wePBgzJ8/H3FxcZg7dy5CQkKwf/9+DB061BPNM3P58mUAQM2aNbnfi9vF/XhkZmYiOTlZ8qeEP+PiIXZga5Oh0otr63ZbYCcweYFKW1n4b7T5/2IwPs+VR03IO37zIepO2IJJ67W5+LiK9ir1zMatPoW6E7bgYlwK5u+7hroTtpiFZRalAcUZrrFqYjKrcbqbLD3X1L/z4wHl/aedlRpuagTmxVGwyViKhfhjFONfL7Lq6C1V33hBENDh691o9cU/ms+vNMAWCTRINJWuzq55Pi5Fsji5IcvI5W9FwSGpsWdtvGC+n6UwAbmSSzYUbhf589BNzNiS7w5oy6QrL+pcGBDTiSsR8yAddSdssdjuStdHuWErmzkXL/5O6zPWqgn/PS9Rk7MX6Eqp6V15L5WsAx3zlGb24g53ze92KK+VbEW8x346nVnoyLbzvnub2681eM9Kfg3yZZTWazQJgnkNpvQTnjukPJGTK2DXCmLbdDogVZb5VW1c2HXR0ptNTciT14x0BqJngztidN0u5BkMBsU4OL1ej5EjR+Lw4cMoUaIE/vrrL+zYscPNLcwnKSn34RYtWpT7fXh4uGQ/Hl9++SWKFi1q/qtYsaLivtkcf3Kr7ppKdfIU+o6zBzM9M+EoZU5Ug3XhEJVDvIShau0WtSWswOgJ1AToFXkWz3l7rpqL2r/F0XwpvfOXneDqovbkg1QGuUzG4iPvb470J17flmsI2fPwauaxbbyd+AgPbSjpoDTAZsosXGKbXLUQ0Km0BcjPrlblo42o8tFG3E6Ulldg2/Xu8hOq5/J0ggG5Aufzv60nFPror9OSz9aew0ZGeWJPge+CTkSIv+r3yw7x495duci3jOXN7+8nOK7aWh+bVk24vYt/a8iHqyYVIwCoK4QcSeQgCILisdVczrTgDjmHrcvoKGYhT68zZ7bOtNNl0N6xfdfFeLSfsRMHr7m3djPXkifrV1fiUyUhNM/N+1fTdZqE/OyP3lIzUERM3Hb0xkO88NMBALlj/K6LUgHTVoWsmkfSb/stLX+OMvXpBgCALF+z5AUHByMsLAwBAQGq+9WpUwezZs2CIAj49ddf3dQ61zB+/HgkJSWZ/5RcO+8kPZKkyo3Nq5Nlt7umSlIJlvjkDAz+9SC2cdzhtOCs5CtAvsWEtzBTG5y8ZSGnJT7E2uBjbRF+MiYRvefsQ+PJ21Dlo41Y+p92S6oz1nDyhaAj1q1QTuyl6Db6cutKFueRn4v9pCQkqcUJKCXmyDYKKB+R6zJcNNjfrMiQP99P1pzGl5sdr9Wp06kP9nLlxSu/Sl3O2HfDWsytqyZtQRAw/q9TVu+HvA/Ot2MCtSaMsJlovWRocCuVrGQiVnKX1bIA3HUhHoN/td3l0TKWN/fzj7uvYvQyS2WX1qyAWhfnrkpVLj+/2DfV5gJHXkG16w0NUA4X0IK3LeitwZZeEr2gMux0QbdXyBu64DBiHjzCgJ//s+v39sJT4suv4Z0/T+AiU0LhzO1knGQSpigx/sk65v/vcIN1zh6GLjhk/r9eBwxoKV0v/HvFNqE7UEVBIlf6OoPqeaVffK6EQmRkJJKSknDvnvU4iRdeeAEGgwFRUVFuaBkf0YKnZKkTXS+VLH1AbumH8PBwyZ+c5YdvWhRgFLOLZeaoa6bkwcW/7L2GH3dfVRyw65eTtvXzjeex7/I9u4OJ5RYguZXBFvQq7ppqk6Y3pPMFlAUeVnO7/7J0ET5/3zXJZ2sT7TM/ROHM7WSzm5Ba9kk5ztDUyycSR5KR8DTaoivS5/2k5TSMPCGP+ajUDjXN8REF161sownN84rrvt2lJjcmL+ZBOn4/eBM/7bnm8ECtg86q2wbbL+RFiW2JQ+T10YxsI8b/dRq7LsTjQlwy3l9xEjEPcl1Gl/53AzOtZE4Ecl1Mlx2KwU97rqmOWc6whtpyu9k+8t+1+xi36pSii52vYG043KKg0NPyaIYuPIx9dsQ5yscesR9M33IBGdmWD1Rroim2P/MSdpn3c5HGXH5cUXhVcxdTKhej6XwqDyk82DEh70GaZUIKHosPRNt03CQbvCtsQbwXfnqdWTlob7ZCpbmxblnL9Zo3wFMGlwi1NJ58JstSO3fnFSSkZGLsypM4flM6/4nvT7PKxaxmdPY0rLuoXqczK2VFpmjwEGEJVPFk4nEn6RE+WHkSZ+zMcSEqJdyhV3GrkNeyZUsIgoDvv//e6r6BgYEICwtDfLznNAnWYu6sxexpZdzq0xbbxE4s9zWWw8bVpGXmYNqm85i+5QISZHEOjfPcSOSuPPfTHLPEVSkRIvnsiDYw35KXv+3TXnUBKE+MH6466RZfcC0oLfYPR+cPpmmygODPN56XWJuUFsElw3IHcEcGBXvioViO3XxokSrdkQXLoesPMGub9HhK7po5JkGSMhuQTnRKQtLNB+nc7WpkG03m58CWUJix9aJ5EcGe7/eDNzUX3o15kG5h7dLprCdBYRd38mvNkn1Wewd5/evX/dex7NBNDF14GMMXHsHqY7fwap6m9NO1ZzB31xXFJDUibKB7WqaKkOcCRYMa7Ole/Pk/LD8Sg+lbLjjcBntZd+K2pJCwVg5HP8A32y5qiuGwV5B2q7umlXFDq4cAK0x1qRupuJ+rYl/k91psj1r7HVF0qF2HWlyRFj7fqG1hPGHdWUWX021n4/Dz3quSbSMWH+bu6yhSd03HlrJKz2Tey80cOq6r4LVXS6/aeSEen649jZVHb+GZH/6VfGcWmnXWlY6PVy+hua2OIhfg5Oh0Om693jXHc+P45+y4bLWcjpolj8eY5Sex6ugt9J5jX+JHa8nUnIljqh8bGTJkCFatWoVp06ahcuXKePXVVxX3jYmJQWJiIooVK6a4j6upWbMmypUrh6ioKKSlpUkybKalpSEqKgpVq1ZVjbNzFFsmJ1aLJc/6FRHsn3c86VDgaMFNec0RR6xqvMQr1USzNmdQO3M7yRzr5g0oxX1Y05BKs1fyj9G+pmNB9QC45RNEapUuovrbqwmp6C+bFADH3DVjkzIwZ6e0iLJcOSFiMgkWRbDZ/i4XdETKFg3iblcjK8dkfu/89Dpzv8zKMWHyhrOY9ozUyihmBu3TuJzVxUb7GbsstulgPWZIrfSBfIz46/htlAgLQKfalote3vOKYQRh0RJ/NSENa47nv1vWtPFs9kvV1N9OSBltizDCswjdvG+74O8MBEHAO3+eAAB0rhNpdfHC8vy83PiT4qEBeLVtVdV97X0n1YSPjGyjzRYcFiV3TSW0ZmBlj6N03efvJOPaPefX8uKdM8dsyVO+PkfGTDWLpNyrJsdoUqzXx8OWkgM5JgGnbj3EudhkvNy6sjn2S/QIal65uNkb4vyd/OMG+TtvcZsv5OkVk9FoRWlMKRFmmcSoakl1d2h3kJiehVVHb6Fvk3LmcURrCQOl+H5REaPXS+M7TSZBknsBcH4SMjULbImwAFUPsYSUDO68+97ykwjw8zMbQqK/6qV4DFuFPC0KczXFgaP91Rbcasnr1asX+vTpg5ycHAwfPhzPPfccDhw4YLFfcnIyhg8fDgBo3LixO5soQafTYcSIEUhNTcXUqVMl302dOhWpqal47bXXXHJucSCxJcUqqy2Vx/GIgcnyBaGjMStxyRnSNjAde+eFu9wU5geu3seWM5YuQ+JAwmplRMtOjlFA1JV7+IeJW1QSCNzF2uO3JXWPlN32BO5/RVgLlT2uUM7AmltKl1l7uNud7VOu5EqXw0m8whalVXpPKhUP4W5XI4ux5Bn0Ovgx/VEs+cGrCWm3hl5nXZnDWj6suWt+sPIkhi6w1J4/TMvCHwelSTcyso0WxxN5b/lJ8/+tWeCkSaOU9+VN5vdTM7HkQLRmN0r5fd51IV5RU8trivzRbTgZy826+NexW3a74/Bgm51sp8uoFmFFrR/eSVJeLKn97rsdl/HFJvssoIIg4M/D0lh0e8aNDSdjMWLRYUk2TrbNd5IysORAtEVdySe/22fzubQi7+vZGix5jni7yBVdLHIhz9ZYogbllcNO5GRkG/Hsjwfw2bqz5mRPrHXvOtNP2VqVTzhBWSnCCiuOWkaUumNYoAFNK0VItgU4aDXUwqHr6u6SY1edwvQtFyTxsTy3Zx5KChSTWWiW1p3jjf1KY8WBq/YloPlDJUu7tZwL91KzFJ/J4ej8+6g25qgJeTw3WJZ42RpYRGlOjwwPctjybAtuteQBwPLlyzFw4ECsW7cOa9aswZo1a1CmTBk89thjKFmyJO7fv49du3YhOTkZOp0Or7/+utPbMH/+fHN9vdOnT5u37d69GwDQrl07jBgxAgDw4YcfYt26dZg+fTqOHz+OZs2a4dixY9i2bRtatmyJd9991+ntA4DnmlcAoM0dbtvZOHSvX0ai5dvOCEN/jXwcv+zNjf2Sd3T2BUrOyMamU3fQs0EZRISod2wlxMktMT0LwxYeAQBcmfakRKM48JfcIOW9Yztxj8G67BnM6etN5hpHhz7pgsgiQQ7aIB3jREyieXITNURKWlZrgjo7cSslznAkI5srsUUJoWVxo2T1PBGTaDFosi6CSgPqfRUrard6pSXviciCqGjz/w0KWmJe33PIDcvKgkzt2Fqt/aP+sExw0e/7KIRoqHVoTXPLtkGtq/IWnkMXHsapW0nYc+ke5g9pYbUt7KIj6VE2hubVdbz0+ZMWGQZ5TWEVKedik80Z21hNb9SVexiz4qTFdnswmQSsOX4bDStoX0Qrwfa7i3EpuMjRKKvNGX3mKMe4qwnn9ibmAnKzw8oVCVosAYIgmJUpl++mmJ/T8/MOYNcHHS2Oc/TGQxy98RCnbiWhd+NyCPb3w2NVi9vdbi2kZEiFdVdb8tSOK7eS7b2UgCcbltV87F6NyuJfjYt0VqBYdyIWIzvWQGUmdOPzjefMaxi2yds44629vJ3XH+6lZsJfwc1fK2r39fHqJSQ1WeVWLZHr99KcZuWzFmYgKpdZgc3RYuTiuOqnl/p3ZWQbLYQSpT58JT4Fbexw5TylokyrUiLEfL2t8t5n+brDn+OuCeQWhBcxCgIepPAFsgCDHiveaGPO2MkSEmg5P7IxgamZOeA5iivNywZ9bgiIn14Hd1SqdXsJhaCgIKxZswaLFi1CjRo1IAgC7ty5g3Xr1uG3337DunXrkJSUBEEQMHr0aLz44otOb8P+/fuxaNEiLFq0CMeO5S58oqKizNvYAuuhoaHYs2cP3n33XZw/fx6zZs3ChQsX8P7772PHjh0IDtbucmMLielZWHE4RlMwtOgiwetUpYoEolmlYuaB6SozKGw/d1cSa9No0jZ89NdpvL74aN6+qVh34raFgCGPw2MR3bHYSZ19IQUVa6OIxJKXN7iwi8OjTIybp4hl3AfEa1LSsrLWiyolLe+dq5ICaMFRt4E/Dt7UPLk4Go8l126yLppK9/CDlSe52wFtKccNTEweC29BbO9zZN1DlVATppUyc8qFat4C7kJcCooEqafc5x1LDnvtasLCXY7WU6xDpLWmHdsW1iLGu4fWtLBKxZkv2OC6Zo3Vx27h/ZUn0X32XvM2e18F1oLc49u95oUui9qClVeTTsvvkq3EhqtxLtayNuzywzGSMZQH2+e7MfeOtRLx3H9XHr2FIb8dwgs/HbDab2MepGP10Vt2eyRM2SCNYxPbrCZoO6IMEt8zXvyd3JJnax+2pVny5Eo37qdJxuNEFyVbUYIXk2ULvDHrqYZlAAABftL7qjRlqlnJbcWeadmRLJCCIJjHJD+d1JI3VxZSAShbxbRaEy3Pr/zdY1XzhUalsBKlMCFWEWw0CRi36hR3v0CDskKIva/bzsbh9K0kiZBn0OuRnJGNievOYEWex0LMg3QsP8zPpC+2VUkwdTZut+SJDB48GIMHD8aBAwewY8cOnD59Grdv34bBYECdOnXw0ksvoX379i4598KFC7Fw4ULN+xctWhSzZ8/G7Nmznd4WpUnol33XbT4WLy5JjCfaeCq3dtTCf6MxqW99XE1IxWuLj3CPcyjPxC266J2LTcb4p+qav49WiWkRNTystit3wssdKNkJ7rco/jWyljzxhWAFpbd+P4bor3rhfqq2bGCuoEhQ/quTkW1CcICf4iI/kVmI9mxQFpfuShP52BJ3WT4i2MI/feWRGPRvVsHmeMj3u9VCr0b5mt6XWlXC7wdvon3NkprdRrOMJvzfjsv4sGcdq/s6mlnxmCwbWOki+fF29hxbi2WRjclj4Z3P3iQ0v+6/jgrF1N1K1a5PKZ7BKAjQa7B3Wyu7AFi3PrDXrrarvS5/LEr3grdQq6SikHIXzizArcW9Xv6sTt9Kws0H6ZJ3nYeaEsYR/QzP3er07SR0/YbvAi7yKNtoVRFji5cEDzFGNjUzB0Mer6K6L4+TskLJ4nugpvBxxJInzhUGPx0gk6PkQh77ed/lBPyw6yp+fbUFQhRKLdjiLSJfzBtNgt2ZLa1xLSEVR288VJ3jeMrKosHWlVcivDGlUYUIAIC/QXrssxylBeDcUk5K16nTKb+Ljljy2Ov30+skfXT3xQTJ+k++P8vCf6Px2hPVbD6/mmKQDblQGqN44ROAtA8YTQK3EDoA1cRiV+7mugVfiEvmZqHPNpnw4cpT5qzFdcuGo89c5YQs4vrWXS6bbrfkyWnTpg0+/fRTLF++HPv378fu3bsxb948lwl43oYzixMvk8XbAMqDxZ1Evtmax097r1nfKY+TeWZ19rTshKc0KYsJVgCphkP8/50ky/a+z7HSxKdkYEHUdZenSWcX/mJNw01MEWaRB2lZmMFk85OnLQY0ui7l/ctzrRu76hRWHeVrjdT4X5eaqFYqzPxZjMuzNS5Qa3ZTR7P3yRcWj9fI1/DZ8x5pEQxvPXwkiclTO5+9QmxcUoZVS4LaPVZSEjizeLu1Y7Hvtb3xZlpRisUV2xjOKGCsJWZy9BZlG01Y8t8NXE3gJzMA+GOw1hIBcrQkypIrL/rM3Y9Rfxzjjj1qv2OxVsoHsEz2JaL0bqYr7C+iZdFqrV8u/c9yTuQd91D0A4tt9iDOdWqJGeRZgm06vjnrr14yZwJAkEwg/nF3vgVm8K+HcODafXT7Zi+UsGW8kN9DP71Ok5BXp4x6gi8enWftwdhVp7BaJYMxb5Fvi3WW10dFwTE7x/I7Xl93RykntXhAe2oEXs7rp+z16/U61C2r/pzEOefFltKkg/aW0FKbvtvWKIFieVnhbQ1bqVU6f32jpu+5dFd5/BbHhmiFeOhso0lSlsZaUhbRClhohLzCjrMWYpfvpnALCyu5qgfamOVKa7A4rxzEg/QszN15GTfvpytOBKwmzk/h/1p45ddDmLzhHMaquOk5m1d+zU03z3OPSUjJlJj7efs4I3nJkTwX1nUnbnOT2gBAPSa5iryUBmD/JKXVLcjRjFxydxT23bEna6OWdy8uKYOrJeZp6lcetS/T67PNK1i15n68xvK9EnFEyBNLq1jDWkzg97vyF5RqiS661i2t6XxqjP4j10Ux6so9cyIcgN+/TsYkSoLvRcTFQjwTo8EuIHguhjwW/RuNz9aeUUxMBPAn86T0bHy/64pFpk+jScAve69JEjqxaHlF5dYlEWvZE9W6YKYGN6y3/7R0Hc09rn3jm5LQyGJtTJnKqZf1DVN2SMTW7HpKiO/iMSaGS05yRu6zv6aiGLB2fINeh6XDW0m+k2fS5LnY8hbhGdlG/G/ZcUzeoL22mFzoDw/21yTkhanUMrTGcZV7ysNaxmIW3vpGfG9Lh1tm2IxNeoTv/uGX1tLKsZsPMX/fNdVzy1GzbGfaYckT3aAlljydDq+0qWL+zFNIifv3bVLO5nMCue/297uu4Epe8hy1J6XT6TCifa51cNmhGEnCNWuwljtHyj2J7RBh+4RcCfDfNfW4VrEsmrvcNUnI8zDOqk301P/xF1Y8VzPAduHykY0DCHv4j/86jZnbLqHP3P3YfYlvkfBjpFFWW2WrtkMUOLadu4vxf51Gnc82u6RGEnt9ator+cTHG4i1JC9Rqh8n8iAtCw/SsvDOnyfw5tKj3GsOzrMCtqhcDBtGt7P43hFN5Pk7yfhi03kkpiu70B5z0G1tw8lYyWepkGf78XZosEDm1smzvPe89/brrRftSs9vNAk2JbCRo7S4yjEJ2HUxHrO3X1JU0mhV3vDGi1O3EvHlpvP4YddVTYL+L3uvIeqK87LHvjT/IObtya/JZTQJeJiWZbG45WlgxcfHurRN+fucOZummtWARe5CzIP3Xn285jS+3noRfebux8O0LEzbeA6X7qZgzfHbmLbpPPp9z0+QotUjjNcnrD1q1ayoGl4wXhKjmAfp+H7XVc7e1tEy59ijINt1IR4/770qGU8CDdprzJ25nYQvN51HcoalxVqLImvq3+fw9daL6PGtslVNCTbrbzkbSnCoMXfnFYux1RpyK6xJECR9RElo1tKPlLAWPy63EtrSN3jPTXxvSxWxFPLeXnYcs/+RKgvWnbit+XwA0P+Hf/H5xvNYy/ndVYUyB6qWPCe6a1pzkxbvl9xFGMi1ZH2x6TwequSTmLXtIr7eetHssm1tHcyOoWIZGi2wrvJya+3wdvmlaEpySmWwLPnvhsQd925yvqAp79PWlL1l8so6kSWvkGCPJW/H+x0sBh6lRaJSJihbk0Swg3okZ9Bj2XUhXrJ4PJiXMCPpUbYkaJ6FHcDZIGpHBI9lh24iI9uEaRulxacFQcDkDWfNQbI8ztxOwnvLT0hqiLFodQ+UD1487aqoYVJzRRDvD29QBXIFFjZ1OE/IEwfmNzpUR0VOaQF7k7B0qFUKT363Dz/vvaaqDb7h5Ppk7L1Veo8ctRw9XqMkV1GitJiLtSP4fuvZOGzkuPqqwaYlV1o4GU0Chi44jO92XMZWheyIWhUg7y4/gYE//yfZ1nduFH7ae81isRNg0GPXxXh8sPIkTt1KRJWPNuK1xUcwbdN5m5VFtrjn5JgEPPbFPxbbeZMpb1GxICra5uK2O85bVxTs4igTxLjmpEfZ+HTtGfyy7zq6z95rdp9SQtQmW7sviY8sF1jWXm9nuveKiBmR7UFLe+xp8+X4VHyx6YI5WydgW/223nP246e91zBz60Vue9hn05iTUVWcD+1R7Ii/saX+nTWOxygrKt7uUpO7XZ4t9X5qlkSxIGbWBIBOtfPLJmixCAPAvD1XLSxl1tYCckWTSdDeP3hJS0RLC08BwIvLU4p1tMYpjuV9FsfaDKgnmBHDGWxdM12JT5G4Mmr5vbh+9NfrLbyCus/ei5/3XsOn685Y/O7UrUS8t/wE1jFKhSvxKYqmPFHYZJu0X6YorFBMm7JD3heshRV82is/DvGztWckcy5LttGkKnzLlQ/V8jKwuqMUB0BCnsexx4JcvVSY5noz4gL1eWbQXXwg2mpAuhxWS2RtYTh04WHFwbVGZBh3Oy+jJgCHUyMDllk8/716HwuiovHhan6mJSB3Il9z/DY37Tyg3QVJLVZHRJy41bJjGQUBj7KMOK2SavgHJgbjXorlIs/EaIF52CtQs31Dra4Yz+3FEdhuqNTflMZRnpaRjeUSaVOtBB5yrJNKFjB77iBvkrfG70yskdJikb0nsZyYVkD7BAkAB6y4obDHHLrgcG6x3rm5FimelYfH77J6SbYs4o1GvkWUJ+Q5qzi2lox21s4lcc3kdCBWaBD1Dbzr7F4vX6Eh9g/2t9Y0/c6MDxexlgpeDS1WMWcVZbbFkiei5P6abRRQLk9b/7/OfCHJXnLYxCsasfbc1RKGvNWhOne7vHTEtI3nJe8C+1hYl7nMHCOORD/Aiz8fwIU4vkt0jtGErzZfwOx/LkmUrPbkNdGqxFp+2DJ2U/Se0aoA0FJncMmBaAxdcEjyTBb+G40qH220quABlD2zgHwX2hAFRbASWTlSK6z8HLw4YPG9M/jp8MeI1tzjnrqVaLGt79worDl+Gwkp+Zawwb8eUlwXisKfvI82KJ8fevJae22JXuRzyTPNypv//zTH7VReDkNJQbH66C1VC7Xcqi0aXpw1B1mDhDwPI59YayukiJWjJRAeyF+4D2NM0xPWnbVal0sOq/nWooFUMr8XV0hpzgoeohawY+1S3KQXgGOuCfIJSg47MSgtwOXvdI7RZNb8vclMjGKtLTXEiZvn/pN/PgHLDllORCzLDuVbJr/eZqllFgdmJWHOGUKe2kRsr6ZTCYklT6G/KY297P61SodhxRttMLyd5WTh76dHbU6yAGWh0nl+9v/rXEPxuzimFEGWwljAtlGpVYE2Lgi0YEtWOzmfrJFqf3mLeCVlgVLMBW9B/AYnS5qnYN29z97OX/iKzy+VsdCLCy75+F+/XDg+YTTPoqWeXXz8zknMxcK6t5lMguQc9cuF837idFa92cbsOiVahnjjtTjmOMsVX2tMHmutOqhQsDrHZDKXJQkO8EN5O90qo++loePXuyTj/oA8a7pSQWseK49YeqykZeag57d7MX2Lerbb4AA/dKxtqVCWW/LikjMk90bsS3KLc1aOCc/NO4D/rj3A8IX87N7sO3+cUYCwh9Jq4deqBIi6YqnAMqhY8nhoiUn8bN1Z7LqYgEWc8lFsmRAleJ5ZYuyqKGQHa6h7Kj0m0HLaP8xn63OYqOQ26HWox4wNPEWpIAhIzshWTPx0JykDkQpjuhgPKJ9XWUG0S11elTpL5NNDa6Y0w1OcepLyvqPUl6y5Z9qjQHImJOR5GPnCRGvK76Ftq1rfCfkaELk2W8ltUkRu6WAXjFomViUhT2lxzMacNatUDHvHdsK8l5srWp3qTdhitQ1KsAG07AJKxFrgLGBpyXuQnmV2pZS7s7ZlskDyyDEJ+O/afTw2bYfqPvKJVQ1ejAU7MPNQ0xKqwbrypmUqC99iv1HTjM54tpHm82pJvKLF4vpOl1p4rGpxi1TZQO7kwlsAKvVjtVuoNf5NRE0o1qJ0kWRMk7VLVLZcuKMtwYj5vBquQcs+n8hScsu5m5yBh2lZXA1pE4VkMdYWdGxtMXH8c0bSIxFnCBzsgiU9KwdHbzxAw0nbLM4hX1AG+fuhcolQhOYt8MT6gGzfuMyJ82HvJZuJ9Imvd6HOZ1vMLuDOiv9SY8azjdCiSnFzLT+xMDHvXavz2Rb8e/UeNiskmbKV73ZYT6KRbTSh22x+gh3WLTzbKJg9ZQx6Hf5vYBO72jRh/VlE30/H+L+Uky7JYS0cYqKtv45bxnytOBKDC3Ep+HH3VavW8sGtK1ts4yUmYt9V8Zjy95e19sUrFKY2KVif2feLl22bh/z9FgQBV+JTNL2r4jqBNy/wsKWERJTGovNyeHN33QlbMP6vU3bXyVt3Qj0e8yLHwii6a4rC1zt5br29G+dbxMTHWHX8JjSatA3P/PCv4jnkyj2RoDwBSR4Dyl5reJ5SkZdMTtJm2VpAKsxavgM7Za749no63El2Xv1EeyAhz8PIY+NCFbQw1WXpkptVitB0fPEllA8OX25W1+BtOKWc5ELLAKkkkCjFAsq17ZVKhCDI309RILHVS+fA1ftcV8IdGgswy2HdDYBc90gT48LAorQoFck2mjCB47/OYjIJDrtTucqSx/6OtUpcTUiVxCOJC06luMJTk7rjBSYls7Vg6DtJGdh46g5yjCYVix1/OyuI9GyQW/R2YMtK3H3l8S/pWTmKz0KtCHCqgk+/Emou++mMMH1SIRMjm6pdnmJcjAe4aoNFANA20WnRnoeqZNlLychGqy92oOnU7dzxItsoIIlzn5f+d8NiG5A75mTlmLjxgEqF5K2x5cwdfC7L3NhLIfmVLRQLyfd0yMoxYerf0njiX/MyKMsXz6IiomaeJ4iSMMhycmJ3rB3VFt0YN09BEHA3OQO3Hj6CIOQrvFxVAw0A2tcsiQtTe0refZEco0mxPw36xf54Px7WrEMX41Is4opFQeql1vljx+6L8eZ+a/DTo0nFYmhZpZjN7ZF7q2hRnqwf1Q6T+tQDAJTPc8XmZaVk3ytr7ysv8YhccHyjQzVJHxEVCnLBg/2spJxim8MmKmNd9tg5Z/qzDRXbLj/HX8duo+s3e/HWUu2WfK0JMpQ8Knjs5dQm1eLFpVSjeNmhGPMarXR4EHcfJVihWmvGR7aUB5A/pzt7nFg4rCUAyyLo7Ho0LE8ZevyzbjjyaVfFY6kldxGtbQtebYkKxYLx5+utLd4LW5W0IjEP8tdEtoRHOAsS8jyM/KVQekHlqYeVij/KEbUVti7g5e0SF3dGk6BJwIpVqMOnNKEoFzl1Thcd+Mt/6D1nPwRBkLh98GKztJzzs3VnJZ/Ts3IUhShr9yvHKEgmEp5GKsdkcthSILr4KMVz2BLnMfCx/AVZuxoluft0mbUHQxceNgshYvuDFYS88CDpdf80uLlqG5YduolRfxzDogM3FC12SgOz2J9zs2fmXnex0AB80L2Wxb7+sud5NzlTsR8PX8R3QQKgyUWatRqqxcosZ1yw7itkMVMTyKxlT1Pi1kPrWkktcXRq7nHspMhzy87KMWHYosMW2xcf4At52UaTYmytFkue/HoeZRnx5tJjFiVr1GotaYXtV59vPK8Y08az5AH5izTxOGqLLtG1ilUs5pgEiVuV2Ae1hgfYQ6BBr6j4ycgxuSQhDI9/rCTR4SXlEReObOz4HwdvmvuVOL6sfPNxm9vDvv0zt15EmgYlkV6vM3sA8AQJHkpjpDjGFwmy7n5dLCRA0tfE2HH5+8vznJHDZmhm51kxKyEgfU9eaGGpHMjfT9r/f9l3DYD0WSt57pTNO5/WBBm21BPmwV5fmbx14BO1tOVeYJn5fGOb9i/FKFO1rreMsrWOOJ6zQryjIb7TnmmA5pWLS44vUiUvXq50eKB5javT6VA8hB8OlNtmy21jutXCiy0rmt3RO9WJxP5xndG6WgkL7xdnxP9aU/i7AhLyPAyrkX2tfVXJi87StJLtmkAAENfttqZr/Upm6RNfakcFDaXFuNJy1hbBQwvHbibiTUaLx/Nft+ecj7KN5glfbn1US0YCACMWH5Fk6+ItgLPzrBH2ciU+3+VCSXjgbVeKxXmmaQVz7GGalXpWolY3311Tm49688rFNE1YU/8+p2zJUxLy8rbLr5lXLoGXyc4Wrd7Pe6/izSVHuZlV5bBucXqdzq5kAyKsACM/zq2H9iXESNJQ6FxLOQU1IZN9BGzGWLGw7f4r9ySpsa2RlWNSTPyiZeI+wLhWCYKAug64iluDHV/XHL+NBwoCvNxCIj5ecZEmHufLzVJLoOQ3eZ2C7d9ZOVLLmbiA0uIK1ryy+hzVo35pDOOEGagVRc/K0abckidJsIdD1213oTOPI0yfNQmCuUabrUpKk0nA6D+O4ftdVyQWuLm7rmguRSF64Wh13zui8C6JiuWqJUMxoXc91WPkGE3IMlo+R63ZNEWMJgETZQpUEV7MX2iAn7kfs9kQ8/eTWWM4kod8LOlerzTG9qiNFnn9WauC/E5ShmIyGS2wc1XpvHVg2+rqoR48akSGSTKaWuNXTn1la5jdkfPWSuJ4bos10xrsOkq+JhLH8zHdpEpZvV6HWQprhhyTCV3z3OH75LmVvt2lJr56thHXaNJCZn2315IHANveewJvPFENU59uYN5WzIp7qbMgIc/DiANXmfAgfNKrnqL2o3W14pj/Sgv8M6aDTcf3s9OSJ1/8KPnYK3E2li/YKC2qBrex9PsHnJvIAgBe/PmA5DNvsSk/Z3xKhiTLF09weJRlVBQolJLNKMEL1N15IV5TrKCIPO7tfmr+YlFp4cHb3kJh4eanz3cnlCeEEQRBMiCKlgJRu2uL4KK1jqRS0g0la5ZokZIvhNiJRYyl5BUt1pJ8KDUzB7O2XcQXmy5gy9k4TN4gXbw8mecmyhIamP/s/fQ6q3GSai5mq5hab/JJzN75StRq37jvWGYwNUte7//Lt5iImv+wQAPG9qhj0zm61Mmd0DMVxqzbiY+4AoT8PY5lXJCPK7jGOgstCaViHqRbKHzEmo/ioku8BmvxNoC0z6dl5UiOLfYvcbH+WvuqiiEF1sbqRhUiJG6NIv+qxCdlWbHkiad0lTupIAg4cztJ8bmICix27DSaBIklTwtpmTm4EJeMQ9EP8PepO/h660WLuZatCalGBw3WH7XariJhgfmLUDZxGw8lJaQtFuCNp+6g4aStivVL2THeXBSeUVBU52RoZN/vy3dTrOYimNC7Hn5+pQVGdaphHjNtma9WH72lOCZbU6yxfUycP+2xHvnpdXi3q6VHihJa4hvlbRMvUez34jpKyYPLHthQAqUEYTzF9LNMJnmWN5YcNT/TxzUIz53rSMsv2RsuM/7JOqhVugjGP1UXxZi14JZ3n8DXz2nPQWAvJOR5mOWyWm28+itA7iKta73SyqlmGZ5qmL94NNfVcVBYEidarcWef9jNn5CUJmz5CyXi7IKR8sV5BkfT+CBVqj1/bNoOtJ+xy+xG0u0by+D7XEte7v/llipbrZ9KC2C2b/C0liydakszTrGLfK2T1gstKii6Bet0OkXXvSyjCRnM5O7vp8eZ20lYEBUNwLbMcJqzqCkIXYeuPzAncmBR6p/sQvWr/rkDsNzSsO9ygiYhp9s3ezBnZ35ZC1ZRcOyzblzhn3XL1ut1qi6bgLqw+dOefPehxZxsbvbw79XcGkUzODXCbEHNkscubMRsggY/ndUkOvK4ZdFK/5PC4rjtVzuR/MjSuirPOMhO7qk2JD8CbKvzBwCzFepjsbSfsUvRwieOlzlGQfO52Xf8sWk7ULlE/n0UPTrExXqXuqVxYmJ37Puwk8VxDl1/gPUnY9H2q52Iz8v+yk47gQY9qpeyPn+xHI5+oNrHxa4SaEOdOyXYAsciK47EoPec/Xht8RHVmpvsNGUUbK9nV3/iVvT8dh92MgKOlhqfVfIStbHDRMe8sV9JGAeAxhWLWj12EU6mRCVyTCaJkBeSd25rmQe3MfU7R/1xTNWqy/YD8f/s+oDnVinudzImEd1m77WqnOPFH9pSz+yXfdcllrFNp++Y49LZuow8jtx4iCt5SgNxnVS3rLZs63IaV4zgvqP20odxVWbHZ3G+TM9TxrElnmwd++Swa0WlZG22GAFuPXxk4WaqhlxBY4/b+Io32uANhTIkpcOD8CQnq6ezISHPQwhCruZrSV6yADEl+vZz/GxhPC0ZWxeJ5UUmgcTdvOM66vYoWlTsdfMSORzNTzuthJMNeRZkcjS0Ixbz46ou3U3F9Xtp3Pomoq8/AEkNw8olQswpjlkCDHpFlwotC5ZKnGLmLHK3OnYRoDT2yoWOZ5tVUBQy/HQ6bkA/ILpYsUk/+PEsLErPWes8oeaaNJoTj1VNwb3rJFPbR1yoyF1WF0ZFW01cBFhqSMVF5AstKqB4aAB30mC15346HZS8vXrUz333We22PKsrizyzotaU8XI+33geK47EIMOKi641Ag1+ZpcZNcRxz6DX46FKUhvAUqsrKlvU4ggvx1u6lv4si62xNekUi7U4LzlaXHoBmBeDcsQFaUaOUdVa++fr/NpWgNTN90JcCpYdumnWqgca9PD306Ni8RDu+PX2suO4nfgIj32xA9lGk6QN9vS5jafumO9/CRWPCKU4X1tYn5eReM3xW3ht8RGkZeaYFVP7Lt9TVbCyfa9CseB8SxMzsP03vovF7y7fTZEkEVoQlS8gqJUiEYWRX19tiW71SmP9qHbm70RvACWB5sztJEX3dhZbymZ8v+uqpAyB+MxYRVMvzoL29SVHrZY0EhHfy8wcY34xbmZdk8aJ9xOfwz8qCdbY+8xz+y0RFoi3OlZXLWnDIq4F4pIyMPL3Yxi68DDGLD+hOF+ydM1TIJtjPf30ZhdnLaVp2OyqFa2sEWyBnT/OMF5a4v3njbFpKt5NWmB/q/R+2+rpxXsvlZAraLS4a8rHqMeqFrehda6BhDwP8eGqU2jx+XaL7f2b8U3NPHe0r5/j+x6zHZ9dJDmCqGGrUMyxgWPpfzet78SgNcGMvdiSdviFnw5g+ELLhA8AcIapb2Xw0+H3Ea0AADfupyuWFVDS8gYa/MyufGIckhxrAbzymnvsXVRygQyRaX4NfjpFi4ufXqeoOIi+ly5ZKPLSbU/uWx+d60TiyKddMblvfez6oCP3WFrniNRM5YXCf9csFQurFDTMbKILUUjoVq80KjOlTewtYireX/G4PFecUkXyJwkDx5InPvcLcSnYcykB8Yz14c0O1THl6fqa2qJ1wcLjw1WnFF2qtBJg0JkFVU37++msFiWWv09akstEa7DIsgocnrWHRe7Wd9GBGB015POBeG/O551vwrqzinWppj5dH62rKbsridZTETaFP+tKPntAE0zoXQ/fvMCfhzrN3C35LMb3rR/dFpP7auunjStGmK9VbUFnr9KCx3vLT2L7ubuYv++6RMmkZkk26PVmq1qQwc8i+yCQm1hDPp7fSnyEB0yiEVYwu52orFBdO6otAKB6qTD88koLNKyQb5kTE69kGXOta3VkdT7fWHIUH6w8qXjskR2rY+bzjdFKpY/w2MJY5bKMJgvlptL7qCXOV+TG/TQ0nLQNn67N7ZPsHMTL6C0+BzVlISs8KRU0H9ezDt7vXltTG8UxOzYpX/DhlbFQQ5yj/XQ6jO1RGxP71MPf/2tn5VeOJztRP3buwQf9kj8+iO+kfO0A5D7X6h9vsvt8VZg5V6n2nzVPFzn7Lud6oqhZjEXkgqAW11lHM6C7AhLyPMTmM3FcrS2vKCPA78xFQ/zNGaBEPuheiyvkORrbNml9bjwRTzPTxsbJwJvguWuqoWWB76fXSQbbQzzrpaAcr3H0xkPMGdgU/4x5Aq8+zo+FiLSSJlkcxFIysvHJmtM4HJ2/4FMS8uRCm59ej5da8csK6HTglZYBAPSZux8zt+W7nS3iZD0c8ngV/PZqS5QMC8SQx6tIXMRYeO4zPJTcnJVQyvLGDuyiMKbT6bBnrDbXl74q1qn4vLIb4nF57xKb6SzQX28RkyfGh924n44hvx1CR2YhPaBlRbzSpoqmdmoRgL54piHmDmrK/Y7nCja2h7ZFEAA8yjKhcx1tRWyBXAHBWlHZq7LYSS2a73SVuo4ibNr8j9eo1yyTJ42wt0SDNeTjltin2LY+N08afyxi+ey1t5H1MogICcCwdlXNmQDlyLX7ovWlUYUIbu01kXkvNzP/v3ioP2O1Ue6zxVSy6tnLg7RMczFmwPoiT0xvv/rYLfO7bS0mz2QScFXBKstTTgG5Vg21AuvsgvtRltEits9aPF7raiXwHCeuafYA7VkbBQEWZYGU3B5vPXyE8X+d0nTcH3ZdRVaOCSdv5VqT2D7RgxPjnGPMTdwzd9cVi+/M++QJ7+1r8rNEs+zmKCOLyDOf5/2rZWzhkZFtZBL66BAc4Iehbatqssw5MxHt+CelMdCiQpwde8SssiEqJXHs5cXH8tcepcIC0ZHjOaC0rrU29u++aF1JKR9vlOL+RXo1LCspoTS6k/2KVGdCQp6XYWs9HfnCfHTnmpKOn22lALZWRHcdnoDAe/kKCq5IDe6n15nvuxICBFWtm8FPjxqRRSwyPGlF1KLO3HoRvx+8KYkzUhLy5IOaQa9TLDDqp9epWkHZZCzymLhXFJLs8OhaN9KcxVONw9fV3YBXH72FR1lG/HvlnqrL3cvM4tMWxYhYm2r9yVhJnAmP5DzNNW/RyE6WgQY/i/jJcIXJS6/Lrz3HS+gip6IVi3z0V70wqFUlxQU8L6OqLa7cNUuHISTAgLOTe6guWPOP/ciq1lbu0i4vO8NDqfwED6V6hCzLj8Tgi03nzfG7rkoIItdEq7kyypG/57a4VPEsZlrjziSZY5l3S/6cejYoa16k/XXsttX6ngDwdNPymtpgDTYTsgDILHnK90lpHpHfG/nQO3zREUl4gNzqxj2mlXHJ309vFuRvPEhTjFdWQkkB9EzTCtj8TnvNx5HH4ykVFR+76iSWHYrhfieHdacHpKUreO/7c/MOYJiC9018cgYEQTC7mWqJ/69SMhS/Dmkh2fbjy9JSP7F5bvpak4bJWfrfDbOwZqtyXh4Ht+DVlor7lg63VKCytUTlaw9e2In4HjvDXVoOm9tAp9Nh4dDHLM+vMCcoKadFtCg55fde7v4sV1rIFaLhwc4XfO2BhDwvQ6fTcbXkSm6L/hw3TLZzigtxvYNCnojY0dmXRKnsgyuwViDbVmxx19SKn05ndWKtGVkEm8+oCwOAZRFQQJuGSFwEXuFkhmxYPoL7G97iQS0T5+fPNOB+Z426ZbXHeuh0Onz0ZB0Li7Uca2Uc3l95EnUnbMGg+QfxfzsuK+73dJPy+OSputyYpf4qC0n2nXt9iXqhXXEh90H3WggPMpitGl3qREomjoxso8V7qyS4sM9JLTYPABYMbYlIzgTPQ8lNhkdogPZJTawHGhpowEcyjbESWlNO14wMw6FPunAFEmsJi9T46C91K57Iz3uvYcyKXHc4V3mbyzMtaqllJiJf4NhSPJlnTdUa760knPC2ii58B68/MLt+q52nT6Oyml1A1RjB1LmUL9LVLHn1yxXlKlfkljxry36ey6HFPhpqzYnKhTtJGZpqQbKoLYDt7c/LX2+NAD/+WMLWxbSGvDyLvE90qFXKIgGT6KInJz3LiPF/nTa77mtVhLMeCGtHtUW7miUtsjWmZebYYB+Xcjvxkbnv2bpse5guVVp1YtoqV8Z/9ax6Zkf53P8o26iYTMXWAuxqRIT44/UnqmnaV0kIfo8prcCbDysVt73kijxWe/uYJySf5Wt0raWiXA0JeV4IT6BTfNc5X7BJOaylYLeFqX+fwws/5boARQT7Y+6gphjSpjJ6NyqHv//XDs8qxBM6E2cvmlYdvcUN2NYKTyD30+usavF47jBK/PBSM8lntXgaEVHrJm9G6fBAxUmcN6grLayC/PVoXdU+N117FJxsTBwPW+I6lIpmi7z2RDXuPa6k0Ib2NUsiVeaao5YKPyxvQV65RCiOT+iOqf0a4OoXT2H+kBaSSSs26ZHF+6sUl8a6lXWsre4G2bpqCc2xrtYEt6eb5LunahXW5GixPAL8IPYuHJfPy/GpiCwSxO3njrj1PdJQjFpk54V4/LD7Cn5UyOLqbJ6xwZIlf8+Vsr/x4N1TnqKRRy0FK5U/55i9GuWGLYQFGswWNINex03eAeTOmUMer6I6P1Qrpb6wq18u3JwADQCyc6QDlVFFcRcc4If3u+cuLNl1p/xeW8s4mJiu3bKshY2n7phr9mlFLb7RioOK8jH9/TRZT2xFbn1bOLQltr3XQdNvTYKAP5ns5rx+yEOn0+HaF0/h2hdPmWOk3+lSU7JP4qNsm4VrkcrFQxTruLaroe5SyosZ/mvk43iueQXMfL4xTk7sjueaV8DvI1pZuJnKkb9L6VlGDPrlIHdfpSSAttK4YgSOftoNHz+lTRmnZHz199Nj4dCWGNCiIjZxrM8vc0q52MKCV1uaY1+VYENkPAkJeV6CWrYzQNlaxnMhKRkWiHe75g46v6mY622FTQ0cn5KJ3o3KYfLTDeCn16FB+aKYpRCAz8Me99G+jctZyLQRIf5Y9lpri6DkmhpKTQC5wsGoP45JXAobM0Hs1pg/xPL+6nQ6q7WKhjxexfyM5Kwf3VbyuaEsGFyL5jzLaEKO0WQhbKoljpAfNyTAT/E5Bfn72Z2x1ZpvOw/WgqAltbga9i42eFaM55pXwG+vtrS4z8MX8V2Eco+Tf362jqVOp5NYC/o1KW8hjCktcllXEmvu08EBfprda6xpaIP9/bDp7fbY8X4HGPz0eEJDjS45Bj+9eVGvBk8w/fXVlooZzHiuPPY++5gH6ZpqI7LM2JJfZqJ1NfUsa47GTL+sEuMmJ1mmEAkLNGCmQgFhOTwBQEs24PmvtLBwy/3uxSYoGRaAX15pbrF/9bwsh6mZOWavBD+9HnMHNcUfeUmteKjJUNvefQJLhj+Gre8+gfmvtLD4PlxmDV1+JEaSVVDJBf/S508CyI1RBKRxURaWPCtdyJpHgq2sPxlrs7Ch1hdtKavAotfZ/+6pcULmQq3T6TS/S/Klk78N76Ber5N4Wcg9LlIzcmzOxCtSjMm8LL+WeYObo3OdSMUwCh7NKhXDzOcbo2RYIIoG+2Pm843RtkZJrnsq+4zka4VHWUYcUKjV6yxPscl969s0Fqq52HasHYnpzzXi9llrApqIUgboTnUirSYCc7SWrLMgIc9LYFP3ypNCvNKmMlpW4S8SlOIE3u1aC9e/fMquRZc7mDuoKSoWtx6Lw1K7TBGLhVuZ8CC0qV7CQgguX0z7sXdfTECLz//BBytP4mpCqjmo2xolQgPQpnoJDHysosV31kz1YsHSH2VWOiA3MQGLPHOV1gK76dnqadTlyIW2+uWKKlp8Ag16u+M87YlTGtq2Sv7vNU6eSiUqbKl7xMJb4D5Rq1RuDIzsmGw6cYvzqyx2xDTuQG5JC/kt1rII1Ol0VpMIqLnMtqicH4thzV3zz8MxqFcu3Fz/bOGrLbkxdrUZt+MFQy0VI98PaqbJjfe19vmJiHa+n6uxD1dYeDpTyGs/Y5emAtJKXLrLT64hUkNWP05uvbeGuDB6WyFr6pLh+fEsPKFM65jCewe0vE9dOZr+p5uUx+FPuqJ5Zcu5jbXMi8XSAw166HQ6PC6zZlhbbIkY/PRoX7MUapcpgrYci4jSAlbkr2P8DIlin5IvJkXFDYu9mXkdwdaYPLkFk6Vi8RAMshLvxKNqyVCnZkB1Bh+tliZ7caQmr3yseWPJEUz9+7xdx8rMMZn7v9wNOyzQgN9ebYnjn3XjWuKsWatZeNfLzulNK0VIvkuzwZNBjhYlHgCrdaDllkwtYw8v5ESrgnrOQH7iMYCv9GX5lWMA8ATe9dYVYljtBWtJiv6qF6Y8rRz7xAp58oxl8gnmva61IOe9rrVQMiwAjSsUxV8jH7e53fYSYNCbMxFqKfAO5Gqk5Os2UTMqdxmyp2TEqqO30GXWHs37780rNmqv0ABYBubzBEb5QttPdm0NyodzF2mJadm2JM6z6Z4F+fvZXd7CnjhI1gVx76UEiSAiIr8H4xVcPuy1mvBccMW06loXmoC0KLqcVoxVyt9Pb9HWTI3ZYL94pqHm9sj5P5WJzRp6vQ6TmNio0uGB+PGlZpI+3EnBnTRY5R52rZv7m9GdaqJtjRKY8VwjVMsTjJQsbOmcRUmAQW9T/S9noVS8XAlb3EpZyxYbi8LSvmYpvPp4FTxWpTiebGC54NL6TvDeeUcKkSuNIWzc2W95tePO3eFn0F0/mp9aXk3B6QqBI8BPL5mfHE125iysJQGTw0vIwfLq41VsOl6TihEoEuSvWZHgLo7ckLrTaU0gxEP+qKPvpysqhQ5/0pW7XRRg7qVmmq3XSlkidTodlo5ohcdkyv+fXra0iivBex5sn5XnP0jVWMOTx3cDmuD4Z90Urx3IteJZS5b1ZX/pvBaowSOFN7bZsmZTSmrFu38T8xKwAdqyO7sDEvK8BPblsmWwYQsu/6+LekKOd7rWxAfd8xcBF6b2xDtda+LIp92wbnQ7NKskXTg76reshl6nw9tdamLOwKZYbsVVddcHHTH/lRZoU72EhbumuPCWZzL6tFdd1SQtL7RwPH5QzGaoJVheCflCgJc9MUimMZL/plvdMtj4dnuUDAvAhN75g8yMrRdsyvClZaG38s02WDuqrUNaz+qltAn1Srz+RDXudYUH+Uu0j0ouifJsn1o5cNVS0y9qcG3RlavF64llCGpEhkGvs9QQa80Gq5Ruu2d96/FvobKJdmTH6igTHoSd73ewugCUc/DjrniyYVlM7FMPxUL88VV/ZeFTnlSB5dsXcwXPoiH++H1Ea7zQIl8ZInevFoWeTafvWBwn0E+PP19v7fYFOM8FfPGwfOtaG1niBp7SoHW14lwrKWvZ4glNm97OjUmZ1Lc+VrzZhmvNdOR+OKLkUoI3pip5AMjHR5HW1YqbF13ybHvOci9j0el0krY4MkbKacaMa805Ci45osW7X5NymtyMG1coir//1w7LXmtttTyPrQWuxb6v1UUOsC1m3Vk48rhsURwqubxeyKtxybp5K3kpALnxayvebGP+/EzT8qjJSdSmBNeSp3IT7iSpezKoWXgNfnoUCw1AqSKB+IxZo7BoSaonn9fsHXtseTeVEi7xxtr2NfMVS65wT7YH72gFIRkkrAVnKxFZxHqGI9aNUc2lMNCgx7iedWx2qdRqlatcIhSBBj/0aVwOJay83FVLhprdfeQvlnin5NurlAzF4U+6KB7TmXWVlAqdapmo5OMEr9i8fEEiWsJEd8TnWlRArdJFcPiTrhjWLt+dbcuZOIvinErxS3KUYohaVilutRC7En+MaIVPe9W1qQg2y+Z32mNsj9oY062WpB6YSNFgf6wZ2RZT+zXA4mGPWQgrImz6eVtiTPiL49xtJpWFj/wdUmoXkDv5XP/yKWx/7wnodDpJ/xjSprJNWcza1sgVHFjtJ7tAFN0d5cjdgD7sWQcHxndGtVJhFn2al2ylVbXi0Omk6eCbViqGY591k9Q+kqNWoFZNwztSlm22Qd6ichQnC22AQY8iQf5opdC/tWbfPPqpVCM9qpN68pIwpp/Ne7m52ZV+49vt8L/ONfC2LHGDvI/0qF8acwY2s8tltJ4Gy6Wd4UMAXLOY+Z+C26kI6/KrlJrfZBIwtG1VXP/yKUxTsWyzoRJaUUp0wwrn9sYsy7n+5VP4a2R+nLaWREXiWsAoaBPK5g1ujgbli1ooG3jIwwf2WqkhKs5fWkqaAMC6UW0x8/nGWMhx65bzYktLzxd7+fuUpVLIFShZke+lWlr7HbEuWoNXuFteDH4lI0R+JqsBKucsU35EDXEOkQt14nxlDVZ5a68XgS1CuXxu5/1UVGTUiAzDl/0b4rdXLWN+PQUJeV4C6yo3smPuBKcU9OkIfRuXx2vtq+Lnwepm/an9GqBIkD9C/PkDs1LMyCeMixyvcKiI1gFfjlwoUrNU6XQ6TH2an1a7mIa6UmwcmBwtkwu7yC0SZDCXAWDN/3LttJbjJj3KnQx+HdJSUmdMLujmmAQcv5ko2dagnLakMmzGvS3vtkf/ZuUR9VFnTb9V4vEaJTGifTW73Tzrlg3HqE41EOTvx61vJhZOH9y6Mp6oVcpiMcJj7ai2VvcR4VkGRaFZbRklv+fWEsfkCne594hdoE3qWx8vctx5lVgyrBXOTu4h6VNsbBS7uJ3Upx6eb14Ba0e15Vo5xPbI4xB4C87wIH+cm9zTIhmSteeuprVWI8jfT+LmGpL3nLrULY23OkqFL1GDy8ZMftW/IYa0qYzfR7RCN+b+NFZQZvz7UWeJYmpMt1oYYsWFTdp3BPO9qF+uKN7vXhvFZeNRrdJFJFa797vXNvdvFp5Vx5a4HBFHajoVCfJHb40xN1qRxyXLYRfKrFaeXSiKU4NSv7v+5VM4+HEXiz5ijdGd8oXyajIBkX3O9oQM8LBnvBRdyf4+FWtlz1zKFtWuzK1cQnrN1hTBooeQVqFXHLc71o60yFopZ2jbqqrf2wJbyNpWHmr87byXm9s9/1nD1qOWkz3zl1tXwixZAialXBA8tJa3Khrsj3NTeuDA+Pz1xOZ32psTF1ljKeOeXtyJynol5GEfvFi76oxxY+BjldC5jnOyjToDEvK8BFaz0LVeaewf1wnfDmhi9XedOSnErZ3nk1710F3BbWvuoKZ4vnkFc2r0Ee35g2hKBn9QY+OtKqgkP3GWkMeurkWXFjbId3CbKtj3YSdz/J+IluyCPNeoyiVC0K9JOXzMaPwblOdryln5c1jbqlgyvBX6Ni4nyaTKJhGpVTpMkxuBqG3T63WqViEeWidaVjCpUyYc37zQxGrRajVXPHcgt8ppibuxxXX0mWb52vsR7ari8CddzQtvNeP7hz2l1i4lV0oeo/MsGv2b5WbaDDT4abbGiv1Dp9Ph4uc9cfDjLhLBjl1slCwSiK+fb2zVSivXgCpZcYID/GzWQic74PY8PM+C3aB8uOS843rWkZTf4GV2DQ00YPLTDdC2RklULhGKQx93wZ6xHbGK0WKziEW9xbp9Tzcph8giQdilotQKNPiZrTxNK1kKZkB+PKZYiubDnrXN34njgjyrHi9+8hdO5khrtK2unqjHGu9y4r0dRR5jPntA/gL09sN8iyY7Zk7qk6/U87My1ul0OpQOD0IbDSVpWIoEGVC1ZCgOftwFm9+VpmdnvWOsuYVf//Ipm84rZlm2lj0XyI9VYselTzSmpdeCqJApVzQIOp1ONZv1/bz7wCqsXmpVSbH2KTumvNu1JvZ92MlC+BCxJRbaldQta91NsmH5ouipYIVtV6Ok2xPTyGP9P+/XkKtIUkL+TOTeCEuH5wpj05+1XBeEBBjg76fHx0/VwahO1W2qndusUgRef6IaPnmqriZlvaMMalUJO97vgO71SqNv43KS2oNm7C2K6Aa8oyR7IUWnyx+E5TERPLc9Hr8OaYGtZ+PQoZZtwp4SvRuVQ+9G5SSfx646ZbFfm2r8RQG7CFFb5Nk7OMsX07UZa9nqtx7H1YQ0VJHVM6tYPARlI6QTihZhqh2TofCbFxqjeqkwNKpgmXHy7c41uQWwWXeIQH89akSGWSzKMphEGvc57ho8tLjlKvH3yVjVGjQnJ3ZHelaO5sG+a91I/HM+HgDwVKOykoLRAQa9XZk0tbDp7fb4YOVJ+Bv0OJmXRlvufqzT6VAsxF+zltUabCmLHg3KSO5Rx9qlMOVvy9+8+ngVu9zBRAY9VgmtqhZHFUZ7fuj6A4v9lMpxiAQa/FA6XFmxodVDXG4ZdhW1SodZzUjJ0r1+Gex8vwN33GRrDWZxMgfKx15rMUki+8Z1RmJ6lvmcas/55daV8eWzDZGSkaPocvv7iFaIvp9uLubMWk3FBSBrbZj1fGOu4qV6qTBM6lMPkzac03QdQK5CYN+HndB+xi7ztsGtKyM00GBReJ2HmtLu46fsq584rF1VLPnvhvlzuxr5wg07NrMJDmqWLoJyRYMQm5SBbhpLrdiidAHyFY2856glEUT+cawr3NistH+81gr3U7NQRcN4IldiViwejBHtq2LaJvsyPspZ8WYbzNlxBe91yy/V1OWbPShXNAjVS4Vhx4V4876iInL9iXyrYv9m5ZXT8TP3RafToWLxEMX5WinkZGjbKlgQFW3TNTlCZJEg/DOmA7p+w0/ctuuDjhKhNsBPjyyjCfXLheO7F5uiSokQbDgVi/eWn7T53I0rRuBkTCKec0KeAR6RRQIRn2KpsJDXFZQroNrVLInor3qpHvv1J2yzogO5fUJrHT2RX4e0wPBFR2w+l0j1UmH4WUV5ZkvuA3fjHWqQQkoks0i0NxBcp9OhZ4OyVlOd2wtPGNv3YSfFwtCtqhbHsLZVMe0Z5YyggH0uKABwi9HgPtO0PKb2yz+PTqdDjcgwrnA5WhafU0xDnRl2YV21ZCgaV4zgtpuXLAWQai55Ge0AaSKNzZyinfYwTMWFJZZJ1MOjaLC/Ta47rEuxPJbLVQIekBtntOmd9mjJuKvxYir+/agL5g6yP1skC9uv5IuOaqXCsH+cZWwKm23LHnL7dBHJueXXE2jQ400bClrzKBGmTSMqt4TJ3QwdYVyexTM37jLfimUt3k2kWqkwrmWRdV+sl6cxHs/EEtob9xIWaNCkjNv8Tnu0qV4C4UH+qtZwg1+uIkjrGKMWj6JUV1UN1hK+YGhLTOxTDx89WcecDEgNef+J/qoXrn7xFP4Z8wRea1/N5rbI2wNIY8HKFg1G1EedcXpSd4vf/fN+B+z7sJNNSSicBS+jK8vAvJhUeVyyaL0VERNKfMF4RxQJ8tck4AGWY2/Mg0dOdROsUyYc37/UDDUic+9xxeIhuPT5k9g9thN+eFkayiGOlaxbbPPKxRGqkIglkpPcScnKpeQi+Fkv28ddR8tNKeUjmPdyM1QtGSoRSNeMehz9mpTDvJebm9cs8gRC8j6hxIo3WmP3Bx3xuIPWeCXkGS1F5Lkj5G683kQXB2vrWsN7RTyy5HmUxhUi0KxyMU0Ch6eQTwzb33tCVfOp0+kwgbOwfaVNZSw+kKuV1Vqo3BqzNbizisjrzZS14noISCcWNX/zVlWL47X2VbHw32j8PDhf28MKeUpa/h71y+CTNWfQqmpxzRYEa6j1J3lhdUdhFxNsX+nVsCyO3Xxozv6qNajaVqwpN4ID/FCtpHP6G2vx4aVPrlAsBHXLhuM8k+rdFfEXvRuVQ9WSoahQLASpmTlW3WjVmDOwKS7fTdHsssYKt3vHdrJaK8gW3uxQDX0al0X5iGDodDr8+1Fn5BgFVbdvLTStVMxsbS6a926wCQbUMksOaFERy4/EaD5X8dAAi3IJtrgisbCu3KGcfq5277vXK4O3Ola3KUlSeJA/KhYPhtEooF2Nkmbhd3i7qriXmqlqGfP30+OphmWw6XSc2arnp9eZhQB7kMfUyq1TSv0+JMCAkOKuW9r0bcxPugKAmxCK5YtnGmB05xoolyeELx3eCjsvxKNvk3JYfeyWeb+Vb7ZBZHigTQo3FnmtXR7NKxfDUVkZAWcQaPDDb6+2wLCFuZYT0b20RZXi2PxOe3MsmFyIb1OtBGa90Jjbr5UUGkoJNPR6nWQs/mdMBxy4eo+bPKRRhaJoXCHCarIfe+nJUfDWL1fUnDFYRK5s0horGmjw0yz8KzGup7K13VrNX5aXW1fC0v9uuiTjrjejNdeBJyAhz4NsO3dX1QTsjVSzMf393/9rhz2XEvD6E9XMQl53O7MrOpMmFSMwtV8DVCkRgo9Wn7bIWicuNH95pQUS07OsCraf9KqHT2TaQzFxQxkV4a1kWCDOTemhmAZc5OfBzTFu9SmLiYGHmoZfjLV0Fk82LIv/23nZ7Eq1dlRbHLp+H8PbVcNfx26ZXX0XDn1M7TB2wwqZShafR9n2x3qxsBOXPGhdZPGwx9By2j9OOZ8a9fMmFUdr8dia3Klr3UhsP3cXABSt+fai0+kklrFyDgivLCPaV4VOB3RkXNpZBY5aprWvnm2IPo3L4eVfDwIAVr/Fj9MT+fejzqjz2RbzZ0dqDgb4Sd3WgNysk3N2Xsn9XiWGR6/XqS7clH6z8/2OMJoEiTAf5O+HiX34CaxYpj/bCPXKhqNXI+eMMfKFoivKHtjK003K2WUlFdHpdBLhtF3NkrlubbIi6Q3KF7W7nicA9GtaHlP+VnfX/X5QM6w6GqMqtNpL5zqlcWpSdxj0OknpBFbh8cUzDdFx5m7z52UqpZTkfaFUkUA8byV7NfuTGpFhOH07kbtfnTJFJB5BjlCnTBFJKRhr7ory37K4yjuLR4sqymU5bCk3MK5nHZQJD3LaGOBMTkzohiZTtju1NNjf/2uHfZfvWU285UlIyCNswtaJp0H5ohZpeR3h9KTueH/FSYzp7nigvxjYv2bk44i6ek/iD//bq7kZlNhse7bSvkZJzBnY1GoKcy31g7rXL4Nu9UprsgwlPVKOQeuhoU6aLYQFGrB3bCdzu5pUjDBbD9j4FGfWjGL5ae818/+fbsJfrFRRcCPpr5AGXQm9Xoc1Ix9HZo5JMeC7VJFAHP20K5p//g/XhdKZKb89wXPNKyI00GBRU9ObCTT4mTMWs9tE1Cx5Op0O7WqWxNZ3n8DtxHQ0r6ye9CbI3w/D21XFr/tzC3j3cSDrZJe6pdGxdik0Z+5170blzEKenwusxP5+etiguJdQJMgfozurx4bagiNCjq180L0WZm67ZP68fnRbHLh6H19uviDZz5Zab7aML3JriaPXLnejjuTEWJcpGuTU5yUnPEhdAWWL9cngp0e7GiWx/8o9LB72GNrXLGl1LpSHSbVg3t0G5cNx5naula+fwrxhD7+80kIS12oLFYuHSDwH3JGI5Z8xTyD6XrpqFk1bSqQ4ewxwJhEhAbj+5VNO9a5x9vrWFZCQ50E2vt3O+k5ewOhONTB31xWHBB4Wa4O/GkWC/J1u/YwMD8IzTSuYhbyxPWpLErrYi16vc2oZDK2D0/e7lBMlaCkrYCtK7XLHJPXtgCZ4d/kJAMrXViIsEC0qF8MRxjWpXtlwzHqBn7FNDaXMiPLzyTW4C4a2xJ6LCTYHjHsbfnqdJDFTQaVYaP4YlKmhSFztMkU0jwmf9a6HoW2rIMCgd2hB4e+nt7CAV2I8Crwls6CrYO+d1vqF9jK6c02M6lQDVcdvApD7DrMu/pFFApH0KBtvWYl9HdKmMhbleaxMVijfw4N1RV0y3PleD2LpFLmlyVsozYnDk8OmzteCXNCtWDwEuz/oiIgQf0SEBCA9Kwe3Hj5CLSfGbrKu5fZkuZ3Yt55ZyFOKWXQmNSKLWHWp5inBioX425zZ3RtwVfkKb4aEPA/hb9CbXa68nTc7VkeFYsEOv9RT+zXAtrNxGNymsvWdPUjTvFIMBZUFr7bE0IWHAeQujj7fmJ9RTWstGmfQpU4kutYt7dL72a9peURduQe9zA1Kzso32yDbKCA1Mwc7zt/FUw3LunXA71Q7Ep1qF7xJ0Vdh3UJdoYzQmh3ZVthYUFedwxtxh+uaTqfD2lFt8TAtC+UjgtGncVl8vCY3W/CKN9qgXESwVavGpjNx5v/bYvULCsg/bjEnjdFf9W9oznYs9vHGFSK8Sshb9WYbzNhykRvH7yjT+jXEB6tO4o0n8hP/sNbDkACDUwU8ILcPrR/dFvHJmZKapFoJCTDgz9dbQxDc666phrwdr7Wvig971nGZdw7hXEjI8xDZLsw86GzCAg148THH/ZgHt65sUfvIm1jwakvcfJDusixV7qJTnUiM7ZFbPPmFFhURHuyPD/Ni49zpAmXw02P+ENfHnH6tUEOJRafTIcCgQ3FDAJ5vUbBdJgnnsOy11jh1K9HmOmmexOCnx5yBTZGVY3IoNqygoeZS60zYRDVhgQb0rF8Gj7KNqFQ8RFNM4JS+9fHW78cA2DbWBhr88GSDMkjNzLE7UY+cZ5qVNwt5Yix978ZlsfxIjENlXZxJiyrFsUKhHqWjVCoRghVvuObYajSqEOHQ71t72XhUvVQYejcqi/iUTMx4tpHmd4HwDnSCPA8q4VKSk5NRtGhRVHx3BW7Oft7TzSlUzN15GTO3XULvRmUxd1Az6z/wEdIyc9B37n60rVESU552ToA5QRCEq6ny0UYAuQmNHE1x7y4uxCWjYrEQc304TzLy96P49+p9HPu0m3lhfuZ2EiqXCLHIOE0QhHsR5YGkpCSEhztHuSOHhDw3Q0IeQRAEQVhn29k4XIhLwf861yiU8TQEQfgu7hDyPK9qKqSUCCUtGkEQBEEo0b1+GXR3ckZggiCIwgJFTnoIeU01giAIgiAIgiAIZ0BCnocI8QJ/fYIgCIIgCIIgfA8S8jxEiI/XOCIIgiAIgiAIwjOQpOEhbKmhQxAEQRAEQRAEoRUS8jxESKB3FLokCIIgCIIgCMK3ICHPQ4SSJY8gCIIgCIIgCBdAQp6H8IZCqQRBEARBEARB+B4k5HmIIH9y1yQIgiAIgiAIwvmQkEcQBEEQBEEQBOFDkJBHEARBEARBEAThQ5CQRxAEQRAEQRAE4UOQkEcQBEEQBEEQBOFDkJBHEARBEARBEAThQ1AefzcjCAIAIDk52cMtIQiCIAiCIAjC3YhygCgXuAIS8tzM/fv3AQAVK1b0cEsIgiAIgiAIgvAU9+/fR9GiRV1ybBLy3Ezx4sUBADdv3nTZQyWI5ORkVKxYETExMQgPD/d0cwgfhfoZ4S6orxHugPoZ4S6SkpJQqVIls1zgCkjIczN6fW4YZNGiRWkAIVxOeHg49TPC5VA/I9wF9TXCHVA/I9yFKBe45NguOzJBEARBEARBEAThdkjIIwiCIAiCIAiC8CFIyHMzgYGBmDhxIgIDAz3dFMKHoX5GuAPqZ4S7oL5GuAPqZ4S7cEdf0wmuzN1JEARBEARBEARBuBWy5BEEQRAEQRAEQfgQJOQRBEEQBEEQBEH4ECTkEQRBEARBEARB+BAk5BEEQRAEQRAEQfgQJOQ5gcOHD+Opp55CREQEQkND0bp1a6xYscKmY2RmZmLKlCmoWbMmgoKCUK5cObz++uuIj493UauJgoYj/UwQBGzevBlvvfUWGjVqhKJFiyIkJASNGzfGF198gYyMDBe3nigoOGM8Y3n48CHKly8PnU6Hnj17OrGlREHHWX0tPj4e7733nnn+LFGiBNq0aYMff/zRBa0mChrO6GexsbF45513UK9ePYSGhqJ06dJo164dlixZAqPR6KKWEwWFpUuX4o033kCLFi0QGBgInU6HhQsX2nwck8mEOXPmoGHDhggODkapUqUwcOBAXLt2zb6GCYRD7Ny5U/D39xeKFCkivPbaa8KYMWOEypUrCwCEmTNnajqG0WgUevToIQAQWrduLYwbN07o37+/oNPphGrVqgnx8fEuvgrC23G0nz169EgAIAQGBgo9evQQPvjgA2H06NFCzZo1BQBCy5YthbS0NDdcCeHNOGM8kzNo0CAhNDRUACD06NHDyS0mCirO6mvHjx8XSpUqJRgMBuHpp58WPvroI2H06NFCly5dhCeffNKFV0AUBJzRz65evSqULFlS0Ol0Qs+ePYUPP/xQePPNN4UyZcoIAIRXX33VxVdBeDtinypZsqT5/wsWLLD5OCNGjBAACPXr1xc+/PBD4eWXXxYCAgKE4sWLC5cuXbL5eCTkOUB2drZQvXp1ITAwUDh+/Lh5e2JiolCrVi0hICBAiI6Otnqc3377TQAgDBw4UDCZTObtP/74owBAeP31113RfKKA4Ix+lpWVJXz++efCgwcPLLb36dNHACDMmDHDFc0nCgjOGs9YVq1aJQAQ5s6dS0IeYcZZfS0pKUmoVKmSUKpUKeHkyZPc8xCFF2f1s7feeksAIHz77beS7Q8fPhQqVaokALB5bCR8i+3bt5v7wJdffmmXkLdz504BgPDEE08ImZmZ5u2bNm0SAAjdu3e3uV0k5DnA1q1bBQDC0KFDLb5buHChAECYPHmy1eO0adOGO0iYTCahWrVqQmhoqJCenu60dhMFC2f1MyX+/fdfAYDQq1cvR5pJFHCc3c/i4+OFUqVKCYMHDxauX79OQh5hxll9TVxM/frrr65oJlHAcVY/Ez2teJaUQYMGCQCEI0eOOKXNRMHHXiFv4MCBAgBhz549Ft917NhRACDcuHHDpmNSTJ4D7N69GwDQvXt3i+969OgBANizZ4/qMTIyMnDw4EHUrl0blStXlnyn0+nQrVs3pKWl4ciRI85pNFHgcEY/U8Pf3x8AYDAY7D4GUfBxdj9788034efnh++++84p7SN8B2f1teXLl0On0+HZZ5/FxYsXMWfOHMyYMQPr169HVlaWU9tMFDyc1c8aNGgAANi0aZNke2JiIqKiolCmTBnUq1fPwdYShZ3du3cjNDQUbdu2tfjO3rUereoc4PLlywCAmjVrWnxXpkwZhIWFmfdR4urVqzCZTNxjsMe+fPky2rdv72CLiYKIM/qZGr/99hsA/kRIFB6c2c+WLl2Kv/76C2vXrkWxYsWQlJTk1LYSBRtn9LWsrCycPn0apUqVwpw5czBx4kSYTCbz99WqVcPatWvRsGFD5zaeKDA4a0wbO3YsNmzYgPfeew9btmxBo0aNkJycjLVr1yIkJARr1qxBcHCw09tPFB7S0tJw584dNGjQAH5+fhbfs7KALZAlzwHEhUvRokW534eHh1td3Gg5BrsfUfhwRj9TYvPmzfjpp59Qt25dDB8+3O42EgUfZ/Wz2NhYvP322xg4cCCefvppp7aR8A2c0dcePHgAo9GI+/fvY8qUKZgxYwbu3r2LW7du4bPPPsP169fRp08fyhxciHHWmFa6dGkcOHAAPXv2xJYtWzBjxgzMmzcPSUlJeOWVV9C4cWOntpsofLhKFiAhjyAKKYcPH8aAAQNQtGhRrFy5EoGBgZ5uEuEDjBgxAv7+/vi///s/TzeF8GFEq53RaMTIkSPx/vvvIzIyEuXLl8eUKVPw/PPP48aNG1i1apWHW0oUdK5cuYK2bdsiISEB+/btQ0pKCmJiYjBhwgRMnToVXbp0oTIKhFdCQp4DiBK3kmSdnJysKJXbcgx2P6Lw4Yx+JufIkSPo3r079Ho9tm7divr16zvcTqJg44x+tmjRImzevBnff/89SpYs6fQ2Er6BM+dOAOjbt6/F9+I2imcvvDhr7nz11Vdx48YNbNiwAe3atUNYWBgqVKiAjz76CP/73/9w4MAB/Pnnn05tO1G4cJUsQEKeA6j5yMbFxSE1NVUx1k6kWrVq0Ov1in62aj7lROHAGf2M5ciRI+jWrRtMJhO2bt2Kli1bOq2tRMHFGf3s+PHjAIDnn38eOp3O/Fe1alUAwNatW6HT6dCkSRPnNp4oUDijr4WGhqJ8+fIAgIiICIvvxW2PHj1yrLFEgcUZ/SwlJQVRUVGoW7cuypQpY/F9p06dAOSPfQRhD6GhoShbtiyuX7/OtQrbKwuQkOcAHTp0AABs27bN4rutW7dK9lEiODgYjz32GC5evIgbN25IvhMEAdu3b0doaChatGjhpFYTBQ1n9DMRUcAzGo3YsmULWrVq5byGEgUaZ/SzNm3aYPjw4RZ/AwYMAABUqFABw4cPR//+/Z3ceqIg4awxrXPnzgCAc+fOWXwnbqtSpYq9zSQKOM7oZ2KW1nv37nG/T0hIAAAKdyAcpkOHDkhLS0NUVJTFd2J/feKJJ2w7qE0FFwgJ2dnZQrVq1VQLbV6/ft28PTY2Vjh//ryQmJgoOQ4VQyfUcFY/O3LkiBARESGEhYUJ+/fvd1PriYKCs/oZD6qTR7A4q69FRUUJAIT69esLDx8+NG+/c+eOUL58eUGv1wsXL1508dUQ3oqz+lnt2rUFAMIvv/wi2f7w4UOhTp06AgBh+/btrrwUogBhrU5eQkKCcP78eSEhIUGynYqheyE7d+4U/P39hSJFigivvfaaMGbMGKFy5coCAGHmzJmSfYcMGcJ98Eaj0Vxss3Xr1sK4ceOEZ599VtDpdELVqlWF+Ph4N14R4Y042s/u378vFCtWTAAg9OzZU5g4caLF3+zZs917UYTX4YzxjAcJeYQcZ/W1MWPGCACEihUrCiNHjhRee+01ITIyUgAgfPHFF266GsJbcUY/27Rpk2AwGAQAQpcuXYQPPvhAGD58uFCqVCkBgPDss8+68YoIb+SXX34RhgwZIgwZMkRo1qyZAEBo27ateRurIJg4caIAQJg4caLFcUaMGGFWXH344YfC4MGDhYCAAKF48eJ2KaxIyHMCBw8eFHr27CmEh4cLwcHBwmOPPSb8+eefFvupTVQZGRnCpEmThOrVqwsBAQFCmTJlhBEjRghxcXFuuAKiIOBIPxMX2Wp/lStXdt/FEF6LM8YzOSTkETyc1dcWLFggtGjRQggJCRFCQ0OFdu3aCX/99ZeLW08UFJzRzw4dOiQ8//zzQtmyZQWDwSCEhYUJLVu2FObMmSPk5OS44SoIb0bsO0p/Q4YMMe+rJuQZjUbhu+++E+rXry8EBgYKJUqUEAYMGCBcuXLFrnbpBEEQbHPwJAiCIAiCIAiCILwVSrxCEARBEARBEAThQ5CQRxAEQRAEQRAE4UOQkEcQBEEQBEEQBOFDkJBHEARBEARBEAThQ5CQRxAEQRAEQRAE4UOQkEcQBEEQBEEQBOFDkJBHEARBEARBEAThQ5CQRxAEQRAEQRAE4UOQkEcQBEEQBEEQBJHH3r170adPH5QrVw46nQ5r1661+RiCIGDmzJmoVasWAgMDUb58eUybNs35jVXA4LYzEQRBEEQBZe3atThx4gSaNGmCfv36ebo5BEEQhAtJS0tD48aNMWzYMPTv39+uY7zzzjvYtm0bZs6ciYYNG+LBgwd48OCBk1uqjE4QBMFtZyMIgiCIAsirr76KRYsWYciQIVi4cKGnm0MQBEG4CZ1OhzVr1kgUfJmZmfjkk0+wbNkyJCYmokGDBpg+fTo6duwIADh//jwaNWqEM2fOoHbt2h5pN7lrEgRBEARBEARBaGT06NE4cOAA/vzzT5w6dQrPP/88evbsicuXLwMANmzYgGrVquHvv/9G1apVUaVKFYwYMcKtljwS8giCIAiCIAiCIDRw8+ZNLFiwACtXrkT79u1RvXp1fPDBB2jXrh0WLFgAALh27Rpu3LiBlStXYvHixVi4cCGOHj2K5557zm3tJCGPIAiCKJQsX74cTz75JEqXLg1/f39ERESgZs2a6Nu3L77//ntkZGRg9+7d0Ol0WLRoEQBg0aJF0Ol0kr/du3dbHPvMmTN4/fXXUbNmTYSEhCAsLAyNGjXCJ598gnv37nHbM2nSJOh0OrO7z4oVK9ChQwcUL14coaGhaN68OebOnQuj0ah4TVu3bkX//v1RoUIFBAQEIDw8HNWqVUP37t0xc+ZMt2qRCYIgfJHTp0/DaDSiVq1aCAsLM//t2bMHV69eBQCYTCZkZmZi8eLFaN++PTp27Ihff/0Vu3btwsWLF93STkq8QhAEQRQ6hg0bZta4AkBYWBiys7Nx5coVXLlyBRs2bECvXr0QEBCA0qVLIykpCRkZGQgKCkLRokUlxwoICJB8njFjBsaPHw+TyQQACAkJQXZ2Nk6fPo3Tp09jwYIF2LhxI5o2barYvnHjxmHGjBnQ6XSIiIhARkYGjh07hmPHjuHvv//GunXrEBgYKPnNlClTMHHiRPPnkJAQCIKA69ev4/r169i+fTtatGhhFiIJgiAI20lNTYWfnx+OHj0KPz8/yXdhYWEAgLJly8JgMKBWrVrm7+rWrQsg1xLojjg9suQRBEEQhYr9+/djwYIF0Ov1mD59Ou7fv4+UlBSkpaXh3r172Lp1K4YMGYKAgAA8/vjjiIuLw4ABAwAAAwYMQFxcnOTv8ccfNx/7119/xbhx4xASEoJp06bhzp07SEtLQ3p6Oo4cOYLOnTvjzp076Nu3L1JTU7ntO3HiBGbMmIHRo0fj7t27ePDgAR4+fIipU6dCp9Nh69atGD9+vOQ3N27cwOTJkwEAY8aMwe3bt5GWloaUlBQkJiZi3759GDlyJIoUKeKiu0oQBFE4aNq0KYxGI+Lj41GjRg3JX5kyZQAAbdu2RU5OjtmyBwCXLl0CAFSuXNk9DRUIgiAIohAxffp0AYDQvXt3zb8ZMmSIAEAYMmSI4j7JyclCRESEAEDYsmULd5/s7GyhefPmAgBh9uzZku8mTpwoABAACIMHD+b+/tNPPxUACAaDQbh9+7Z5+/LlywUAQq1atTRfE0EQBMEnJSVFOH78uHD8+HEBgPDNN98Ix48fF27cuCEIgiC89NJLQpUqVYTVq1cL165dEw4ePCh88cUXwt9//y0IgiAYjUahWbNmwhNPPCEcO3ZMOHLkiNCqVSuhW7dubrsGsuQRBEEQhYqIiAgAQEJCgmp8m62sXr0aiYmJaNq0KXr06MHdx2AwYODAgQBy4+eUmDBhAnf72LFjERwcjJycHKxevdq8Xbwm0SJJEARB2M+RI0fQtGlTs1v9mDFj0LRpU/PYvGDBArzyyit4//33Ubt2bfTr1w+HDx9GpUqVAAB6vR4bNmxAyZIl8cQTT6BXr16oW7cu/vzzT7ddA8XkEQRBEIWKLl26ICgoCMePH0f79u0xfPhwdO7cGVWrVnXouFFRUQBy6yOJLjs8Hj16BCDXxZJHxYoVUaNGDe534eHhaN68Ofbv348jR46Ytz/22GMoWbIk7ty5g1atWuHNN99E165dUbt2beh0OnsviSAIolDSsWNHCCqlxP39/TF58mSzmzyPcuXKSZRx7oYseQRBEEShonr16pg/fz7CwsJw4MABjBgxAtWqVUNkZCQGDBiAdevWqU7uSsTGxgIAMjIycPfuXcW/5ORkAEB6ejr3OOXLl1c9j/h9fHy8eVtERASWLVuGUqVK4ezZs/jf//6HunXrolixYujbty+WLl2K7Oxsm6+JIAiCKJiQkEcQBEEUOl566SXcuHED8+bNw4ABA1CxYkUkJCRgxYoV6NevHzp06GAWxrQiun4OGDAAgiBY/YuOjnbqNXXt2hXXr1/H4sWLMWTIENSsWRNJSUnYsGEDBg8ejKZNm+L27dtOPSdBEAThnZCQRxAEQRRKihcvjjfeeAN//vknbt68iStXruCjjz6CTqfDvn37MGnSJJuOJ7poKrlhasWaICZ+HxkZafFdaGgoBg8ejIULF+LSpUu4desWpk+fjqCgILOFjyAIgvB9SMgjCIIgCOS6cX755ZcYNGgQAGD79u3m7/T63OlSzY2zbdu2AICjR4/izp07drcjJiZGknabJSUlBUePHgUAtGjRwuqxypcvjw8//BDvv/8+AOk1EQRBEL4LCXkEQRBEoSIzM1P1++DgYAD5gh2Qm/AEABITExV/9/zzzyMiIgLZ2dkYM2aMqkBoMplUjzV16lTu9lmzZuHRo0cwGAx49tlnzdvtuSaCIAjCd6HRniAIgihUjB49Gi+88AJWr14tSV6SmpqKefPmYfHixQCAXr16mb9r0KABAGDfvn24cOEC97gRERH49ttvAQB//vknevXqhYMHD8JkMgHIFezOnz+PWbNmoX79+vj777+5xylatCgWLVqEd955B/fu3QOQa8H74osvMGXKFADAqFGjUK5cOfNvpk+fjieffBJLlizBrVu3zNszMzOxYsUKfP311xbXRBAEQfguVEKBIAiCKFRkZ2dj5cqVWLlyJQAgLCwMBoNBYllr164dPvnkE/PnZ599Fh9//DESEhJQt25dlCxZEqGhoQByBbrWrVsDAIYMGYJHjx7hnXfewebNm7F582YEBgYiLCwMycnJkgyXSqUNmjRpglatWmHGjBmYM2cOIiIikJycbE7s0rVrV3z11VeS35hMJmzZsgVbtmwBkGu5Cw4OxsOHD80Wxbp16+Kbb75x5NYRBEEQBQQS8giCIIhCxWeffYbmzZtj165dOH/+POLi4pCamorIyEg0btwYAwcOxCuvvAI/Pz/zb4oVK4a9e/di8uTJ2LdvH+Lj481WtoyMDMnx33zzTfTs2RPff/89tm/fjuvXryMxMRHh4eGoXr062rRpg759+6Jz586KbZw+fTqaNWuG77//HqdPn0ZAQABq166NoUOHYtSoUZK2AcDrr7+O8uXLY9euXTh9+jTu3LmDpKQkFCtWDPXr18ezzz6LN954A0FBQU68kwRBEIS3ohPsKQZEEARBEIRTmTRpEiZPnowOHTpg9+7dnm4OQRAEUYChmDyCIAiCIAiCIAgfgoQ8giAIgiAIgiAIH4KEPIIgCIIgCIIgCB+ChDyCIAiCIAiCIAgfghKvEARBEARBEARB+BBkySMIgiAIgiAIgvAhSMgjCIIgCIIgCILwIUjIIwiCIAiCIAiC8CFIyCMIgiAIgiAIgvAhSMgjCIIgCIIgCILwIUjIIwiCIAiCIAiC8CFIyCMIgiAIgiAIgvAhSMgjCIIgCIIgCILwIUjIIwiCIAiCIAiC8CFIyCMIgiAIgiAIgvAhSMgjCIIgCIIgCILwIUjIIwiCIAiCIAiC8CFIyCMIgiAIgiAIgvAhDJ5uQGHDZDIhNjYWRYoUgU6n83RzCIIgCIIgCIJwI4IgICUlBeXKlYNe7xqbGwl5biY2NhYVK1b0dDMIgiAIgiAIgvAgMTExqFChgkuOTUKemylSpAiA3IcaHh7u4dYQBEEQBEEQBOFOkpOTUbFiRbNc4ApIyHMzootmeHg4CXkEQRAEQRAEUUhxZegWJV4hCIIgCIIgCILwIUjIIwiCIAiCIGzm+r00jP/rFKLvpXm6KQRByCB3TYIgCIIgCMJmXvrlP8QmZWD/lXvY92FnTzeHIAgGEvIIgiAIgiAIm4lNygAAxDx45OGWEO7AaDQiOzvb080oEPj7+8PPz8+jbSAhjyAIgiAIgiAILoIgIC4uDomJiZ5uSoEiIiICZcqU8VhdbBLyCIIgCIIgCILgIgp4kZGRCAkJ8ZjQUlAQBAHp6emIj48HAJQtW9Yj7SAhjyAIgiAIgiAIC4xGo1nAK1GihKebU2AIDg4GAMTHxyMyMtIjrpuUXZMgCIIgCIIgCAvEGLyQkBAPt6TgId4zT8UxkpBHEARBEARBEIQi5KJpO56+ZyTkEQRBEARBEARB+BAk5BEEQRAEQRAEQfgQJOQRBEEQBEEQBEH4ECTkEQRBEARBEAThk/z333/o0qULSpQoAZ1OJ/lLTk72dPNcBpVQIAiCIAiCIAhCE4Ig4FG20e3nDfb3szmZycmTJ9GxY0eMHj0ac+bMQUxMDAYNGoSmTZvi9ddfR3h4uIta63lIyCMIgiAIgiAIQhOPso2oN2Gr2897bkoPhATYJrq8/fbb6N+/P2bOnAkAqFevHgYOHIijR4/ihRdecEUzvQYS8giCIAiCIAiC8Cnu3r2L/fv3Y8+ePZLtoaGhHi9v4A5IyCMIgiAIgiAIQhPB/n44N6WHR85rC0ePHoXJZELjxo0ttrdo0QIA8NRTT6FFixbYsWMH7ty5g/Xr16NBgwY4deoURo0aheTkZFSrVg1//vknAgMDcfnyZbz77ruIi4tDaGgoVq1ahcjISKddozOhxCsEQRAEQRAEQWhCp9MhJMDg9j9brW8mkwkAkJaWZt526tQp7N27F4MGDQIAnDlzBpUqVUJUVBTefvttrFu3DhkZGXjxxRcxf/58nDx5EuXKlcPvv/+OzMxMjBw5Ej/99BOOHj2KQYMG4eeff3bejXUyJOQRBEEQBEEQBOFTtGrVCsHBwRg7diwuXLiAjRs3om/fvhg1ahRat26N5ORk6HQ6jBgxAgCQnZ2NiIgIrF27Fk8++SRq164NAKhTpw4SEhKwdu1anD17Fr1790aTJk3w3Xffwd/f35OXqAq5axIEQRAEQRAE4VOUKlUKK1aswPvvv49GjRqhUqVKGD16NMaMGQMg14rXsmVL8/6nT5/GsGHDsGvXLtSrV8+8/ezZs+jVqxcOHjyIWbNmYeDAgW6/FnsgSx5BEARBEARBED5H7969cfHiRWRlZeHKlSv44IMPoNfnij9nzpyRxOudPn0aDRs2RNmyZXHhwgUAwIkTJ/Dvv//iySefRJkyZbB1a35W0VOnTrn3YmyEhDyCIAiCIAiCIAoVZ86cQaNGjQAAOTk5SExMRIkSJTB48GCcO3cODRo0wOjRo7F8+XIYDAYMHToUiYmJqFOnDho3boylS5d6+ArUIXdNgiAIgiAIgiAKFf/3f/9n/r/BYMD169cB5JZY2Lhxo8X+oaGhWLt2rbua5zBkySMIgiAIgiAIgvAhSMgjCIIgCIIg7CbQQMtJgvA26K0kCIIgCIIgCILwIUjIIwiCIAiCIOxG8HQDCIKwgIQ8giAIgiAIgiAIH4KEPIIgCIIgCMJ+yJTn85hMJk83ocDh6XtGJRSscPv2baxcuRKbNm3ChQsXEBcXh+LFi6Nt27b48MMP0apVK083kSAIgiAIwmMIJOX5LAEBAdDr9YiNjUWpUqUQEBAAnU7n6WZ5NYIgICsrCwkJCdDr9QgICPBIO0jIs8KcOXMwffp0VK9eHd27d0epUqVw+fJlrF27FmvXrsUff/yBAQMGeLqZBEEQBEEQBOFU9Ho9qlatijt37iA2NtbTzSlQhISEoFKlStDrPeM4SUKeFR577DHs3r0bHTp0kGzft28funTpgrfeegv9+vVDYGCgh1pIEARBEARBEK4hICAAlSpVQk5ODoxGo6ebUyDw8/ODwWDwqNWThDwr9O/fn7u9ffv26NSpE7Zt24bTp0+jRYsWbm4ZQRAEQRCE5xHIW9Pn0el08Pf3h7+/v6ebQmiEEq84gNjRDQaSlQmCIAiCIAiC8A5IOrGTmzdv4p9//kHZsmXRsGFDxf0yMzORmZlp/pycnOyO5hEEQRAEQTjEqqO3cPzmQ0x5ugH89MpuZ2TIIwjvgyx5dpCdnY3BgwcjMzMT06dPh5+fn+K+X375JYoWLWr+q1ixohtbShAEQRAEYR8frDyJ3w/exNazcar7CeSvSRBeh88JeUuXLkWzZs0QHh6OihUr4siRI049vslkwquvvoq9e/fitddew+DBg1X3Hz9+PJKSksx/MTExTm0PQRAEQRCEK3mYnuXpJhAEYSM+JeQtXrwYr7zyCkJCQvDSSy8hNjbW7B4ZHx+PgQMH4ujRo3Yf32QyYdiwYfjjjz/w8ssvY968eVZ/ExgYiPDwcMkfQRAEQRBEQUEH9QyBZMcjCO/Dp4S8WbNmoVevXti/fz+mTp0qcR+IjIxEXFycJsGMh8lkwtChQ7Fo0SIMHDgQCxcu9FjdC4IgCIIgCHfBywLPunCStyZBeB8+JaVcvnwZffr0AQBuXYp27dph//79Nh9XFPAWL16MAQMGYMmSJapxeARBEARBEL7MG0vs94wiCML1+JSQV6xYMSQlJSl+X6lSJcTGxtp0TNFFc/HixXj++eexdOlSEvAIgiAIgiAIgvBafKqEQpcuXbB06VKMHTuW+31KSorNAtqUKVOwaNEihIWFoVatWvj8888t9unXrx+aNGliT5MJgiAIgiC8GvWIPIIgvBGfEvLGjx+PFi1a4KWXXrIQxgRBwPLly1G9enWbjhkdHQ0ASE1NxbRp07j7VKlShYQ8giAIgiB8EnkEzPk7VPOXILwdnxLy6tati7Vr1+KFF17Axo0bodPpsHbtWpw4cQKrV6/GkSNHbE68snDhQixcuNA1DSYIgiAIgvBCjKb8bCpB/lIvqFsPH7m7OQRB2IhPCXkA0K1bN5w5cwZTpkzBqlWrMHfuXACAwWDAyJEjMWLECA+3kCAIgiAIwru5m5xh/n9ogHS5GOTvUykdCMIn8TkhDwDKly+Pn376CT/++CNiYmKQnJyMypUrU406giAIgiAIDeQY8y15fnqpv6bcskcQhPfhk0KeiF6vR+XKlT3dDIIgCIIgiAKFkSl+Z5IVwmMFQBFBELjlqwiC8Aw+Z2/ftWsXevTogapVq6JBgwZ46aWXsGrVKphMJk83jSAIgiAIokDAxuSZZDLde8tPqO5PEITn8Skhb/PmzejWrRsOHjyIihUrolixYti6dSteeOEFNGnSBNevX/d0EwmCIAiCILweqZAnFeDimHi9/H1c3iSCIGzAp4S8CRMmoHHjxoiOjsbevXuxb98+JCQkYO3atUhKSsITTzyBBw8eeLqZBEEQBEEQXg0r5AmCdQlOLggSBOFZfErIO3PmDIYNG4aIiAjzNp1Oh759++LAgQPIzs7GlClTPNdAgiAIgiCIAgArtBk1RLyQkEcQ3oVPCXnh4eEwGo3c78qVK4c33ngD69evd3OrCIIgCIIgChZq7prW9icIwvP4lJD3xBNPYMmSJYpJVipWrIjY2Fg3t4ogCIIgiIJOZg5fieyr5Ngo5JGMRxDehU8JeR9//DFOnTqFF154Affu3bP4fteuXShTpowHWkYQBEEQREFl/clY1P50C9Yev+3pprgNVrDT4olpIimPILwKn6qT17RpUyxevBhDhgxBpUqV0Lt3b9StWxeBgYHYv38/tm7dikmTJnm6mQRBEAThs6RkZOO3/dHo3bgsqpcK83RznMLby44DAN5dfgL9mpb3cGvcg83umhSTRxBehU8JeQAwYMAANGjQANOmTcOGDRuwatUqAEBwcDAmTJiATz75xMMtJAiCIAjf5YtN57HsUAxm/3MJ0V/18nRzCDsxqdTJ4+5PQh5BeBU+J+QBQP369fHHH3/AaDTi2rVr0Ol0qFq1Kvz8/DzdNIIgCILwaY7eeOjpJhBOgLXMaXHFVEiHQBCEh/CpmDw5fn5+qFmzJmrUqEECHkEQBEG4gUt3Uz3dBMIJsIlX/j59x+r+ZMkjCO/Cpyx5d+/exZgxY3Do0CEEBwejTp06aNq0qfmvdOnSnm4iQRAEQRCE18Na7/ZeSrC6P5VQIAjvwqeEvOHDh2PTpk1o3749AgIC8O+//2LVqlXQ6XQAgNKlS6Np06bYuHGjh1tKEARBEL5HelaOp5tAOAlbhTYy5BGEd+FTQt7evXsxcuRIzJ0717wtISEBx44dw/Hjx3Hs2DGcOHHCcw0kCIIgCB/mQVqWp5tAOIGsHBNeX3LUpt9Qdk2C8C58SsgLCwtD48aNJdtKlSqFHj16oEePHh5qFUEQBEEUDij5hm+w9WycxbYcowkGP+VUDhSTRxDehU8lXunTpw+OHrVN80QQBEEQhHPwVWtOXtSHhLTMHGRkG93fGDeQlWMprT+ycq1UDJ0gvAufEvImT56Mbdu2Yf/+/Z5uCkEQBEEUOnw1+YZcxsvMMaL+xK1oPHkbBB8UbA1+llJtamZ+vGXLKsUAAGGBBkSE+APwXQGfIAoqPiXk1apVC0ajEV26dMGoUaOwc+dOpKZSKmeCILyPozceoP8PUTh1K9HTTXEbiw9EY9Av/yEtk5JzeDu3Ex/h+Xn/YrOG1Pksvuqyp5eZ8u4kZgAAMnNMyDL6no+q/HoBICM7/zrDAnOjfSb0qQf/PBdOctUl3I0gCHjnz+OYsuGcp5vilfiUkNe/f38UL14cOp0OP/74I7p164aIiAjUqlULL774IqZPn45t27Z5uplEASIhJRPf/XMZd5IeebophI/x7I8HcOxmIvrOjfJ0U9zGhHVn8e/V+/i/HZcV98nMMeL7XVdw5naSG1tGyPl0zWkcjn6It34/ZtPvfNaSp1P+nGP0vWvmuadmM8Ks+Jj1Oh388nb2VQGf8F6uxKdi3YlY/BZ13dNN8UoKVOKV3377DU2aNEHDhg3h7+9v8f3ChQsBADk5OTh37hxOnjyJEydO4MSJE/jnn3+wYsUK6HQ6GI2+6UNPOJ+3lh7FkRsPsfnMHWx59wlPN4co5DxMy8K1e6loVqmYuTRMQeSnvdcw/qm63O8WRkXj660X8fXWi4j+qpebW0aI2Jsl02eFPOgA8K8tM8eE0ED3tsfVhAZYLg/ZOD1RoNPrAD89CXmEZ2Ct6GduJ6FB+aIebI33UaAseSNGjEDLli2xbNky1f0MBgMaNWqEwYMHY9asWdixYwfu3buHmzdvYv369W5qLeELHLnxEABwIS7FacfMzCElgxp0f3Lh3Yc3lhzFsz8ewL7L9zzQIvdw/k6yp5tAwP74Kl9d6Ger+CJ+vfWiG1viHgINlstD1s06X8jTma1+virgE94LO9zcekgeV3IKlJAn5+7du7h16xZycrTFd1SoUAG9epFmmNCGKyasaRvPocHErbgS7zyh0ZeYsuEcan+6BZfuFu77s/tiPGp/ugXz912TbD8U/QAAsPmMbXFS3karqsUVv/PTF+hpyWewN77KV9f5ctmVnR+WHbrp5ta4Hp6QP+Dn/3D6Vq4btdg/9HodY8lzW/MIwgJfjI11lAI5m86bNw+RkZEoV64cKleujODgYDRv3hwTJkzAzZsFY7C9l5KJ/j9EYcWRGE83hVDgXmqm04/5y77ryDYKmL1dOSapMCP61X/3j+fuT7bRhMG/HsTs7Zc81oYxK04CAD7feJ77fUHXmIcGKkcKFGAvVJ/CXotcQe+bWvH167yo4L3y+cbcBBesu6aeYvIID8F2uWxO2Q9XcTvxEfp9H4X1J2Pddk57KJBC3sGDB3Hv3j0IggBBEGA0GnH8+HFMmzYNNWrUwNixY5GZ6fwFujP5vx2XcexmIj5cdcrTTSEU4GUXcxbZpHFS5dbDdI+de9vZu9h3+R6+23EZN++7rh0lw5SDeNiex0vPXtC7j9oCmdaJ3oG9Y1RhWOhH30tDjo8LeUoKpoPXH+BBWhYOXs/1KtDrdMgz5Plsnbx1J27jy03nfbJUhi+R48b0rhPXncGJmES8vey4285pDwVSyBMEAQMGDMDSpUuxefNmLFq0CMOGDUOJEiWQk5ODb775Bt27d/fq8gkpmdmebgJhhaRHrntGvBpERD6erLfExsK9uvCQy86jpkNgF8riYorFWMBzlasJArSQ8g6uJqTZ9TtWgA/wc94SY8XhGPyy9xqWH/a8t87g3w76ZEZNrUxaf9b8f9aSt/rYLfx37b75u0PXH2ClD3grvfPnCfy09xp2X0pw+blMJgFLDkR7RXbhg9fuY/XRW55uhirsWiHLgXcy6so9rDtxW/P+iekFYw1foLJrinz77bd4++23JdsGDx4Mk8mEefPmYdy4cdi/fz+GDh2KlStXeqiV6tAS3/uZ+rfr6q640kroC/g7cXFoK+yjuWbnQlcLepUu8JCZQHiTSUFXmKstkG29tKwcE77Zfgnd65dGs0rFHGuYG7md+AjXElLRvmYpTzfFqbDWHGcNc4ejH+DD1fleLxWLheDxGiWdc3A7iHnwyK1WA2/jcny+Al2vy4/JW3HkFlYcuWXOivvCTwcAANUjwwrUu6nEg1T7Ms7awoZTsfhsXa4Q7enswgN+/g8AULtMEa/NWskOMUGcZEFaeWn+QQBAowoRqFoy1Or+BWUKLnCWPIPBgDfffJP7nV6vx8iRI3H48GGUKFECf/31F3bs2OHmFmqD7SCUTdA72eNCrZ2f2gqfMLvsXb6b4rOFsxNStLmU8xbKnrR02su1hPyF4cN05cWSre5+by87jnl7rqL/D//a3TZP0ParnRj86yFEXXF9ptQcowlnbie5JY6M7ZvO6qY3ZG7TVxO0e+kIgoDzd5KRkW3/PMtzQ/T1mDyt5GbXVJ/Pbtx3nbLMnbgjJ9T5O96XdCzmgefCJ6zBdr3wYMvSaray0Mfq7RUoIS84OBhhYWEICAhQ3a9OnTqYNWsWBEHAr7/+6qbW2c+IRUc83QSCQ5C/9PVY9G+0045NQp46giDgcPQDdJu9Fz2+3evp5jidHKNJszWOZ/U1mQTEJ2cUGNfGK/Gp6Dxrj/mzWkkSW92kt5yNs7td7iIxPUtRyOC54zqbKX+fQ+85+/GdShF6Z8EKP85QRiSkZFpYvW2Rr9afjMWT3+3DK7/Z73rNi7/ztpi8h2lZkjp2ruK55hUk446fnw7WHC8KegyxiM4NPlje6OTjXT1dCjvepGTkICXDMTfKRQduaNqvoMy9BUrIi4yMRFJSEu7ds675fOGFF2AwGBAVFeWGltkO+x77cs2rgkywv5/kszPdN/28cST3MGwMwslbSdh4KrdMgLtr3/xx0PUxP6lWrJPVGHcR3gJq85k4PPbFDrcs2p3Bv1e1j3F3EjPM//eFBEUP0rLQZMp2dJq522NtWJy3cPk/N/QX1hLraBKWA1fvo+W0f8zZZkWyckya+4Z47YccEKZ5rpmesOTlGE1cz5+7yRloOnU7Os/a7fI26HVSN/a0zByL+UxMiifiKwlZbJ22H2XZbj3ecf6uzb9xNba+xvZct72w7+EHK0+i4aRtDlnttVJQenSBEvJatmwJQRDw/fffW903MDAQYWFhiI+Pd0PLCF9EPom/3Lqy045NljxL/pQlVPBUzZvD0Q/t+p0gCJoXfmuOqwd4lw4PMv9fTXv8rYOlJowmwS0aSbG2lhY61Yk0/z/dxsWCJ7WrOQr99WBeIoo7SRnc751xDhZb+qEj51GC/akgOPZM5u25yt0+bdN5tPlyh6Z2OnIt5mNw7uc2D1iQe3y7F82mbLdYxO7NCy1wlUKsSokQ8/9zTIJkbD59O8nCXXPwr4ck+xRE93Ie1txSWQ5HP0DdCVtsLsVz6W6+K7I7hBUtyOdmNS7EJaPuhC34eM1pF7YoH95YF2fjWGvPGFVQunSBEvKGDBkCQRAwbdo0LFy4UHXfmJgYJCYmIiQkRHU/LSxduhRvvPEGWrRogcDAQOh0OqvnJ/gUFBM3j+AAP+s7aURPQp5VWItafLLjC2Q1nNEvX/z5P3SfvUeTy9TkDVKrsFzYYmM/bNUea72WjGwj2k/fiWELD9t2AjtYycnQZlIQMAOYzLO8RY7a9XnKYBCfkoHmn/+DTzgLG2cpKzacjEW9CVux1YpwMeDn/9D1mz2Kli5r/eODlSfRYto/drdTvuiy99VKepStGhd9LzVLk3Uu2wlZMI2cY2h163ImVxPSkJZltHB35t1jQRCcZkGLZmIijSYB1UvlexoE+uktlJb7r9xDJjMO+kr8orVpm323Plt7BgBs9rZ4vHoJ8//P3Um26bfOhL0WW7zNftiVq5jR6hEjt/raCq9v2TpnZrqxvp67KVBCXq9evdCnTx/k5ORg+PDheO6553DgwAGL/ZKTkzF8+HAAQOPGjR0+76effoqff/4ZN27cQNmyZR0+nrfiTAGM9+LuvhiPRpO3md3wvJ1+TctLPjvqesQORoXRXVOtf126m4Kl/ylPCgsU4iGd0Wf/PhWLRpO3Yd9l/oJy8oaz3O0siem5daOuJqThtB2pr/84dBONJm8zu+pEXclPQy4u6LQs2M7cTkKTKds1xY9GXbmH2KQM7LpoX4IhR+996y934LXFRy22/9/OK+b/yy15C6Kuo8mU7TgXy1/8eCrj4ZIDN5D0KBu/cxY2WqyYWu7l/5YdR5bRhDeWWN4z9jiHrj/A9XtpuHSXH/fYctoOxKcoK01WHb3lUHpw+ThprxVnvYZ05nN3XeFuZ+cfZwgYy7ygbAPbR+T9ReA4j4364xi6zt7j9MRuOSZBEic8vH01rvCTme0bQh57r9W8Km7eT0fzz//Bt//kWu7Y98CW6w8Pyk8e4knXTXmTf9l7TdPvQgNtS9o/ZMFh9J6z3+4+whtfbD2WNc8aHgWlRxcoIQ8Ali9fjqeffhqCIGDNmjVo164dypcvj2eeeQavvfYa+vfvj8qVK2PHjh3Q6XR4/fXXHT7n/PnzER0djYSEBMXMno5irzbDWZq64zcfounU7VjhhJo2JpOAZ374F6/8dkhyTSMWHUFKRg5G/XHM4XO4gyBZTJ6jWR5ZC09Bcdd0VMsm8jAtC49/tVMxrnHiOnVBine3HmUZ0WnmboxZccKhNo7+4zhSMnIw+Fd+YoYFUdFWj8Eu7tUWY0p8tvYMUjJyMJyThOmHvIWslsXyxPVnkfQoGxPXS+8n7zk68lhnbbuIVl/s0OwW82yzChbb4lMy8Y+VRUx6lvSdm/z/7J13fNTkH8c/171boGW0lJZRym6BsvdeMgQBQREVlCEuUIaKTGWIKAg/UFGmyBJBZCNllN1SNgUKtBTaUtrSTdddfn9cc01ymXe5Lp736+VLmuSSJ8mT53m+e98tpL8oQP+Vp3mPL4uLyXVh7GxtXAvLyv/uYcDKMNXdCoUWpMlZebIXbKbAFfJMVY7J+ZWQBWvs+ksYsvoMtDoKqSKZXOWy9NAds89hLsx71XHcYJndns48euB6Ih48y8bZ+8UKI1OY2a8B629bKw3L2uTuaMubHIppwd58vuStnmpAURTrm7LSCM+Ja05GIzU73+BCn8sQchPShd1ouecKqOZi+PfqUH535ZKAqzD75sBtWb+r4iyeGJEJRVE4dfcZbsZn4I5IMi4x+MZ8pZa5b/fLuzf2dcuH9a/cCXkODg74+++/sXHjRtSrVw8URSEhIQF79+7F77//jr179yI9PR0URWHKlCl4/fXXzb5mz5494eenXjwWH7VnHUDtWQeQztGgii1aTt19hmbzjuDPi+ZrGYevPYe0nAJM33VN8liphdSj1BxciUvD6Xtslw052cj4zq3Vqed2Ipd7TzPxC2ch9CLfvI+6vAl5FEXhrd8vYuAq07VsNJvPxyIhPRe/cRa8cuEzfB6+mYiYlBzsvvwE74i4HJbEwp/Zz+m2frbzKjp/FyqZZEUK+vcmazp1FF75Kcys7IJcfjoejaTMPMGYKS5V3exNuo7SmJTSyngo9jW/1rJYwNXpKNSedQB1vjjAOuZWQoZJFmAuzPqDYs4CQo8pOYu/rIeS8Vctd0051+SzYGl1+oXj1cfpuP8sS3apkrIOU8nzx4VYBM8/imuP0wCwn/FCjiLN1LmTLmQ/KMgblRkLd59KjoY6phO61AHAnwE4j/HtRifJL3lhKUwZP7t8dwIBXx40/K3R6Gv/DV97zkg4s+NkyGJmCRaq+/rP1XgEzTuCsyVQRkUJFEVh9K8XeLdLIWRd54P5Tvi+ZaXnoFGaZdbFodj6WMdLukbek7QXuPGk9FxplVDuhDyaMWPG4M6dOzhz5gzmz5+P4cOHo127dujUqRPef/99nDx5EitWrCjtZgoi1J13RhRb0m7FZyBo3hH87wT/RzP3n5vIyivErN3mB7jKXRx9sPUyAr86aBBG8wq1RpMIc8Av1FHIK9RKxpEAwOrQaATNO8JyMyrU6tB/xWkM+CnMSKtvSfieab2qLjxHyoep2ZQS8SiKMinoukCrU8UiAOjf3el7ybjxJAMPky1b5+jcA+XaZmafPXHnGe8EtPhgFJrNPWx2naaoRPEBnfnM8wv17dgV8RhxqS/w92XjeLSWfvyFgW2thXuGnG+U7xnEpebgZnwGTt9LVj3rmVyvY7G1gdgiVGniFW7sVG6BFll5hSjQ6pBboC2VmGAfD0fDv2NE+qHQPiXjQIHOWNnAB99j2H8tASEL+WPxkhQIStxC96Za8p7KuCZf12EKQ9y2lGeYi9ndl58g/UWBIeso8xln57H7i6l6D3q+srbSoAOj8DxFFY9FNkXKSj6lpaXjnJR8zwv+vYXGcw4hPk1+YhqKovCIUx8uJTsfl2KeIzz2OVKz2RZiO0Yh7osPU1ljrdDY/dGfkcjILcQYhgKOG0PKVfyXBNn5WkTEPjfarnYyNOZzMXVo5hXyFLaTGb8sRxnwPwWCbGlTboU8mnbt2uGrr77C9u3bERYWhhMnTmDt2rXo1KlTaTcNAJCXl4eMjAzWfwCQlcs/cTOzNy05FIWsvEJBVxGxBYMleJL2AvuvJaBQRyFo/hFk5BYgaN4RvP7redZxzKQRGS8K0HlpKG8cSU5+IUtw++7wHWTlFbJc+lKy83HnaSZuJ2Sg0deHJd2MUgQ00UpIzc5HOM8AZ6qmieYpI3mItkiIE7LyTNtxFQ1mH8KjFPlFSAu1OnT97gT6rjht8mKWoiikZufjRb4WzxmTmI0JlscX+VpDEVVz7Zap2flG98SthzPjL2Mr9NqT95Gdr8XPRf0mJSvPpGfT90d+90AaptDGnWBe8CzSA6u78p6HL0nEG230XgRyks/w3Rlz8cF8ZsxjTdX2y+0XVV2FLXliwqtSIY95rgPXE9Bg9iE0mXMYAV8eRIPZhzDlz0hF55MNY9w+cYed0Zn1nEX6Ht84fzshAw1mH8Lcf6TjQgGOJU/kq0vjcWEUc6Mfv0l+ch7uIumrv28IHis2Bsr5TPmUT8zrmxtHrYTn2fkW9TjhuxfaQpbB+K5jU9nPxBQLFnNettJo2PFljOyt1kWTPZ9CwdzwBjGeZeahwexDePM3Y2sTH7+FPURugQ7tFx+XfQ2+58Z8BYkZuaw1DHOc/ejPSLwSVJy/gS9xj9C1uEra7eElGw/6/ZE7aDLnMO8+pR6KUnMt8763XzItVIgvflh5vcjiDpySJezenVugRXZeoeS8R69DC7Q6xXVf1abcC3llnUWLFsHd3d3wn6+vLwCgVhVH3uOZfYf57/9uP2UJCQUKiikL8Tw7X1HWwi0cv/pTd58ht0BnlOGM+V1HJ2XhaYax4FWo1aHZ3CNoOveI0aAmFrAs5he+9cIjtFx4DKuOF2ezyswtMAgactl/nT8xjNRALcW+a/GGf+t0FNp8+x+azDmMg9cTWAPB4+c52F0UCLz+rHz3xkepOXiS9gLRSVksLeqDZ1myB71pO66ixYKjaPj1IbT+9j/Ddj53HCkafn0InZaGIiL2udnZRP+8GIcljEXwi3ytUYbKHeFsi9kZhguMo6019l2NR8uFx/CNCf73UjxhaIi5z/rwTeO4syciqc65E6NGA6w4do9VTFz4t8bbmN9QTr4W959loUCrY13H1OQYNlJVkIsQW2wztetcS6OUFYs7gTLvlU9osVTSJ2bvFvOsEBNo+Z7RiqL4ng0yEukA7AWimFJqd+QTwcQsfPC5Jr3I1/Iqobj3uDvyCSiKQnRSllHGz+bzj6LJnMP8WVRlKNWeZeaxvnPu9bU6CtUZ5UgsSfMFR9F3xSmk5xTgYXK22W7aXMSEtYLC4n1PM/IkBd34tBeii88LD4rndGsrDXus0FKyLHmT/ij+/pr4uAleyxRoj6cz0SkWE6z5FG7M5zBgZRgafX0YLRYcRVRiBiuZmo21Bi6MBCQFCqQj7nvhu73cAi1iLORd89NxYSuV0sRWUpltmfOO0rjN/EIdImKfYzqPclco2VBaTj5rHa0flzIxurWvYVtWXiFvDCVFUWix4CgazzmMfJH7WnHsHlouPIYd4XF49X9nEDTviKGMTmlAhDwLM2vWLKSnpxv+i4vTD05C1mTmYMmcrMZtDEebb/8zDN5qxBk0X3AUrb/9z2gyEnKL5ApjQgt/Zru5Lg00aS8KUKjTawSf5xTgalyaYZ9Op68xs+V8rCJ3G7ouy7IjxXVpOi8NRaelobIEvefZ+bjwIIWVwp2JOfE+hVoda+Is1FGGwXzSH5cRNO8IAH2Gro5LQg3HKdHCMo+lM5vtuxqP7t+fxGiOtVWI3QJZpriDZkxyNm7LTO+sVhF5ZvzXvSTpBSoznb2bgy0W7te3g5sIQw0cbIqT9ByPSmItWrluLxm54qnhue9807lY/HBMXq0lvt7CPN+eK0/Q4/uTGL8xnHWsqfF+TGtvboEWp+89451gxWRIZvIVOmkEjZQl7/Ij9rNljmWWyGCbX6hDGI/bK/NSYvXwdoYbu+7SKFWk5OQX4kx0MktwYlqRpcZOJZrzYF8Po219fjyFzt+FGuLCaPgSEuyMeIyey09i0pYIxnGUwcrNNz5zY5yE+O4w2wLKXPRrKQoeTrbcn1iMu0+zEDT/CLotO4ExHCvTrfgMs9zGM3OFhcb61dihBLP3FltPud92UmYu2i8+bphz+GB6H1hrNKjiXGyJ11vyil05Af6+y1yjMJUEOh2Fc/dTzHJDZCqGLFVPle+8fIv73AId+v54mpUV2NbaiiXgKBlfueVmGvB4fQxZfQZdl53A+RIWHpS6PwuVcaExR3H+3qZwDFtzlndfsoA1Lnj+UbT59j+cu5+CRyk52HYpDj2Xn2K9OwA4dtu4vnaBljLMR9Ei6w96rv7y7+uGfj/yl/O4FCNd7sUSECHPwtjb28PNzY31HyBcoJU5VPJZX+gFlJrFbrna2CQeyxsA/Mfp+Idu8MfZMSf5T7ZfkWzLwv23MHj1GcPf5x6kYPjac/hqzw1WjKIUfPFMz4smEjn1lJovOIqRv5zH3ivxvPvFMmQxOf8gBWGcujKvrT2HKwxBVuj9nY5mL/6V1HjaxKjbdCNen8ThwyL3ND73Uy5irhUf/hmJ3ZcfG9rdddkJ9FtxWtYzaVO7skmWQDHknI9Z20mjYS86hJ6/qVphpkbyz4uPMHjVGcFjpVxwzUoewvMOmeej3Z1P3mXHMMqN99t75QlrgtvGEBRm77mBMb9d5BXqxSyFTEsD1yIgJeRxY2xG/FxcUkftPgfoXejf/O0Cei6XtqoaYNyfWOIhpruXGG5FSQImbI7AG+suYBVjgVLIs7AU+q6VuDJ2qFfFaBsdr8T1fODrS3RCr2O3k7AjPA4J6S9YC0C+V9XY29j6U5cnKQJ3nmRev1BLlVoynshHaYZ/34rPQP+Vp9HluxMmn0/Mqs29RWaNMu57vsFI8BN6Jwmf77zK8kQA2ItzHUVhaq/6xX/rjC159hJ9192xWNDeHfkEo349j4GrwgDoXZIPCHjPCMEcvy2VWItvjSa3HMXD5GzW782JDX17vbGrNF1WZ6+MMiNqImWR5I41UvetxMLJRUxRypdAMCK2eA046tfz6PxdqKjXxaEbiaxvhWnFbFGLP6aeCXft9v2R0snQS4S8UkJoYMor1GHZ4Tu4nZDBG7hMu2Vw43zENAt87GJoi7ht4VuQxae9wAOOe8A/V4uFoWO3irXxSrNoCglVAL/rgNCihbuoY06KSmq3CKWc5roD8lGo1eH1X87jzd8usDSVTAEPENY+cmvFyUnTm5qdj+8OR7HcHd5YJx2rsPvyY+xklMy4ICIIRyVmYuqOq5i1+xorCcnU7Vd5j2cKSz+feiBZRFYpNgLWVv+Z+43ctwC98oTZLYWs1SkClmcpuH3+DsMVrn/T6rjxJB3Lj9zBi3ytZKyROYsW7jcKsL8D5qkXMtxW5WhUD998io+3XUHP5ad499MaaL56h2L3xHx23DEvl5Whz3iM+5IT78X0HJCr4X+akQv/mfvxd6T0900LadxFsVj8m1z8qxgLMHzCDy0I0wWKmdmVmQsR+rkKja9KPHTFxvRUjtZcqv9O33UNr6wM45zT+Eb5Xt/9Z8b9mxubzrx+fqGuTJTVECr5oQSh+4h89FzUjY77O+Y8+c76S9gZ8RgdOLFqNozAelsbK1RytsMnPQMA6IvA04t3ui/yxR0zSX9RYGjH/qKwBVpJ0G/FaUz+4zJrES5Gdl4h/rxYPG9ZKrkOn4KVWRZBCqblhu/dqePCZ/zd/HstHn9csEzJiiM8oQdMuPfJHINTsvKw9FCUwc30dkIGWn/zH+TyV8Rj1rpVCRRFYdga45raQpy6+wwTt0TglZ/CDNuY/YE7Dr274RLyC3WiNXXtGN4+JQkR8koJoUnzh6N3sSo0Gv1WnBa15HFdLIUWXnzodBRmMjQY+Vr2AJ3HM5BJWWzGbyqu7yVn0JUy44shNNlxF0TM+7DS6BdoX++9YdEMe8xFakp2seWoU4An6zghCx3XBZKvn6w4dg+LD0YZ/p6y9bLiejov8rWYuuMqPt91zeA2GiXD/XJH+GNWEhKhrJj/RbGtvkxLohoxFGKueHwCLvfwT7Zd4W2HqZlqxe7JwdYar/wUhpXHo7Hy+D1sPBcjei5zFi18AeE/M5IVMRdjjxlxgRO2hItqRgEIugYduZmISIbbJJ9AL/Z87idlY8LmcFx/nI61J9j9mCmM3xQogM6HmFvcpC0RLCGtTVHs6acCCgsAuPY4DRM2G9cwlIPceMfWtSsb/p1boMXH2yJxkMdbgqvMYqZnZ44rtAXnlMB7Tc3Ox6WYVEzcHIH+K8SFELE+yXXJl6PkS8nOZykWNp6Ngf/M/djOKDrO99yc7YwXSlxrL/P6+VotSwAq6VI8fJg6/wg917tPM0WtsvTPVv53D/4z9+P6Y/FSHcejnmLqjiuGv+nYMuaYe7RIqUuPN2IxxjRSVqe7T+WVWfj+CNt1XUmcmJIEYnxrFCWZbpmeJHwWqygFdeGEBGC+aXDK1kh8+fcNHLiegImbIyQzYydl5GLSlgicvS9dxkFoLKHhrmvoZ5iZW4CWC4/hfyfuG+bnfhJjDpOsvEJM23kVn+28ykoyJBelCbyOMowWdP0+pmWWW9/1eFQSRv16XrSmbr5MK7DaECGvlBAamLIZnZFPE00LEeZk7OFqy7kfgNKYGhratC3kxkljpTFvISu0aOJq2fK0TAsGhQX/3sKmc7F4b1NxXMiDZ1lot+g/xRqiWbuvYfSv57HlfCx6LT9piClhCubMOdmLk12wQGYilN2Xn7DiVfILdfjh2F2sPXnf4KpmSrFbZjvpiUtNheh7m9gLYuagyX1/50xovxI3VsDYnem/qCReoebkXWNffAC8yRuY2eNEE2ow9l2NS8ODZ+KLGaXB7UwcbIsXwXT7rnNipvg4/yAVYwXq6OXkF4KiKEHL2PubI1hF0XUU0OeHU1h3uli4FBN0/rr8GIdvPsXAVWG4zSlVwcyquvK/e3w/5+W5SLzPwRuJ+Fggy6b/zP28yrVha84aJdBhLta5iy36necVamVr/wu1+iLL2XmF2HI+VtACx3VpZbqpM8dV+t9CCUCeZuRi+NpzOHQzEbckFDz0AiclK89QjoKG2ecA+ZZopsKB9kKY8VexkoXPi0GOS6uOa8ljPBPmN5+dV4jsvEJZQlejGnrX0Y+615M8lklKVh4GrwpjbRN7PvT750PQxZwSn0/p57H8qF44+v6oeHzvuxvCDWuENgzFAzN5Fv3urIsUDPdk1MGjLTgaEQWd/8z98J+5Hy0XHBV0a6dDEWiklArM91vFRX6hbj4hz9QSNFqd/ttOzspDj+9P4Psjd2SXnwGAewICMFdmZfb9yX9cxqGbiaw4WD6+3HMDB28k8tbF43LhYarhHdHeSRcepMB/5n688tNpozmCfobLGX2O6wUhB+Z66UW+1iizthRi8axSFGfKFO9nfCUnmCjP+KkORMiTwbp16/D222/j7bffxs6dO422rVu3TvE55Wg7+YLd6Y/InIBV7qTPnVT43ETlXG3cRr3vuFQxTB1l3kJWq6MQl5ojWWCV+VExzevHbj81DPzdvz+JhPRcfLZTWItPBz53ru9l2PbnxTicvZ+Cr/bcwL2kLEPGRqHaQG4O7OB/ofvnUzR+y8goypx4rsalsRbXSlhyuNgSSFH6LKhKXX5NhbtY+VYkY6rcc0ixnGdhk5FbYBSrKTSQc9/XrojHaDznMNadfoDLj56LutUym1qg1aFXo+qibTXHvYz528ZzDuPYradm1auKSc5Go68Po/asA6w4Hy4n7rAF5jtPM7Fw/22DB4BcC8qrzX1Yf/95MQ7jN+oVBkwXMjHScwowZLVwTCTAn3qf5uNtxgIgX78Qm/Tp+qAhC46JxuGxf6PD7L030HjOYYTe4Vc2AMZCHlPwYVoMkjL1Y8ORW/wuVl0CvXi381Gg08djtlx4DAFfHjRYPwHjmC+5Cry2i8RdtfjOIyUw5xZoWUqjc/dTWMkyaKvjkkNRaDznMBrPOWyUpZcPWghu4uMOVwWu/y0XHsPVx8JCSXRSFkuJN2VrJBrPOYyb8cbWNqE1A0WJjxnmlJFg9i2+DJpKMjzSTTzO8PJgjr/M8kgp2fn4co+AVwXndqTWUvms+EKZjQV/iSopt1Sa1v6VWX8XailM23kVIQuP4f6zbPx0PFqRu7SQQBgaxR53+Z5FVGImnmfns5LbMVGSDIhpXBhftN4b+Ys+qduNJxlGgjGdxVnMwiUH5v0/TM5G07nCSYP4MKfG8uy9N5CRW2CW9xlguQRBUhAhTwZhYWHYuHEjNm7ciMuX9WmBz5w5Y9gWFhYmcQZj5BSszuLRPtCCizlCEje1OFdDzTe5ytFC8JVKEOL8g1TpgwTQ6ih0WhqKnstP4n8noo0y7NEwF7fcDGzTd13DRplpyZ2KXITENL5xz40tecykENwJki9LV36hDhO71DXazpxYmAPNpD8uiy6UtDqKd2IG2IH5F2NS0XP5SVacg1J0Ogr/OxGNj/6MlMxkyrVCc5UMTjwuWTSn7+knNXP6P82q49GsRB1iJGflY8rWy4ZFDa0UWLj/Nob+7yx+PS28kGe+6UIdBVcH8UWiOYkiuAu6L/dcZ30HSnOR/MKwxomxPZy/77RbdLyoXfq/R7X2Rc+G1QTP8+MxY2sd7fort+1B86UXAGKWxYM3EmUJ2sxvkfvOtDoKD5OzkakgjX6hjjLEM56JFrZui7prMt71x9uuiF5PibBSqNWxzsf8hp9yyvDIiSOWwx0edzYHW/Ely+e7rrFSqm88F4tkntqpaxhuwXLKU9SspC95ZGtjhZWjm0seLwbdV9JzCtBz+Ul0WhpqmFvoJDYDVhqvKYSeq44STy6jo8Byp1aCPSOO6L/bxsqC41HCygguF3myCzLHX248sdzszYVaHbLyCvHrqQesuSc7rxC/nLqP2wnF/UhsCPlm/y2M33jJsDZ7d4Oxe7ZcYYE7Dkc/y8Luy2x31TkCtS/lJmAC9FYx5jpDaNzq9v0JDF59hjcOkOkmq8SdmS+DZUIaeyzIL6QUu0rywWzj67/IyxTOxJw59f6zbAxYedrsBE7EkleG2bBhAyiKEvxvw4YNis8p530fumns9lgs5Jne4bjWi785afO1FIU9kU/wwdbLBrec9WfkaaPlYk6NF6YGfemhOxj6P/40umIf1c6Ix4KDLJfYIreR0/eSERqVxDuQ3ozPAEVRLFfXtxjub9w043z+2c9z8lHZ2didhLmoUzJQcJMOUBSF7w5H4fVf2IKNqcHMTL47cgdLD93BP1fjJQdhbrIMroZLTPM85jf9M5XT//myrTKR42LE5N9rCei67ATvPrGSJqwaUzqKJRy48Cy06XfmZGdtlBpdjF9O3TeaeHUUOyOhUqU+X9Fspey/lmB4x852NrCXWKgLwS0gL2Z9l0LKE0LOYo6pDOO6uBfodIoLB8u14HLfiY21FXQ6Cs8y8wxWTzkocXkWs85dfpTG6uPcdORK+eCPy9h3NZ631AnXNZRm3r6bWHX8HvZdFU7iBQBWVsBZnsRMjb4+BP+Z+1llWpjQ78bLxd7sunt3ilySEzKKF+e5BTqD5VUIoXdAMYqT86GlKLwqMEdKwcyaeSnGWFCc1lufdXP+4MaS57r4MFWWcptGKA0+t35ioY7Cgn238M2B2+i0NNSgwFx8MArfHohiWfWFHtP1x+n49fRDHLudhA1nYwSfp1xFdgHn97P33BA4shidjsLsPTd45/gD14VDYIavLZ7Pfz7F33/pguFSQnmaQBjQG21qif6O5lYC2wKdmVvAez8pPIoXMUwtFUGPS+Za4eJSXyjqu3wQIe8lw1R3y7xCHe4kZho+Whol2h8uXMuJTkfhk+1XsP9aAhrMPgStjsI1iWBtGrlB5c14XFHlwtUcC6HWR8XMuPjOhkuCA8blR2m8rnH3nmYaTZAveNyO8gp0OMwj2LPKavBcu5JAHSjuoiHgy4NYHXrfyIpax9M4q59chha51zE141I+99yg5Q512UlppFyyrj1OY01sfOy7Gq84bk8uQjEzQjBbodFoDIs1O2srBPm6Gx1P9y9rK41sF0UA+PZAlNE2nY5CpwD5bnlc5AoeDWsYp7un+WDrZfxS5IplY20FWxnJD/gEdG5TzFFOMJUEAVWNBensPGntM9M18ueTbIunVkvJcpPTaIDJXfXWe7kLEZ8iqxLN1bg01PniAFp9c0yR5VCJCxN30cpl5C/nVUtotf96gqH0CxchIW/9mRhWfVQhrDQajOZJzERbG5gJrZjQ/cXaSiPoHSGXt367CJ2OYiWwyswtYMWKc8nILcAZgdhlHSXed8Jl1ufi1qgEpEsjeLnoY83HtPWTdQ2u15AaTN91DScYsdRf/H0dmQK1SIWe04Pk4ns/dvsprsTxWz4zZOZCiH6qPPTh2pN0VobsXRPbGf4tlhSLOd/yeUIwYSbh4mOrQFZOe5mZIZkxtQAQ9/wFcnkU2mKZvLkkZeZKJo/hIzwmFcHzj2JXxGNVMrCa625JhLyXDNrdbNnwIEW/+2RbJPr8eApfcTRD5mQN45rTrz9hC3TLjtzBOx1qyzpX7VkHZB0nd7Dkg8/NcgensK9YogilNK/lwfpbyIqU8aLASAD4as919PrBOPPpC54FVlh0Mq+2lA5Uv/Y4Dat54h0rOfEHk3PjB4Ta7SjiHimF1OJPiLjUHKwOjUZ6TgHqVlUmZA4SqUFHI7RIVAOpeC8jGI/ISlM8Wbza3IdXiKP321lbSVojAb0gJiSMaTnWZaXIXbfz1S/jw8ZKA2sZgiufgC5mpeHG8knBdNfkU5Bl5UmPT2ILhxX/3ZPtpuRS5L6b8UKe0CU3C6EUcoQiGikt9sWHqUaKR0sg5sotBykXViHo78vGSoO6XvKt63xk52vRYPYh1raM3EI8EPEs6L38lGDioZ0RcaKp7cVKFDHhG0OY38bMfg2M9tsW7RdLpsIkVQXPgKgEtgAVEfvcyMLW54dTRhY/QCipHMVy2T3/IFUw3b7czI7ZJrgocsNzzO1ncuCuG+MFYvyFvC+OR4kL7S/y9UmkuEz+4zLP0XqFVcjCo/CfuR/ZeYU4ez8Zrb/5z8jbTIoqznaYuCUC6S8K8NnOq1ghM2lX70bCoQTmKo25ITrXH6dj/Rl54RDmIN8pn6AqdIdxk4jP4SL0EdIL+EsxqQYrx/lZPVDdXe9aQlEUYlNyeBNQcOEes+bEfSwa2lRRO6XgCqlK4BtAmXEYgD4IWC3NSWv/yqzCtsMEXF+Ss/KMLHl8NcMA/gVdVCJ/DAI9MQkJN9yJx87GCvmFOtmLzPsK3RaZ5BZoTVIwDFtzFkmZeUaxku92qI3fGa7B7etWMSl7qBp8NaAhImKfG6WxV+rmybTopOcUGDK02dpoeIU4er+DrTVsrOUIRDpBDXVaToGi2k5c+JIP8FGFx82YDxtrjaI05jRi7j02Vhr8MDJY0UKA7cZsvP92QibqVXU13sFAzHqy4WwMb/IMLhQFOBVZp5RY1pS4z3ep7yVZHkMKoQydTCxjN2fj6WIvfZAFKGRY18215AHGVoFpO68aWWEjHz3H/H9v4cv+DZEo4r1y44nxvOHt7iC4VhDil1MPjNzOmZa8oJoeRr+xVeBpAMjPKi2GHGt1fHou/Ko4GW3PK9QnAtFoNNDpKKS/KMClmFTW/C56bTOyNErBVSxZqV1clkGBVocJm43LJvAl1/rutWascjtM+OIWmeyMeCzbCwwABjMUqAv332bVAFWCjqKQyVhjyYkdbeLjJpikClDuYsqF6+kwcFUYdHni+QvUgFjySgl6kWFrbYVjU7ugYz1PiV/Ig+nG9sn2YmvGkNVn0HXZCVYBcyUwrUBSLhyWRihLFJPfwh6YXPOMyRf9G2AIx0pwR8AV4/Nd12QLr3yTdlMfd1RzM17EnL6XLLqgZAqW7epUgX2RYCA33bPYwCZFboFWMv06H0k8MWz9m1bH1wMbsbbxJaIpCSo722F8pzpYPLSZ2edifjsPkrMN2WdtrKx4LXkJRYuzrLxC0XqANJdiUpEiEL8CQHZ2RwDYER5nWNBGJ2XKthrJzTpna21lUjyxmGXWUcCFTwymkMenXPnwz0jodBSm77rKaz0H9O9y+6VHglYuPqs8H3TmX76aeELIyQhJIze7Yh0RayxdeF2MhPQX2MZYlLk62OCjHgGyri0XU961GhQaLHmWmfv45rS3119C5KM0vCbhms6HUgEP0Ls/c5UBTEues73xs7eR4WnAZKcK8d+1ZYYXxPKUYKAo4H8n7mPTuRi8/st5NF9wFPuuJci+thpJRIT4PSyG9bcSZcLVuDS8+j/5HiZ/nI/F8agkWQrA4SG+JsdRKxHwuCgR8L4a0JD19/OcAsXzjNQwuZnHIqmElOx8zOQYI0oCIuSVErS7po21BvWquqBjgPlCXofFx1l/M91nuGmclUKnN36lWQ2jLHeLVbbySfFIInsjAOy5Ei/rODGa1/LAe53qmGR5MIUCLSUY2C22iKe1i4uHNsXmca0NE7PS2DFTOH0vGa/8pDy7LB9X44z7aOf6Xlj/TitVzq+EHRP08RBKFzF8CFmU7WyseM9Pu7Kkvygwcjnicy0c89tFs+pmMpm+6xo2novF4+c56Lnc2M2YScd6noaFCF+MKR8ZuQX467LyhZ6YNVdMs//tq8JjE0VRWPnfPcFkDP9FJWFH+GMjazPN2N8vYsZf1zF3n7wETkJsv2R6VlspkjJz5df2MtMUN2T1GcxkKNb6N6mBqb3q48a8PuadGED4Vz0RtaAvrwteSWCIyVNhPJCLKd80n/XKHJixWE28jeOHlc6NcjNm0vB5iZgSn8Xku8N38PXem4Zsn1LJekoKbvZRrpdHarbwGmDw6jOyrZEAMFemkqilXyUA+oRZlmInI/bQVIaH+GLdWyGSmavFEFtjAcZlgkxh26U4hCrISKsGRMgrJZiB3ADQVUHNIiG4CS+iEjMl09nLhRaYbKw0mNYrkLXPr4rpiTu4NKjuip9GmZeiWi0iH6VBo9FY1G2CiVhZALGU7zTeHo6wsS4WHORaV0qaejyJLoBiTfEvY1oCKHYBrOFuXjY7U6AnC1sZ7pJSCCUKoihK8vzcNc7+DzvyHicU4yDEvEHC2fAW/HsLHZeESp5j2fAg2Cm0GvOVhVGLL/obxwyJGUK/2nND1H1dqDQLFyGXbC58C/DBwd7ied3NJDE9F+ESRXpp5IwxYnBjVqYUFQ53sbcxW1Hj6WIPB1trjGqtz/IX4lcJ0/sGSvzKNJKz8vB72ENWFlOD543EXLD2zZYWaZNc+KxX5sBUKllZaQyJtpjbpAib0c3k69f5Qh/jf+9pJjafE856WdL4eDjyblfLIwvQx2QzLdctFhzFooO3WXUgTUFuGEsdT2f8Plb/3aqlROTD3ZE/cZxcfhwZDHdHW/RsVA17Puhg8nnEXKLN4e32/qy/39lwSXExd3MgQl4p8ahoMKYXeZUFkmdIIeW+0mmp9GJNCVoKGN+JnYQlV0CYaOLjJstdh/mRt65dGQODvPFwUX/zGqoiclzm1CC3QMtbQgEA3maUYxCC1qrSLkXPRTR/ANBLJMiYhi/zoLkIFbGnXQN7N66OU593w5mZ3QHIy3QoF40GaCSSCZKGdkk2J2stTRRPvS8A+PX0Q1FN+JttaxktamytrTChSx2jY6UymnIZ1rKmouP5qOZmb9A2C40BXHQUhR4Nqpp9bT4CeGLoans6Yw7HBZjmD5Hi7gA7Y6wa1KpsLOR9OaChUeFkNZGTpIhG7QU0szxIt0B13nnXwKo4+XlXbH2vLXo0kB6/TCFk4THM//cWBq4Kw2trzuLnk/cNz0bMhW5IsDf6NqlukTaVFtzxj6uUYpb3oWsJhhRZf4q3m29d7PXDKczeexObzsWYfS414FPYfPdaM8yTUUpCLhqNBj05c/TPJx9g1K/K68QxeXfDJVnHHf+sK9yLMnfz1ZpUC3M9pZjhNG4O5gmMM/oaKwrNwdZag+EhxnOt0mLu5kCEvFKikJGtCwCqmlh7p7uMBdMomcUj5Sxo912NN8qkxZfxzEoD/PthJ0ztVV/0fHW8nHF1Tm90KnJXfaONPhWz3GxdloRuuxqB9jQTOhsv0Gm+PRAluNCSk+yDbidtORJzyfh5TEt4uYonMVj/Tiv8+xG/5cgU+OINmTAH+1pVnAzp0s2NAWVmhaMo4PXWvpK/MVW4GxzsjX4KFnpi7qBuDrZGwdo6isKsfg0Rs3iASe2jMSe2qYqzHWIWD4BGo4FdkTuXXKtxfiGF5SOCTb62GFx3pk4Bnmhbp4pg2n0+PumpbgwZzYfd66GpT7G7m18VJ8QsHoCqrg6S/dGSQiCT9JwCBFYTTzajBDUUJACMLHZ+VZxhZ2MFKSP7Z73F5x4p4lJfIDz2ORYxyirQCrQFRYv5L/sXxwKZk6VYLTrUq6Lq+Z5zsmFy45yYU+OOCe3wZf+Gqidpm8dwhxZynS5pmMnf/hjfBj+MDMLwEF+DZwPNpz2N+2CwgvJRzP6lFmE8dSKlGBEiPWdK8bGAwl9N3ZLUmkYMTxd70fWZKcwb1KTU4ohpiJBXyjjzFENWArdAMB/nZBaSbFNb/mLij/FtDP9uzfM75ndbVeTDo9OQb3inNSJn95J1PyWFf1GAt5rums14MpQxMcctwr5oMJETcNyncXVZwpPc+jhysJIQ3JvVNI75AIDG3vyWN7lFiZnJW6q52csadLmTtVze61RHkYvng2fC8SUOttZ4zklLL1QuQynWVhreBYgcBjSrYfg3reGN4HEJnP2KsQWtQKszaIfFkKO84tK/aQ3W3/TCRO67PD6ti6pCDpNpvQNZmVJ7NSzW0CeKJMno3qAqJnVVJ/mQlMY8M68QP49piZ4Ni5+9lGJGDO7cZup9TO5aj3e71HjS0q94XuqmQjgEUByTN6adPyK+6on3WItC/T5znpkUG99tLbq/irPya697K0RwHzfcgxtPy3wH3h6OeK9zHbPc75x5BOX1Z2IM/7Zk4hMlJKYXe050qOeJV5vrrTXcOZUvDIfPoi+EOTFmasJX/1cp9rZWhpqgTLxKKWMuFztr5aE5G99tjfZ1hRUrrfwrlbryhwh5pYyLmUJekBlFxbkILbL56FDPE3+Mb4OzM7vzWt2YBggxSxgdSG9tpUEljquiWppgLnwDDR92RRO6mu6algzvc1CYAUtKgOMWKTcXqfTTi4fxZ7LUaDSYxmMRntS1riHmalLXutj7QQeMbSdelPez3oEGYVgIKw1klS7gw87GSnYG269faSRaFNbexsooeRD3GzGHj3sGYP3bymOlBgZ5C+4bwXBN8a1kHLdCDwvfvdZMVOv6q8jCkwsdH8Pt//S1bGWOI1XdHCzqQcCM52K6GL1eFGfGR9dAL9XGQTnKH39PZ6wb2wo/jWqO6m4OqsaYmTKOXviih/D5RAbTMzO7sxbI76mkoWcKylWKFqcz+zWAj4ejIQZx/0edVLkWH1JKCKmkDlzF2N4POhi5BDLhuq9xa+XVFPnGTWH/R53wzxTT46oswZo3Whhte6udP+pXczEqAs/9VmvzZKxVosg1NyZciUApBtMLwVSy8woNiVxoto5vI0vpVxLQCpwfRgahhrsDlo8QrmH929gQ7JrYDl3qe2Hre21xenpx3GmIXyWc/Lwrtr/fFgHVXM025JgLEfJKGXM1NZ3NyMrJdfkKu5eMW/P7wMnOGvWrueBdiQLoHep5wlsgAJnJwiFNAPC7QonF+ksFuZsKc63xeZ9AwXdAD9h8WbNHKnBf2PZ+W95rq42DQqubUFusNPq+wZ2whCxqchGrtXVsahfUF1nAvN+ljlHBbWd7Gxz5pDNm9G2Aj3sEIMjXA3NFEooAem2zg8SimXvfYkINF1trK7zRRnjRzqR3Y/GYIiVuhqbSNdBLNAkLH2J1EZlB/XyxOPRvh4f44tKXPQXr64kt4Ne+yV50xRdp1bkCGj1+yM3o52hrDS9X04VoqQRBKQx3UmZJFDFFn521lWitwvmDG6Nv4+qw0sCQlEQNBgZ54/wXPdC8ViXpg2ViynBeTcRaL2bJ8/FwZGnQ5abdl4KvX07sUhdnZnY3KBs8Xexx6JNORuVf3uJRQCnxngGkXULFFpSf9wnErknsTIa0kti3svE87mRnbZRUjWm1eK9TbV6lCF+5H6FEJVxcHWzMLnivNv2a1jBaK7k72uLIp12woGhtQ8MVylztbYz6XryC+GlzFTx/TWov67gGHA8qbty60nZ0qW9swfw9LMboPO0VJqqZ2a8BdkxoZyhazucdYGrylYbV9ff8avOaODerBxoJrHcGNK2BHg2rIYThRs8cF+xsrOBXxRlt6ui/FUtmJpUDEfJKGWYHmNJNrwnk812uV9XFkIiCiamaZz4Nz9XH6XCys0HEV71w4KNOmNq7Pt5sK2/hIJTcAAB6NKyGG/P64BMe9zCx5k/rrX72tG3vtzUs2gOrueKDbvUEYwiSisoZ8C0m7G2t8EqzGkbb+Whbp4rBRbAFz6KJLxHIxS97IPqbfviXJ5vixndbY1TrWvjuNbblS6lQcEUg5TI3WU7/pvoYMyl3q1WjxbOiDhIQlqZ0qyeYcZPG3sYaf3MGbxd7GwRUc8WkrnUN9y70Pax4PRiTu9ZF+7pVBJPb0HAL/K58PRjX5/aWlUTI1lqDng3lJYSws7ESdaGTW9/MHDQaDcZysn9JIeZSzRTk3RyNJzdu/Nn5L3rgxrw+iFrQ1+hYoYVF3yY1sJXhLi70mKoVCV1y6moC+oma7/vkIvR+payPHgyNtVR/p7G3tRJ1S+4c4IW1Y1riwaIBkrFQprjAAmBlxuQm1VAE49vc8E4rDG3hI3KwNFLlTZhu2XzffCcTFKRyrZENqrvhox7Fbqa/jQ3BnIHGyhSmAlAOUgKQi4jS+INu9QSToLzSzHhsvjant9E25hwjVLqVr5ag3KQ+Lg42sJZZi3AAZ/6tV1VaMW0OzP4ipJzihgJoNBoc/qQzfn87BK8290HUgr6scW3JsKZw43lnfBZSU/BytcdrMpJsrRvLHrv288Tir3g9GO93rsM7VnMZ295YoVHDQ3gck+u50aGuJ1rXroxf3grBjXl9eBOlBCnwSAOAfVM6YnSbWviWM34Kufnvv25cV5HZu7mCvpo5HUyBCHmlDNMHeFrv+gj9rKuRxev09G7Y/1FHwYHFFA2uWOkGRztr2FhbwcXeBguHyAuilsp0RmurP+rOjq/QiOQPf6eDP0I/66qoIPbYdn64PLuX4W9uLEZjbzc0qO6GsBndsLfILYRvggOAGkXaR76JPS2nAD+Nao7Qz7riwbf9JV1dL33VExe+6IGqbg4sl5tOAZ745lW2NtDexgpVXR1gY23FGzfXpb4XFg1tiuEca6JSd82UbP6MWa+3Yvenla83x8nPuwo+p76Nq2PlqOZ4pZm30SRHZ18MrOaKxcOM+9Kuie3wWR95wrybg62hvAIgz9WZFoQHB/tget8G0Gg0aOlXSTQ5CrfumkajgauDrVESoYVDmrDcNAD9xMDsLmIZTO1trEUF8+2X4kQzUQq97yHB/O9JLFPq3YX9BPcB+lpG1+f2xsUvesBDJC6QuY/7fk593g2dAtjfo23ROMP3HCK+6oldnBpKfYqsn+3reRqUDkz3LlqzPqatH5oXWSmqKyjBIaY0WzikCU593g0t/Dx490spD7zdixdurpwscEICmL2NNboFVkXPhtV4lX9cQYd2geUuEjvX98K6t0Kw8d3Wgos0ocVIx3qeGBLsjbfa+eHP99vi8z6BaOlXyaBN54NrGQDYlryugVWxfEQwVrweLHgOKbjPkKZ+NX0/9/ZwxPud6+DTnvV5XdOVuATTKInZYV7T1cGW9/lqNBpWJumWfpUwoKmw8tDW2sogHH/YvZ7R+CNHOKC/S+bcwqds4nNZZ3qLRMbxl+Zgfm/jO+qFLm55ID6F2fS+gbC3sZadbXHFyGDW39FJWUZFsc0hqKY7wr/qafj797dbYULnOnitZU30bsw/f1hZaYz6vp2NFbo3qIYfRgbDwdYaN+OLPQtGtqqFDJ4whg3viMdeKmG4DCGvZiUn3FnYF4ODvfH98CDecXBwsA++6N8QDrbWopbZY1M7ozvPenDB4Casb4I5P4jNk/9+2BFTe9XHW+380MSnWCEuNP8rNXw0remOb19tCk9ObGAdLxfZAiMzO35pJ1rhQoS8UqQPx11Lo9GgtqezUSf1rexkWBByB3UAhkG/kpMt/p7cnrdeFBe6DMJohoC4b4p0JsX3BWIb5JrzP+5ZH6MZ7mxiGj76edAL8irOdhjFsQT0bFiV5Uqh0WhQ2dkO8wY1hn8VJywbzvardiqynNas5MRaWK54PdhIIKRdU/ha+E9RltHans6wstJg+/vtsG9KR0TO7oUjn3bG7fl9sWRYU0MhYBd7G4Prka1N8fttUN3VKNsW0yVHiRaIvh+p4Hw6MYBQ4g3uYtXG2oq3FuLp6foyB2vHtDRY6Zippd/rVBsXv+iJI592xuFPOxuePZM6XspKNNRinJ+uqycGVxAG9H1kzZstWfVr5CZxYfJGm1rwreyE/6Z1MWyr4mLP+n7b1REOyra3scK4okVQ/6bVjd61rbWV6IQV+llX3u1vC2izQ/yFrTB2NlZG9XyYtPKvDFcHW6MswFx3M6arKte1rJbCQs2uDrZG/Y75PGf0bYCYxQNYyYzGtPVDzOIBWDCkieHZfcNQVH0/PIh3IcyX8IFLYHVX1KriJBjLypcUZ0CzGgahaljLmuhYzxOf8yg1hOLl7KytYGWlwbqxIfi0V33s5VizuZaZY1O74ODHnViJsQCgf5PqsLLSoEt9L16BumM9T8FYKFtrK/z4enPMH9wEttZW+KBbPfw1qT1+ERCSGtZww8GPjePSuhaVUWA+a74FLg2fyxcToXfWg2Fp/aJ/Q3wskDHV0u7QzO9ZbOGn0WgMSsIRITUl68QuGdYMez7ogE961ocvxyPnqwHCHjU02ye0RacAT+yaWOzKxx17hLwWmN+0mJJt5ajm6BbohQ+768/D/Y7HdazN6stDgr0NCXbkzHnzBzfmFUKtrDSC85+Uyy7tSUWzd0pH1sLf1toKs/o3xLLhQaJtXP9OK3QK8BSMd+Z6AL3KqT24clRz2ZZ+JguHNGGthej7bVOnCg5+3Am/jRVXatjbWGPF681lldc58mlno21LhzVDxFc9Ua+olM1gjrLRt5ITWvpVwqAgb7za3MdoLcvnWtqrUTU08XHHRz0CMH9wE9kCHNdLYFqv+ugU4MnymupS38vI9Z/L3ikdZVlCHe2sDQrtIc3lh3dMUmDAMJWykbrnJUWOlYyrSeAO6oB+AfbPlA7wreSESs52cHO0xbcHoljHrH2zBWpWcoK9jRVSs/MN/sTM1OdMLQmTYF8PXClyeZouYHWRK+RZW2kwrmNtbC2qUcVX84tLkK8H/v2wI2q4O+BBcjb+vBgHQG8FasIJCKbjYsa29+d1QxManAcH+2BwsA/8Z+43bDPUMHS2w9vt/bHnyhOkFWU75FruHO2s0bRoG50cY2QrfgvrW239Mf2vawD0Cw3uwJXGyKjI5/oiBK2Z5cZp7p7cHlYaDcJjUhF6Jwlfv6J3G+rbpDp2T26Pof87yzpe7rvk64u/vhViqM04pq0/KjnbsZKFHP20M3r9cMrwt1LrI7MOjrlJi+YOaow5AxvhSlwa6lV1UVy7hn5vdb1ccPiTznB1sIG1Fds2LRZDY2dthY96BKBTgCea+LjjeU4+2i06bti/eVxrrPjvnuFv7sRfzdVYMA3y9UCwrwe+ebUJvvz7hmH7d681w2UB91zD+RgC3Pb32xb1TfHg/b5NqhuSx4xuUwvNa1XCm21rwcXeFvY21qjibMeKRVOKpwtbcDJlYe5oZ425A/VJbgYFe6NAq8PM3dcN+zsFeMqqj+RftFAd1doXC/41Lk/iaGeNzeNaY/Ifl9GlvhdsrDRYPiLYYP2xttJgC0f4ojl19xnvdq57XpCvBzoFeOL0Pf406O6Otobshhe/7IHW3/wHAIb4EBorTXHqclcHG8F2mcK6sSG8i7HgonGcGcetFfD5a1jDTTLpC/caP44Mxt4rTwTdyr/o38BoXrQ0n/QMwJPnL3jnVmZWyz/fa4s7TzPR3NdDciFra23FUgy6O9oaknnUq+qC6G/6Gca04PlHAbAFnMbe7tg8jv2+mWP+gGY1jDxuaJhjrti4MCjIm+WeH1jdlZWB18nOmpU0jqnk8JBIxDG6TS1DwpO32vlh07lY1v4u9b1Yws6jlBzoKAq/hT3Ew2Th+Na32vnBy9Uec/65KXiMHGq4Oxo9XyaLhjZFTr7WIOwtHNIEf0c+Mex34oxxNlYaWUmTaKXnzontsPK/e6wQmoY13ETzHyjF2d4GF7/sgZSsfBy8kYjE9BcYHlKT1XeXDGsG30pOWBUabWiftZUGKwWUGC39KmH/Rx0Rl5qDiVsuA5Afy8llcLAPdl/WP9MH3/Y3jMETN0fgVlGMtpQynGZqr/pIyswTHKNpLs/uheikLN4SGZvHtcb/Qu8bZbqXcjlXAyLklRI35vWBm0h2uT6Nq+Hwzaeys4Ixtdl1vVyw54MOePAsC1N3XIWrgw36NuF3AWHG0AhNLkxtllDWQSVJOup6ueDfDzviWVYeugSIa2tpaGGucpE1r66XCyvwdfmIIByPSlIcX8SFOWEymTuoMZrX8sDH264AAL591fRaQK+1rGkQ8qRSE1szBoF/P+xo5HrmX8UJMSn6DIz0++O+RzrOKNjXA+M7FfcnjUZeDBKTqb3qY/nRu7zWCEAv+EV81RPJWfm8lpsATnIVpSUamOm53SRSdQ9tLh3zo9FoTEouwbUiMOPUmBYdpl9/l/peOMmYKOiJh+7HXGuih5MdJneth/VnYuBga4Xdk9maTj7XsU1Fbj5vtPFDi1qV4OFki2eZeWjq4y4p5I1t74clh6JQxdkOrWtXlqU1ZQohCwfrXSWZyislAfu0Mon5bLltMNX68naH2gYL58hWvvjjwiNcf5IOAKILMkC/0Hi1uY/BFdLJzsawiGQqhQCgU4AXrs/tY1Ib+Qiu5WG0TUjA41LV1QERX/VEana+kRVjZr9igUcskY4Uez7ogPEbLyE5q1iQF7NacZVyzMynA4O8sa8oM+2SYU1lpR6nhdWPewRgSHMfVtZSLu93rou7T7OwK+Kx4DFqwxeHTsPMaulsbyM4FjvZWSMnX2uU2ZLm3Q618cOxu4a/baytDGPKxz0CcOFhCtaNFc+i27dxdSw9pK9B9/3wIMF53tHOGnW9nHH/WTa+VOAaOa1XfTxNz8Xj5y/w4+vBBgVqx3qeCItOZnkUOdnZIPSzrrC30ScdGv3rBcO+Gu4OrLl39iuNDELeaIGEV/Q8xLTgu9jbGCUCc7Czxtj2/mhTp7JJnh1ycXWwxe8MK5+zvQ061KuCM9Ephr+ZWMsU8trV0St3W/lX5h3TGtZQtzxMVVcHVHV1QEOenAKAfqxuyfAekZNlsrG3Oxp7u+PTnvURHptqcpmfLvW9sP+jjvCr4syaJ3MLlZfg8PZwxKZ3W2PpoSj878R9I4svjauDreBaolOAFzoFeGHyHxE4cD3RsF2t2EsxiJBXRlk1ugXiUnNE3dnEfK2DizT6bepUEc3g2athNXz59w204FlM0DTxccOx209F28tczPp4OBq5FRmf07SUvBqNBouGGqfaH9qiJoa24H8ei4Y2xazd1/GhgHaSiZinCFMgkdI2il6DcRE6qcugIG/e1Ps+Ho74qEcAvFzteZ/Zm239sHD/bZPbopQp3eqhX5PqqCvSL6u42BvSi/NxbW5vLDkYhYCqLoqDkp3tbTCrXwNQEM68t2tiO+yKeCy4KDKHz3rXx7Ijd7H0NeH0yk1ruuPD7vXg4+HI0tSNCPFlCXlc+IQqL1d70cLn977ph4AvDxr+ZiY7oSffGkWxYFKLeabwIhfm+MQndFZxsUOCSB04JqtGN8fK/+7h3Y7CyRPk1HaUQqPRu3QtORiFEa2kXXGm9w3E4GB+4cHaSiM7qYQY9MKZC5+LsxKEvsX3OtXBL6ceIDkr3yiBhRKCfT0Q/lUvNPr6kKGGmZKYFKZ1YTBDyBPLtMsk+pv+eJCcbZR5V4hmNd1ZQt7S15ph+q5rmNWvAbLzCrHyeLTgb/lCJZTSsIabrGyvtNXx97dD0K6OJ5Kz8ng9JwDg3Y7+SMx4wRsz/SlP6Rk+6ni54PT0bqjsbCepSPlvWldZ52RSxcUev/G4L64bG4KE9FwjJQT9t7eHI/6a1A7fH7mLUa1roUdDduyqrbUVvN0dEJ+eKxmP90ZbP8Sk5GBA0xr4eu8NYyGvaH5vUN28LNKmMLFLXYOQx/Ve6FDPE8dFSmP8Pbk9qrk5SMYeM+cXR1trONpZIzU7XzDXg9ooGbuFXKyV0NjbeL00pVs9nLjzTFacIpfP+wRiaIuasscaPhYMbgJXe1u4OthAS1GCxhc1IUJeGcXW2kpQwKtX1QXRSVnoLBGzAEibu6u6OeDa3N6iaV4ndqkLK41GNDubrbUGnQI8kf6iAH9P7lDqGYWYjGpdC/2aVBdNGEEzONgHG87G8FoimWtwV3t1arvQMU0LhjQRrK/GTfjBRCoDI9ffn49JXetizYn7kscB+oU81xqnFDcHW3xjhiV0goQfe4h/ZZaVV02mdA/Am239JPsSnRl228VHhm1pL/Kh0YiXDXGwtUJugfzCs7bWVjgzszs6LNa7eYpZ3yxRWLeVf2XMHdgIfgLxLnMHNsa7Gy5hVn9prX/NSk6iwjOgXu3Mys52WPKasbII0Mf5HrstXm+MZkq3eljx3z34K4w35LJseBDeXn8J0/sGwtnOBp9svyLoQiqkEFKCRqPBjgnt8Nflx2Z7PwDA0aldDH1QiQv2wGbeWB0ajR4Nq6JHw6r4vE8gAqu5yrbYWllpFMUvjW5dCxkvCgyp20eE+KJ3o2qG73l4iC98PBxR54sDRr8VErKUsHRYM4z5/YLomA7orY7vdy4e58Su7epgy6v4VIoa96cUB1tryVi5ln6VsfU94SykoZ93hVZHSSpEXOxtDBlomRkQm/q4w8PJ1mJ1eeUQm1JcD5UbE//da82w8VwshresaQiFAPQJhhxsrdGspofi9dYbbWphUte62Hg2hjduXS3a1K4M38qOaO5byaI1SOUS4l8ZV7/uzZv5WQqNRtlYw0cVF3vWvJORIa+8jzkQIa8csu6tEFx9nIb+Ilm4lOAmkKWMxsHWWjJ9vEajwaYiH+ey8DFzkSPgAXo3pmBfD14BulBbvDqXk/RDjOPTuuBOYqYhu6m7hOuhEELWrGXDg7DjUpysbGMz+jbAtF71cfBGIpqLWHQJeuT2JYDtjmtjpYGPhyMePxeukxTiVxlh0cmKakX5eDhiy7g2khPXB93q4dqTdLwmYPE2FaFEL0DRpDqnt1ljQmA1V9x5mgkAiHyUxkqsYQl+fL05msw5bPjbS8QqPblbXdTxckb7uqbXKwWA5rUq4crXvQzPaXCwt+AzmzuoMRIzck3SRjOp4+WCz/uoY+328XDE5nGt4eFop+hduzvZ4uzM7obffCDgCqUWNtZWmNKdPZcxv2da0Pmyf0N8c+A2xnWsjSY+bujVSDgbrxKa1nRH5OxeZXKOLK8odfkH9BZdekwpC8XXR4T44qs9+hhqruW9iou9kVLg9Va+BoFVSV+iwzv6N6uhP68FylQxcbKzwanPu5Wp/l5Wiq+XFBqKKoFiTAQDGRkZcHd3R3p6OtzcSt4tgGA6f0U8xrSdVwEYF5JXg7Un72PxwSjM7NdAdtkIrY7C0sNRaO1f2eKL34pO7Vn7QVH6uI9zs3qocs6/Ix/j0+36PnNtbm/8cvIBVoVGo66XM6/bU1JGLlaFRuPNtn6yXdYqOn9efIRZRYlSTn7elTfTq9osO3wHq0KjMTjYGz+ODC5TixQCgWAe6TkFWH70Doa2qMlKAFPWiYh9jr1XnuDzPoGCJUTEyMkvREJ6rmi4BaHkKAl5gAh5JQwR8sovSRm5aP3tf6hfzQVHPu0i/QMTKNTqBIPeCZbl8qPnWH7kLr56paFqcRkFWh0+3haJYF8PvN+5LvILdTh4IwHt63oaEnkQxKEoCt8euI16VV0EM9ZaAvItEggEAsFSECGvAkKEvPJNanY+XOxtStV/n0AgEAgEAoFQfikJeYDE5BEICuAGRRMIBAKBQCAQCGUNYo4gEAgEAoFAIBAIhAoEEfIIBAKBQCAQCAQCoQJB3DVLGDoEsiTqYxAIBAKBQCAQCISyBS0HWDI1ChHySpiUlBQAgK+v5QpQEggEAoFAIBAIhLJNSkoK3N3dLXJuIuSVMJUrVwYAPHr0yGIvlUDIyMiAr68v4uLiSBZXgsUg/YxQUpC+RigJSD8jlBTp6emoVauWQS6wBETIK2GsrPRhkO7u7mQAIVgcNzc30s8IFof0M0JJQfoaoSQg/YxQUtBygUXObbEzEwgEAoFAIBAIBAKhxCFCHoFAIBAIBAKBQCBUIIiQV8LY29tjzpw5sLe3L+2mECowpJ8RSgLSzwglBelrhJKA9DNCSVESfU1DWTJ3J4FAIBAIBAKBQCAQShRiySMQCAQCgUAgEAiECgQR8ggEAoFAIBAIBAKhAkGEPAKBQCAQCAQCgUCoQBAhj0AgEAgEAoFAIBAqEETIU4FLly6hf//+8PDwgLOzM9q2bYsdO3YoOkdeXh7mz5+PgIAAODg4wNvbG++//z6SkpIs1GpCecOcfkZRFA4ePIhJkyahWbNmcHd3h5OTE4KCgvDtt98iNzfXwq0nlBfUGM+YPH/+HD4+PtBoNOjbt6+KLSWUd9Tqa0lJSfj0008N82eVKlXQrl07rFmzxgKtJpQ31Ohn8fHx+Pjjj9GoUSM4OzujWrVq6NixIzZv3gytVmuhlhPKC1u2bMGECRMQEhICe3t7aDQabNiwQfF5dDodfvrpJzRt2hSOjo7w8vLCqFGj8ODBA9MaRhHM4vjx45StrS3l6upKvffee9TUqVMpPz8/CgC1bNkyWefQarVUnz59KABU27ZtqRkzZlBDhw6lNBoNVadOHSopKcnCd0Eo65jbz168eEEBoOzt7ak+ffpQn332GTVlyhQqICCAAkC1atWKys7OLoE7IZRl1BjPuIwePZpydnamAFB9+vRRucWE8opafS0yMpLy8vKibGxsqMGDB1MzZ86kpkyZQvXo0YPq16+fBe+AUB5Qo5/dv3+f8vT0pDQaDdW3b19q+vTp1MSJE6nq1atTAKi3337bwndBKOvQfcrT09Pw7/Xr1ys+z/jx4ykAVOPGjanp06dTb775JmVnZ0dVrlyZunv3ruLzESHPDAoKCqi6detS9vb2VGRkpGF7WloaVb9+fcrOzo6KiYmRPM/vv/9OAaBGjRpF6XQ6w/Y1a9ZQAKj333/fEs0nlBPU6Gf5+fnUwoULqdTUVKPtAwcOpABQS5cutUTzCeUEtcYzJrt27aIAUKtWrSJCHsGAWn0tPT2dqlWrFuXl5UVdvXqV9zqElxe1+tmkSZMoANSPP/7I2v78+XOqVq1aFADFYyOhYnH06FFDH1i0aJFJQt7x48cpAFTnzp2pvLw8w/YDBw5QAKjevXsrbhcR8szg8OHDFADqnXfeMdq3YcMGCgA1b948yfO0a9eOd5DQ6XRUnTp1KGdnZyonJ0e1dhPKF2r1MyHOnj1LAaAGDBhgTjMJ5Ry1+1lSUhLl5eVFjRkzhnr48CER8ggG1Opr9GLqt99+s0QzCeUctfoZ7WnFZ0kZPXo0BYAKDw9Xpc2E8o+pQt6oUaMoANTJkyeN9nXt2pUCQMXGxio6J4nJM4MTJ04AAHr37m20r0+fPgCAkydPip4jNzcXFy5cQGBgIPz8/Fj7NBoNevXqhezsbISHh6vTaEK5Q41+JoatrS0AwMbGxuRzEMo/aveziRMnwtraGitWrFClfYSKg1p9bfv27dBoNBg2bBju3LmDn376CUuXLsU///yD/Px8VdtMKH+o1c+aNGkCADhw4ABre1paGs6cOYPq1aujUaNGZraW8LJz4sQJODs7o0OHDkb7TF3rkVWdGdy7dw8AEBAQYLSvevXqcHFxMRwjxP3796HT6XjPwTz3vXv30KlTJzNbTCiPqNHPxPj9998B8E+EhJcHNfvZli1bsHv3buzZsweVKlVCenq6qm0llG/U6Gv5+fm4fv06vLy88NNPP2HOnDnQ6XSG/XXq1MGePXvQtGlTdRtPKDeoNaZ9/vnn2LdvHz799FMcOnQIzZo1Q0ZGBvbs2QMnJyf8/fffcHR0VL39hJeH7OxsJCQkoEmTJrC2tjbaz5QFlEAseWZAL1zc3d1597u5uUkubuScg3kc4eVDjX4mxMGDB/Hzzz+jYcOGGDdunMltJJR/1Opn8fHx+OijjzBq1CgMHjxY1TYSKgZq9LXU1FRotVqkpKRg/vz5WLp0KZ4+fYrHjx9j9uzZePjwIQYOHEgyB7/EqDWmVatWDefOnUPfvn1x6NAhLF26FGvXrkV6ejreeustBAUFqdpuwsuHpWQBIuQRCC8ply5dwsiRI+Hu7o6dO3fC3t6+tJtEqACMHz8etra2WLlyZWk3hVCBoa12Wq0WkydPxrRp01C1alX4+Phg/vz5GD58OGJjY7Fr165SbimhvBMdHY0OHTrg2bNnOH36NDIzMxEXF4evv/4aCxYsQI8ePUgZBUKZhAh5ZkBL3EKSdUZGhqBUruQczOMILx9q9DMu4eHh6N27N6ysrHD48GE0btzY7HYSyjdq9LONGzfi4MGDWL16NTw9PVVvI6FioObcCQCDBg0y2k9vI/HsLy9qzZ1vv/02YmNjsW/fPnTs2BEuLi6oWbMmZs6ciQ8//BDnzp3Dtm3bVG074eXCUrIAEfLMQMxHNjExEVlZWYKxdjR16tSBlZWVoJ+tmE854eVAjX7GJDw8HL169YJOp8Phw4fRqlUr1dpKKL+o0c8iIyMBAMOHD4dGozH8V7t2bQDA4cOHodFoEBwcrG7jCeUKNfqas7MzfHx8AAAeHh5G++ltL168MK+xhHKLGv0sMzMTZ86cQcOGDVG9enWj/d26dQNQPPYRCKbg7OyMGjVq4OHDh7xWYVNlASLkmUGXLl0AAEeOHDHad/jwYdYxQjg6OqJ169a4c+cOYmNjWfsoisLRo0fh7OyMkJAQlVpNKG+o0c9oaAFPq9Xi0KFDaNOmjXoNJZRr1Ohn7dq1w7hx44z+GzlyJACgZs2aGDduHIYOHapy6wnlCbXGtO7duwMAbt26ZbSP3ubv729qMwnlHDX6GZ2lNTk5mXf/s2fPAICEOxDMpkuXLsjOzsaZM2eM9tH9tXPnzspOqqjgAoFFQUEBVadOHdFCmw8fPjRsj4+Pp27fvk2lpaWxzkOKoRPEUKufhYeHUx4eHpSLiwsVFhZWQq0nlBfU6md8kDp5BCZq9bUzZ85QAKjGjRtTz58/N2xPSEigfHx8KCsrK+rOnTsWvhtCWUWtfhYYGEgBoH799VfW9ufPn1MNGjSgAFBHjx615K0QyhFSdfKePXtG3b59m3r27BlrOymGXgY5fvw4ZWtrS7m6ulLvvfceNXXqVMrPz48CQC1btox17NixY3lfvFarNRTbbNu2LTVjxgxq2LBhlEajoWrX+w/dugAAi7JJREFUrk0lJSWV4B0RyiLm9rOUlBSqUqVKFACqb9++1Jw5c4z+++GHH0r2pghlDjXGMz6IkEfgolZfmzp1KgWA8vX1pSZPnky99957VNWqVSkA1LfffltCd0Moq6jRzw4cOEDZ2NhQAKgePXpQn332GTVu3DjKy8uLAkANGzasBO+IUBb59ddfqbFjx1Jjx46lWrRoQQGgOnToYNjGVBDMmTOHAkDNmTPH6Dzjx483KK6mT59OjRkzhrKzs6MqV65sksKKCHkqcOHCBapv376Um5sb5ejoSLVu3Zratm2b0XFiE1Vubi41d+5cqm7dupSdnR1VvXp1avz48VRiYmIJ3AGhPGBOP6MX2WL/+fn5ldzNEMosaoxnXIiQR+BDrb62fv16KiQkhHJycqKcnZ2pjh07Urt377Zw6wnlBTX62cWLF6nhw4dTNWrUoGxsbCgXFxeqVatW1E8//UQVFhaWwF0QyjJ03xH6b+zYsYZjxYQ8rVZLrVixgmrcuDFlb29PValShRo5ciQVHR1tUrs0FEVRyhw8CQQCgUAgEAgEAoFQViGJVwgEAoFAIBAIBAKhAkGEPAKBQCAQCAQCgUCoQBAhj0AgEAgEAoFAIBAqEETIIxAIBAKBQCAQCIQKBBHyCAQCgUAgEAgEAqECQYQ8AoFAIBAIBAKBQKhAECGPQCAQCAQCgUAgECoQRMgjEAgEAoFAIBAIhAoEEfIIBAKBQCAQCAQCoYhTp05h4MCB8Pb2hkajwZ49exSfg6IoLFu2DPXr14e9vT18fHzwzTffqN9YAWxK7EoEAoFAIJRT9uzZgytXriA4OBhDhgwp7eYQCAQCwYJkZ2cjKCgI7777LoYOHWrSOT7++GMcOXIEy5YtQ9OmTZGamorU1FSVWyqMhqIoqsSuRiAQCARCOeTtt9/Gxo0bMXbsWGzYsKG0m0MgEAiEEkKj0eDvv/9mKfjy8vLw5Zdf4s8//0RaWhqaNGmCJUuWoGvXrgCA27dvo1mzZrhx4wYCAwNLpd3EXZNAIBAIBAKBQCAQZDJlyhScO3cO27Ztw7Vr1zB8+HD07dsX9+7dAwDs27cPderUwb///ovatWvD398f48ePL1FLHhHyCAQCgUAgEAgEAkEGjx49wvr167Fz50506tQJdevWxWeffYaOHTti/fr1AIAHDx4gNjYWO3fuxKZNm7BhwwZERETgtddeK7F2EiGPQCAQCC8l27dvR79+/VCtWjXY2trCw8MDAQEBGDRoEFavXo3c3FycOHECGo0GGzduBABs3LgRGo2G9d+JEyeMzn3jxg28//77CAgIgJOTE1xcXNCsWTN8+eWXSE5O5m3P3LlzodFoDO4+O3bsQJcuXVC5cmU4OzujZcuWWLVqFbRareA9HT58GEOHDkXNmjVhZ2cHNzc31KlTB71798ayZctKVItMIBAIFZHr169Dq9Wifv36cHFxMfx38uRJ3L9/HwCg0+mQl5eHTZs2oVOnTujatSt+++03hIaG4s6dOyXSTpJ4hUAgEAgvHe+++65B4woALi4uKCgoQHR0NKKjo7Fv3z4MGDAAdnZ2qFatGtLT05GbmwsHBwe4u7uzzmVnZ8f6e+nSpZg1axZ0Oh0AwMnJCQUFBbh+/TquX7+O9evXY//+/WjevLlg+2bMmIGlS5dCo9HAw8MDubm5uHz5Mi5fvox///0Xe/fuhb29Pes38+fPx5w5cwx/Ozk5gaIoPHz4EA8fPsTRo0cREhJiECIJBAKBoJysrCxYW1sjIiIC1tbWrH0uLi4AgBo1asDGxgb169c37GvYsCEAvSWwJOL0iCWPQCAQCC8VYWFhWL9+PaysrLBkyRKkpKQgMzMT2dnZSE5OxuHDhzF27FjY2dmhffv2SExMxMiRIwEAI0eORGJiIuu/9u3bG87922+/YcaMGXBycsI333yDhIQEZGdnIycnB+Hh4ejevTsSEhIwaNAgZGVl8bbvypUrWLp0KaZMmYKnT58iNTUVz58/x4IFC6DRaHD48GHMmjWL9ZvY2FjMmzcPADB16lQ8efIE2dnZyMzMRFpaGk6fPo3JkyfD1dXVQk+VQCAQXg6aN28OrVaLpKQk1KtXj/Vf9erVAQAdOnRAYWGhwbIHAHfv3gUA+Pn5lUxDKQKBQCAQXiKWLFlCAaB69+4t+zdjx46lAFBjx44VPCYjI4Py8PCgAFCHDh3iPaagoIBq2bIlBYD64YcfWPvmzJlDAaAAUGPGjOH9/VdffUUBoGxsbKgnT54Ytm/fvp0CQNWvX1/2PREIBAKBn8zMTCoyMpKKjIykAFDLly+nIiMjqdjYWIqiKOqNN96g/P39qb/++ot68OABdeHCBerbb7+l/v33X4qiKEqr1VItWrSgOnfuTF2+fJkKDw+n2rRpQ/Xq1avE7oFY8ggEAoHwUuHh4QEAePbsmWh8m1L++usvpKWloXnz5ujTpw/vMTY2Nhg1ahQAffycEF9//TXv9s8//xyOjo4oLCzEX3/9ZdhO3xNtkSQQCASC6YSHh6N58+YGt/qpU6eiefPmhrF5/fr1eOuttzBt2jQEBgZiyJAhuHTpEmrVqgUAsLKywr59++Dp6YnOnTtjwIABaNiwIbZt21Zi90Bi8ggEAoHwUtGjRw84ODggMjISnTp1wrhx49C9e3fUrl3brPOeOXMGgL4+Eu2yw8eLFy8A6F0s+fD19UW9evV497m5uaFly5YICwtDeHi4YXvr1q3h6emJhIQEtGnTBhMnTkTPnj0RGBgIjUZj6i0RCATCS0nXrl1BiZQSt7W1xbx58wxu8nx4e3uzlHElDbHkEQgEAuGlom7duli3bh1cXFxw7tw5jB8/HnXq1EHVqlUxcuRI7N27V3RyFyI+Ph4AkJubi6dPnwr+l5GRAQDIycnhPY+Pj4/odej9SUlJhm0eHh74888/4eXlhZs3b+LDDz9Ew4YNUalSJQwaNAhbtmxBQUGB4nsiEAgEQvmECHkEAoFAeOl44403EBsbi7Vr12LkyJHw9fXFs2fPsGPHDgwZMgRdunQxCGNyoV0/R44cCYqiJP+LiYlR9Z569uyJhw8fYtOmTRg7diwCAgKQnp6Offv2YcyYMWjevDmePHmi6jUJBAKBUDYhQh6BQCAQXkoqV66MCRMmYNu2bXj06BGio6Mxc+ZMaDQanD59GnPnzlV0PtpFU8gNUy5Sghi9v2rVqkb7nJ2dMWbMGGzYsAF3797F48ePsWTJEjg4OBgsfAQCgUCo+BAhj0AgEAgE6N04Fy1ahNGjRwMAjh49athnZaWfLsXcODt06AAAiIiIQEJCgsntiIuLY6XdZpKZmYmIiAgAQEhIiOS5fHx8MH36dEybNg0A+54IBAKBUHEhQh6BQCAQXiry8vJE9zs6OgIoFuwAfcITAEhLSxP83fDhw+Hh4YGCggJMnTpVVCDU6XSi51qwYAHv9u+//x4vXryAjY0Nhg0bZthuyj0RCAQCoeJCRnsCgUAgvFRMmTIFI0aMwF9//cVKXpKVlYW1a9di06ZNAIABAwYY9jVp0gQAcPr0aURFRfGe18PDAz/++CMAYNu2bRgwYAAuXLgAnU4HQC/Y3b59G99//z0aN26Mf//9l/c87u7u2LhxIz7++GMkJycD0Fvwvv32W8yfPx8A8MEHH8Db29vwmyVLlqBfv37YvHkzHj9+bNiel5eHHTt24LvvvjO6JwKBQCBUXEgJBQKBQCC8VBQUFGDnzp3YuXMnAMDFxQU2NjYsy1rHjh3x5ZdfGv4eNmwYvvjiCzx79gwNGzaEp6cnnJ2dAegFurZt2wIAxo4dixcvXuDjjz/GwYMHcfDgQdjb28PFxQUZGRmsDJdCpQ2Cg4PRpk0bLF26FD/99BM8PDyQkZFhSOzSs2dPLF68mPUbnU6HQ4cO4dChQwD0ljtHR0c8f/7cYFFs2LAhli9fbs6jIxAIBEI5gQh5BAKBQHipmD17Nlq2bInQ0FDcvn0biYmJyMrKQtWqVREUFIRRo0bhrbfegrW1teE3lSpVwqlTpzBv3jycPn0aSUlJBitbbm4u6/wTJ05E3759sXr1ahw9ehQPHz5EWloa3NzcULduXbRr1w6DBg1C9+7dBdu4ZMkStGjRAqtXr8b169dhZ2eHwMBAvPPOO/jggw9YbQOA999/Hz4+PggNDcX169eRkJCA9PR0VKpUCY0bN8awYcMwYcIEODg4qPgkCQQCgVBW0VCmFAMiEAgEAoGgKnPnzsW8efPQpUsXnDhxorSbQyAQCIRyDInJIxAIBAKBQCAQCIQKBBHyCAQCgUAgEAgEAqECQYQ8AoFAIBAIBAKBQKhAECGPQCAQCAQCgUAgECoQJPEKgUAgEAgEAoFAIFQgiCWPQCAQCAQCgUAgECoQRMgjEAgEAoFAIBAIhAoEEfIIBAKBQCAQCAQCoQJBhDwCgUAgEAgEAoFAqEAQIY9AIBAIBAKBQCAQKhBEyCMQCAQCgUAgEAiECgQR8ggEAoFAIBAIBAKhAkGEPAKBQCAQCAQCgUCoQBAhj0AgEAgEAoFAIBAqEETIIxAIBAKBQCAQCIQKBBHyCAQCgUAgEAgEAqECQYQ8AoFAIBAIBAKBQKhAECGPQCAQCAQCgUAgECoQNqXdgJcNnU6H+Ph4uLq6QqPRlHZzCAQCgUAgEAgEQglCURQyMzPh7e0NKyvL2NyIkFfCxMfHw9fXt7SbQSAQCAQCgUAgEEqRuLg41KxZ0yLnJkJeCePq6gpA/1Ld3NxKuTUEAoFAIBAIBAKhJMnIyICvr69BLrAERMgrYWgXTTc3NyLkEQgEAoFAIBAILymWDN0iiVcIBAKBQCAQCAQCoQJBhDwCgUAgqAZFUVh1/B7C7iWXdlNYbD4Xg3+vxZd2MwgEAqFckJVXiO8OR+FWfEZpN4VgIkTIIxAIBIJqHLyRiGVH7uLN3y6UdlMMxKZkY/bem5iyNbK0m0IgEAjlgmWH72B16H30X3m6tJtCMBEi5BEIBAJBNR6l5pR2E4xIyyko7SYQCARCueLGk/TSbgLBTIiQRyAQCIQKDVXaDSAQCIRyhhWp5VzuIUIeodzwLDMPOfmFpd2MMs2zzDxk55FnVBF4np2PjFxigSKUXyiKwqWYVOQWaEu7Kaqh01GIK4PWaoLlKNTq8CTtRWk3o+QhMl65hwh5hHJBUmYuWn1zDK0WHivtppRZUrLy0OqbY2g+/2hpN4VgJrkFWjRfcBTN5h6BTle+7FBUGWwuWauUDjP/uo7ha8+hwexDpd0U1fhq7w10WhqKzediSrsphBLizd8uoMPi4zh971lpN6VEIeNm+YcIeYRyQXjMcwBAdn7F0QirzbUi//l8ra6UW0Iwl4T0XMO/tWVRaiIQZLA9PK60m6A6Wy88AgB8f/RuKbeEUFKcf5AKAPjj/KNSbknJQtw1yz9EyCOUCwrLmTWjNLAmA3KFgSKCnaqQp0kgEAjKIEuK8g8R8gjlAq2OWKeksLYiIzKh9KGISEUgEAjlHiLklX+IkFeKHL6ZiL4/nsKdxMzSbkqZp1Bb9heOWXmFGLz6DNacuF+i1734MBV9fzyFiNjnhm0V3RKk01F4d8MlfPH39dJuihH7ryWg74+ncP9Zluhx1x+no++Pp3DiTpLRPubbq+CvssQpa9+G3P5S3pj7z02LnDcztwCDV5/BzyeVjbMn7iSh74+ncP2xemnhw2P0Y+/Z6GSM+e0C5u2zzD2XVWKSs9H3x1PYe+WJ0T6KojD5jwhM3XGl5BumIi9lwhUAOfmFOBOdUtrNkIRed/3vRHSptuPx8xz0X3EaO8uYizoR8kqRCZsjEJWYiQ+2Xi7tppR5dGVsYcbHxrMxuBqXhiWHokr0uiN+PoeoxEwsZ8SIVHT31pvxGTgelWSIjylLfLD1MqISM/HZzquix7278RKiEjPx9vpLoscRy5i6lLWhhO4v03aI95fyxoazMRY57/oz+nF20UFl4+zb6/Xf2zsbLqrSDg2A19bqx97R6y7g9L1krD8To8q5ywszd19DVGImPt52xWhffHouDlxPxO7LT8p1dtUF+24Z/v0yWba2XSxbwooQm87px4Olh+6Uajvm77uFWwkZ+HzXtVJtBxci5JUBSMp7acrawoyPvMKy41JaHp6XORSUA/fdzFzx7zrjhbzyCOXtXZa39pYVyDwgj3wzx9kMie+SIJ/0F8LPkpkVuDwoaYXIZpRtKse3oZiytJ4R40UZScaXXUbLexEhj1AueInGVlUoz5OqHMrD7ZU1t0CCHvJWyjck9LjsIBYr/zJZvSoi5cWDRFvBvZbMhQh5ZYCE9Fwcu/W0tJtRLjl7Pxmz99xATn4h/rkaj8UHo8rc4lqro7Dg31s4fDPRaF9cag5m7b5e4eJxaFYdv4c/L5Y9l0ohQu8kYe4/N2VbC5IycjFr93VciUvDnL03cOpucR0loW4Yn/YCM3ZdE9WUMn9L//vc/RTM3nMD2XmFyC/UYe4/NxHKE89XEuyKeMxyDxaC1rLmFWox95+bvPGHXFaHRpvkhkt/S9FJ4t9SWRkfrsSllVpMKUVRWHwwCvuuxpfK9c3BylwprwRf/4UHKfCfuR+/hz0s6pvlN/7+wPUEfHvgNstCd/epvHmrjHxyJU5McjZm7b6OmOTsUm3Htcf6sSYlK8/kc5SVcZMLU8jzn7kfq47fK5HrpucU4Ks91xERm2q071lmHr74+zpuPFEv/tdUyo2Qt2XLFkyYMAEhISGwt7eHRqPBhg0bFJ3jxIkT0Gg0gv8Jne/u3bsYMWIEPD094ejoiKCgIKxZs0bVTj9+U7hq56qICD3q0b9ewObzsVh1PBof/RmJtSfv48TdslWw9J+rT/Bb2ENM2BxhtO/dDZfw58VHGLH2nKrXLAuWvAfPsrDsyF3M2l32kqMI8c76S9hwNgabZBY6nrbzKv68+AhDVp/BxnOxeOv34ngfoXew6GCUovphtEZ11K/n9X09NBqbz8diw9kYvCMRz2cpPtt5FSv/u4crcWmix60pCobffE7fXqn4w4fJ2fju8B2ThJ9xG/Xf0mtrz4oeV/pfhp4hq8+UWkzpybvPsPbkfXz4Z2SpXN8cykrtLo2Mdoz85TwAYP6/t4rGCfG+WZaZ/Mdl/HLqAa+y8mVBadd7Y90F/HnxEd5Yd8EyDZLJoFX6searPTdMPsfFh8bCTFmAO88uO1Iy9SsXHbyNLecfYdga/dqN2YxZu69h64VHeOWnsBJpixg2pd0AuXz11VeIjY2Fp6cnatSogdjYWJPP1aVLF3Tt2tVoe3BwsNG2W7duoX379njx4gVGjBgBb29v7N+/H5MnT8atW7fw008/mdwOgnykXAdiU3MM/36WYbq2yhIkibTnXpHVISU7X9VrlgUPBsvGvlj2Bh8/l5dR7XZChuA+oXdw7r6yjGVcWfFRSg4Kyki8RLpEXCH9Xcan5YoeR2NOXBptVUjLkRfr+DKTkqXueFOSmG/IK73BMasCxF0+zZD3LTOF4DIwHZkMn1eFXOjMnGUlQ+c9CS8HMaTG+tJCW0pT4YNnbOsss29ElaGM+eVGyFu3bh0CAgLg5+eHxYsXY9asWSafq2vXrpg7d66sYydNmoT09HQcOHAA/fr1AwAsWLAAPXv2xKpVqzB69Gi0a9fO5LYQ5CE1uDKtqtoyYMViUhqa57LqWvEyoZY1le8sZcSYIQkt6NpYl50Gk08DsCo3PjzGmOuuaen3T1GULCtfeaUsKBAJpmFOryyrdXhLrYayyOMoS3NMuRnqe/bsCT8/vxK95t27d3Hq1Cl069bNIOABgJ2dHRYsWAAA+PXXX0u0TZbm2uM0bDwbw/K7LwtItYb5nasdiHv3aSZ+C3uI/EIdsvIK8cup+4hjWA75+OdqPEKj9PFHSuf7pxm5aLfoP3RcchyPn+fg55P3karQ0lcSry82JRu/nLqPHIGsUkoEzdwCLdadfoD7z7KQmp2Pn0/eR1KmsMaYeerYFON4h9sJGfgt7CEKTVTzJabnYvulR7jwwPQ6QeYM9Mw+zH2OaS/yTV5Emvpctl18hIsPU5GUmStYn2xneBzO3k9mtZcWdG1UWCDkFmjx66kHeMATv7r78mPR3zLbVBKWnAfPsrDu9ANVUsdHJ6lzrhtP0rHhzEPodBQ0PCuU+yq2WQ7JWXn4+eR9XHuchlbfHBN0B+OOudYm9P3zPN/xc3qckWmZuvzoOTafL/YgEhqT6W/370jxPllekau8Yr4lSygdQ+8k4R8VY0rp/vgsk+15w+xu3K6XXdQ3t154JDkGCXHy7jPeOoOWwByLIi3kHbyegKOcHBKHbiSKuvGm5xTg55P3sfl8LPZfSxC9TmK6fo5Jy2F/X/mFOqw7/QD3nrKtZHxrnTG/XTB57ufjVnwGfufMm8yu8PPJ+3gmEO/4y6n7yM4rNIzjeYUlmw203Fjy1OTevXv48ccf8eLFC9SsWRPdu3eHj4+P0XEnTpwAAPTu3dtoX8eOHeHs7IyTJ09aurklyqBVZwAAHk62GBxs/EzKKsyJR20hr/cPpwAABVodYpKzse1SHFb+F40b8/oI/uajoliXmMUDFC/Ix/x2AQnp+oVHxyWhAIBT957hj/FtZZ+jJCx5vX84hbxCHR4/f4H5g5sYt0HBuVb+dw//O3EfC/ffRrs6VXDuQQr+uRqP/R91kvxtz+Unce+b/qxt/VacBgBYa4C3O9RW0BI9h24m4lDRpBWzeIDi3wPmWfL+uCDsjn4mOgVNfNxNOi/9XGysNBjb3l/Wby4+TMXMorjKRjXccIvHRfXGk3RDfaDPetcv3lH0CEzRAnMtIj8cu4ufTz7ANwdus95JdFImpiqoMXfqbjJ6NaqmuD1K6P69fl5Iyc7HjL4NZP1GyEW453L9uTJeFGBq70CT20THh7g52vJ6F/QoavPznHx83kdem81h0pYIXIp5bvh7xM/neL+1b/bfwp8Xi8dcUzwjXi+KjWPy0bZInL6XjL8jn+DQJ50lzzH0f/Li6XSUXmD+dHvFqnuoFOZrssRsRMcjh/hVgreHo9nnm7g5AuGxz3HgRiL2ftDBsF1sGF9yKAqbzhWP1U193BFQzVXRdccWxXG3qFUJvpWdlDVaITlmlBuwttIgLScfk/7Q13W+u7Af7GyskJVXiIlb9PkGbs3vAyc7Y7Fi5u5rOHijWAhsU6cnPF3sea/z+i/nEJOSg0sxz7FubIhh+6+nH+C7w3ewcD97/Ofz3Dp9Lxl/XHgke46Tov9K/bxpa63BmHb6czL7N7dmJ3Pftwei8DA5x5CALiuvEJ/0rI+S4qUU8rZu3YqtW7ca/raxscGHH36I7777DtbW1obt9+7ps/QEBAQYncPa2hq1a9fGrVu3UFhYCBsb/keZl5eHvLxiCT8jQziGpyxxpwz5FAOQNIsw5TpLCTjXHqfhxhP9+5MbW0FRlOIYEr6MZWeizYvjsgR0dsgLD/g18EraEB5bvNg7V6R1vxkv71sp0Apf6IbMc5Qs0g/mOiMrF6+7plmON1CU9SuGYSnlE/AA4PFzfss2LejKVXSwFoYU+28hS89ThTG4959loRcsK+TRRDCEGCleSFjQmN+IOdxJzEQjbzfh6yhoszlcknmds0UxrPSYa3Z2zSJO30sGoH78jI6ikJguzzpYHpFvyWPE5FlwPkrNzldFyKO/r6sSyaSYcC3ECem5ioU8mmdZeRYX8pTAfWfWVhpW7Vdamc705Mkv1MHJzvhcpzjJ8NJy8gWFvJiUHN7fRD7iHy+E+pYlMlvS6z9A2RzM9Ai6/ChNzSZJUm7cNdXAy8sLixcvxo0bN5CVlYWnT59iz549qFevHn744QdMnz6ddXx6ur6TuLvza83d3Nyg0+mQmSk8SSxatAju7u6G/3x9fdW7IQtSxrw1ZSyLKZ5/lT46qnRi8spCdk1LUh7uTskrEHOP5jtPWQmP4GsGs70GIU/2+YqP5PZhoecp59xMIbO8fhtqxniKCd1l/emU9QoKOooqUzE5amPS2qCCPg9zlW1MynqfsbGyYrWRHkJY2wSeB3cNJMuTknMqpc/HEmtY5hhsalxzSedLeKmEvMaNG2PGjBlo3LgxnJ2dUbVqVQwePBihoaHw8vLCypUrkZSkbt2pWbNmIT093fBfXJxw6vS/Iizvw59XqMXWC4+w4cxDxVn+opOysCvisUmd9PDNREQwNNHhMamGGk3RSZnYFfEYTzNy8d3hKGw4o49/+zvysWyLIvOD3n35iVEbD99MxJjfLqCAZ3RJyszF1guPjDL7xae9wDZGjTeuZSE6KRNnopNx+p5wyYatFx8ZXC9pYpKzsSM8TrFbKVezJQb9DP65Go+b8WyNFkVR+CvisZFvO5O0nHxsvfAI6QozFd54ks6ovaXg/mQempqdj19PPcAvpx6wtu8Ijyv1WkRclMR+cWMlWN2X5zR8a/RCrQ47LsXxxijK+b0pJKSLx3gonWiZ7dp7hR1vw0qupGOtLIz48+IjVhZAVpxgCWqwnhSNIabGYTA9BuQ2Oye/EH9efGSINbsUk4r/bhfH0FAUZdbS9O7TTOy+/NgwvvBpzPlilg/dSMBJFcrbMBeMcutZMrH0IktHiX/7N+PTeWPJtDoKO8Lj8FDlcSzy0XMcusGOl9LpKOwMj8P9Z1nQ6ShsPh+Lb/bfkhWfSC90xWq7xiRnYy0jdtfUONjsvEJsvfCIFSeX/qLA4qVHLj5MNcSOhUUnG7Yz4zCfZuTijsgcKsTeK0+w5FAUbhl5mbCfUVxqDrZfesS7ZhEiv1CH7ZceITQqyfCNqsWpu8+MFE33nmZi92XpeELufCNn7ZNfqMPsPTcQHpOKf6+xv5c/Lz5izD385/rr8mOjuD4hUrP1652MXPH1DvNKYgK+0WMvRaXsS+muyaV69eoYPHgw1q1bhwsXLmDgwIEAii14tEWPS0ZGBjQaDVxdhc3z9vb2sLfnN0tzmbbzKno0rAoPPnu3Smy7GIc5/9w0/P3g2/687i98gzIdG2JjpcGQ5vLj9e4/yzLUiKN9qV8rqgtXr6qLIU6Iyb/XEgzuEzGLB0hqcZiDxvUn6Th0IxH9mtYwbKOv//6mcKx/pzXrt6//ch4PnmUj8tFzfDc8yLC9/8rTounYey4/Zfi3UHzebJ66NF2XnQAA0WLYfLz1+0Vcm9sbbg62ksd+c+A2EjNy8VvYQwDsuLKDNxIxbedVo+1MPth6GWeiU3DoZiI2vdua9xg+6LifGu4OrO1qZZwbv/ESr7vD9KJ4MFPj58TIyC2Q9czlwrcw7fXDSUQt6MdzNP+3yIyteJGvhaOdNTafj8W8fbcAWOY58DHjr+sY2aoWaxtLPi36w5RXP23nVdRwd0D7ep5G591+KQ6j2+ivy2cpn7X7Oqq52ePCFz2N9pWkIvVJ2gvM3H0dCem5+LSX8jgMZo1JuQu2b/bfxh8XHqFWZSecmt4Nwzk1OLnKKiMkLkPHKN9OyMCvp43HFwDotDTU6HcTt+hjeSJn90IlZ/lzHLepzPlqXdgDTO5aT/a5AMsblbQ6cUvegJX6MbKqqz3a1qli2L4zPM4Q+6rm9/tqUSzh0U87G1wJ/7r82BBDu3xEkGGeOngjEWEzuouej743OoaTD3qO4/5GKXP+uYldEY+x/sxDHJ3aBYA+3l0NZYEYI37WfzPpL5qytl9guIwPWX1G8XnPRCfj421XAABrTtxnvWfuM+r8XSgoCnieU4CJXerKOv/PJ+/j+6PFdeJc7G3Qu3F1xe3kY1VoNDrX92K1t9cPp1jHaATMRtw15tPMXDSCsMs4zebzsYZkRx5OxXPwrN3X4elih/Cveon2rQ+2XpaVy4BeV5y8m4Sfx4QIHlfWra18vFSWPDE8PfULiezsYi0aHYtHx+Yx0Wq1ePjwIWrXri0Yj2cKlq5FEnqHbakUcgES68xCvtFCiGWiFNrHjT+RWuBw914T8McOvWM8OdD1To7eZmeM4gp4YgsjU+p7hccoLy6apaD23A6BgttXH6dJ/paOAVRiPWRyLymLd7FvLiXtzw6YXrtN6J75YghzC4QFfr7zMNuULxEbyYeabkaA2Pul3TWVx+QB7Hgp5lgVHlt8r0JnForVKw1XdKY1QAkHrxdnopPbbjrz3SOBsZWCOu9fjgafj1SZ2nUarnKIuV4Mu2fac7UkFCXPbnWXYwWKUCnmUog4RtzsFUbcGfO6cuqDmmIJN/WTozM2Muu7WVrAY8JdLzHheugA0vcpVleV+1t6uDurwOOKO86oHZOezMggydfLhUYVriLOlBAW7nosWUatT7m5DOh1xeGbT0WPY95zeamSQoS8Ii5cuAAA8Pf3N2zr0kWvOTpy5IjR8WFhYcjOzjYcU17gmsnLi3u91DW5QqApQoWs2B7B6yu/HmDZgULtLKPmUHZaUnKodc9S56G1pxYrDWDGaZVa8rjCB/N3zDIpzOOUWohLIybP1M+c2VK57ZYeK8Xj2uT2I1Mt80rHJSNLHuO6hWVojKPRW/Kk28U9pCRjt82peWbKIzfVbbC019Hlrd6spb0EmWOQkkdjyRjyEn1FrJhE+TfFLieiXnPkUCGFvOTkZERFRSE5ma3ViIiI4D1+xYoVCA0NRUBAAFq1amXYHhgYiM6dOyM0NBQHDx40bM/Pz8fs2bMBAOPHj7fAHRhzPOopK/ZLp6Ow/dIj0Zi10/ee4XgUWzPB7WCsJAkitbmY6APLKby3KRy/hz3EP1fjERH7HHefZmLQqjAjDSX7eqb1cOli6Oy/zz9IQd8fT2HL+VjBekWp2fnYdC7G8Hd2vhabzsWwYnnkIncBxs3KaclJrFAg6yR3IX39cbqhxk9ugZZVC8oc9kQWa/onbonAZYYFeF9Rn9HqKKw5cR8XTbBqlhTmpJ3mkpKVJ5hFkVUbj7Gd75vZEV7cp+nFITNeRErbvj08ztAXdToKiw7cxrx9N1WpLcS0MlLQx7csZ7gQGfZR+jEsKjEDFEVhx6U4RCWyNc9bLzzC5UfPsTM8jvWNaTT6uNFN52JkxV2I1R2Ui05H4Z31F036PuSuB5Kz8rDpXAyvRwdF6S0Lr/9yDqF3krAr4jHiUnOw7vQDPM/Ox/1nWUbxS3z8fuahUbyjKaRms69z6EaCrLqSl2JSJV3dcvILsflcjFHM5xvrzrPcnYUERv34oh9TuLFjYq+/QKvDHxdijeLiMiVidZhk52mx+ZzyPqI0a+iVuDTWGKsEppCn9GuITcnGhjMPFf3GVFmc+a7ElAORj55bpNbcFYFMm9wYRyZPM3Kx+VyMYDZgJpsZ64+NZ2OQkpVn6IM09HiVmK4/r5hnCXdsWx0ajdWh0ZLtAIrnfjpT8mUeyzIz87dYmZ9rj9M4dQP5+zZFUdgV8RgXH6Ziswlrr20XH0muvUzNskmvD/nmF4qiTPZyokDh8M1ExTkxTKXcxOStW7cOYWF6X/br168bttG17Dp27GgQuFatWoV58+Zhzpw5mDt3ruEcw4YNg62tLUJCQlCzZk1kZ2fj/PnziIyMhIeHB7Zs2cIqoQAA//vf/9ChQwcMGTIEI0eORI0aNbB//37cvHkTU6ZMQfv27S1+7+k5BXh3QzgA4N43/WBrbYV/rsZjxl/C/vv5hTqM+U1ff+Xq173hXuTPbGzJK/6bKfBIuY9tOR+Lo7eeGhXFBPQxGyxfc8Y+bqycWnA/dHpw/oonJo5m4uYIlnCRX6jD13tv4rewhzj5eTej48XGEr0LlDTcGD2NRmMx1U4Bw/QR+eg5mteqxHvcwFX676qamwNO3XuGn08+4D1OCZGPnrMEEbqvxCwegJvx6fiwqI7gt682xZJDUUKnKRN8u/82fnu7lfSBHPhe67iN4YLH74qIK45vo/gFPj7ofsdMSb/nyhMMbVFT9Hdf77mB5SODsevyY/xclMjGt5IT3u2ovK4gk58ZSXEoijLEt3D591qCYQz73xstMP2va0bH3EvK4q1PpgHw0bYrOHX3mSwtMVMwM3XBuSo0GqF3niH0zjOMaeun6Ldy3SPfWX8J15+k4/S9ZPz6Fjs2hKIoQ22w8xzX3AfJ2YqSURwSKVwsNhydYbiDMZ/jo5QcQ8ydVDzZl38Lj8k0dFzhqtBoPM8uFrDORKewXLD4lBK3EzIM40vM4gGisWNcNpyJwTcHbht+SyM2j3BZsP8W/otSnsDNWqHKnRaUfSs7oqVfZWXXYmgd5Ew/zMRQuyOfYLdC4dJUL4NMhkDDjMPlQscd1qrsJDjPmQKfS2Bcao6hLhwfQ/93VnbR8dl7i/Mj/HstAXGpORjQrAa+PWA8Jw5boz/vzfgMLB7WTNb5C3UUvjt8R9axdB1SZztr3Jzfl7cPr/yvOHSJr430W6brLddwd0S7ulVYZRaAYmH01L1kfLazuJ7kWoVrj5m7r0tapV/5KcykGNcJm8NxKeY5jt0ufg70/ZnjMpyQlmvIEXHtC+k6wOZSbix5YWFh2LhxIzZu3IjLl/WTyZkzZwzbaAFQjEmTJsHX1xenTp3CTz/9hA0bNuDFixf45JNPcP36dbRubZxgonHjxrhw4QIGDRqE/fv3Y8WKFbCyssLq1auxcuVK1e+TD2bGH1pIu/ZYXDvBzMiUmVf8e7G05Ex/brGMTjqquMaQUm7Em6ZVkZoiTHHBErIexaYIxxAKmejlWgeOMYRiDSxryWM2SU7GtntPM02KceF7JPefCV+P+XyVxneWBqYP6MZ9QkgzrN/HXxvPFB2A1PgAAMeKYlCvMWI0I0x8H0JNFGs6U8N6XaG2VaMpjheVI7QxteqmLjjFtPeSyPzQ6efApzwTu086EyAXU6yWYlZHIc8RqSyrSjlRFDv9NCMP+SJzUT6Pt4JQLKIcLgnMCcd43ocQx27LO5b7nE3V9d1PUp6Nk+0GLX1hU7xbWKigx7wSJz02PRCZd9QiXkKAkyvg8XH1cbpg/Uj6vGJxguboi+m5P1tFz5V7SfrxQqgmHjfDtynPzlJhKfR7YFrs6HXm7QTTa2tKeVqoTbmx5G3YsAEbNmyQdezcuXNZFjyaGTNmYMaMGYqvHRgYiJ07dyr+nSnwaXzNNfSI1Ygy7dyUMp9+xjUoyrSFh2TilVJ2nZfMWEcfx/lbaRiGqbfJvI7QNSmo9xzlvuPyEPFgaqiM0mfJLQRu+LfEUzK9T+gvWBp1HPUNKP6n4melUD3CdvtSdi3DOUz7GQAzYvKYpR9MGjflXYM5R4g925LqKnKvo4Z7sdrIfU1GoRMmXs/cfsH0+LAUlhznS3ru11r4gtyuLxZiw6W051Ohtjrasj3k6PHGpqwUfJUJfT9KFYXM8bWk31G5seRVNL5gpMZm0vm7UIPP9X+3n6LVN8dw9n6xdSW8SLvAnAQ3n4/FoRtsTS63I52NTsb/TkQbZSekJ4gLD1JYZmmmduTx8xwsY5j8/7wYpzh+gOZeUha+P1Icn5MhI1tk07mHcZ4R68GnVVU67vJpys1h3MZL+PGYcRZWLsYxecqe46urz2DyH8KuIkKsOHYPSZm5+P7IHTwQqW8kl41nYwz/jkrMNKrFJ5QFc8OZh6x3tUtGbcikzFwsO3zHECsgxrLDd1h14mJTshEalWQoJcGlUKvDT//dQ3hMqqDvfoGWgv/M/Vh8MArPs+VnBkzJzsf3R+4guigznJQGj9kTmJYtijLOxCeFHCGbHkOY19Wg+HnvvfIEP/13z6xFjdBPkzJzWW7BlkpwsOzwHcSl5rAmZW7NJblwM+PdeJKOz3ZexYJ/peuLaTR6K+53h6OQlVco6365mYdvimTKE8rKLOep6iiwanZdjElF3x9PMepd6inQ6rDqOH98D3MR8zOjPppSZu2+jh+O3pVdG6xAq8Ot+AzM33cL3ZadgP/M/QZXKABYLzN2bPflx5wYIjZqWjdo1py4j9Wh0Ya5jdkllh2+g0sxqVhx7B4O3UjEhM3h6PJdKFp9cwy7Lz9meRcsO3IHSZns/rf3yhNM2Bwu6/75sqTmFmjxw9G7JsczcZHzeWfmFuD7I3cEx7od4Y9ZayHDuTkZDy/FpKLNt8dY1u07iZnwn7mf5W5sKgevi7k6mz+OcRUcmbkFWH6keP2VlJknWJtXjsCf/qIAo389jzfXXcCXf1+H/8z92HI+1iIKHG6/pKGfkzkJgJSwOjQa7Rf9h9fWnIX/zP3wn7lfsG/ff5aFvj+e4t1H17dU+pqjk8xfc5lKubHkVTT+uRoPK3sn3n3LjtzBnIGNDfE7MxkC4Zu/XUDM4gGsgZCO82LXXGH3wtHrLvBeiz5q5C/nWduZFvBRv55HXCrbjH6KpxSBHLhxfPP23RQ5Wk9mbiFLAB2/KdzIx1qpZuW9TcKxUWIIDUnMgGRVTihAUmYeDlxPxI0n6Wji4y7bjSYmJQetv/lP8ji+p3jtcRqa1fQw/H0rPoNVaxHQ136S4/c+d98tTOoqr+YPoF9sfPDHZVyKeY49MgLrV4VGYyujgP2lmOd4Z4M+jinY190odmVXxGN9XaGj0m1Ze/I+HiZnidbR4fLT8WisCo3Gw0UD8OGfl2X95irHpfPfawlY8O8twePlLiy4rrF0SmquC/LkLZdZJUya1/KQdX4+hNLCT/kjkvW30qWR3AXJqtBo7L78GM19Kxni0OSkiZcDXRMSAC4/eo6/J3cQPFYDDSZtiUBCei7srK3RyFu6RtRIgVhGJeQKJPlhQlEU+q9k1yqNSszEh39GYmCQt2Hb5nOxSBFQcjD74KKDpsfY/nlRWZHrAq1x25nQdSOlmLpDHxfUvm4ViSPVIzEj1xAvpa8FW/wMV4Xqxw0+6LbSJGfl44M/LmPnRH1+gLxCraEWm1RKeCFWFY1bK/67p0rNPjnz8zf7b2PbpTj8dDxa8Jqjf+VfxxiuQ8FQF/KDrZcxoJn+PH2KFu1vrLvAe24hYYQPtRKTCcENF7n6OB1XOe73Y367yHsfYoogmgX/3jKUZQgr6mJf7bmBxjLGJEkofd1WmtWh9/F5nwaCh1tblYydif7O4hllL4Ri9fr8cEoya68pZUT4KInsrcSSVwY5K6O2h5RVQG4fFOpkzO1cAQ9gB0RLXkNkgM9UUPdNjJLIpG2J79FUPRb9/pVkfZMDX39g1sbh+1spiTz1hcSgfePlLs5TBRaiienG7ZYTq8jElFpW9CPlJsvgQgsuiRzBPUZhGwF+oUnuc+fWqLwvQwvJ7Davt/I1/JtruabhxsMqnTSVaJ3j03PRvUFVRedXSqSM+o10Xa3w2FRZcWPxCr8TPuRYxMQePXM8UGpNLgnULoeRV1h67p/m3AozjksoqzLrWhL7b4nUczMFOZ83X7xyYFHxdkuT8UKddYgacOvBKSFfRv8ViwtXA74YWqHxuix6a8opy6LWqFMSrsZEyCunSHVEuRoCodOUxfpDYpRY7SuVB6XyUFCTq20zt81lqX6fcrdjy70w2nWXewWpvs23l+8nQmeRislT+mnZWCt/Rsq7RDn4cBiwEl0oeKDmfilyLiXWHuZ7Ka24Z7G4HbXbVJp10SxW59IE1P66TH2utjYl9Z2XnWdvaRdGiyZ7A6VofVAe1j98mDNMmBtnrRQi5JVB7jzNxHwJNxO+hTJzG+2iBgBjBFw1AQiObf9cjYf/zP2sWDgl+M/cj6k7rqDfitOG8g9q8tqas/iBUXtLjiadRip+BgCm77pqtE2jUX+AZMbkfbD1suxaP+9suISwe8lmL3LSGVrD9WdieI+R4/IFSGcdo1ES4zVepOSAGgjF6gmRnJUnaJ0yF6EJ7w+J1PjHbycZjQebz8ciPCYV728KN8R28T32Aq0OvzPidv67bZy5TcpqX6DVidZukoPSBa5Stz7u+ZceioL/zP24+DAVM/+6ZhS7tOHMQ3RcchzvbQrH7YQM+M/cL3mNqduvCCYCYb5bucWy1WDI/8Tr0QEQrVk3YXM41p1+gPc2heNmgnB8FtfdX03EFoJcq7dcpm6/wrud762o5ZolhVpdQso7IS41R3Tcm7g5wqQSEGJ0XBIK/5n78Yjhinj/WRbe2xSOa4/TEBqVhChG5lb6O7rxRJlFcdpO43mbi//M/fh4G9tdPL9QnYf/9vpLgvsm/xEha+6Q68HY98dThrqiBVodPuHckxBCHh1MV0+6xqRSrj9Jx4RN0jkDKOjjZb+QUU7FkvxzNR6zdhuX7hGjQKszSzhjxvdO3XHF5PPIhcTklVF+lwiYbuVfyWgwP3QjEQOa6WvQMYWeByKDvlRnfd2MyZsvoFstwmOfG7mVyaGOl7OsgYVZ482SMBcw+68lCKZC5+PN3y7g6Kedzbr+uI3Fk9Kj1Bxe95hN52LQp3F1w99CyWKm75I3WCpZNIWpECgvhhz3Fi5rTkSLxhmYiqkKhE+2X4EDJ3sZALxWFJuSkp2Pvya1R3V3B6NjuEWxhQq1i/F35BP8FCqddEiMkjag/O+EPjkIs4bfOx2K6wPOLVKyPX7+QnaSpt2RT9Al0AuDg32M9jG/mZI0ZIuVg6GJEiiLAADHbiex4qFLA0v0DSV13k4KJLlQG7VuU0ox9pGEMMCtoSiU1McUOn8XaoiDenfDJcSm5PB+X/9cjZes82kOe6/EY8XrzQ1//x1p+fn+wPVEWWVYrGWat6ISMzHql/OI/Lo3/o58gj1X5CWUkhNqM2yNafHAdG1mSSj58bKW5KM/5QnGTP6KeKyaku54lOXHFotY8rZs2YIWLVrAzc0Nvr6+CA+3rDb+ZcSvirPRtgwT4rPKjpNCydDav7Jsi5OlEaq5V5JwY4P4LCopnIKwQs2WbckrQ+6apsCOhy39dwiIf/t0VlInO2NBMC1HfrZQwWu/KGA9E6UZYwHLu8mVlBApJ1uwBqan2SeUPFkqxY1LoZbrlpR1U3HiIQv1QTEFhJqCpRzkXs/V3jy7iJypT0kIwfMiT5yMEn5e5lKWXJOVkvaiQLL1pen2zUV1IW/Tpk1466234OTkhDfeeAPx8fHIyNCbgZOSkjBq1ChERChPAU9gw9eJ6Bp0SjqY0uPLO3Lr2fFhCf9pc0UEc+Ulrv8/3y3SQhlFUUWuZuZds7TiPbkTi6n9nl3rsYx8O6LJM/Tt5eu/llA0mDKBW/opyulySvqDkDVaaH3GfMxWGk3JxRBXAErySfG9lpLQxVEUZXG3UPrebJXGfGnkKxt0MlyR5XxnSh6FGo9Nbq1QS9fIA5SvCcrj+q0MlreUjU5gLmVSlt6I6u6a33//PQYMGIB9+/YhOTkZP//8s2Ff1apVkZiYiLVr1+LXX39V+9IvFVvOG8ekfPH3dXzxN3/9PSH+jnyClf+Z52pVnth3LR45JtY8MjUdtRDnH6SYvcjuI1DPRS7cye0eTybFAq0OOh2FOl8cED2XmFswk+Mqx3vIZcrWSCSm52J8pzqgKAp9fxROvS7GzojHiErMxJ4PhFPmm8LGc7Go7ekMbw9Hxb9de0q4NllSZh5qzxJ/d+bAne/4xiYpLC30yBkXa886gO3vt0WbOtJp9N/fLOydwq1vBwCn7xW7HWs0JeuyWd4pScu/pTMPCjHq1/OS2XflIFYcftxGfekhpcmm+vxwSlbJj1vxGaLlLGgmbI7AL2+Jl6FZ8O8t2ZmjxWJKvz1wGwObeQvup5Gb7KQkFJRKh8J2i46bHJtaWphawqossPTQHcljElTIjKwWqlvy7t27h4EDBwLg1xJ37NgRYWFhRtsJylDro164/7YsF6OKgqkCniVISM8tdWc/OZOblqIQKyPle3lg4f7bAICnGXm4Y0ZK+OtP0lUpKs9l7r5bJgn+D54pL7NQligrQs/4jeGyNONCcWqJ6bn4/oj4IkAv5JWRGyaUCdQQ8ADghkSdNJ2Okm21oknMyJWlmHtjnbz4/SMyY1x/PGa+8vmXUw/wqYzkFl0D5ZVYKYkkPO5OtoqOLw8CHhnuSg/VhbxKlSohPV04C1etWrUQHy8vQJRAqPCUspQnZ77X6Uq9mWUSLWW+6yofJel+o9Z7VRKHJ+RqXhYo1FEokFFnTAypX5sSs0goPcrT+5JSHhTodBZzPy0rihouYtZNGgdbeUvhknDXVCqEEwhiqC7k9ejRA1u2bBHcn5mZCWtr4wQABPlce5xW2k0gqEUpT4zsJCL8FFpwYVAaRD56jjMqZO0Mu5cs2yLzSEaWQxpLlWjg44kKSYiy8wsVZeXcylP+QGlJBEuh1VGyCogLEZeaI1l2Jiw6WdZ3RyhdNp2LwdYLj8zqDyWN1HBUqKWQkGYZy4+SxG/LDku7vKlFjMTYGxH7HEkZ8r7HsqKMKm88yyLjXWmhekzerFmzEBISgjfeeAMLFy5k7aMoCtu3b0fdunXVvuxLxaBV0rWPCOUDOemMLYkc91Wtrnxps6V49X9nVTkP7foph87fhco+duoO6VpPaqG0TiAfSt2qvizl2khiFOp0KDTDkic3jfmGszEmX4NQMny99yYAoLKzXSm3RD5SXgAFWh3yLSS0KhGAVoVGW6QNSqAoCpFxaRi2Rp35gCBMarb5WZwJpqG6kNewYUPs2bMHI0aMwP79+6HRaLBnzx5cuXIFf/31F8LDw7F27Vq1L0sgECyEjqIqlCWPQBBCo9GUiEsWofxQnhaoUj23rLpUlhbn7otb3UsDMtUS1MQixdB79eqFGzduYP78+di1axdWrVqlv5iNDSZPnozx48db4rIEAsECFGorlrsmgSCEBiQpCqH8QrqufMwpp0QglBcsIuQBgI+PD37++WesWbMGcXFxyMjIgJ+fH9zcpFPxEgiEskNGbqHZySgIhPJAoY5CfmH5icEiEGjafHsMTyViy+QkIXlZeJL2okwmOQmPfV7aTVCVT7ZFlnYTXmosJuTRWFlZwc/Pz9KXIRAIFmRXRFxpN4FAKBF2hJO+Tih/SAl4APDX5Scl0JLywafbr6BXo2ql3YwKj9w4ZYJlUD27JgCEhoaiT58+qF27Npo0aYI33ngDu3btgk5HtEgEQnmEZAMkvCwkk0xwhAoK6dvFSGXdJBAqAqoLeQcPHkSvXr1w4cIF+Pr6olKlSjh8+DBGjBiB4OBgPHxofjY3AoFQslQ0FxICQYi4VPPLShAIZZGb8cI1jF82krPykJBe9guJEwjmoLqQ9/XXXyMoKAgxMTE4deoUTp8+jWfPnmHPnj1IT09H586dkZqaqvi8W7ZswYQJExASEgJ7e3toNBps2LBB0TnCwsIwbdo0tGzZElWqVIGDgwMaNGiAGTNmIC0tjfc3/v7+0Gg0vP917dpV8X0QCOWRB8+yS7sJBEKJcPLus9JuAoFgEc4/UL72qsiQUiaEio7qMXk3btzAsmXL4OHhYdim0WgwaNAghISEoEWLFpg/fz5+/PFHRef96quvEBsbC09PT9SoUQOxsbGK2/baa68hOTkZHTt2xFtvvQWNRoMTJ05g6dKl2LVrF86ePYtq1Yx9tN3d3fHJJ58Ybff391fcBgKBQCAQCISKgoeTLdJy5BdDJxAIJYPqQp6bmxu0Wv4Cy97e3pgwYQI2b96sWMhbt24dAgIC4Ofnh8WLF2PWrFmK2/bpp59izJgx8Pb2NmyjKAoffPAB1qxZg/nz52P16tVGv/Pw8MDcuXMVX49AIBAIBAKhImNdBrNUEggEC7hrdu7cGZs3bxZMsuLr64v4eOXZdnr27Gl2ls4ZM2awBDxAb2WcPXs2AODkyZNmnZ9AIBAIBALhZUJLCvQRCGUS1S15X3zxBdq2bYsRI0Zg7dq18PT0ZO0PDQ1F9erV1b6sWdja2gLQF2vnIy8vDxs2bEB8fDzc3NzQqlUrtGnTpiSbSCAQCAQCgVDmIK6aBELZRHUhr3nz5ti0aRPGjh2LWrVq4ZVXXkHDhg1hb2+PsLAwHD58uMy5Pv7+++8AgN69e/PuT0xMxDvvvMPa1qpVK/z555+oW7eu6Lnz8vKQl1ectjgjI8PM1hIIBAKBQCAQCASCMBYphj5y5Eg0adIE33zzDfbt24ddu3YBABwdHfH111/jyy+/tMRlTeLKlSuYN28eqlatiunTpxvtf+edd9CpUyc0adIELi4uuHv3LpYvX47NmzejR48euH79OlxdXQXPv2jRIsybN8+St0AgEAgEAoFAIBAIBiwi5AFA48aNsXXrVmi1Wjx48AAajQa1a9eGtbW1pS6pmAcPHmDAgAHQarXYtm2bkWspAMyZM4f1d3BwMDZt2gQA2Lx5M3799VdMnTpV8BqzZs1i7c/IyICvr69Kd0AgEAgEAoFAIBAIbFRPvMLF2toaAQEBqFevXpkS8B4+fIhu3bohOTkZu3btQrdu3RT9fsKECQCAM2fOiB5nb28PNzc31n8EAoFAIBAIBAKBYClUF/KePn2KN954AwEBAWjWrBlGjBiBRYsW4dChQ3j69KnalzOJBw8eoGvXrkhISMCOHTvwyiuvKD4HbfXLziZFoi1FzOIBpd0EAoFAqPDUr+ZS2k0gEAgEgsqo7q45btw4HDhwAJ06dYKdnR3Onj2LXbt2QVNUR6VatWpo3rw59u/fr/alZfHgwQN069YNCQkJ2L59OwYPHmzSeS5cuACAFEQnEAgEQvnGitQ5IxAIhAqH6kLeqVOnMHnyZKxatcqw7dmzZ7h8+TIiIyNx+fJlXLlyRe3LskhOTkZycjI8PT1ZcXa0i2Z8fDy2b9+OV199VfQ8UVFRqFWrFpycnIy2z5gxAwAwevRo9W+AYOD74UGYtvNqaTeDQCAQKiw21kTIIxAIhIqG6kKei4sLgoKCWNu8vLzQp08f9OnTx+Tzrlu3DmFhYQCA69evG7adOHECANCxY0eMHz8eALBq1SrMmzcPc+bMYZVr6NatGx49eoS2bdvi2rVruHbtmtF1mMdv27YNy5cvR+fOneHn5wdnZ2fcvXsXBw4cQEFBAWbNmoXOnTubfE8EadrXq1LaTSC8xMzs1wCLD0aVdjNkM39wY3y992ZpN6PM0tjbDTfjSRkbLrbWFg/PJxDKLatGN8eUrZGl3QxZ/DY2BOM2hpd2MwhlBNWFvIEDByIiIgLvvfeequcNCwvDxo0bWdvOnDnDSnxCC3lCxMbGAgDOnz+P8+fP8x7DFQpv376NyMhInD59Gjk5OfD09ET//v0xefJkwbp6BAKhYmBdztzYiNsdwRSIkEcgCFOexlUrq/LTVoLlUV3ImzdvHtq3b4+wsDB07NhRtfNu2LABGzZskHXs3LlzeQuuUxSl6JpdunRBly5dFP2GoC46Za+MQFAVjQaoWckRj5+/KO2myELpGPey0bZOFWLJ48HGggtDVwcbZOYWWuz8pU39ai64+zSrtJtBsCCOdmUnM7wUjWqQDO6EYlRX39WvXx9arRY9evTABx98gOPHjyMriwyABNMo1OpKuwkmU9fLubSbQFCBfVPUU1YRSpeAqiSLJB+WMlQc+KgTwqZ3t8zJywhfDWiEnRPblXYzCADa11U/vGN0m1qwtVK2VA7xqyT7WLWFsmpuDqqez6kcCbgAMLSFT2k3oUyhupA3dOhQVK5cGRqNBmvWrEGvXr3g4eGB+vXr4/XXX8eSJUtw5MgRtS9LqKAUaMuvZaJBdcto1BxsiWtVSWJrU36ed/n9WixPeVuslCSWckdr5O0Gdydb3n3WFcStzMZKg1b+lUu7GQQAdiqM1VVd7Vl/+1V2UqwE6dagquxjp/Wur+zkJYx9OZr/AKChhdZd5RXFb++jjz5Cenq64P4NGzYgMjISWVlZuHLlCjZs2ICPP/4Yvr6+OHbsGGbNmoV+/fqZ1WjCy4O7I/8CoTxgqUWMbyUn6YMIqqDRaFCelqI64t8syPCWNYkQLICXi730QSpTUYQ8eoAoR2FbFZa2dcy35HXnCGhaioK3h6OicyjpC35VyvZ8HuzrUdpNYNHKX9xKWr+6awm1pHygWMhbtWoVAgMDsX79etHjbGxs0KxZM4wZMwbff/89/vvvPyQnJ+PRo0f4559/TG5wRWTB4Maldu0GpfBBrBzVHK+1rGm0vXVtY22ol2vJLz7UwlJxLg3Kuc/9b2NDsP+j8uMCyTdh357f1+zzvtpcmVtJOxkLmNISYhYPbYpugV5mnUPKLXb/Rx3Rt3F1k88/tVegyb/lUs3NHn++1xZLhjVV7ZxKWDCkiarnq+aurouXHGw542NZW0zKhVYDkXDY0iVydi+826E2Fpr5bcx+pRFrTabTUajtKT/0Yut7bRT1hXpV5a/Bdk9ujx9GBqFmJX6hc1zH2vIvXMTnfYzHRaY1c0SIr+JzmsOf77UV3S91j50DPEX3lxbdG1Q1MlrMfqWhxa+rWMgLCQlBUlISxo8fj3bt2iEiIkLR72vWrIkBAwYovWyFZkw7/1K5brdAL/z7IXthVaMEJvtO9Twxpq2f0fZRrUt2MLE0lspypSvjqwmuYN7Y2w2z+jUw/N2jYTU09na3eDs2vtva7HNoULyIY6JGIP5wHkUHE6574eRudSXPWVqGvNdb18L6d+Q/b7541aY1xftEY293rB3TEnVMjHV1d7JVbSE+sUtdtKtbBSNb1VLnhArhGz/NoTSMUFxLnhrjv9px0HJc1UrLgle/2ssRX9qilofkMTGLB6CSsx3sbKzwppnfhrO9DWtNpjQtQPu68oUMpUuEFrUq4dXmNbH2zZa8+13s5eVSZPZZPoGxrpcL41hljYxZbN76vp1EXKWUS67S9pYUE7vUxdU57Iz8JTF/KBbyLly4gJ9//hlVqlTBhQsX0KZNG0yYMAEpKSmWaB/BglhbWZWKy4yDrXXFcdURgTlQqkmtymXbvYOP0hA+5E54Ymg0pbeI415WjuNoecmu2cTHXZHlhpUwxYxb1OrUSeRUVkevKs52AJT3/dLo4zacsg1q5NhSO4tnc4aAQT9bLua6SJuaeKOcfOpm08i7dD1XvD2UK759ZLp3hviZFssp9L3SsbW21uIfNHNvVVfx+/Ny5e/3pUX5CqAoxkMgNtnSKBbyNBoN3nvvPdy9exeTJk2CRqPBunXrEBgYiDVr1pSbRcbLQs+G1Qz/Xj26Bd7rVGzqtrXWsLQeY9r6WezzqevljHmDGmPx0KZwtLNWFOjfTELDryYTu9TF6tEtBPf/ODIY0/uKu33V9XLGhC518E4Hf5Vbp2c8x11hQuc6FrmOqRgJJxqAUrAy//3tENnHvtm2lpH7RhMfN8wd2EiRVbpXI/13smp0c9m/+fWt4nYOCvKW/TsaqSfC1UjK+WTUSKBREjEi8wY15tVG/zSq+Pnb2VhhXMfa8HCyxfp3Whm2F5qxqK6jkuKF+W4Of9JZlXMyFwFiSrBPegYI7vt5TEu826E23uskf0z4eUxLxQunlgqyBwrBvMfvhwdBK7F2eF9inNv0bmukZOeb1Jat49sYbRva3AcrX2+OOl7OGNCsBvo24XcVVuLqOq5jbbzd3h+jWhdr8HdIZOZ8t0Nt2DEE4nEda+PwJ51V9+iwRGZKNZjRt4H0QRz+94bwHC6XzeNa44NudTG0hbjHBR8DZcwHb7f3l5xvKgsoFpjjfCeGe6JNkXD3Wktxqzjz923rGAuazGkk2LcSq//xcfDjTni/cx3sntweAEz2tqD57rVmAPTvcVzH2vBnzEkaDbBoqLib/IZ3WmFKt3pmtYHLz2OM56uZ/RrA1d5GcK237q0QrHg9GF/0b4D61UonVtDktDkeHh5YvXo1wsPD0b59e6SmpmLKlCkICQnB2bNn1WwjwQy+GlDs89vExw1fDmhk+JurSeW62QVJaNqHKogpmtY7EGPb++P1osnNRkLTZEmE/Ou/6N8AM/s1wIBmNQR/O6S5DyZ1EXeba1unCmb1awgH22J3u/5NTY8lAtixk1U4SRJm9ef36y4J11s++OQMqfUI0yUnqKaH4HFcAqu7YfYrjVjb/v2wE97uUFuRdeLXt0IQs3gAXmkmX1jrwQjQn9S1Llwd1C07yicsS/5Ghc/qwEedLO4K5uFkh+o8/ZO5OGrlXwmzX2mEK1/3Rk1GsqECM0w+zipYdwH2cw6s7opvXpUXB8TtI8x+z4yN6dlQODufmJUuxL8yvh7YCG6OxcesfVN4wdspwBN9GldX3G8WDDY/JpAZs9ysprukReyL/g1F29m5vpdi9zea9vWMXewaebuhqpsDjk/ritWjW7CufenLnoZ/M8d5KWa/0ghzBzVGh3rFApWLvQ2a+PBbq+p4OuPrgY1QxaV4sT/7lUYIrO4qqiQyJZb964GNpA8yg+ompPb3dLGHq4NyC0j/psJzuFw6BXjh8z4NFHkd0THD1lYaoyydXOYOaoyqEs+kq0CcM7Mv8lnimN8/H0whT6PRwJHTh5nn1wD4coB47FjDGm74on9DtKilV/5YmzkRDQ/xRcziAejftAZmv9KI9T41Gg1Gta6FfgJKFwDoGlgVn/HEGjJhCo5yPB+4FvePegRgYpe6uD6vD7oG8o/XPRtVw+BgH7zfWTrUwlKYnRs1KCgIp0+fxsaNG1GtWjVERkaiU6dOGDt2LJ4+fapGGwlmwJyA7G3YH3KtymyXAuZEAgB2EoKYEj2iG2eg5rM4MAUBX0bb1NZYCrk7VnGWNzFK+XzzZeIy109cSeA3jaXcRaXgswpIWfh9Ge9ErXTuarh1aCDcHmbMpZOdteKrSU0sARxBS879qPHsLJVOXy1M+RZo3FQSxLnfs9w6WtxkTLU9lX+jchbwnjKzZdJjodRi0xIw36NGA1QSsFowCZTQhjdToCCSQmzMZu6SsnLwoXRKUzqWV3ZS7mKXV2DZmrRlfFhRnaTMPIud29mueBxjxtRFPnoOAHCxEx/nuLGm3Bhz5lyj0SgPAxAao+WOS2LQLfM1M2yF+X2b4pLLHMqVzCu0oq+ksqqqVgBjzJgxuHv3Lj799FPY2Nhgy5YtCAwMxA8//ACtVqvWZV46mO5LSpnaqz6quzvgqwENDf8GgPXvtMKIkJr4oMicveaNFhjVupZRFiWuYMaFOWYzJzorDfBxD7ZLEVNzCbBddVrU8sD3w4NY+ze/W+w+k8uYfHZObCfqKtTSrxI+6FYXy0cECR7D5/4xqrUvBgcrd7kD9O4ODaq7YnjLmhgZ4sub/UnuwnlWvwYY2sIHf09ub3A3OD29GxYMaYJhLWrir0ls1x46nTA3Scc/Uzrg+xFBGNrCByteD5Z9L2oUEuUqPjXQSC5qmK4V3Gc1vGVNyUyltDsf83tRY1Gh0WhgZ2OFL/s35J24Zr/SCB91rwe/Ks6yE+0sHNIEE7rUEXRDru7mgKHNffATx21YowGWDRfu14DyQH6aP99ri89618esfg3gaGctGUPJ/V5p+NyPlFj8mQj1me9Fvm2AX4kzrZe+FhXXXdNUoY/7mB1EEvEwM8lyrQJfv9IIr7Wsia3vGbsLMvmsd32seD0YY9r6ybI2929aA2Pa+mHF68GCY0+fxtUwvWgsfL2VsqQnFCjMHdjILJeoOQOLMxhqNBoMKGrzvEHC2aZ/fSsE1lYao0zMtHveJgXJlqZ0q4dJXesaMpX+MDIIb7UTTtrB7I9axgfCJ+T9Mb4NGtVwQxMfNwzgsSqJfV5MQZbuL8uG68fyvR90kHWSPiJWjsYCMW7ZecXxjEJuglK83d5fcJ/U0MTnNkiz/u1id+2yUlapR4OqRsmzpFyOhdg8TlmSMN/KTvi4RwBmv9IIExmeRafvJQMAKrsYv78ZfRtget9AfN4nEG6cZ8gdMwsZscsajUZxTP03rzZFEM/8tmp0c8HMoN0bVMW3r/K7YbIsi0X//qhHAIa3rGmyl5QGwJZxbTC8ZU1M6ipuaVv6WjOj9QTTWhns6yE7bOavSe0xtLkPNihIVGYOqlY5dHFxwffff4+IiAg0aNAAGRkZ+Oyzz9CkSRNMmzYNf/zxB27dukXi9hTA9e1mpgdeOqyZ6G8/KhK0xneqY/g3AHQLrIqlrwXBqUjb069pDSwa2hS2nMlKcpHM2M/MjPdg0QB82qu4wOe7HWobaUWZH8i8QU0wjDNY+jMW1DmMyaeVf2X8Nak9yw2V5s22tfDXpPb4vE8DUT96vuK8C4c0NXJfFYPpyrpqdAsc+qQzvhsehCWvNeN13xFbfDMtOp4u9lg+IhjNa1XCZ30CEbN4AHwrO8HTxR7fjwhCS06gNv1cmdfsGuiFZjU9UM3NActHBGNwsDK3WnPhiyUTmyRc7W3YmkTOs/pueBCiv+0ves1ugVURs3gA63tRU3P8Xuc6mM7j/jGuY21MLXpmcgX5N9v6YVa/hryWgpjFA3D+ix5YPjLYKHjfSqPBay1riqeQ5pwzZvEA3hTZTKb1qo92datgSvcATChaMEiN0f0EJlY+AcTUdP9CTajhLp7UYAnPuMj85pkxbdfm9pF8Pnxw37XQ84pZPEAwk6xfFSe4O9li2fAgtK/rydKeM08Xs3gApnQPwOBgHywY0kSW+5i1lQYLhjTB4GAfweN/HhNiWDDbWlvhFRE3dT7e7lBb0iVKDKYgoWG0eWx7f8QsHsCrMPCt7IT73/bHjgnFyq6vGe5cStxxP+sTiBl9Gxgylb7avCbmM9xQxR5zfmHxItjWxvjADvU8ceDjTvj3w068i1puf2G++8OfFsd40nNydXf9WM6cd8S+ULG2L32Nf93AnP+EFttSKHFd5bJSRKHNLC4u1zVaDHMzQAL6MeU7jrKr0ERX8k4BXqij0EPh0171Ma5jbdbcSXcrvuGoQXVXTO5aDx90q2c0N3L7Y4HWvDW6l6u90bMB9AlpwmZ0N9oes3gAfn+7FUa34c82yWwePfa62Nvgu+FB+N8bLfGZKQXlNUDHAE98NzwIrvbsNSEzPGZS17oYEeJrNF8zlboajUYwbIZL/WquWD4y2CyPFCWY5bvy4sUL3LlzB7dv30ZUVJTh/9HR0cjLy4NGowFFUbhz5w7u3r1r+J2joyOCgoJw5swZs2/gpaaU3R8qMVxCxBaFfLFh1tbMD0T/f6HsQzUrOyE+PZe1jetaCoAVtyMGX1pspY+yrpczrsalAZBXD09MAPD2cMDdp1kAlGspaxYJAnU8nZFalHTAHHc7qaxc9jZWyCtUNpFpwP++aOpUdeEM4vLPXUkkY5Ua7ppMFzKpdyN2NUdba7wo0KoysHM/NSc7a+Tk670l+Ny0pLTyfFpfqSleSZyKVMprIc49MC1js5QbLNdlyFOkbwph6ifGt1ixNGXJ/dbB1srgmcHsQnwKD0vogr3dHYzmEiHEnhozppyrHOXC515rZEmp4oTrT9KNjqstksDCr4oTHiZn8+4Te3Zy+oOpIRI7w+ME90mFLPC5PPMl8FCrP3u52uOZGS6VfHFn1SUUUGLwPfH0nAJF56jqZi94LrC+N/FrJ2flie6Xg5ZHs2vqXMA8k1rDGfM03HMy+yr9KXAva8q8URoofuJpaWmYMGECateuDVdXV7Rs2RJvvvkmFi5ciF27duHGjRvIzc0FRVGoXr06unXrhvfffx8DBw5EzZo1QVEUcnJycP78eUvcT7mFL2Mjn/mX1dkFzjWxS12jZBRyYQ/E4l9TxwBPjG3nh0VDm/IOAitHNceQYG+M4tHOMAdIetDuWr8qxrT1Myow/P3wIAwM8sY/U4pdVQY288ao1r74cWSwIb36ux34LRw+Ho7Y+G5rfN4nEJ/0DOD1C1c6cNCuRiF+leAhI/5B7Pwf96iPpa81w5tta6F7A+GEC0y2vtcGQ4K98VXRe17BdFOUdQY20/sG4qMeAawg7irOdpjSrR6rxh3Xj3z35PZYzMl0xXevI0J8MSKkJsud8p8pHTAoyBurORp7qUm8UQ03fD88qCj4Wtj6oMZkwHS1ale3Ct5u7y/LpYRpaQD0z2lgkDfL7Qjgz+onhJBc9dek9lg2PAij29RC3ybVMb+okO9vY/XZP18TqMe3clRzjAipyVvslrvG41oPmfG9UjFiNlYabHinFaq5mR+PQUNnWgzhcd1uWMM4bov56Lh9cWgLvZs1l6EtfFCrspPheQqdjwvtUvsLTzY25mM1t4oMM8NcY283QZdPU+p1tq9bRdR9ndk/dk1sJ+nq/suYlhjWoiYr62dJ1rN6u70/hgR7Y++UjhjXsTbvO+XCfW7MNWsNd0d82L0eZvZrICnkvdnWD6+1rIk1jIyPXQK88Fa74rlu3qDGGBLsjW3v6wtBb3u/LQYHe4u6ri4Z1gyDg73RNdALn/QMMEqeQTOxS11WEhA+BU29qi4sRS1FgdVeuZia3RTQK9SYoRSDgrzx48hgo+Pk9hq+cW9Yi5oGC/HW8W3QopaHoPuqFLZFAsvyEUHwq+KEQUHemMFYxylNNMOnKM9XaBmkQ3D4zsUUorkKUK5QX8BR5Jrifcc857AWNfFRjwBUK3omUgXPuTAvb4kSCtw1B/MToTODc4crPm8x+vsFIPrtliSKLXnvvvsu9u7da3jp9vb2qFevHho0aIDAwEA0aNDA8G9XV+PJNiUlBZcvX0ZkZKT5rS/HDA72xr7baYa/J3eth8ld62Hajqv46/JjANKB6EKT5Mx+ylMO859ffL+VRoN5Re4t2y8Za/AGBXkLppZnKu3o61gVuetw8a3sZBSbaGNthUVD9W4nQyRifpaPCEKbOlXQpT5/pip9G5QNHO6OtopcPsQEFzdHGwxoVoN3sS1E+7qerKKrTNc+UxZPk7vyx9bQ7liLDkbpz80YYK00+uKsLWpVwuuta8F/5v6i6xufx87GCktfY7tvNKvpYXDRiUvNYbRfvK2zX2mEdnWrGLn4cjF3Khgc7M1aEGk0GswVGbiZz52OlaRpWMONN76WL6ufEPSik1mOol5VFzSs4YaGNdwMi5q32vnjLUYxX6FFqNj3yZ3UP+oegN/CHspuKxONRoOugVWxfEQw3lh3gbWvrpcz7j/jt0aI8UX/hviif0NQFIXasw4YXY+nEYZ/cvuirbUVlrzWDG+0rYVBq4q9S5aPCDb8++u9N4VOB4C9CHmtZU1BwZr5XM21SIwI8cWs3dcB6Eu7BAgkJTEl052niz1WvN4ce6/ESx4b4l8ZIf6VRY/t3bg6ejeujtWh0YZtUrKn3GUl9/ZcHWyM6uW1qV0Z/YoUNnIVoNzmcb8Jua7tDrbWRrG0VlYalmuop4s9fny9eHxoW6cK2tYRL2lQzc0BKxi/qVnJCZ/tvKpvK+O4mf0a4PM+gaj7hf474XvsgdXZfUdHURjQzBvV3RyQmCHP8snHvEGNMeefm9IHFsFUGAm5b8qd39rVqYJdEY9Z25jxvAHVXLF7sl5xTM9dSqBjMYe2qMm74G9eywMHbyTKPh9ffy9U6DZJJ/Xgk8mYXjrcb497fIEKhW2Z51w2vBnrvUkVPBfDlOzd/OdhmjZFriFwbr55tW2dKqq4AquJYiHv+PHjAIDp06dj3LhxqFevnqJFZZUqVdCrVy/06tVL6aVfCpj++14qZCJSSv1qLniS9kLWsR4Ml5M6Xs64UuS+KAcbmdno1IDrGlMaiNWNUVszpZaCnDvxc88t9N2bez9Sv5fr0mor0zVE6HxKF8cNqrsa3H+UjInWVhpe1xYuJel2V6+qK2JSigVvsZInUhkPafiec0BVV5OEPBq+52zqU1LSb7neAHITVTT2dkdYtD45Ajd7KnOBKyfzGrO13Ox4TOQW4fXj1KISQ2mxdRqmRYntEmXc/+VaD+S8NTneFly471jtLM9qw3wOXCsSc5+TvU1RxsTibX7/b+/O46Iq9z+Afw7bADPCsMqiIiggiysumPsSYpa5ZF5NxS1tQSsrzTaXUpPsVle9bRbatV8uLZaVoveWZeSt645lpkW4oeACCMoiPL8/aMYZGGaBMwMzfN6v17yUc86cec7MM2fO9zzf53l8PfWuZeU6Vt00/eigFrWuLQwF5KYYS9HXVd/BY8xV1wAiGpaeryMDWyBH55wL3Eq/NJfmmA1lK+k2GtQ8b7YLUOHn80Xav2ODvfDttXzt38ayNer6PHQHg2toq73ujU25Bt4xlrOm+9lpvgv2Ogm7xWdqtVoNFxcXvPTSS9YoT7NhLNXy/346DW8PV5MtVDWl9A5DfyOtVeZYeU8n9Fz2H6Nl1NDtBP78nbFQuDjXeQe7Jme9H3hLS2mel8Z0xPnCUsQEW56O8c/7uuGhDw42uAyrxnXGH/nFeHBAOxSX3sQ/9/ze4H2a0tBT0Zdz++Jf+3L0Bs+x5HVqns/NSRfTS8eoY/MVYzriQmEpYs1MrzE1OqxGzRFLNSxNc3tlXGf8ffdvmJSoP0KfoZQjXYvvisVznxm+2/33eztj3pbqu/MNTe+zxIoxHeG9wxV/XCpG6qD2UP41l9exc7cuBL6Y0xcb/5uDeTXqyccP3oaPDpyBkyTpnSPiQ70xd3B7hOpcHL04Oh4+Slf8rcetlO75ydFI23kCe+cPsqjMcSFeeGlM7VHQzGXu8+7vF14rrbpfpD9m94+o81yjeU/mD+uApz45ioyfL+LFUfppv0M6BOL+fuHo2EqNwR0Ccb280uhImtWtQXG4VnrTaH/k+FDDA7/U9PCg9lj7TfX5ydAF6n292qCtnxKlFZV6A2NpfJ7aB//342lM6xOO9T9k632mGqO7huLn80VIjPCrkRJVmzk3PkzpF+mPuBBvoyM31rRmYlccOl2AYXH6gwvJUByr0i3euO6t8NvFa9oJzp2cJCwZGYfispsIVXtgxyP9sD7zT/Ro64uDp68idXB7vZu0cv0mD48PxvQ+BUgI80GPcB/8fddvuK9XGErKb+LzI+fRPkCFpV/8ot3e2Ffw7/d2xsm8YvQM98ULo+Lx3LZjRl97YHQAZvWPQFyIF/68dB3+LRoW9K2b0h3fnczHbe388cPvl/SyJQzR/f3QfE9fzjhR5/YrxnREwG43fPjTrayoSYlh2hZyY6n9mvem91+tv8PjgzCjbzi6tfFBwY1y5F8r05uMu+b7vHhkHJQKZzhJEtSerkgdFIllX/2i/Q7c2SkER84UokdbHzz413XR2G6t4OxU/a8hEQEqPDY0qs7++G4uTnoDGBmlUx8tuZ4b3CEQX/+aZ3K7minMBvvk6Wzy9B3yZMvZgsVB3p9//oni4mJrlIVQfUdWd6LVWoycfZfIMEGtbp8s3UrdrY0aB08XaP/uF6mfZqb2dNPrI2KKbkOeqFe3XtM0E6/XR4+25l8UGKMb9M5P7mAwyJP74r2hLT5xId54qY6RW825I1fz9c1pETOnDkxowOdpTPtAedLcAr3cDb5voSbu+BprZRjTrZVOkGe7KC+ghaLWVAXT+4RrywJUBw+GjjchzKfOaU7m1Uhx81cptGnXGprUdUu9NKaT3ii/uuR65wZEBeCZEbXT/UyNrqb7nrw1ubvBbZycJL19LzNjhENTF5qW8NSZW8vQ+2WqPJ1aqbXz1NX8TDVcnJ20Kc+6Q/YbUt9J72v2v6w5QrUpd3YKMRhcN/WWPF2uOu+zRorO9AYdgry0311t2rvO4WlbLxr4xXF2kvQmWdc9XyRG+GFLjW4exl5PNyVycmKYySBPkiQ8beaIh+YYGtsSQ2NbAgCSjUxRoaGb/KD5nhoL8gJaVJ8LNUGem7OT3vQcxlL7a6aLOjlJRtOSa77Pvkq3Wt9Z3ZtQNT9HAAjyVuDJYcaDnUd0RjKuyd2SIK+ejM1/p/se1MwsM5StqbusrsC2KapXzpxK1TiTLDsSY+k1TYXuHZMwP/07t3UNC24u3TsnjfHbGdXSeB2252k+LP1hNjbvYK19G3kdzd9d26j1lpvTIqab/mXJyI0NZWw00foMWGGIXEejSbvTrZr2XE/lZiwt0VRqFWDe98aWranWVHOeuVpscJxOJrI5TE2VUZee4bf6+5jzuZvL3LRke+Wvk5KnmVPX6tWgxgvUnDbGntUng6gma6WcWvKbX5d2AQ2LAyxJ4TT1WnX9CrbXeV4XnawSAOja+tZ7UDMtVrd7jXZaCp31thw0qqEaNIUC1V/NeTnqw1oXeF/M6Yv/HM/D7AERSAjzwa+51+CrdMOnh84BqJ5nanZ/45NHmqJ7Id8Yd0g3TO+J6ev343hukcH19Z3UtD7kPmFY2uLzxiTLR1EDaueo/3veAHx2+Dxm9A3HJwfP6ZTH9L78VAq8fE8nKFydTY5WJ5ept7U1OvlxU7mgf+O+bii8UWH2FCHNzZuTuuHq9Qq0NjAJ+tTb2iJU7WF00CUNc7439vTjbkjHUG8Mig7AZFOpZjY4Tv2XqH2+rZktUvd+9Mv68j2dkJL+ExLCfNC1TcMvZjWm9QlH+c2qBneJaKqiWrZAUmxLXCu9qU37031v5w6JxJ2dgvHv4xeRtrPuFqkts3vj3rf24Ys5fS0uQ68IPzx/Z6zRPuz2YlqfcJTdrDLr3GOIgEBrX0+sGNPR7H6I5nr2zlgEe3vgrs6WzY0JVH++//vzCkZZMP9uQ41NaIX84jL0MnVzqob7EsNwrfQm+kb6I1TtgY3/zUGPcF/s//MqZvQL125XM4gc1SVUew2jyTLSmxvTxFRTTYndBHkbN27E3r17ceDAAWRlZaG8vBzp6emYOnWqRfupqqrC2rVr8fbbb+PUqVNQqVQYOnQoli1bhogIwzPWZ2RkYPny5Th48CAkSUJCQgKeffZZDBkyRIYja3riQ721/Tj6RQagX2QAPtYZperRofWYeLIGW/TJMybY2wOPDInEAxsPGFwvR38Qc8kdTFh6faabomvRvmu8TrsAVa3+WYD5LXPjLBhdVA7zkqKM9tuTq0WxodfLwzta/kPcnCQbmUajb3t/DIkJxM2bN1FZWWl0P+JmOUJb3MqwKC29NaqgZrmPQn+5vdCUPybQHQ/1DwMgDB6Hl8IJ18qqtF9tlcIFxSbSKuvLVEueJEmY3icc72UaH9W15vfLR+mGz1MtDzBMcXNxwpwhdaefOYK3pxhOJQagPbdHtWyB7Udy67xB2jPct0EjDE6vMV2LvXJzccJcGeqLNbopeLm7muxzX5ee4b6mMwFk5uwkaaeHsISrs/53VtNdoF+k8cDbUKaZbvp4fef7awx2E+Q9++yzyMnJgb+/P4KDg5GTk1Ov/cyePRvr1q1DXFwc5s6di/Pnz2PLli3YtWsX/vvf/yIyUv9LuXHjRkyePBkBAQHagHLz5s24/fbbsWXLFtxzzz31KkeXNmrgJ/OH19Ww1ybjmhq7Ja9a3a9ryxE55f4cDe3v7i4hZg2Hbnrf1akeB3KuYrSZd/IGRZs395+tKUycqHuF13+YZ10hJlKQLP34e4b7Yv0Pf9a/QPVkaLTVpk4SlTh9+jSuX79uctublVVYPOhWXc3OvhVcaJZ7uDrpLbcX5pY/7fYAHL1QihJnzYhy1mNOve8Z7mMyyKvvPGdyG9EpGF8ezW20lr4Odvj9jAlqGp/d7bEtsfuXixhi5jy19ZUcF4SdP1/AwGjTdcTRM/Hv7hKC9/flyPL9rZmKKSdNxpyPTt95NxtlG8nBboK8devWITIyEmFhYXjppZewcOFCi/fxzTffYN26dejfvz92794NN7fqD23ixIm44447kJqaioyMDO32V69exZw5c+Dv74+DBw+iVavqzpYLFixA165d8eCDD2LYsGEG5wM0pV+kP96clGCXJ2Y56I1e1EhlMHYSNXdkxvrSHcJa9pY8A8tWjOmIwR0CsWT7L7jy14S16VN7mBwUpPa+JbyX0gN7fstDUqzpzudAdcpcYxsUHYArJeU4crYQQPXk5LoTeuvaO38Qjp0rNKtzvTFfzOmLohsV9e5bVJfh9ShX5lODseTzn7FoZByOnClApzoGKDEmLsQb6dN62E2/GRcJ8L55BRUV7ggJCYGbm5vRGyplFZUQl6uncwj3U8JNZ3Lpco/qVguVwgWhdpg2a075hRAoc7sKb+VVlJSWo6rKuoMimJMSOiwuCG9O6obY4Nr19d/zBiDncgkSwmzbqlCXtLGdkBTbEoOsHCjUJT7Uu17n9MbUsVV1meXsO1kfr47vgv8cv1hr1Fy5rbq3M4YfDzLrdRw8xsPTd8QgIcwH/U20qpmjf1QA3pqcoDeCaEMYGnjFR+mGTbMS4eHqbFcNLHYT5A0damTESTO98847AIAXXnhBG+ABwPDhwzFw4EDs2rULp0+fRps21c3jW7duRUFBAZYsWaIN8ACgVatWSE1NxeLFi/Hpp59iypQpFpdFkqQGX0TakjVPOI01eERjDoktQWfUJtn75NVe5unmgru7hOLV3b9pg7z6Xox4e7ribgvy8V2awF2v7m19cbGoVBvkdTPSV6e1r6fB/l2WMnfoekvVp76Eqj20qVgNCdKaaqusIQFKZ7hIQEhICDw9zfg8nSshuVQAAFQqT70gRHKpTm10cXOFu7v56c1Nhab8zq7Gy++kKIOn2hniygWUl5dbtUymplAANL+ThtNx2weq0D6w6QwCp1S4WHRetAa5A0xbXMs2VlCsS2Wjz86S13H0QbXcXZ1lfc9rTnnSILrnJp2PITFCnuweW2r8qy8b2rNnD5RKJfr06VNr3bBhwwAA3377rd72AJCUlGTW9tby2F994B4c2E7biddfpdA7CTxqZKhaOfT+a76dFu7y3xeoawh7a+vRtvpC393V9l8D3Ska5GrJ04yYNd7A/FQamrx2S4cVT/pr6OhZ/Q33W7UHTfU3U1MXPFyb/oi79sRJqu6T4eTU8O+38q/RX609wbK1aMpf15xVGh5uzoAkQamZTsGKF/m6NysauyWHDLM0yPOywvVBXTR9BB8Y0LBB4JqqJvpz1SzEBnsh9q/RUUd3a9wbNw1lNy15DVVSUoLc3FzEx8fD2bn2xZSmL97Jkye1yzT/r9lPr67tDSkrK0NZWZn276Iiw52VjZk7pD1GdQ1BG19PSJKE/y4cArWnK7YfudXHytonulC1B358eoisaYxZi5NQWlEFbxv2f9MV6OWOn54eAlUdP0xBXu64UGSdQRY0Q1QD8rXkbZqViItFpUZHYRzXvTV6hftZfFH1xqQEnC+4YXYLl246alNhrfkYG6qliXpIlstanIRrJTdQmHfO9MYG1PxGhvsrcbOyCm51pPg2deaWv12ACsUlzjh347JNynVkURJuVlbpzdFH9uv1v3W12WvNGdwed3epvi4iaqhHh0bitX9XX8+rPd2w7eE+yC8us5vuCXVpNi15hYXVaVre3oZTqLy8vPS2M/UcQ9sbsmLFCnh7e2sfrVtbPoKgJEkI81Nqg4Egb3e417jrb4u0ipZe7rLO79fC3RUBLRSmN7SiQC/3Oi8wrNnCp9tx19JJt+vi6uxk1jD7bfw8LZ4DztlJsiiF0bOJtUo5SVKtCU+bEmP10Bh7DTqsrYW7q8Wtbob6YWg4SZJdv9fmlr96u1vfk2ul1hlZU8PbwxV+qsb9DSDL6Q5apdt6Z8tB1GpeFzmapnaT1NG51LgmcnNxsvsAD2hGQV5jWbhwIQoLC7WPM2fOWOV1bDGvUXOzZmL95o8z5tkRMQj3V+LxpGjc3SUEiRG+TWZ0ODm9P6MnWvt6YJ2RIbmN2TQrEa18PLB+Wo8GlWPO4PaIaqnCpMQ2SB3cHhEBSsxPjm7QPpuCV8d3RhtfT7w2vktjF8VhuLk4QaVwgbeHK8+nRKg9F6rGqnGdEObniZfv6aR3Q4SBCVHT0mxyJDStcXW1vGnSKHVb7XSf4+fnZ3J7QxQKBRQK69yp1L2DxUsS+Vlj4IyZ/SIws191vzZbprbYWkKYL/bOH1zv5ydG+OH7BfV/vsbjSdF4/K+5cVoA+PrxgQ3eZ1MwumsrjO7ayvSGZDZJkhAR0HQG8iBqqtoHtsC3Tw4CACzd/ot2OWM8oqal2bTkKZVKBAcHIzs72+CkuIb63xnrd2esv56tHDlToP2/o6YsEBERke1ZellhamAfoqbKUa+hm02QBwADBgxASUkJMjMza63TzI/Xv39/ve0BYNeuXXVur9mmMRw9d6tV0jGrJxGRPIQQuF5+s1Eelg6HHhUVhd69e+PGjRt65U9MTKzXHLFE9WHOdYVuzTY2NQ0R2Z5DpmteunQJly5dgr+/P/z9/bXLZ82ahU2bNuG5557Tmwx9x44d2LNnD5KSkhAWFqbd/t5778WCBQuwevVqTJ8+XTtX3tmzZ7FmzRr4+/tj9OjRtj04HboXDg56E4KISBY3KioR+3xGo7z2L0uHWTSwzubNm5GYmIjMzEztHLEffPABcnJy8PTTT1urmEQWKy6z7uA8RFR/dtOSt27dOkydOhVTp07F1q1bay1bt26ddts1a9YgJiYGa9as0dvHoEGDMHPmTHz33Xfo1q0bFixYgClTpmDUqFHw9fXF6tWr9bb38fHBmjVrcOnSJXTr1g1z5szBnDlz0K1bN1y+fBn//Oc/0aJF48zxBuh3cnbUpmYiouama9eu6NKlC3799VcAwPXr17Fw4UK8+OKLNv3NCfa2v4nfST68rrC9SYnV89zOHdJ4XYHIcdhNS97333+PDRs26C3LzMzUS72cOXOmyf289dZb6NixI95++228/vrrUKlUGD16NJYtW4Z27WrPNTdp0iT4+/tj+fLlSE9PhyRJSEhIwLPPPqu9w9pYbDlcMRGRPfNwdcYvS4c12mtbKioqCidOnAAApKWlwd/fH9OmTZO7aEZlLhiMr47lYmhMS5u+LlFztWRkPCYlhiG6ZeM1IDRHlVWOeT1tN0He+vXrsX79erO2Xbx4MRYvXmxwnZOTE+bOnYu5c+ea/drJyclITk42e3tbacHJk63Oy90FRVaeK4qIrE+SJLuadDs6Ohrfffcdzp49i5dffhlffvklnP6a6/GOO+5A9+7d8Z///Ae5ubn4/PPPER8fj6NHj+Lhhx9GUVERIiIisGnTJigUCpw8eRKPPvooLly4AKVSiY8++giBgYEmy+DkJOHOTiHWPlRqogJUCmRfKmnsYjQrzk4SOgQ53rRKTZ2jBnl2k65JtU3vE97YRXB4/3d/YmMXgYiaIU1L3lNPPYWkpCQMHDhQu+7YsWNo06YNMjMzMXfuXHz22WcoLS3F3/72N6xbtw5HjhxBSEgIPvjgA5SVleGhhx7CW2+9hQMHDmDixIl4++23G+/AyG68cm9n9I7wQ3oD5yslauocNTPOfm5rUi0qBT8+a4sP9Uaf9n7IPHW5sYtCRM1IVFQUzpw5g48++gjHjh3TLi8qKoIkSdruCRUVFVCr1di2bRuGDx+O6OjqeSE7dOiA/Px8bNu2DT///DPuvPNOAEBZWRmmTp1q8+Mh+9Pa1xMfzuKNTnJ8jhrksSXPnrFPNBGRQ4qKigIApKamon379trlx44dQ48et1pWsrKyEBcXh+PHjyM2Nla7/Oeff0ZsbCyysrLwyiuv4PDhwzh8+DCOHz+OBQsW2O5AiIiauD7t/E1vZIcY5NkxiVEeEZFDKi0thRACU6ZM0Vt+7NgxdO7cWft3VlYWOnbsiODgYO1onIcPH8YPP/yA4cOHIygoSDuvKwAcPXrUNgdARGQnbmvvj82zEvHTM0MauyiyYpBnx9xd+fHZgq9S0dhFIKJm5siRI3Bzc0NMTIze8mPHjqFTp04AgJs3b6KgoAB+fn6YPHkyfvnlF8THxyM1NRWbN2+Gi4sLpk2bhoKCAnTo0AGdO3fGxo0bG+NwiIiatF4Rfghs4VjTxrBTlx3r0lqNUV1C0NrXs7GL4tCeuzMGV0rKMKlXWGMXhYiaiSNHjiA2Nhaurq56y//xj39o/+/i4oLs7GwAgFKpxJdffllrP0qlEtu2bbNqWYmIqOlhkGfHJEnCa3/r2tjFcHiBLdzxwUx2Pici23n00Ufx6KOPNnYxiIjITjHfj4iIiIiIyIEwyCMiIiIiInIgDPKIiIiIiIgcCIM8IiJyWMJBJ7m1Fr5fZAkXJ07lRNRUMcgjIiKHoxmV8vr1641cEvuieb9qjupJZIjChZeRRE0VR9ckIiKH4+zsDLVajby8PACAp6cnJImtDnURQuD69evIy8uDWq2Gs7NzYxeJ7AC/U0RNF4M8IiJySEFBQQCgDfTINLVarX3fiExhiEfUdDHIIyIihyRJEoKDgxEYGIiKiorGLk6T5+rqyhY8ssicIe2x/KtfMaZbaGMXhYhqYJBHREQOzdnZmcELkRXc3y8CA6MD0S5A1dhFIaIaGOQRERERkcUkSUJUyxaNXQwiMoDDIhERERERETkQBnlEREREREQOhOmaNqaZaLaoqKiRS0JERERERLamiQM0cYE1MMizscuXLwMAWrdu3cglISIiIiKixnL58mV4e3tbZd8M8mzM19cXAHD69GmrfahERUVFaN26Nc6cOQMvL6/GLg45KNYzshXWNbIF1jOylcLCQrRp00YbF1gDgzwbc3Kq7gbp7e3NEwhZnZeXF+sZWR3rGdkK6xrZAusZ2YomLrDKvq22ZyIiIiIiIrI5BnlEREREREQOhEGejSkUCixatAgKhaKxi0IOjPWMbIH1jGyFdY1sgfWMbMUWdU0S1hy7k4iIiIiIiGyKLXlEREREREQOhEEeERERERGRA2GQR0RERERE5EAY5BERERERETkQBnky+N///oc77rgDarUaSqUSiYmJ2LJli0X7KCsrw9KlSxEZGQl3d3eEhIRg1qxZyMvLs1Kpyd40pJ4JIbBjxw48+OCD6NSpE7y9veHp6YnOnTtj+fLlKC0ttXLpyV7IcT7TdfXqVYSGhkKSJCQnJ8tYUrJ3ctW1vLw8PPbYY9rfTz8/P/Tu3RtvvPGGFUpN9kaOenb+/Hk88sgjiI2NhVKpRMuWLdG3b1/861//QmVlpZVKTvZi48aNmD17Nrp37w6FQgFJkrB+/XqL91NVVYXVq1ejY8eO8PDwQEBAACZMmIA//vijfgUT1CBff/21cHV1FS1atBD333+/mDdvnggLCxMAxKpVq8zaR2VlpRg2bJgAIBITE8WCBQvEmDFjhCRJIiIiQuTl5Vn5KKipa2g9u3HjhgAgFAqFGDZsmHjiiSdEamqqiIyMFABEjx49RElJiQ2OhJoyOc5nNU2cOFEolUoBQAwbNkzmEpO9kquuHTp0SAQEBAgXFxdx9913i6eeekqkpqaKIUOGiOHDh1vxCMgeyFHPfv/9d+Hv7y8kSRLJycli/vz54oEHHhBBQUECgJg6daqVj4KaOk2d8vf31/4/PT3d4v3MnDlTABBxcXFi/vz5YtKkScLNzU34+vqK3377zeL9MchrgIqKCtGuXTuhUCjEoUOHtMsLCgpEVFSUcHNzE3/++afJ/bz33nsCgJgwYYKoqqrSLn/jjTcEADFr1ixrFJ/shBz1rLy8XLz44oviypUrtZbfddddAoBIS0uzRvHJTsh1PtP10UcfCQBizZo1DPJIS666VlhYKNq0aSMCAgLEkSNHDL4ONV9y1bMHH3xQABCvvfaa3vKrV6+KNm3aCAAWnxvJsezevVtbB1asWFGvIO/rr78WAET//v1FWVmZdvlXX30lAIikpCSLy8UgrwEyMjIEADFt2rRa69avXy8AiCVLlpjcT+/evQ2eJKqqqkRERIRQKpXi+vXrspWb7Itc9awuP/zwgwAgRowY0ZBikp2Tu57l5eWJgIAAMXnyZJGdnc0gj7Tkqmuai6l3333XGsUkOydXPdNkWhlqSZk4caIAIPbv3y9Lmcn+1TfImzBhggAgvv3221rrBg4cKACInJwci/bJPnkNsGfPHgBAUlJSrXXDhg0DAHz77bdG91FaWooff/wR0dHRCAsL01snSRJuv/12lJSUYP/+/fIUmuyOHPXMGFdXVwCAi4tLvfdB9k/uevbAAw/A2dkZr7/+uizlI8chV13bvHkzJEnC2LFjceLECaxevRppaWn4/PPPUV5eLmuZyf7IVc/i4+MBAF999ZXe8oKCAmRmZiIoKAixsbENLC01d3v27IFSqUSfPn1qravvtR6v6hrg5MmTAIDIyMha64KCgqBSqbTb1OX3339HVVWVwX3o7vvkyZPo169fA0tM9kiOembMe++9B8DwDyE1H3LWs40bN+KTTz7Btm3b4OPjg8LCQlnLSvZNjrpWXl6OrKwsBAQEYPXq1Vi0aBGqqqq06yMiIrBt2zZ07NhR3sKT3ZDrnPbkk09i+/bteOyxx7Bz50506tQJRUVF2LZtGzw9PfHpp5/Cw8ND9vJT81FSUoLc3FzEx8fD2dm51nrdWMASbMlrAM2Fi7e3t8H1Xl5eJi9uzNmH7nbU/MhRz+qyY8cOvPXWW4iJicGMGTPqXUayf3LVs/Pnz2Pu3LmYMGEC7r77blnLSI5Bjrp25coVVFZW4vLly1i6dCnS0tJw8eJFnD17Fs899xyys7Nx1113ceTgZkyuc1rLli2xb98+JCcnY+fOnUhLS8Obb76JwsJCTJkyBZ07d5a13NT8WCsWYJBH1Ez973//w/jx4+Ht7Y2tW7dCoVA0dpHIAcycOROurq74xz/+0dhFIQemabWrrKzEQw89hMcffxyBgYEIDQ3F0qVLMW7cOOTk5OCjjz5q5JKSvTt16hT69OmD/Px87N27F9euXcOZM2fw/PPP44UXXsCQIUM4jQI1SQzyGkATcdcVWRcVFdUZlVuyD93tqPmRo57VtH//fiQlJcHJyQkZGRmIi4trcDnJvslRzzZs2IAdO3Zg7dq18Pf3l72M5Bjk/O0EgJEjR9Zar1nG/uzNl1y/nVOnTkVOTg62b9+Ovn37QqVSoVWrVnjqqacwZ84c7Nu3D5s2bZK17NS8WCsWYJDXAMZyZC9cuIDi4uI6+9ppREREwMnJqc48W2M55dQ8yFHPdO3fvx+33347qqqqkJGRgR49eshWVrJfctSzQ4cOAQDGjRsHSZK0j/DwcABARkYGJElCly5d5C082RU56ppSqURoaCgAQK1W11qvWXbjxo2GFZbslhz17Nq1a8jMzERMTAyCgoJqrR80aBCAW+c+ovpQKpUIDg5Gdna2wVbh+sYCDPIaYMCAAQCAXbt21VqXkZGht01dPDw80LNnT5w4cQI5OTl664QQ2L17N5RKJbp37y5TqcneyFHPNDQBXmVlJXbu3IlevXrJV1Cya3LUs969e2PGjBm1HuPHjwcAtGrVCjNmzMCYMWNkLj3ZE7nOaYMHDwYA/PLLL7XWaZa1bdu2vsUkOydHPdOM0nrp0iWD6/Pz8wGA3R2owQYMGICSkhJkZmbWWqepr/3797dspxZNuEB6KioqREREhNGJNrOzs7XLz58/L44fPy4KCgr09sPJ0MkYuerZ/v37hVqtFiqVSnz//fc2Kj3ZC7nqmSGcJ490yVXXMjMzBQARFxcnrl69ql2em5srQkNDhZOTkzhx4oSVj4aaKrnqWXR0tAAg3nnnHb3lV69eFR06dBAAxO7du615KGRHTM2Tl5+fL44fPy7y8/P1lnMy9Cbo66+/Fq6urqJFixbi/vvvF/PmzRNhYWECgFi1apXetikpKQY/+MrKSu1km4mJiWLBggVi7NixQpIkER4eLvLy8mx4RNQUNbSeXb58Wfj4+AgAIjk5WSxatKjW49VXX7XtQVGTI8f5zBAGeVSTXHVt3rx5AoBo3bq1eOihh8T9998vAgMDBQCxfPlyGx0NNVVy1LOvvvpKuLi4CABiyJAh4oknnhAzZswQAQEBAoAYO3asDY+ImqJ33nlHpKSkiJSUFNGtWzcBQPTp00e7TPcGwaJFiwQAsWjRolr7mTlzpvbG1fz588XkyZOFm5ub8PX1rdcNKwZ5Mvjxxx9FcnKy8PLyEh4eHqJnz55i06ZNtbYz9kNVWloqFi9eLNq1ayfc3NxEUFCQmDlzprhw4YINjoDsQUPqmeYi29gjLCzMdgdDTZYc57OaGOSRIXLVtfT0dNG9e3fh6ekplEql6Nu3r/jkk0+sXHqyF3LUs59++kmMGzdOBAcHCxcXF6FSqUSPHj3E6tWrxc2bN21wFNSUaepOXY+UlBTttsaCvMrKSvH666+LuLg4oVAohJ+fnxg/frw4depUvcolCSGEZQmeRERERERE1FRx4BUiIiIiIiIHwiCPiIiIiIjIgTDIIyIiIiIiciAM8oiIiIiIiBwIgzwiIiIiIiIHwiCPiIiIiIjIgTDIIyIiIiIiciAM8oiIiIiIiBwIgzwiIiIiIqK/fPfdd7jrrrsQEhICSZKwbds2i/chhMCqVasQFRUFhUKB0NBQLFu2TP7C1sHFZq9ERERERETUxJWUlKBz586YPn06xowZU699PPLII9i1axdWrVqFjh074sqVK7hy5YrMJa2bJIQQNns1IiIiO7Rt2zYcPnwYXbp0wahRoxq7OEREZCOSJOHTTz/VO/eXlZXhmWeewYcffoiCggLEx8dj5cqVGDhwIADg+PHj6NSpE44dO4bo6OhGKTfTNYmIiEzYtm0blixZUq+UHSIiciypqanYt28fNm3ahKNHj2LcuHFITk7GyZMnAQDbt29HREQEvvjiC4SHh6Nt27aYOXOmTVvyGOQRERERERGZ4fTp00hPT8fWrVvRr18/tGvXDk888QT69u2L9PR0AMAff/yBnJwcbN26Fe+//z7Wr1+PAwcO4J577rFZOdknj4iIiIiIyAxZWVmorKxEVFSU3vKysjL4+fkBAKqqqlBWVob3339fu927776LhIQEnDhxwiYpnGzJIyKiZmnz5s0YPnw4WrZsCVdXV6jVakRGRmLkyJFYu3YtSktLsWfPHkiShA0bNgAANmzYAEmS9B579uypte9jx45h1qxZiIyMhKenJ1QqFTp16oRnnnkGly5dMliexYsXQ5IkbZ+OLVu2YMCAAfD19YVSqURCQgLWrFmDysrKOo8pIyMDY8aMQatWreDm5gYvLy9EREQgKSkJq1atsmmqEBGRIyouLoazszMOHDiAw4cPax/Hjx/H66+/DgAIDg6Gi4uLXiAYExMDoLol0BbYkkdERM3O9OnTtWk1AKBSqVBRUYFTp07h1KlT2L59O0aMGAE3Nze0bNkShYWFKC0thbu7O7y9vfX25ebmpvd3WloaFi5ciKqqKgCAp6cnKioqkJWVhaysLKSnp+PLL79E165d6yzfggULkJaWBkmSoFarUVpaioMHD+LgwYP44osv8Nlnn0GhUOg9Z+nSpVi0aJH2b09PTwghkJ2djezsbOzevRvdu3fXBpFERGS5rl27orKyEnl5eejXr5/Bbfr06YObN2/i999/R7t27QAAv/32GwAgLCzMJuVkSx4RETUr33//PdLT0+Hk5ISVK1fi8uXLuHbtGkpKSnDp0iVkZGQgJSUFbm5uuO2223DhwgWMHz8eADB+/HhcuHBB73Hbbbdp9/3uu+9iwYIF8PT0xLJly5Cbm4uSkhJcv34d+/fvx+DBg5Gbm4uRI0eiuLjYYPkOHz6MtLQ0pKam4uLFi7hy5QquXr2KF154AZIkISMjAwsXLtR7Tk5ODpYsWQIAmDdvHs6dO4eSkhJcu3YNBQUF2Lt3Lx566CG0aNHCSu8qEZHjKC4u1rbQAUB2djYOHz6M06dPIyoqCvfddx+mTJmCTz75BNnZ2fjpp5+wYsUKfPnllwCAoUOHolu3bpg+fToOHTqEAwcOYPbs2bj99ttrpXlajSAiImpGVq5cKQCIpKQks5+TkpIiAIiUlJQ6tykqKhJqtVoAEDt37jS4TUVFhUhISBAAxKuvvqq3btGiRQKAACAmT55s8PnPPvusACBcXFzEuXPntMs3b94sAIioqCizj4mIiAz75ptvtOdj3YfmN6C8vFw8//zzom3btsLV1VUEBweL0aNHi6NHj2r3ce7cOTFmzBihUqlEy5YtxdSpU8Xly5dtdgxsySMiomZFrVYDAPLz8432b7PUxx9/jIKCAnTt2hXDhg0zuI2LiwsmTJgAoLr/XF2ef/55g8uffPJJeHh44ObNm/j444+1yzXHpGmRJCKi+hs4cCCEELUe69evBwC4urpiyZIlyM7ORnl5Oc6fP49PPvkEHTt21O4jJCQEH3/8Ma5du4YLFy4gPT0dvr6+NjsG9skjIqJmZciQIXB3d8ehQ4fQr18/zJgxA4MHD0Z4eHiD9puZmQmgehLcoKCgOre7ceMGgOoUS0Nat26N9u3bG1zn5eWFhIQEfP/999i/f792ec+ePeHv74/c3Fz06tULDzzwAIYOHYro6GhIklTfQyIiIjvFljwiImpW2rVrh3Xr1kGlUmHfvn2YOXMmIiIiEBgYiPHjx+Ozzz6DEMLi/Z4/fx4AUFpaiosXL9b5KCoqAgBcv37d4H5CQ0ONvo5mfV5ennaZWq3Ghx9+iICAAPz888+YM2cOYmJi4OPjg5EjR2Ljxo2oqKiw+JiIiMg+McgjIqJm57777kNOTg7efPNNjB8/Hq1bt0Z+fj62bNmCUaNGYcCAAdpgzFya1M/x48cbTPOp+fjzzz9lPaahQ4ciOzsb77//PlJSUhAZGYnCwkJs374dkydPRteuXXHu3DlZX5OIiJomBnlERNQs+fr6Yvbs2di0aRNOnz6NU6dO4amnnoIkSdi7dy8WL15s0f40KZp1pWGay1QgplkfGBhYa51SqcTkyZOxfv16/Pbbbzh79ixWrlwJd3d3bQsfERE5PgZ5REREqE7jXLFiBSZOnAgA2L17t3adk1P1z6WxNM4+ffoAAA4cOIDc3Nx6l+PMmTP4/fffDa67du0aDhw4AADo3r27yX2FhoZi/vz5ePzxxwHoHxMRETkuBnlERNSslJWVGV3v4eEB4FZgB1QPeAIABQUFdT5v3LhxUKvVqKiowLx584wGhFVVVUb39cILLxhc/sorr+DGjRtwcXHB2LFjtcvrc0xEROS4eLYnIqJmJTU1Fffeey8+/vhjvcFLiouL8eabb+L9998HAIwYMUK7Lj4+HgCwd+9e/Prrrwb3q1ar8dprrwEANm3ahBEjRuDHH39EVVUVgOrA7vjx43jllVcQFxeHL774wuB+vL29sWHDBjzyyCO4dOkSgOoWvOXLl2Pp0qUAgIcffhghISHa56xcuRLDhw/Hv/71L5w9e1a7vKysDFu2bMHLL79c65iIiMhxcQoFIiJqVioqKrB161Zs3boVAKBSqeDi4qLXsta3b18888wz2r/Hjh2Lp59+Gvn5+YiJiYG/vz+USiWA6oAuMTERAJCSkoIbN27gkUcewY4dO7Bjxw4oFAqoVCoUFRXpjXBZ19QGXbp0Qa9evZCWlobVq1dDrVajqKhIO7DL0KFD8dJLL+k9p6qqCjt37sTOnTsBVLfceXh44OrVq9oWxZiYGPz9739vyFtHRER2gkEeERE1K8899xwSEhLwzTff4Pjx47hw4QKKi4sRGBiIzp07Y8KECZgyZQqcnZ21z/Hx8cF3332HJUuWYO/evcjLy9O2spWWlurt/4EHHkBycjLWrl2L3bt3Izs7GwUFBfDy8kK7du3Qu3dvjBw5EoMHD66zjCtXrkS3bt2wdu1aZGVlwc3NDdHR0Zg2bRoefvhhvbIBwKxZsxAaGopvvvkGWVlZyM3NRWFhIXx8fBAXF4exY8di9uzZcHd3l/GdJCKipkoS9ZkMiIiIiGS1ePFiLFmyBAMGDMCePXsauzhERGTH2CePiIiIiIjIgTDIIyIiIiIiciAM8oiIiIiIiBwIgzwiIiIiIiIHwoFXiIiIiIiIHAhb8oiIiIiIiBwIgzwiIiIiIiIHwiCPiIiIiIjIgTDIIyIiIiIiciAM8oiIiIiIiBwIgzwiIiIiIiIHwiCPiIiIiIjIgTDIIyIiIiIiciD/D+nNah0jJVfJAAAAAElFTkSuQmCC\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""convergence = biceps.Convergence(filename=os.path.join(outdir,\""traj_lambda1.00.npz\""), outdir=outdir)\n"", ""convergence.plot_traces(figname=\""traces.pdf\"", xlim=(0, nsteps))"" ] }, { ""cell_type"": ""code"", ""execution_count"": 18, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""convergence.get_autocorrelation_curves(method=\""block-avg-auto\"", maxtau=500, nblocks=5)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""After the autocorrelation times have been stored, $\\verb|C.process|$ is called to perform a series of operations including the output of plots (Figure \\ref{fig:JSD_conv_unconv}a.) from the resulting JSD analysis. By default, there are numerous preset arguments for JSD analysis: $\\verb|nround=100|$ is the number of rounds of bootstrapping when computing JSDs, $\\verb|nfold=10|$ is the number of partitions in the shuffled (subsampled) trajectory.\n"", ""\n"", ""Jensen-Shannon divergence (JSD) is an improved method from Kullback-Leibler divergence and is a statistical way to measure the similarity between two probability distributions. In our convergence test, we are aiming to check if we use more data, will the distribution be different or similar to the less data which is a perfect situation that JSD calculation could be helpful. Given two sets data from BICePs sampling $P_1$ and $P_2$, to check if these two distribution is similar or not, we can compute the JSD as:\n"", ""\n"", ""\\begin{equation}\n"", ""JSD = H(P_{1}\\cup P_{2}) - {\\pi_1}{H(P_1)} - {\\pi_2}{H(P_2)}\n"", ""\\label{eq:JSD_def}\n"", ""\\end{equation}\n"", ""where $H$ is the Shannon entropy of distribution $P_i$ and $\\pi_i$ is the weight for the probability distribution $P_i$.\n"", ""Specifically, in BICePs the $P_i$ is the distribution of sampled parameters and ${H(P_i)}$ can be computed as:\n"", ""\n"", ""\\begin{equation}\n"", ""{H(P_i)} = \\sum -\\frac{r_i}{N_i}*\\ln{\\frac{r_i}{N_i}}\n"", ""\\end{equation}\n"", ""where $r_i$ and $N_i$ represents sampled times of a specific parameter index and the total number of samples of the parameter, respectively. $\\pi_i$ can be computed as $\\frac{N_i}{N_{total}}$ where $N_{total} = \\sum{N_i}$. Combined together we have:\n"", ""\n"", ""\\begin{equation}\n"", ""JSD = \\sum{(-\\frac{r_{total}}{N_{total}}*\\ln{\\frac{r_{total}}{N_{total}}})} - \\frac{N_i}{N_{total}}*\\sum(-\\frac{r_i}{N_i}*\\ln{\\frac{r_i}{N_i}})\n"", ""\\label{eq:JSD}\n"", ""\\end{equation}\n"", ""\n"", ""where $i = 1, 2$ in this example.\n"", ""In BICePs, we can import different amount of data into our JSD calculation. To do that, we may use $p\\%$ ($p = 10,20,...100$) data and divide the dataset ($P_{total}$) into two parts (the first half and second half) to get $P_1$ and $P_2$ in eq \\ref{eq:JSD_def} and compute the JSD value ($JSD_{single}$) using eq \\ref{eq:JSD}. Then we can randomly pick up $N_{total}/2$ points from $P_{total}$ as $P_1$ ($N_{total}$ is the total number of data after chopped) and the remaining data as $P_2$. In this way, we are mixing the data and the computed JSD ($JSD_{random}$) from this mixing data should be smaller than the computed JSD from just first versus second half data. But if the dataset is completely converged, $JSD_{single}$ and $JSD_{random}$ should be close. Repeat mixing data $N$ times, we shall get $\\Big\\{JSD_{random}\\Big\\}_N$ values and a corresponded distribution. Our null hypothesis is the computed $JSD_{single}$ is not in the distribution of $\\Big\\{JSD_{random}\\Big\\}_N$. To test if we can accept or reject the hypothesis, we rank the $JSD_{single}$ values in $\\Big\\{JSD_{random}\\Big\\}_N$ in ascending order. If it is in the top 99\\% ranked (see Figure \\ref{fig:JSD_exp}b), then we reject the hypothesis which indicates $P_1$ and $P_2$ no matter mixing the data or not are drawn from a mutual distribution and the data is converged. If the ranked $JSD_{single}$ is in the last 1\\% (Figure \\ref{fig:JSD_exp}a), the data is not converged yet.\n"", ""\n"", ""\n"", ""As an exmaple, Figure \\ref{fig:JSD_conv_unconv} shows JSD analysis on trajectories with different amount of steps (10K, 100K, 1M, 10M, 100M) with two $\\lambda$ values ($\\lambda = 0.0, 1.0$). Panel (a) shows JSD values (red dots) for a given percentage of the dataset, where the shaded region defines the 95\\% confidence interval of the distribution. Interestingly, panel (b) suggests that the 10k step trajectory has locally converged and panel (c) shows JSD values outside of the 95\\% confidence interval representing false positives suggesting that more sampling is needed. Hence, the need to analyze convergence of trajectories for various number of steps. The last two panels (d and e) clearly show convergence and suggest that 1M steps is sufficient.\n"", ""\n"", ""\n"", ""\n"", ""
\n"", ""\n"", ""
An example Jensen-Shannon Divergence (JSD) analysis. (a) The JSD between the\n"", ""first and last half of the σNOE trajectory, plotted as a function of the percentage of trajectory\n"", ""that has been sampled. The shaded region in this plot represents the 95% confidence interval\n"", ""of the JSD metric for the null distribution, calculated using a bootstrap procedure. (b-c)\n"", ""Extending the MCMC trajectories by 1M steps and 10M steps, respectively, results in the\n"", ""trajectory having complete statistical indistinguishability between the first and last halves \n"", ""
\n"", ""
\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""The convergence submodule is extremely convenient and useful for users to objectively quantify sampling quality. Still, convergence checking could get complicated. For example, a larger value of $\\verb|maxtau|$ may be necessary in cases of more slowly decorrelated time series. Occasionally, negative values of $\\tau_{auto}$ may be obtained indicating the amount of data is not enough for computing autocorrelation time. Despite there not being a one-size-fits-all approach to checking the validity of MCMC trajectories, our team decided to include a depot of methods to check convergence. By checking convergence, we can put more trust in our next step, analysis.\n"", ""\n"", ""\n"", ""\n"", ""\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""#### Analysis\n"", ""\n"", ""\n"", ""Our biceps workflow ends by predicting conformational state populations, computing the biceps score and plotting distributions. This has been made easy via the $\\verb|biceps.Analysis|$ class which automatically analyzes our MCMC trajectories. As we mentioned here \\cite{Voelz:2014fga,Ge:2018bdb, voelz2021reconciling}, BICePs uses a free energy perturbation approach in $\\lambda$ space, where sampling is done independently for multiple $\\lambda$ values. Then using MBAR we can infer the potential energy of snapshots in ensemble $j$ which is originally sampled in ensemble $i$. From this, populations can be predicted for each conformational state and the biceps score can be computed. More details can be found in this work \\cite{Shirts:2008eza}.\n"", ""\n"", ""\n"", ""From Bayesian model selection, BICePs is able to calculate a Bayes factor-like quantity that we call the BICePs score, which quantifies the support of evidence for one model over another. The quality of a model $k$ that uses a prior $P^{(k)}(X)$ from theoretical modeling can be assessed by the posterior likelihood $Z^{(k)}$ of model $k$:\n"", ""\n"", ""\\begin{equation}\n"", ""Z^{(k)} = \\int P^{(k)}(X,\\sigma | D) dX d\\sigma =\\int P^{(k)}(X) Q(X) dX.\n"", ""\\end{equation}\n"", ""\n"", ""One way to think of $Z^{(k)}$ is as an integral over the entire input space (including nuisance parameters) of the model. Another way, however, is to think of $Z^{(k)}$ as an \\textit{overlap} integral between the prior $P^{(k)}(X)$ and a likelihood function $Q(X) = \\int [Q(\\mathbf{r}(X)|D,\\sigma)/Q_{\\text{ref}}(\\mathbf{r}(X)) ] P(\\sigma) d\\sigma$. This integral reaches the maximum when $P^{(k)}(X)$ most closely matches the likelihood distribution $Q(X)$ specified by the experimental restraints.\n"", ""\n"", ""Suppose we have two models (1) and (2) with priors $P^{(1)}$ and $P^{(2)}$, and we want to know which one is more consistent with experimental measurements. In Bayesian statistics, the comparison is often made using the ratio of posterior model probabilities, $Z^{(1)}/Z^{(2)}$, also called the Bayes factor.\n"", ""\n"", ""In BICePs, we consider a free energy-like quantity, called the BICePs score:\n"", ""\\begin{equation}\n"", ""f^{(k)} = -\\ln \\frac{Z^{(k)}}{Z_0},\n"", ""\\label{eq:reference_state}\n"", ""\\end{equation}\n"", ""\n"", ""\n"", ""Not only can this be used to show that reweighted populations are more consistent with experimental data, it can also be used to rank different simulated ensembles by their accuracy in reproducing experimental observables (Ge and Voelz, 2018). Instantiating this class requires a path to glob the $\\verb|'*.npz'|$ trajectories as well as the number of states ($\\verb|nstates|$).\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 19, ""metadata"": { ""scrolled"": false }, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""not all state sampled, these states [ 1 4 5 9 11 13 14 15 16 18 22 23 24 25 26 27 28 34 40 41 42 48 51 53\n"", "" 54 57 60 61 62 64 69 71 73 76 77 81 83 87 89 95 98 99] are not sampled\n"", ""BICePs Scores = [0. 0.1831955]\n"" ] }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""############ MBAR and Figures ###########\n"", ""%matplotlib inline\n"", ""# Let's do analysis using MBAR algorithm and plot figures\n"", ""A = biceps.Analysis(outdir, nstates=len(energies))\n"", ""biceps.toolbox.save_object(A, \""analysis_object.pkl\"")\n"", ""#pops = A.P_dP[:,n_lambdas-1]\n"", ""pops, BS = A.P_dP, A.f_df\n"", ""print(f\""BICePs Scores = {BS[:,0]}\"")"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""The following analysis files will be exported to the directory where the trajectory live: (1) the predicted populations of each conformational state using PyMbar\\cite{Shirts:2008eza} ($\\verb|populations.dat|$)\n"", ""(2) the BICePs score ($\\verb|BS.dat|$). Invoking the $\\verb|plot|$ method in $\\verb|Analysis|$ produces Figure \\ref{fig:BICePs_outcome} ($\\verb|BICePs.pdf|$). This figure shows the posterior distribution of inferred state populations and sampled nuisance parameters ($\\sigma_J$, $\\sigma_{noe}$ and $\\gamma$). Our results shown in Figure \\ref{fig:BICePs_outcome} perfectly reproduce previous published work \\cite{Voelz:2014fga} which indicates reliability of the latest version.\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 20, ""metadata"": {}, ""outputs"": [], ""source"": [ ""import pickle\n"", ""with open(\""analysis_object.pkl\"", 'rb') as f:\n"", "" A = pickle.load(f)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 21, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""pops, BS = A.P_dP, A.f_df\n"", ""pops0,pops1 = pops[:,0], pops[:,len(lambda_values)-1]\n"", ""\n"", ""legend_fontsize=16\n"", ""#fig = A.plot(plottype=\""hist\"", figname=\""BICePs.pdf\"", figsize=(14,8),\n"", ""fig = A.plot(plottype=\""step\"", figname=\""BICePs_.pdf\"", figsize=(14,8),\n"", "" label_fontsize=18, legend_fontsize=legend_fontsize)\n"", ""ax = fig.axes[0]\n"", ""high_E_confs = [79, 21] #87\n"", ""for i in high_E_confs:\n"", "" #print(pops0[i], pops1[i], str(i))\n"", "" ax.text( pops0[i], pops1[i], str(i), color='r' , fontsize=legend_fontsize)\n"", ""fig.savefig(os.path.join(outdir,\""BICePs.pdf\""), dpi=600)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
\n"", ""
\n"", "" (a) A comparison of conformational state populations $p_{i}(\\text{exp})$ inferred using only experimental restraints, vs. BICePs populations $p_{i}(\\text{sim + exp})$ inferred using a combination of the simulation-based prior and experimental restraints. States on the lower right are highly compatible with experimental restraints, but are conformationally strained according the simulation model. Conformational states near the top of the graph are both reasonably compatible with experimental restraints, and highly-populated according to the simulation model. (c) The marginal posterior distribution of $\\sigma_{\\text{NOE}}$, the uncertainty parameter for NOE distance restraints. (b) The marginal posterior distribution of $\\sigma_{\\text{J}}$ , the uncertainty parameter for J-coupling constants. (d) The marginal posterior distribution of $\\gamma_{\\text{NOE}}$, the scaling parameter for the NOE distances, remains near 1.25 throughout the MCMC sampling.\n"", ""
\n"", ""
\n"", ""\n"", ""\n"", ""In panel (a) in Figure {} we can see the population of each states in the presence (y-axis) and absense (x-axis) of computational modeling prior information. You can find some states (e.g state 38, 59, 65, 90) get awarded upon including information from simulation. After mapping back to the energies of these states, we find that these correspond to some of the low energy structures. Conversely, some of the high energy states have been pentalized e.g., state 0. For futher information regarding how well our reweighted populations relate to the crystal isoforms of albocycline, the O-methylated analog of cineromycin B, please see this work\\cite{Voelz:2014fga}. Panels (b)-(d) show the distribution of nuisance parameters in the presence or absence of computational modeling information. \n"", ""\n"", ""\n"", ""The populations ($\\verb|pops|$) are stored is a NumPy array containing a row for each state ($\\verb|nstates|$=100) and four columns corresponding to our 2 lambda values (first 2 columns) and their corresponding population change (last 2 columns). Using the reweighted populations of Cineromycin B, the experimental observables $r_{j}^{\\text{exp}}$ can be compared to our ensemble-averaged back calculated observable $ = \\sum_{X} r_{j}(X)P(X)$ after BICePs reweighting. \n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""Maximum-likelihood values of nuisance parameters $\\sigma_{\\text{J}}^{*}$, $\\sigma_{\\text{NOE}}^{*}$, $\\gamma_{\\text{NOE}}^{*}$ from posterior sampling can be considered the best estimate of the uncertainty in the experimental observables. The treatment of experimental NOE distances (2.5Å for all) comes from the lack of experiemntal data. We can see from the posterior distribution of $\\gamma$ with greatest frequency about 1.25Å indicates that the estimated true NOE distance is our initial guess of 2.5Å scaled by 1.25 resulting in an experimental ensemble averaged NOE distance $3.12 \\pm 0.7Å$, as shown as the dotted black line in Figure {}.\n"", ""\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""\\section{Conclusion}\n"", ""\n"", ""We have introduced the BICePs v2.0 software package which is a Bayesian inference approach that can be used for protein structure determination, reweighting simulated ensembles, performing objective model selection, and more that exceeds the scope of this application using cineromycin B. Our algorthim is special in that it is used as a post-simulation processing step, properly accounts for differences in experimental restraints by correctly implementing reference potentials, and provides an objective metric for model selection through the BICePs score. This tool supports a range of experimental observables (NOE, Jcouplings, chemical shifts and protection factors) and will continue to grow. BICePs v2.0 is currently written in Python, but we have plans to imrpove the speed of the sampling routines with C++ and include more enhanced sampling techniques inside the algorithm. Users can install the package through pip/GitHub (\\url{https://biceps.readthedocs.io/en/latest/installation.html}). More detailed documentation and tutorials can be found at: \\url{https://biceps.readthedocs.io}. For any issues or questions, please submit the request on GitHub: \\url{https://github.com/vvoelz/biceps}.\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", "" "" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""### Data and Software Availability\n"", ""\n"", ""The BICePs v2.0 algorithm is freely available at \\url{https://github.com/vvoelz/biceps} and can be installed using: \\verb|pip install biceps|. All input files and analysis for this work can be found here: \\url{https://github.com/vvoelz/biceps/tree/master/docs/examples/full_examples/cineromycinB}. Detailed documentation and tutorials can be found here: \\url{https://biceps.readthedocs.io}. For any issues or questions, please submit the request on GitHub.\n"", ""\n"", ""\n"", ""### ACKNOWLEDGMENTS\n"", ""This research was supported in part by the National Institutes of Health through grant 1S10OD020095-01. R.R and Y.G were supported by National Institutes of Health grant 1R01GM123296. This research includes calculations carried out on Temple University’s HPC resources and thus was supported in part by the National Science Foundation through major research instrumentation grant number 1625061 and by the US Army Research Laboratory under contract number W911NF-16-2-0189.\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# SI"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Table. Maximum-likelihood values of nuisance parameters $\\sigma_{\\text{J}}^{*}$, $\\sigma_{\\text{NOE}}^{*}$, $\\gamma_{\\text{NOE}}^{*}$ from posterior sampling."" ] }, { ""cell_type"": ""code"", ""execution_count"": 22, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
sigma_Jsigma_noegamma_noe
05.3531640.7389131.392666
16.0285320.6826411.236647
\n"", ""
"" ], ""text/plain"": [ "" sigma_J sigma_noe gamma_noe\n"", ""0 5.353164 0.738913 1.392666\n"", ""1 6.028532 0.682641 1.236647"" ] }, ""execution_count"": 22, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""mlp = pd.concat([A.get_max_likelihood_parameters(model=i) for i in range(len(lambda_values))])\n"", ""mlp.reset_index(inplace=True, drop=True)\n"", ""mlp"" ] }, { ""cell_type"": ""code"", ""execution_count"": 30, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""import uncertainties as u\n"", ""\n"", ""pops_std = A.P_dP[:,-1]\n"", ""\n"", ""# NOTE: Get Prior MSM populations\n"", ""prior_pops = np.loadtxt(data_dir+\""prior_pops.txt\"")\n"", ""prior_pops /= prior_pops.sum()\n"", ""\n"", ""noe = [pd.read_pickle(i) for i in biceps.toolbox.get_files(data_dir+\""J_NOE/*.noe\"")]\n"", ""# Get the ensemble average observable\n"", ""noe_Exp = noe[0][\""exp\""].to_numpy()\n"", ""noe_model = [i[\""model\""].to_numpy() for i in noe]\n"", ""\n"", ""noe_prior = np.array([w*noe_model[i] for i,w in enumerate(prior_pops)]).sum(axis=0)\n"", ""noe_reweighted = np.array([w*noe_model[i] for i,w in enumerate(pops[:,n_lambdas-1])]).sum(axis=0)\n"", ""\n"", ""noe_prior = np.array([w*noe_model[i] for i,w in enumerate(prior_pops)]).sum(axis=0)\n"", ""noe_reweighted = np.array([u.ufloat(w, pops_std[i])*noe_model[i] for i,w in enumerate(pops[:,n_lambdas-1])]).sum(axis=0)\n"", ""\n"", ""\n"", ""\n"", ""distance_labels = [f\""{row[1]['atom_name1']}-{row[1]['atom_name2']}\"" for row in noe[0].iterrows()]\n"", ""distance_label_indices = np.array([[row[1]['atom_index1'], row[1]['atom_index2']] for row in noe[0].iterrows()])\n"", ""\n"", ""\n"", ""J = [pd.read_pickle(file) for file in biceps.toolbox.get_files(data_dir+'J_NOE/*.J')]\n"", ""# Get the ensemble average observable\n"", ""J_Exp = J[0][\""exp\""].to_numpy()\n"", ""J_model = [i[\""model\""].to_numpy() for i in J]\n"", ""\n"", ""J_prior = np.array([w*J_model[i] for i,w in enumerate(prior_pops)]).sum(axis=0)\n"", ""J_reweighted = np.array([u.ufloat(w, pops_std[i])*J_model[i] for i,w in enumerate(pops[:,n_lambdas-1])]).sum(axis=0)\n"", ""\n"", ""\n"", ""\n"", ""J_labels = [f\""{row[1]['atom_name1']}-{row[1]['atom_name2']}-{row[1]['atom_name3']}-{row[1]['atom_name4']}\"" for row in J[0].iterrows()]\n"", ""J_label_indices = np.array([[row[1]['atom_index1'], row[1]['atom_index2'], row[1]['atom_index3'], row[1]['atom_index4']] for row in J[0].iterrows()])\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""fig = plt.figure(figsize=(12,12))\n"", ""gs = gridspec.GridSpec(2, 1)\n"", ""\n"", ""\n"", ""ax1 = plt.subplot(gs[0,0])\n"", ""ax2 = plt.subplot(gs[1,0])\n"", ""data = []\n"", ""for i in range(len(noe_reweighted)):\n"", "" data.append({\""index\"":i,\n"", "" \""reweighted noe\"":noe_reweighted[i], \""prior noe\"":noe_prior[i],\n"", "" \""exp noe\"":noe_Exp[i]*mlp['gamma_noe'].to_numpy()[-1], \""label\"":distance_labels[i]\n"", "" })\n"", ""data1 = pd.DataFrame(data)\n"", ""\n"", ""_data1 = data1.sort_values([\""prior noe\""])\n"", ""_data1 = _data1.reset_index()\n"", ""#print(_data1)\n"", ""\n"", ""reweighted_vals = np.array([val.nominal_value for val in _data1[\""reweighted noe\""].to_numpy()])\n"", ""reweighted_std = np.array([val.std_dev for val in _data1[\""reweighted noe\""].to_numpy()])\n"", ""\n"", ""\n"", ""#ax1 = data1.plot.scatter(x='index', y=\""reweighted noe\"", s=5, edgecolor='black', color=\""b\"", label=\""BICePs\"")\n"", ""ax1.scatter(x=_data1[\""label\""].to_numpy(), y=_data1[\""prior noe\""].to_numpy(),\n"", "" s=45, color=\""orange\"", label=\""Prior\"", edgecolor='black',)\n"", ""ax1.scatter(x=_data1[\""label\""].to_numpy(), y=_data1[\""exp noe\""].to_numpy(),\n"", "" s=150, marker=\""_\"", color=\""k\"", label=\""Exp\"")\n"", ""#ax1.scatter(x=_data1[\""label\""].to_numpy(), y=_data1[\""reweighted noe\""].to_numpy(),\n"", ""# s=40, color=\""c\"", label=\""BICePs\"", edgecolor='black')\n"", ""\n"", ""ax1.errorbar(x=_data1['label'].to_numpy(), y=reweighted_vals,\n"", "" yerr=reweighted_std , fmt=\""o\"", capsize=5,\n"", "" markersize=5, markerfacecolor=\""c\"", label=\""BICePs\"",\n"", "" ecolor=\""k\"", markeredgecolor='black')\n"", ""\n"", ""ax1.legend(fontsize=14)\n"", ""#ax1.set_xlabel(r\""Index\"", size=16)\n"", ""ax1.set_ylabel(r\""NOE distance ($\\AA$)\"", size=16)\n"", ""\n"", ""\n"", ""data = []\n"", ""for i in range(len(J_reweighted)):\n"", "" data.append({\""index\"":i,\n"", "" \""reweighted J\"":J_reweighted[i], \""prior J\"":J_prior[i], \n"", "" \""exp J\"":J_Exp[i], \""label\"":J_labels[i]\n"", "" })\n"", ""data1 = pd.DataFrame(data)\n"", ""\n"", ""reweighted_vals = np.array([val.nominal_value for val in data1[\""reweighted J\""].to_numpy()])\n"", ""reweighted_std = np.array([val.std_dev for val in data1[\""reweighted J\""].to_numpy()])\n"", ""\n"", ""ax2.scatter(x=data1['label'].to_numpy(), y=data1[\""prior J\""].to_numpy(),\n"", "" s=45, color=\""orange\"", label=\""Prior\"", edgecolor='black',)\n"", ""ax2.scatter(x=data1['label'].to_numpy(), y=data1[\""exp J\""].to_numpy(),\n"", "" s=150, marker=\""_\"", color=\""k\"", label=\""Exp\"")\n"", ""#ax2.scatter(x=data1['label'].to_numpy(), y=data1[\""reweighted J\""].to_numpy(),\n"", ""# s=40, color=\""c\"", label=\""BICePs\"", edgecolor='black')\n"", ""ax2.errorbar(x=data1['label'].to_numpy(), y=reweighted_vals,\n"", "" yerr=reweighted_std , fmt=\""o\"", capsize=5,\n"", "" markersize=5, markerfacecolor=\""c\"", label=\""BICePs\"",\n"", "" ecolor=\""k\"", markeredgecolor='black')\n"", ""\n"", ""ax2.legend(fontsize=14)\n"", ""#ax2.set_xlabel(r\""Index\"", size=16)\n"", ""ax2.set_ylabel(r\""J-coupling (Hz)\"", size=16)\n"", ""\n"", ""ticks = [\n"", "" ax1.xaxis.get_minor_ticks(),\n"", "" ax1.xaxis.get_major_ticks(),]\n"", ""xmarks = [ax1.get_xticklabels(),\n"", "" ]\n"", ""ymarks = [ax1.get_yticklabels(),\n"", "" ]\n"", ""for k in range(0,len(ticks)):\n"", "" for tick in ticks[k]:\n"", "" tick.label.set_fontsize(16)\n"", ""for k in range(0,len(xmarks)):\n"", "" for mark in xmarks[k]:\n"", "" mark.set_size(fontsize=16)\n"", "" mark.set_rotation(s=65)\n"", ""for k in range(0,len(ymarks)):\n"", "" for mark in ymarks[k]:\n"", "" mark.set_size(fontsize=16)\n"", "" mark.set_rotation(s=0)\n"", ""\n"", ""\n"", ""ticks = [\n"", "" ax2.xaxis.get_minor_ticks(),\n"", "" ax2.xaxis.get_major_ticks(),]\n"", ""xmarks = [\n"", "" ax2.get_xticklabels(),\n"", "" \n"", "" ]\n"", ""ymarks = [\n"", "" ax2.get_yticklabels(),\n"", "" ]\n"", ""for k in range(0,len(ticks)):\n"", "" for tick in ticks[k]:\n"", "" tick.label.set_fontsize(16)\n"", ""for k in range(0,len(xmarks)):\n"", "" for mark in xmarks[k]:\n"", "" mark.set_size(fontsize=16)\n"", "" mark.set_rotation(s=70)\n"", ""for k in range(0,len(ymarks)):\n"", "" for mark in ymarks[k]:\n"", "" mark.set_size(fontsize=16)\n"", "" mark.set_rotation(s=0)\n"", ""\n"", ""\n"", ""axs = [ax1,ax2]\n"", ""for n, ax in enumerate(axs):\n"", "" ax.text(-0.1, 1.0, string.ascii_lowercase[n], transform=ax.transAxes,\n"", "" size=20, weight='bold')\n"", ""fig.tight_layout()\n"", ""fig.savefig(f\""{outdir}/reweighted_observables.pdf\"", dpi=500)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
\n"", ""
\n"", "" BICePs reweighted observables compared against experiment and prior for (a) NOE and (b) J-coupling.\n"", ""
\n"", ""
\n"", ""\n"", ""\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""\n"", ""\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""#### To quickly test MCMC convergence (w/ out knowing if you have sampled all of the states in other $\\lambda$-trajectories) "" ] }, { ""cell_type"": ""code"", ""execution_count"": 25, ""metadata"": {}, ""outputs"": [ { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""100%|█████████████████████████████████████████████████████████| 5000000/5000000 [01:42<00:00, 48737.90it/s]\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted 64.25766 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [32.70802 29.95912 29.95912 1.59052] % \n"", ""\n"", ""not all state sampled, these states [ 4 5 9 11 15 16 18 22 24 25 26 27 34 40 42 48 51 52 57 62 64 73 76 77\n"", "" 81 87 95 98 99] are not sampled\n"" ] }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""lam = 1.0\n"", ""nsteps=5000000\n"", ""ensemble = biceps.Ensemble(lam, energies)\n"", ""ensemble.initialize_restraints(input_data, options)\n"", ""sampler = biceps.PosteriorSampler(ensemble)\n"", ""sampler.sample(nsteps=nsteps, print_freq=1000, verbose=False)\n"", ""traj = sampler.traj\n"", ""init, frac = biceps.find_all_state_sampled_time(traj.__dict__['state_trace'], len(energies))\n"", ""convergence = biceps.Convergence(traj, outdir=outdir)\n"", ""convergence.plot_traces(figname=\""test.pdf\"", xlim=(0, nsteps))\n"", ""convergence.get_autocorrelation_curves(method=\""auto\"", maxtau=5000)\n"", ""convergence.process()"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
# NOTE: The following cell is for pretty notebook rendering
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 23, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"" ], ""text/plain"": [ """" ] }, ""execution_count"": 23, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from IPython.core.display import HTML\n"", ""def css_styling():\n"", "" styles = open(\""notebook_theme.css\"", \""r\"").read()\n"", "" return HTML(styles)\n"", ""css_styling()"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""Python 3 (ipykernel)"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.8.13"" } }, ""nbformat"": 4, ""nbformat_minor"": 1 } ","Unknown" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/figures/custom_plots_from_biceps_convergence.py",".py","2335","67","# -*- coding: utf-8 -*- import sys, os import numpy as np import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt from scipy.optimize import curve_fit from matplotlib.offsetbox import AnchoredText import warnings warnings.filterwarnings(""ignore"",category=DeprecationWarning) #import c_convergence as c_conv def plot_JSD_distribution(all_JSD, all_JSDs, nround, nfold, fname=""JSD_distribution.png""): """"""Plots the distributions for JSD"""""" rest_type = ['sigma_noe', 'gamma'] colors=['red', 'blue','black','green'] # convert shape of all_JSD from (fold,n_rest) to (n_rest,fold) n_rest = len(rest_type) # compute mean, std of JSDs from each fold dataset of each restraint JSD_dist = [[] for i in range(n_rest)] JSD_std = [[] for i in range(n_rest)] for rest in range(n_rest): for f in range(nfold): temp_JSD = [] for r in range(nround): temp_JSD.append(all_JSDs[rest][f][r]) JSD_dist[rest].append(np.mean(temp_JSD)) JSD_std[rest].append(np.std(temp_JSD)) #plt.figure(figsize=(10,5*n_rest)) plt.figure( figsize=(3*len(rest_type),6)) x=np.arange(int(100/nfold),101.,int(100/nfold)) # the dataset was divided into ten folds (this is the only hard coded part) for i in range(n_rest): plt.subplot(n_rest,1,i+1) plt.plot(x,all_JSD[i].transpose(),'o-',color=colors[i],label=[""$\\sigma$"",""$\\gamma$""][i]) plt.hold(True) # at 95% confidence interval bounds = np.sort(all_JSDs[i]) # remove top 50 and lower 50 lower = bounds[:, int(nround*0.05)] upper = bounds[:, int(nround*0.95)] plt.fill_between(x,lower,upper,color=colors[i],alpha=0.2) plt.xlabel('dataset (%)', size=18) plt.ylabel('JSD', size=18) plt.legend(loc='best') plt.xticks(fontsize=14) plt.yticks(fontsize=14) plt.xlim(left=10, right=100) plt.tight_layout() plt.savefig(fname) if __name__ == ""__main__"": all_JSD = np.load(""all_JSD.npy"") all_JSDs = np.load(""all_JSDs.npy"") #plot_JSD_distribution(all_JSD, all_JSDs, nround, nfold, fname=""jsd_distribution.png"") plot_JSD_distribution(np.array(all_JSD), np.array(all_JSDs), nfold=10, nround=100, fname=""JSD_distribution_.pdf"") ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/figures/block_avg/plot_block_avg.py",".py","412","18","import sys, os import numpy as np from matplotlib import pyplot as plt plt.figure( figsize=(3.3, 3) ) nblock=np.arange(1,11) # 10 blocks sigma = [1.1,1.2,1.3,1.1,1.0,1.3,1.2,1.1,1.1,1.1] # make up some sigma values avg = [1.08] # make up an average sigma values plt.plot(nblock,sigma,'o-',color='black') plt.plot([1,10],[avg[0],avg[0]],color='blue') plt.ylim(0,4) plt.savefig('block_avg.pdf') plt.show() ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/figures/convergence_with_JSD/convergence_with_JSD.py",".py","2463","71","# -*- coding: utf-8 -*- import sys, os import numpy as np import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt from scipy.optimize import curve_fit from matplotlib.offsetbox import AnchoredText import warnings warnings.filterwarnings(""ignore"",category=DeprecationWarning) def plot_JSD_distribution(all_JSD, all_JSDs, nround, nfold, fname=""JSD_distribution.png""): """"""Plots the distributions for JSD"""""" rest_type = ['sigma_noe', 'gamma'] colors=['red', 'blue','black','green'] # convert shape of all_JSD from (fold,n_rest) to (n_rest,fold) n_rest = len(rest_type) # compute mean, std of JSDs from each fold dataset of each restraint JSD_dist = [[] for i in range(n_rest)] JSD_std = [[] for i in range(n_rest)] for rest in range(n_rest): for f in range(nfold): temp_JSD = [] for r in range(nround): temp_JSD.append(all_JSDs[rest][f][r]) JSD_dist[rest].append(np.mean(temp_JSD)) JSD_std[rest].append(np.std(temp_JSD)) #plt.figure(figsize=(10,5*n_rest)) plt.figure( figsize=(3*len(rest_type),6)) x=np.arange(int(100/nfold),101.,int(100/nfold)) # the dataset was divided into ten folds (this is the only hard coded part) for i in range(n_rest): plt.subplot(n_rest,1,i+1) plt.plot(x,all_JSD[i].transpose(),'o-',color=colors[i],label=[""$\\sigma$"",""$\\gamma$""][i]) plt.hold(True) # 2 Standard deviations from the mean plt.fill_between(x,np.array(JSD_dist[i])+2*np.array(JSD_std[i]), np.array(JSD_dist[i])-2*np.array(JSD_std[i]), color=colors[i],alpha=0.2) # at 95% confidence interval bounds = np.sort(all_JSDs[i]) # remove top 50 and lower 50 lower = bounds[:, int(nround*0.05)] upper = bounds[:, int(nround*0.95)] #plt.fill_between(x,lower,upper,color=colors[i],alpha=0.2) plt.xlabel('dataset (%)', size=18) plt.ylabel('JSD', size=18) plt.legend(loc='best') plt.xticks(fontsize=14) plt.yticks(fontsize=14) plt.xlim(left=10, right=100) plt.tight_layout() plt.savefig(fname) if __name__ == ""__main__"": path = ""./"" all_JSD = np.load(path+""all_JSD.npy"") all_JSDs = np.load(path+""all_JSDs.npy"") plot_JSD_distribution(np.array(all_JSD), np.array(all_JSDs), nfold=10, nround=100, fname=""JSD_distribution.pdf"") ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/figures/autocorr_flow/autocorr_flow.py",".py","390","13","import sys,os sys.path.append(""../../../"") import biceps C = biceps.Convergence(trajfile=""./traj_lambda1.00.npz"") #C.plot_traces(fname=""traces.pdf"", xlim=(0, 1000000)) C.get_autocorrelation_curves(method=""normal"", maxtau=50000) C.plot_auto_curve(fname=""auto_curve.pdf"", xlim=(0, 10000)) C.process(nblock=5, nfold=10, nround=100, savefile=True, plot=True, block=True, normalize=True) ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/figures/autocorr_flow/plot_traces_with_hist.py",".py","2957","85","# -*- coding: utf-8 -*- import sys, os import numpy as np import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt from scipy.optimize import curve_fit from matplotlib.offsetbox import AnchoredText import warnings warnings.filterwarnings(""ignore"",category=DeprecationWarning) #import c_convergence as c_conv def get_sampled_parameters(traj): """"""Get sampled parameters along time (steps). :return list: A list of all nuisance paramters sampled """""" parameters = [] rest_type = traj['rest_type'] for i in range(len(rest_type)): parameters.append(np.array(traj['traces'])[:,i]) parameters = np.array(parameters) return parameters def plot_traces(traj, fname=""traj_traces.png"", xlim=None): print('Plotting traces...') rest_type = traj['rest_type'] n_rest = len(rest_type) allowed_parameters = traj['allowed_parameters'] sampled_parameters = get_sampled_parameters(traj) labels = [""$\\sigma$"",""$\\gamma$""] fig = plt.figure(figsize=(9,4.5)) for i in range(1,2):#len(rest_type)): total_steps = len(sampled_parameters[i]) x = np.arange(1,total_steps+0.1,1) grid = plt.GridSpec(3,3, hspace=0.01, wspace=0.01) #main_ax = fig.add_subplot()#grid[1:,1:]) y_hist = fig.add_subplot(grid[1, 2:]) y_hist.hist(sampled_parameters[i], #histtype='stepfilled', #histtype='barstacked', histtype='bar', #histtype='stop', orientation='horizontal', color='blue', edgecolor='black', linewidth=1.2) #y_hist.invert_xaxis() y_hist.yaxis.set_label_position('right') y_hist.yaxis.set_ticks_position('right') y_hist.xaxis.set_label_position('top') y_hist.xaxis.set_ticks_position('top') y_hist.locator_params(axis='y', nbins=3) y_hist.locator_params(axis='x', nbins=3) y_hist.set_xlabel('counts', fontsize=14) #y_hist.set_ylim(left=np.min(allowed_parameters[0]),right=np.max(allowed_parameters[0])) x_trace = fig.add_subplot(grid[1, 0:2], sharey=y_hist) x_trace.plot(x, sampled_parameters[i],label=labels[i]) x_trace.xaxis.set_label_position('bottom') x_trace.yaxis.set_label_position('left') x_trace.yaxis.set_ticks_position('left') x_trace.set_ylabel(labels[i], fontsize=14) x_trace.set_xlabel('steps', fontsize=14) if xlim: x_trace.set_xlim(left=min(x), right=max(x)) plt.tight_layout() plt.savefig(fname) print('Done!') if __name__ == ""__main__"": testing = False if testing: trajfile = ""/Volumes/WD_Passport_1TB/new_sampling/new_sampling/d_1.01/results_ref_normal_10000/traj_lambda1.00.npz"" else: trajfile = ""traj_lambda1.00.npz"" traj = np.load(trajfile)['arr_0'].item() plot_traces(traj, fname=""traj_traces_with_hist.pdf"", xlim=[0,1000000]) ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/figures/autocorr_flow/plotting_JSd_histograms.py",".py","576","22","import sys,os sys.path.append(""../../../"") import biceps if __name__ == ""__main__"": testing = False if testing: trajfile = ""/Volumes/WD_Passport_1TB/new_sampling/new_sampling/d_1.01/results_ref_normal_100000/traj_lambda1.00.npz"" else: trajfile = ""traj_lambda1.00.npz"" C = biceps.Convergence(trajfile) C.get_autocorrelation_curves(method=""normal"", maxtau=50000) # C.get_autocorrelation_curves(method=""normal"", maxtau=1000) C.process(nblock=5, nfold=10, nround=100, savefile=True, plot=True, block=True, normalize=True) ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/figures/autocorr_flow/plot.py",".py","2330","62","# -*- coding: utf-8 -*- import sys, os import numpy as np import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt from scipy.optimize import curve_fit from matplotlib.offsetbox import AnchoredText import warnings warnings.filterwarnings(""ignore"",category=DeprecationWarning) #import c_convergence as c_conv def plot_JSD_distribution(all_JSD, all_JSDs, nround, nfold, fname=""JSD_distribution.png""): """"""Plots the distributions for JSD"""""" rest_type = ['sigma_noe', 'gamma'] colors=['red', 'blue','black','green'] # convert shape of all_JSD from (fold,n_rest) to (n_rest,fold) n_rest = len(rest_type) # compute mean, std of JSDs from each fold dataset of each restraint JSD_dist = [[] for i in range(n_rest)] JSD_std = [[] for i in range(n_rest)] for rest in range(n_rest): for f in range(nfold): temp_JSD = [] for r in range(nround): temp_JSD.append(all_JSDs[rest][f][r]) JSD_dist[rest].append(np.mean(temp_JSD)) JSD_std[rest].append(np.std(temp_JSD)) #plt.figure(figsize=(10,5*n_rest)) plt.figure( figsize=(3*len(rest_type),6)) x=np.arange(int(100/nfold),101.,int(100/nfold)) # the dataset was divided into ten folds (this is the only hard coded part) for i in range(n_rest): plt.subplot(n_rest,1,i+1) plt.plot(x,all_JSD[i].transpose(),'o-',color=colors[i],label=[""$\\sigma$"",""$\\gamma$""][i]) plt.hold(True) # at 95% confidence interval bounds = np.sort(all_JSDs[i]) # remove top 50 and lower 50 lower = bounds[:, int(nround*0.05)] upper = bounds[:, int(nround*0.95)] plt.fill_between(x,lower,upper,color=colors[i],alpha=0.2) plt.xlabel('dataset (%)', size=18) plt.ylabel('JSD', size=18) plt.legend(loc='best') plt.xticks(fontsize=14) plt.yticks(fontsize=14) plt.xlim(left=10, right=100) plt.tight_layout() plt.savefig(fname) if __name__ == ""__main__"": all_JSD = np.load(""all_JSD.npy"") all_JSDs = np.load(""all_JSDs.npy"") #plot_JSD_distribution(all_JSD, all_JSDs, nround, nfold, fname=""jsd_distribution.png"") plot_JSD_distribution(np.array(all_JSD), np.array(all_JSDs), nfold=10, nround=100, fname=""JSD_distribution_.pdf"") ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/figures/autocorr_and_JSD/autocorr_flow.py",".py","432","16","import sys,os sys.path.append(""../../../"") import biceps C = biceps.Convergence(trajfile=""./traj_lambda1.00.npz"") #C.plot_traces(fname=""traces.pdf"", xlim=(0, 1000000)) print(C.rest_type) print(C.labels) exit() C.get_autocorrelation_curves(method=""normal"", maxtau=50000) C.plot_auto_curve(fname=""auto_curve.pdf"", xlim=(0, 10000)) C.process(nblock=5, nfold=10, nround=100, savefile=True, plot=True, block=True, normalize=True) ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/figures/autocorr_and_JSD/plot.py",".py","2335","67","# -*- coding: utf-8 -*- import sys, os import numpy as np import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt from scipy.optimize import curve_fit from matplotlib.offsetbox import AnchoredText import warnings warnings.filterwarnings(""ignore"",category=DeprecationWarning) #import c_convergence as c_conv def plot_JSD_distribution(all_JSD, all_JSDs, nround, nfold, fname=""JSD_distribution.png""): """"""Plots the distributions for JSD"""""" rest_type = ['sigma_noe', 'gamma'] colors=['red', 'blue','black','green'] # convert shape of all_JSD from (fold,n_rest) to (n_rest,fold) n_rest = len(rest_type) # compute mean, std of JSDs from each fold dataset of each restraint JSD_dist = [[] for i in range(n_rest)] JSD_std = [[] for i in range(n_rest)] for rest in range(n_rest): for f in range(nfold): temp_JSD = [] for r in range(nround): temp_JSD.append(all_JSDs[rest][f][r]) JSD_dist[rest].append(np.mean(temp_JSD)) JSD_std[rest].append(np.std(temp_JSD)) #plt.figure(figsize=(10,5*n_rest)) plt.figure( figsize=(3*len(rest_type),6)) x=np.arange(int(100/nfold),101.,int(100/nfold)) # the dataset was divided into ten folds (this is the only hard coded part) for i in range(n_rest): plt.subplot(n_rest,1,i+1) plt.plot(x,all_JSD[i].transpose(),'o-',color=colors[i],label=[""$\\sigma$"",""$\\gamma$""][i]) plt.hold(True) # at 95% confidence interval bounds = np.sort(all_JSDs[i]) # remove top 50 and lower 50 lower = bounds[:, int(nround*0.05)] upper = bounds[:, int(nround*0.95)] plt.fill_between(x,lower,upper,color=colors[i],alpha=0.2) plt.xlabel('dataset (%)', size=18) plt.ylabel('JSD', size=18) plt.legend(loc='best') plt.xticks(fontsize=14) plt.yticks(fontsize=14) plt.xlim(left=10, right=100) plt.tight_layout() plt.savefig(fname) if __name__ == ""__main__"": all_JSD = np.load(""all_JSD.npy"") all_JSDs = np.load(""all_JSDs.npy"") #plot_JSD_distribution(all_JSD, all_JSDs, nround, nfold, fname=""jsd_distribution.png"") plot_JSD_distribution(np.array(all_JSD), np.array(all_JSDs), nfold=10, nround=100, fname=""JSD_distribution_.pdf"") ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/figures/autocorr_subplots/autocorr_subplots.py",".py","611","21","import sys #sys.path.append(""/Users/tuc41004/github/biceps/BICePs_2.0/"") import biceps file = ""traj_lambda1.00.npz"" C = biceps.Convergence(trajfile=file) C.plot_traces(fname=""traces.pdf"", xlim=(0, 1000000)) #print(C.rest_type) #print(C.labels) C.get_autocorrelation_curves(method=""exp"", maxtau=5000) C.plot_auto_curve_with_exp_fitting(fname=""autocorrelation_curve_with_exp_fitting.png"") C.get_autocorrelation_curves(method=""normal"", maxtau=5000) C.plot_auto_curve(fname=""auto_curve.pdf"", xlim=(0, 10000)) C.process(nblock=5, nfold=10, nround=100, savefile=True, plot=True, block=True, normalize=True) ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/figures/SI_JSD_comparison/compare_JSDs.py",".py","3474","113","import numpy as np import glob,os,datetime import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt # User specified paths base_dir = ""../../all_JSDs/"" numpyFile = ""all_JSD.npy"" full_path = base_dir+""d_*/results_ref_normal_*/""+numpyFile n_restraints = 2 def condition1(path,f1,f2): """"""Check to see if a file in the directory exists by replacing f1 with f2 for a given path."""""" return os.path.exists(path.replace(f1,f2)) def condition2(path,f1,f2): """"""Check to see if the timestamps match from last metadata change."""""" ans = 0 t1 = datetime.datetime.fromtimestamp(os.path.getmtime(path)) t2 = datetime.datetime.fromtimestamp(os.path.getmtime(path.replace(f1,f2))) date1 = str(t1).split()[0] date2 = str(t1).split()[0] if date1 == date2: ans = 1 return ans def plot_JSD_comparison(steps, JSD, restraints, fig_name=""JSD_comparison.png""): """"""plot that compares JSDs of 100% data distribution against number of steps"""""" n_restraints = len(restraints) plt.figure(figsize=(10,5*n_restraints)) for i in range(n_restraints): ax = plt.subplot(n_restraints,1,i+1) plt.plot(steps[i], JSD[i],'o-',color='k') plt.xscale(""log"") plt.xlabel('Steps', fontsize=18) plt.ylabel('%s for %s'%('JSD', restraints[i]), fontsize=18) ticks = [ax.xaxis.get_minor_ticks(), ax.xaxis.get_major_ticks()] marks = [ax.get_xticklabels(), ax.get_yticklabels()] for k in range(0,len(ticks)): for tick in ticks[k]: tick.label.set_fontsize(18) for k in range(0,len(marks)): for mark in marks[k]: mark.set_size(fontsize=18) plt.tight_layout() plt.savefig(fig_name) # Get all the directories that satisfy the conditions files,FILES = glob.glob(full_path),[] count = 0 for i in range(len(files)): file = files[i] if condition1(file, f1=numpyFile, f2=""JSD_distribution.png""): if condition2(file, f1=numpyFile, f2=""JSD_distribution.png""): FILES.append(file) count += 1 print(""%s of %s""%(count,len(files))) del(files) # Create a bunch of sublists that sort the directories by the different number of steps FILES_sublists = [] subs = [] for i in range(len(FILES)): file = FILES[i] subdir = file.split(""results_ref_normal"")[0] if len(FILES_sublists) >= 1: if str(subdir) in FILES_sublists[-1][-1]: subdir = file.split(""results_ref_normal"")[0] FILES_sublists[-1].append(file) else: FILES_sublists.append([file]) subs.append(subdir.split(""/"")[-2]) else: FILES_sublists.append([file]) subs.append(subdir.split(""/"")[-2]) # Now put the data into sublists that sorts the dirs index = -1 # Index of the data point from the file x,y = [],[] for i in range(len(FILES_sublists)): x.append([]) y.append([]) for j in range(len(FILES_sublists[i])): file = FILES_sublists[i][j] x[-1].append([int(file.split(""/"")[-2].split(""_"")[-1])for k in range(n_restraints)]) y[-1].append([float(np.load(file)[k][-1]) for k in range(n_restraints)]) X = np.array(x[i]).transpose() Y = np.array(y[i]).transpose() restraints = [""$\sigma$"",""$\gamma$""] plot_JSD_comparison(X, JSD=Y, restraints=restraints, fig_name=""JSD_comparison_%s.pdf""%(subs[i].replace(""."",""-""))) ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/BICePs2.0/figures/Good_JSDs/plot_JSD_distribution.py",".py","2561","73","# -*- coding: utf-8 -*- import sys, os import numpy as np import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt from scipy.optimize import curve_fit from matplotlib.offsetbox import AnchoredText import warnings warnings.filterwarnings(""ignore"",category=DeprecationWarning) #import c_convergence as c_conv def plot_JSD_distribution(all_JSD, all_JSDs, nround, nfold, fname=""JSD_distribution.png""): """"""Plots the distributions for JSD"""""" rest_type = ['sigma_noe', 'gamma'] colors=['red', 'blue','black','green'] # convert shape of all_JSD from (fold,n_rest) to (n_rest,fold) n_rest = len(rest_type) # compute mean, std of JSDs from each fold dataset of each restraint JSD_dist = [[] for i in range(n_rest)] JSD_std = [[] for i in range(n_rest)] for rest in range(n_rest): for f in range(nfold): temp_JSD = [] for r in range(nround): temp_JSD.append(all_JSDs[rest][f][r]) JSD_dist[rest].append(np.mean(temp_JSD)) JSD_std[rest].append(np.std(temp_JSD)) #plt.figure(figsize=(10,5*n_rest)) plt.figure( figsize=(3*len(rest_type),6)) x=np.arange(int(100/nfold),101.,int(100/nfold)) # the dataset was divided into ten folds (this is the only hard coded part) for i in range(n_rest): plt.subplot(n_rest,1,i+1) plt.plot(x,all_JSD[i].transpose(),'o-',color=colors[i],label=[""$\\sigma$"",""$\\gamma$""][i]) plt.hold(True) # 2 Standard deviations from the mean plt.fill_between(x,np.array(JSD_dist[i])+2*np.array(JSD_std[i]), np.array(JSD_dist[i])-2*np.array(JSD_std[i]), color=colors[i],alpha=0.2) # at 95% confidence interval bounds = np.sort(all_JSDs[i]) # remove top 50 and lower 50 lower = bounds[:, int(nround*0.05)] upper = bounds[:, int(nround*0.95)] #plt.fill_between(x,lower,upper,color=colors[i],alpha=0.2) plt.xlabel('dataset (%)', size=18) plt.ylabel('JSD', size=18) plt.legend(loc='best') plt.xticks(fontsize=14) plt.yticks(fontsize=14) plt.xlim(left=10, right=100) plt.tight_layout() plt.savefig(fname) if __name__ == ""__main__"": all_JSD = np.load(""all_JSD.npy"") all_JSDs = np.load(""all_JSDs.npy"") #plot_JSD_distribution(all_JSD, all_JSDs, nround, nfold, fname=""jsd_distribution.png"") plot_JSD_distribution(np.array(all_JSD), np.array(all_JSDs), nfold=10, nround=100, fname=""JSD_distribution.pdf"") ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/apomyoglobin/apomyoglobin.ipynb",".ipynb","20382","602","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Apomyoglobin\n"", ""============\n"", ""\n"", ""\n"", ""\n"", ""
\n"", ""\n"", ""

Summary:

In our previous work (DOI: 10.1002/jcc.23738)\n"", ""\n"", ""\n"", ""\n"", ""Warning: This notebook will require a significant amount of memory.\n"", ""\n"", ""
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 1, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""BICePs - Bayesian Inference of Conformational Populations, Version 2.0\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""Warning on use of the timeseries module: If the inherent timescales of the system are long compared to those being analyzed, this statistical inefficiency may be an underestimate. The estimate presumes the use of many statistically independent samples. Tests should be performed to assess whether this condition is satisfied. Be cautious in the interpretation of the data.\n"" ] } ], ""source"": [ ""import numpy as np\n"", ""import pandas as pd\n"", ""import biceps\n"", ""import warnings\n"", ""warnings.filterwarnings(\""ignore\"", category=UserWarning)\n"", ""warnings.filterwarnings('ignore', category=FutureWarning)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 2, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Possible input data extensions: ['H', 'Ca', 'N', 'J', 'noe', 'pf']\n"", ""Input data: ['H', 'Ca', 'N', 'pf']\n"" ] } ], ""source"": [ ""####### Data and Output Directories #######\n"", ""print(f\""Possible input data extensions: {biceps.toolbox.list_possible_extensions()}\"")\n"", ""T=[0,1,4,9,10,12,14,16,18,19,20,21,24]\n"", ""states=len(T)\n"", ""datadir=\""apomyoglobin/\""\n"", ""top=datadir+'pdb/T1/state0.pdb'\n"", ""dataFiles = datadir+'new_CS_PF'\n"", ""input_data = biceps.toolbox.sort_data(dataFiles)\n"", ""print(f\""Input data: {biceps.toolbox.list_extensions(input_data)}\"")\n"", ""energies_filename = datadir+'energy_model_1.txt'\n"", ""energies = np.loadtxt(energies_filename)\n"", ""energies -= energies.min() # set ground state to zero, just in case\n"", ""states = len(energies)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 3, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
refsigmause_global_ref_sigmaextensionweightfile_fmtprecomputedpf_priorNcs_fiNhs_fibeta_cbeta_hbeta_0xcsxhsbsstates
0uniform[0.05, 20.0, 1.02]TrueH1pickleNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
1uniform[0.05, 20.0, 1.02]TrueCa1pickleNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
2uniform[0.05, 20.0, 1.02]TrueN1pickleNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
3uniform[0.05, 20.0, 1.02]Truepf1pickleFalseNaNNaNNaN(0.05, 0.25, 0.01)(0.0, 5.2, 0.2)(-10.0, 0.0, 0.2)(5.0, 8.5, 0.5)(2.0, 2.7, 0.1)(15.0, 16.0, 1.0)NaN
\n"", ""
"" ], ""text/plain"": [ "" ref sigma use_global_ref_sigma extension weight \\\n"", ""0 uniform [0.05, 20.0, 1.02] True H 1 \n"", ""1 uniform [0.05, 20.0, 1.02] True Ca 1 \n"", ""2 uniform [0.05, 20.0, 1.02] True N 1 \n"", ""3 uniform [0.05, 20.0, 1.02] True pf 1 \n"", ""\n"", "" file_fmt precomputed pf_prior Ncs_fi Nhs_fi beta_c \\\n"", ""0 pickle NaN NaN NaN NaN NaN \n"", ""1 pickle NaN NaN NaN NaN NaN \n"", ""2 pickle NaN NaN NaN NaN NaN \n"", ""3 pickle False NaN NaN NaN (0.05, 0.25, 0.01) \n"", ""\n"", "" beta_h beta_0 xcs xhs \\\n"", ""0 NaN NaN NaN NaN \n"", ""1 NaN NaN NaN NaN \n"", ""2 NaN NaN NaN NaN \n"", ""3 (0.0, 5.2, 0.2) (-10.0, 0.0, 0.2) (5.0, 8.5, 0.5) (2.0, 2.7, 0.1) \n"", ""\n"", "" bs states \n"", ""0 NaN NaN \n"", ""1 NaN NaN \n"", ""2 NaN NaN \n"", ""3 (15.0, 16.0, 1.0) NaN "" ] }, ""execution_count"": 3, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""options = biceps.get_restraint_options(input_data)\n"", ""pd.DataFrame(options)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 4, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
refweightpf_priorNcs_fiNhs_fistates
0exponential0.333333NaNNaNNaNNaN
1exponential0.333333NaNNaNNaNNaN
2exponential0.333333NaNNaNNaNNaN
3exponential1.000000apomyoglobin/b15.npyapomyoglobin/input/Ncapomyoglobin/input/Nh[0, 1, 4, 9, 10, 12, 14, 16, 18, 19, 20, 21, 24]
\n"", ""
"" ], ""text/plain"": [ "" ref weight pf_prior Ncs_fi \\\n"", ""0 exponential 0.333333 NaN NaN \n"", ""1 exponential 0.333333 NaN NaN \n"", ""2 exponential 0.333333 NaN NaN \n"", ""3 exponential 1.000000 apomyoglobin/b15.npy apomyoglobin/input/Nc \n"", ""\n"", "" Nhs_fi states \n"", ""0 NaN NaN \n"", ""1 NaN NaN \n"", ""2 NaN NaN \n"", ""3 apomyoglobin/input/Nh [0, 1, 4, 9, 10, 12, 14, 16, 18, 19, 20, 21, 24] "" ] }, ""execution_count"": 4, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""####### Parameters #######\n"", ""nsteps = 1000000\n"", ""n_lambdas = 2\n"", ""outdir = '%s_steps_%s_lam'%(nsteps, n_lambdas)\n"", ""biceps.toolbox.mkdir(outdir)\n"", ""lambda_values = np.linspace(0.0, 1.0, n_lambdas)\n"", ""options = [\n"", "" {\""ref\"": 'exponential', \""weight\"": 1/3},\n"", "" {\""ref\"": 'exponential', \""weight\"": 1/3},\n"", "" {\""ref\"": 'exponential', \""weight\"": 1/3},\n"", "" {\""ref\"": 'exponential', \""weight\"": 1, \""pf_prior\"": datadir+'b15.npy',\n"", "" \""Ncs_fi\"": datadir+'input/Nc', \""Nhs_fi\"": datadir+'input/Nh', \""states\"": T}\n"", "" ]\n"", ""pd.DataFrame(options)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 5, ""metadata"": {}, ""outputs"": [ { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""100%|█████████████████████████████████████████████████████████| 1000000/1000000 [00:27<00:00, 36768.86it/s]\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted 59.564499999999995 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [19.0833 19.0586 19.0551 0.2746 0.2746 0.2746 0.2746 0.2746 0.2746\n"", "" 0.2746 2.0929] % \n"", ""\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""100%|█████████████████████████████████████████████████████████| 1000000/1000000 [00:27<00:00, 35870.99it/s]\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted 61.9413 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [19.1311 19.0861 19.0675 0.2291 0.2291 0.2291 0.2291 0.2291 0.2291\n"", "" 0.2291 4.4275] % \n"", ""\n"" ] } ], ""source"": [ ""####### MCMC Simulations #######\n"", ""for lam in lambda_values:\n"", "" ensemble = biceps.Ensemble(lam, energies)\n"", "" ensemble.initialize_restraints(input_data, options)\n"", "" sampler = biceps.PosteriorSampler(ensemble)\n"", "" sampler.sample(nsteps, verbose=False)\n"", "" sampler.traj.process_results(f\""{outdir}/traj_lambda{lam}.npz\"")"" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""not all state sampled, these states [1 3 4 9] are not sampled\n"", ""not all state sampled, these states [ 1 2 3 4 9 12] are not sampled\n"" ] } ], ""source"": [ ""####### Posterior Analysis #######\n"", ""A = biceps.Analysis(outdir, nstates=states)\n"", ""A.plot(plottype=\""step\"")"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
# NOTE: The following cell is for pretty notebook rendering
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 1, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"" ], ""text/plain"": [ """" ] }, ""execution_count"": 1, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from IPython.core.display import HTML\n"", ""def css_styling():\n"", "" styles = open(\""../../../theme.css\"", \""r\"").read()\n"", "" return HTML(styles)\n"", ""css_styling()"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""Python 3 (ipykernel)"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.8.13"" } }, ""nbformat"": 4, ""nbformat_minor"": 2 } ","Unknown" "Conformation","vvoelz/biceps","docs/examples/full_examples/apomyoglobin/mp_lambdas.py",".py","1606","47","import numpy as np import biceps ####### Data and Output Directories ####### print(f""Possible input data extensions: {biceps.toolbox.list_possible_extensions()}"") T=[0,1,4,9,10,12,14,16,18,19,20,21,24] states=len(T) datadir=""apomyoglobin/"" top=datadir+'pdb/T1/state0.pdb' dataFiles = datadir+'new_CS_PF' input_data = biceps.toolbox.sort_data(dataFiles) print(f""Input data: {biceps.toolbox.list_extensions(input_data)}"") energies_filename = datadir+'energy_model_1.txt' energies = np.loadtxt(energies_filename) energies -= energies.min() # set ground state to zero, just in case states = len(energies) ####### Parameters ####### nsteps = 1000000 print(f""nSteps of sampling: {nsteps}"") maxtau = 1000 n_lambdas = 2 outdir = '%s_steps_%s_lam'%(nsteps, n_lambdas) biceps.toolbox.mkdir(outdir) lambda_values = np.linspace(0.0, 1.0, n_lambdas) parameters = [ {""ref"": 'exp', ""weight"": 1/3}, {""ref"": 'exp', ""weight"": 1/3}, {""ref"": 'exp', ""weight"": 1/3}, {""ref"": 'exp', ""weight"": 1, ""pf_prior"": datadir+'b15.npy', ""Ncs_fi"": datadir+'input/Nc', ""Nhs_fi"": datadir+'input/Nh', ""states"": T} ] ####### MCMC Simulations ####### @biceps.multiprocess(iterable=lambda_values) def mp_lambdas(lam): ensemble = biceps.Ensemble(lam, energies) ensemble.initialize_restraints(input_data, parameters) sampler = biceps.PosteriorSampler(ensemble) sampler.sample(nsteps, verbose=False) sampler.traj.process_results(f""{outdir}/traj_lambda{lam}.npz"") ####### Posterior Analysis ####### A = biceps.Analysis(trajs=f""{outdir}/traj*.npz"", nstates=states) A.plot() ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/cineromycinB/CineromycinB.ipynb",".ipynb","135944","630","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Cineromycin B\n"", ""==============\n"", ""\n"", ""\n"", ""\n"", ""
\n"", ""\n"", ""

Summary:

In our previous work (DOI: 10.1002/jcc.23738), we determine solution-state conformational populations of the 14-membered macrocycle cineromycin B (O-desmethyl albocycline), using a combination of previously published sparse Nuclear Magnetic Resonance (NMR) observables and replica exchange molecular dynamic/Quantum mechanics (QM)-refined conformational ensembles. Cineromycin B is a 14-membered macrolide antibiotic that has become increasingly known for having activity against methicillin-resistant Staphylococcus Aureus (MRSA). In this example, we show how to calculate the consistency of computational modeling with experiment, and the relative importance of reference potentials and other model parameters. We will walk through the process of setting up a `biceps` script. You are welcome to take this as a template for you and make necessary modification to get it work for you. All input files used in this tutorial are prepared from this tutorial.\n"", ""\n"", ""\n"", ""\n"", ""**To convert this Jupyter Notebook into a script use the following command:**\n"", ""\n"", ""```\n"", ""$ jupyter nbconvert --to python cineromycinB.ipynb\n"", ""```\n"", ""\n"", ""\n"", ""\n"", ""
"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""First, we need to import source code for BICePs classes. More information of these classes can be found [here](https://biceps.readthedocs.io/en/latest/workflow.html)."" ] }, { ""cell_type"": ""code"", ""execution_count"": 3, ""metadata"": {}, ""outputs"": [], ""source"": [ ""import numpy as np\n"", ""import pandas as pd\n"", ""import biceps\n"", ""# NOTE: timeseries module Warning is from MBAR"" ] }, { ""cell_type"": ""code"", ""execution_count"": 4, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Possible data restraints: ['Restraint_cs', 'Restraint_J', 'Restraint_noe', 'Restraint_pf']\n"", ""Possible input data extensions: ['H', 'Ca', 'N', 'J', 'noe', 'pf']\n"" ] } ], ""source"": [ ""# What possible experimental data does biceps accept?\n"", ""print(f\""Possible data restraints: {biceps.toolbox.list_possible_restraints()}\"")\n"", ""print(f\""Possible input data extensions: {biceps.toolbox.list_possible_extensions()}\"")"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Now we need to specify input files and output files folder."" ] }, { ""cell_type"": ""code"", ""execution_count"": 5, ""metadata"": {}, ""outputs"": [], ""source"": [ ""####### Data and Output Directories #######\n"", ""energies = np.loadtxt('cineromycin_B/cineromycinB_QMenergies.dat')*627.509 # convert from hartrees to kcal/mol\n"", ""energies = energies/0.5959 # convert to reduced free energies F = f/kT\n"", ""energies -= energies.min() # set ground state to zero, just in case\n"", ""\n"", ""# REQUIRED: specify directory of input data (BICePs readable format)\n"", ""input_data = biceps.toolbox.sort_data('cineromycin_B/J_NOE')\n"", ""\n"", ""# REQUIRED: specify outcome directory of BICePs sampling\n"", ""outdir = 'results'\n"", ""# Make a new directory if we have to\n"", ""biceps.toolbox.mkdir(outdir)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Next, we need to specify number of steps for BICePs sampling. We recommend to run at least 1M steps for converged Monte Carlo samplings. In BICePs, we also prepare functions of [checking convergence](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Convergence/convergence.html) of Monte Carlo. More information can be found [here](https://biceps.readthedocs.io/en/latest/biceps.html#convergence)."" ] }, { ""cell_type"": ""code"", ""execution_count"": 6, ""metadata"": {}, ""outputs"": [], ""source"": [ ""# REQUIRED: number of MCMC steps for each lambda\n"", ""nsteps = 100000 # 100 k steps for testing\n"", ""#nsteps = 10000000 # 10 M steps for production"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""We need to specify what lambda values we want to use in BICePs samplings. Briefly, lambda values are similar to the parameters used in free energy perturbation (FEP) and has effect on the BICePs score. The lambda values represent how much prior information from computational modeling is included in BICePs sampling (1.0 means all, 0.0 means none). As we explained in [this work](https://pubs.acs.org/doi/10.1021/acs.jpcb.7b11871), one can consider BICePs score as the relative free energy change between different models. More lambda values will increase the samplings for [multistate Bennett acceptance ratio (MBAR)](http://www.alchemistry.org/wiki/Multistate_Bennett_Acceptance_Ratio) predictions in free energy change and populations. However more lambda values also will slow down the whole process of BICePs (as more samplings need to run), so balancing the accuracy and efficiency is important. To successfully finish a BICePs sampling, lambda values of 0.0 and 1.0 are necessary. Based on our experience, the lambda values of 0.0,0.5,1.0 are good enough for BICePs sampling."" ] }, { ""cell_type"": ""code"", ""execution_count"": 7, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""[0. 1.]\n"" ] } ], ""source"": [ ""# REQUIRED: specify how many lambdas to sample (more lambdas will provide higher \n"", ""# accuracy but slower the whole process, lambda=0.0 and 1.0 are necessary)\n"", ""n_lambdas = 2\n"", ""lambda_values = np.linspace(0.0, 1.0, n_lambdas)\n"", ""print(lambda_values)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Print what experimental observables are included in BICePs sampling. This is optional and provides a chance for double check before running BICePs sampling.\n"", ""\n"", ""In this tutorial, we used both J couplings and NOE (pairwise distances) in BICePs sampling. "" ] }, { ""cell_type"": ""code"", ""execution_count"": 8, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Input data: ['J', 'noe']\n"" ] } ], ""source"": [ ""# OPTIONAL but RECOMMENDED: print experimental restraints included (a chance for double check)\n"", ""print(f\""Input data: {biceps.toolbox.list_extensions(input_data)}\"")"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Another key parameter for BICePs set-up is the type of reference potential for each experimental observables. More information of reference potential can be found [here](https://biceps.readthedocs.io/en/latest/theory.html).\n"", ""\n"", ""Three reference potentials are supported in BICePs: uniform ('uniform'), exponential ('exp'), Gaussian ('gau'). \n"", ""\n"", ""As we found in previous research, exponential reference potential is useful in most cases. Some higher level task may require more in reference potential selection (e.g [force field parametrization](https://pubs.acs.org/doi/10.1021/acs.jpcb.7b11871)).\n"", ""\n"", ""(Note: It will be helpful to print out what is the order of experimental observables included in BICePs sampling as shown above.)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Users can specify reference potential to use for each experimental observable will be in the same order as input_data.\n"", ""If you want, you can specify nuisance parameters (uncertainty in experiments) range but it's not required. Our default parameters range is broad enough.\n"", ""\""gamma\"" is a scaling factor converting distances to NOE intensity in experiments. It is only used when NOE restraint is used in BICePs sampling."" ] }, { ""cell_type"": ""code"", ""execution_count"": 9, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
refsigmagamma
0uniform(0.05, 20.0, 1.02)NaN
1exponential(0.05, 5.0, 1.02)(0.2, 5.0, 1.02)
\n"", ""
"" ], ""text/plain"": [ "" ref sigma gamma\n"", ""0 uniform (0.05, 20.0, 1.02) NaN\n"", ""1 exponential (0.05, 5.0, 1.02) (0.2, 5.0, 1.02)"" ] }, ""execution_count"": 9, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""parameters = [\n"", "" {\""ref\"": 'uniform', \""sigma\"": (0.05, 20.0, 1.02)},\n"", "" {\""ref\"": 'exponential', \""sigma\"": (0.05, 5.0, 1.02), \""gamma\"": (0.2, 5.0, 1.02)}\n"", "" ]\n"", ""pd.DataFrame(parameters)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Now we need to set up BICePs samplings and feed arguments using variables we defined above. In most cases, you don't need to modify this part as long as you defined all these parameters shown above. "" ] }, { ""cell_type"": ""code"", ""execution_count"": 10, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""lambda: 0.0\n"", ""Step\t\tState\tPara Indices\t\tAvg Energy\tAcceptance (%)\n"", ""0\t\t[54]\t[151, 116, 81]\t\t123.122\t\t100.00\tTrue\n"", ""10000\t\t[27]\t[246, 127, 99]\t\t6.384\t\t66.61\tTrue\n"", ""20000\t\t[87]\t[209, 131, 97]\t\t5.411\t\t66.99\tTrue\n"", ""30000\t\t[77]\t[229, 135, 102]\t\t7.863\t\t67.57\tFalse\n"", ""40000\t\t[45]\t[250, 124, 97]\t\t7.009\t\t67.86\tTrue\n"", ""50000\t\t[87]\t[209, 141, 96]\t\t5.762\t\t66.97\tTrue\n"", ""60000\t\t[87]\t[212, 144, 99]\t\t5.530\t\t66.58\tTrue\n"", ""70000\t\t[32]\t[220, 142, 91]\t\t7.669\t\t66.80\tTrue\n"", ""80000\t\t[58]\t[239, 150, 98]\t\t8.864\t\t67.51\tFalse\n"", ""90000\t\t[21]\t[249, 125, 93]\t\t6.046\t\t67.99\tFalse\n"", ""\n"", ""Accepted 68.364 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [32.502 29.963 29.963 5.899] % \n"", ""\n"", ""lambda: 1.0\n"", ""Step\t\tState\tPara Indices\t\tAvg Energy\tAcceptance (%)\n"", ""0\t\t[77]\t[150, 116, 81]\t\t123.708\t\t100.00\tTrue\n"", ""10000\t\t[38]\t[227, 155, 99]\t\t9.126\t\t63.02\tFalse\n"", ""20000\t\t[65]\t[249, 144, 92]\t\t6.959\t\t63.90\tTrue\n"", ""30000\t\t[65]\t[243, 131, 90]\t\t5.939\t\t63.73\tFalse\n"", ""40000\t\t[39]\t[275, 137, 94]\t\t8.569\t\t63.88\tFalse\n"", ""50000\t\t[90]\t[242, 142, 95]\t\t6.631\t\t64.19\tTrue\n"", ""60000\t\t[65]\t[248, 129, 92]\t\t5.834\t\t64.26\tFalse\n"", ""70000\t\t[65]\t[232, 129, 88]\t\t6.763\t\t64.28\tTrue\n"", ""80000\t\t[65]\t[222, 136, 95]\t\t7.673\t\t64.22\tTrue\n"", ""90000\t\t[38]\t[213, 134, 96]\t\t8.254\t\t64.19\tTrue\n"", ""\n"", ""Accepted 64.298 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [32.632 30.075 30.075 1.591] % \n"", ""\n"" ] } ], ""source"": [ ""####### MCMC Simulations #######\n"", ""for lam in lambda_values:\n"", "" print(f\""lambda: {lam}\"")\n"", "" ensemble = biceps.Ensemble(lam, energies)\n"", "" ensemble.initialize_restraints(input_data, parameters)\n"", "" sampler = biceps.PosteriorSampler(ensemble)\n"", "" sampler.sample(nsteps=nsteps, print_freq=10000, verbose=True)\n"", "" sampler.traj.process_results(f\""{outdir}/traj_lambda{lam}.npz\"")"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Note that all output trajectories and images will be placed in the previously defined `outdir` as 'results_ref_normal'...**\n"", ""\n"", ""**Also note that the user can quickly check to see if our MCMC trajectories have converged using our `biceps.convergence` module. See [this tutorial](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Convergence/convergence.html) for an example and more details.**"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Then, we need to run functions in [Analysis](https://biceps.readthedocs.io/en/latest/biceps.html#analysis) to get predicted populations of each conformational states and BICePs score. A figure of posterior distribution of populations and nuisance parameters will be plotted as well. "" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""The output files include: population information (\""populations.dat\""), figure of sampled parameters distribution (\""BICePs.pdf\""), BICePs score information (\""BS.dat\"")."" ] }, { ""cell_type"": ""code"", ""execution_count"": 15, ""metadata"": { ""scrolled"": false }, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""not all state sampled, these states [ 0 1 3 4 5 7 8 9 11 12 13 14 15 16 18 19 20 21 22 23 24 25 26 27\n"", "" 28 29 34 36 40 41 42 44 48 49 51 52 53 54 55 56 57 60 61 62 63 64 66 69\n"", "" 71 73 74 75 76 78 81 82 83 86 87 88 89 95 96 97 98 99] are not sampled\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""/Users/rr/github/biceps/docs/examples/full_examples/cineromycinB/biceps/Analysis.py:246: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n"", "" for g in np.array(traj[0][4]):\n"", ""/Users/rr/github/biceps/docs/examples/full_examples/cineromycinB/biceps/Analysis.py:250: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n"", "" rest_type = np.array(rest_type)\n"", ""/Users/rr/github/biceps/docs/examples/full_examples/cineromycinB/biceps/Analysis.py:246: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n"", "" for g in np.array(traj[0][4]):\n"", ""/Users/rr/github/biceps/docs/examples/full_examples/cineromycinB/biceps/Analysis.py:250: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n"", "" rest_type = np.array(rest_type)\n"" ] }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""############ MBAR and Figures ###########\n"", ""%matplotlib inline\n"", ""# Let's do analysis using MBAR algorithm and plot figures\n"", ""A = biceps.Analysis(outdir=f\""{outdir}\"", nstates=len(energies))\n"", ""fig = A.plot()"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Now, let's take a look at the output figure above (\""BICePs.pdf\"").\n"", ""\n"", ""\n"", ""The top left panel shows the population of each states in the presence (y-axis) and absense (x-axis) of computational modeling prior information. You can find some states (e.g state 38, 59) get awarded after including computational prior information. If you check [this work](https://onlinelibrary.wiley.com/doi/full/10.1002/jcc.23738) you will see how misleading the results will be if we only use experimental restraints without computational prior information. \n"", ""The other three panels show the distribution of nuisance parameters in the presence or absence of computational modeling information. It may not be clear in this example due to the limit of finite sampling, but based on our experience, including prior information from our simulations will lower the nuisance parameters than only using experimental restraints."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Next, let's take a look at the populations file."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""There are 100 rows corresponding to 100 clustered states. Four columns corresponding to populations of each state (row) for 2 lambda values (first 2 columns) and population change (last 2 columns). "" ] }, { ""cell_type"": ""code"", ""execution_count"": 16, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ "" 0 1 2 3\n"", ""0 0.013974 2.559152e-05 0.003707 6.883350e-06\n"", ""1 0.001994 6.042650e-06 0.001408 4.276702e-06\n"", ""2 0.006086 9.142238e-04 0.002294 3.463398e-04\n"", ""3 0.000000 0.000000e+00 NaN NaN\n"", ""4 0.000000 0.000000e+00 NaN NaN\n"", "".. ... ... ... ...\n"", ""95 0.007000 1.918854e-11 0.002636 7.275900e-12\n"", ""96 0.000991 9.009883e-06 0.000990 9.013945e-06\n"", ""97 0.001994 6.065073e-06 0.001408 4.292571e-06\n"", ""98 0.001000 1.475099e-11 0.000999 1.475777e-11\n"", ""99 0.000000 0.000000e+00 NaN NaN\n"", ""\n"", ""[100 rows x 4 columns]\n"" ] } ], ""source"": [ ""import pandas as pd\n"", ""pops = np.loadtxt(outdir+'/populations.dat')\n"", ""df = pd.DataFrame(pops)\n"", ""print(df)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
# NOTE: The following cell is for pretty notebook rendering
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 17, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"" ], ""text/plain"": [ """" ] }, ""execution_count"": 17, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from IPython.core.display import HTML\n"", ""def css_styling():\n"", "" styles = open(\""../../../theme.css\"", \""r\"").read()\n"", "" return HTML(styles)\n"", ""css_styling()"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""Python 3 (ipykernel)"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.8.13"" } }, ""nbformat"": 4, ""nbformat_minor"": 1 } ","Unknown" "Conformation","vvoelz/biceps","docs/examples/full_examples/cineromycinB/mp_lambdas.py",".py","1871","51","import numpy as np import pandas as pd import biceps ####### Data and Output Directories ####### energies = np.loadtxt('cineromycin_B/cineromycinB_QMenergies.dat')*627.509 # convert from hartrees to kcal/mol energies = energies/0.5959 # convert to reduced free energies F = f/kT energies -= energies.min() # set ground state to zero, just in case states = len(energies) print(f""Possible input data extensions: {biceps.toolbox.list_possible_extensions()}"") input_data = biceps.toolbox.sort_data('cineromycin_B/J_NOE') print(f""Input data: {biceps.toolbox.list_extensions(input_data)}"") ####### Parameters ####### nsteps=1000000 print(f""nSteps of sampling: {nsteps}"") n_lambdas = 3 outdir = '%s_steps_%s_lam'%(nsteps, n_lambdas) biceps.toolbox.mkdir(outdir) lambda_values = np.linspace(0.0, 1.0, n_lambdas) parameters = [dict(ref=""uniform"", sigma=(0.05, 20.0, 1.02)), dict(ref=""exp"", sigma=(0.05, 5.0, 1.02), gamma=(0.2, 5.0, 1.02)),] print(pd.DataFrame(parameters)) ###### Multiprocessing Lambda values ####### @biceps.multiprocess(iterable=lambda_values) def mp_lambdas(lam): #for lam in [0.0]: ensemble = biceps.Ensemble(lam, energies) ensemble.initialize_restraints(input_data, parameters) sampler = biceps.PosteriorSampler(ensemble) sampler.sample(nsteps=nsteps, burn=0, print_freq=1000, verbose=0) sampler.traj.process_results(f""{outdir}/traj_lambda{lam}.npz"") #''' ####### Convergence Check ####### maxtau=1000 C = biceps.Convergence(filename=outdir+""/traj_lambda0.0.npz"", outdir=outdir) C.get_autocorrelation_curves(method=""auto"", maxtau=maxtau) C.plot_auto_curve(figname=""auto_curve.pdf"", xlim=(0, maxtau)) C.process(nblock=5, nfold=10, nround=100, savefile=True, block_avg=True, normalize=True) #''' ####### Posterior Analysis ####### A = biceps.Analysis(trajs=f""{outdir}/traj*.npz"", nstates=states) A.plot() ","Python" "Conformation","vvoelz/biceps","docs/examples/full_examples/cineromycinB/full_workflow.py",".py","3356","94","import glob, os, sys, pickle import mdtraj as md import numpy as np import pandas as pd import biceps ## Compute model_data for NOE and J coupling ### NOE #data_dir = ""../../datasets/cineromycin_B/"" #outdir = ""NOE/"" #states = biceps.toolbox.get_files(data_dir+""cineromycinB_pdbs/*"") #nstates = len(states) #ind=data_dir+'atom_indice_noe.txt' #ind_noe = ind #biceps.toolbox.mkdir(outdir) #model_data_NOE = biceps.toolbox.compute_distances(states, ind, outdir) #model_data_NOE = str(outdir+""*.txt"") #exp_data_NOE = data_dir+""noe_distance.txt"" # ### J coupling ##### TODO: create function #ind = np.load(data_dir+'ind.npy') #indices = data_dir+'atom_indice_J.txt' ##print(ind) #outdir = ""J/"" #biceps.toolbox.mkdir(outdir) #karplus_key=np.loadtxt(data_dir+'Karplus.txt', dtype=str) #print('Karplus relations', karplus_key) #biceps.toolbox.compute_nonaa_scalar_coupling( # states=data_dir+'cineromycinB_pdbs/*.fixed.pdb', # index=ind, karplus_key=karplus_key, outdir=outdir) #exp_data_J = data_dir+'exp_Jcoupling.txt' #model_data_J = data_dir+""J_coupling/*.txt"" # ## Now using biceps Preparation submodule #outdir = ""J_NOE/"" #biceps.toolbox.mkdir(outdir) #preparation = biceps.Observable.Preparation(nstates=nstates, top=states[0]) #preparation.prep_noe(exp_data_NOE, model_data_NOE, indices=ind_noe, outdir=outdir, verbose=False) #preparation.prep_J(exp_data=exp_data_J, model_data=model_data_J, indices=indices, outdir=outdir, verbose=False) ##exit() ####### Data and Output Directories ####### energies = np.loadtxt('cineromycin_B/cineromycinB_QMenergies.dat')*627.509 # convert from hartrees to kcal/mol energies = energies/0.5959 # convert to reduced free energies F = f/kT energies -= energies.min() # set ground state to zero, just in case states = len(energies) print(f""Possible input data extensions: {biceps.toolbox.list_possible_extensions()}"") input_data = biceps.toolbox.sort_data('cineromycin_B/J_NOE') print(f""Input data: {biceps.toolbox.list_extensions(input_data)}"") ####### Parameters ####### nsteps=100000 print(f""nSteps of sampling: {nsteps}"") maxtau = 1000 n_lambdas = 3 outdir = '%s_steps_%s_lam'%(nsteps, n_lambdas) biceps.toolbox.mkdir(outdir) lambda_values = np.linspace(0.0, 1.0, n_lambdas) parameters = [dict(ref=""uniform"", sigma=(0.05, 20.0, 1.02)), dict(ref=""exp"", sigma=(0.05, 5.0, 1.02), gamma=(0.2, 5.0, 1.02)),] print(pd.DataFrame(parameters)) ###### Multiprocessing Lambda values ####### @biceps.multiprocess(iterable=lambda_values) def mp_lambdas(lam): ensemble = biceps.Ensemble(lam, energies) ensemble.initialize_restraints(input_data, parameters) sampler = biceps.PosteriorSampler(ensemble) sampler.sample(nsteps=nsteps, print_freq=1000, verbose=False) sampler.traj.process_results(outdir+'/traj_lambda%2.2f.npz'%(lam)) #filename = outdir+'/sampler_lambda%2.2f.pkl'%(lam) #biceps.toolbox.save_object(sampler, filename) ''' ####### Convergence Check ####### C = biceps.Convergence(trajfile=outdir+""/traj_lambda0.00.npz"", resultdir=outdir) C.get_autocorrelation_curves(method=""auto"", maxtau=maxtau) C.plot_auto_curve(fname=""auto_curve.pdf"", xlim=(0, maxtau)) C.process(nblock=5, nfold=10, nround=100, savefile=True, plot=True, block=True, normalize=True) ''' ####### Posterior Analysis ####### A = biceps.Analysis(nstates=states, outdir=outdir) A.plot() ","Python" "Conformation","vvoelz/biceps","docs/examples/datasets/albocycline/prep.py",".py","1338","44","import glob import mdtraj as md import numpy as np import biceps # Compute model_data for NOE and J coupling ## NOE data_dir = ""./"" outdir = ""NOE/"" states = biceps.toolbox.get_files(data_dir+""pdbs/*.pdb"") nstates = len(states) ind=data_dir+'atom_indice_noe.txt' ind_noe = ind #biceps.toolbox.mkdir(outdir) #model_data_NOE = biceps.toolbox.compute_distances(states, ind, outdir) model_data_NOE = str(outdir+""*.txt"") exp_data_NOE = data_dir+""noe_distance.txt"" ## J coupling #### TODO: create function #ind = np.load(data_dir+'ind.npy') indices = data_dir+'atom_indice_J.txt' ##print(ind) ##outdir = ""J/"" #biceps.toolbox.mkdir(outdir) #karplus_key=np.loadtxt(data_dir+'Karplus.txt', dtype=str) #print('Karplus relations', karplus_key) #compute_nonaa_scalar_coupling(states=data_dir+""cineromycinB_pdbs/*.fixed.pdb"", # index=ind, karplus_key=karplus_key, outdir=outdir) exp_data_J = data_dir+'exp_Jcoupling.txt' model_data_J = data_dir+""J_coupling/*.txt"" # Now using biceps Preparation submodule outdir = ""J_NOE/"" biceps.toolbox.mkdir(outdir) preparation = biceps.Restraint.Preparation(nstates=nstates, top=states[0]) preparation.prep_noe(exp_data_NOE, model_data_NOE, indices=ind_noe, outdir=outdir, verbose=False) preparation.prep_J(exp_data=exp_data_J, model_data=model_data_J, indices=indices, outdir=outdir, verbose=False) ","Python" "Conformation","vvoelz/biceps","docs/examples/datasets/albocycline/pdbs/new_cluster.py",".py","346","22","import numpy as np import mdtraj as md import os, sys #t=md.load('traj0.xtc',top='conf.gro') #a=np.load('Assignments.npy') Ind = np.load('Ind_noe.npy') for i in range(100): print i p=[] t=md.load('%d.pdb'%i) d=md.compute_distances(t,Ind) p=np.reshape(d,(30,1)) np.savetxt(""../NOE/average_state%d.txt""%i,p) sys.exit() ","Python" "Conformation","vvoelz/biceps","docs/examples/datasets/cineromycin_B/prep.py",".py","1363","44","import glob import mdtraj as md import numpy as np import biceps # Compute model_data for NOE and J coupling ## NOE data_dir = ""../../datasets/cineromycin_B/"" outdir = ""NOE/"" states = biceps.toolbox.get_files(data_dir+""cineromycinB_pdbs/*"") nstates = len(states) ind=data_dir+'atom_indice_noe.txt' ind_noe = ind biceps.toolbox.mkdir(outdir) model_data_NOE = biceps.toolbox.compute_distances(states, ind, outdir) model_data_NOE = str(outdir+""*.txt"") exp_data_NOE = data_dir+""noe_distance.txt"" ## J coupling #### TODO: create function ind = np.load(data_dir+'ind.npy') indices = data_dir+'atom_indice_J.txt' #print(ind) outdir = ""J/"" biceps.toolbox.mkdir(outdir) karplus_key=np.loadtxt(data_dir+'Karplus.txt', dtype=str) print('Karplus relations', karplus_key) compute_nonaa_scalar_coupling(states=data_dir+""cineromycinB_pdbs/*.fixed.pdb"", index=ind, karplus_key=karplus_key, outdir=outdir) exp_data_J = data_dir+'exp_Jcoupling.txt' model_data_J = data_dir+""J_coupling/*.txt"" # Now using biceps Preparation submodule outdir = ""J_NOE/"" biceps.toolbox.mkdir(outdir) preparation = biceps.Restraint.Preparation(nstates=nstates, top=states[0]) preparation.prep_noe(exp_data_NOE, model_data_NOE, indices=ind_noe, outdir=outdir, verbose=False) preparation.prep_J(exp_data=exp_data_J, model_data=model_data_J, indices=indices, outdir=outdir, verbose=False) ","Python" "Conformation","vvoelz/biceps","docs/examples/datasets/apomyoglobin/prep_cs.py",".py","1666","49","import glob import mdtraj as md import numpy as np import biceps # Compute model_data for CS data_dir = ""../../datasets/apomyoglobin/"" #outdir = ""CS_test/"" outdir = ""CS/"" biceps.toolbox.mkdir(outdir) states = ""../../datasets/apomyoglobin/pdb/*.pdb"" # NOTE check the pH and temp with simulation parameters #biceps.toolbox.compute_chemicalshifts(states, temp=298, pH=6, outdir=outdir) #model_data = str(outdir+""*.txt"") states = biceps.toolbox.get_files(states) nstates = len(states) preparation = biceps.Restraint.Preparation(nstates=nstates, top=states[0]) # NOTE may need to be fixed exp_data = data_dir+""new_exp_H.txt"" model_data = str(data_dir+""model_data/H/*.txt"") indices = data_dir+""cs_indices_H.txt"" #biceps.toolbox.get_indices(states[0], top=states[0], # selection_expression=""name H"",out=indices,debug=True) preparation.prep_cs(exp_data, model_data, indices, extension=""H"", outdir=outdir, verbose=False) # NOTE may need to be fixed exp_data = data_dir+""new_exp_N.txt"" model_data = str(data_dir+""model_data/N/*.txt"") indices = data_dir+""cs_indices_N.txt"" preparation.prep_cs(exp_data, model_data, indices, extension=""N"", outdir=outdir, verbose=False) # NOTE may need to be fixed exp_data = data_dir+""new_exp_Ca.txt"" model_data = str(data_dir+""model_data/Ca/*.txt"") indices = data_dir+""cs_indices_Ca.txt"" preparation.prep_cs(exp_data, model_data, indices, extension=""Ca"", outdir=outdir, verbose=False) exit() # load in a structure and find the indices that correspond to H, Ca, N ind=data_dir+'atom_indice_noe.txt' biceps.toolbox.mkdir(outdir) model_data = biceps.toolbox.compute_distances(states, ind, outdir) model_data = str(outdir+""*.txt"") ","Python" "Conformation","vvoelz/biceps","docs/examples/datasets/apomyoglobin/pdb/mv.py",".py","329","10","import os, sys T6=[0,3,8,11,12,14,15,16,17,18,19,20,21,22,23,24] T6=[0,1,4,9,10,12,14,16,18,19,20,21,24] T6=[0,2,4,5,8,9,11,12,13,14,15,16,17,18,19,20,21,22,24] l=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25] for i in range(len(T6)): print T6[i] os.system('mv state%d.pdb T6/state%d.pdb'%(T6[i],l[i])) ","Python" "Conformation","vvoelz/biceps","docs/examples/datasets/apomyoglobin/for_Rob/runme.py",".py","882","62","import sys, os sys.path.append('biceps') from Preparation import * from toolbox import * os.system('mkdir PF_CS') ind = np.loadtxt('cs_indices_H.txt') path = 'H/*txt' states = 25 exp_data = 'new_exp_H.txt' top = 'state0.pdb' out_dir = 'PF_CS' p = Preparation('cs_H',states=states,indices=ind,exp_data=exp_data,top=top,data_dir=path) p.write(out_dir=out_dir) ind = np.loadtxt('cs_indices_Ca.txt') path = 'Ca/*txt' states = 25 exp_data = 'new_exp_Ca.txt' top = 'state0.pdb' out_dir = 'PF_CS' p = Preparation('cs_Ca',states=states,indices=ind,exp_data=exp_data,top=top,data_dir=path) p.write(out_dir=out_dir) ind = np.loadtxt('cs_indices_N.txt') path = 'N/*txt' states = 25 exp_data = 'new_exp_N.txt' top = 'state0.pdb' out_dir = 'PF_CS' p = Preparation('cs_N',states=states,indices=ind,exp_data=exp_data,top=top,data_dir=path) p.write(out_dir=out_dir) ","Python" "Conformation","vvoelz/biceps","docs/examples/datasets/apomyoglobin/input/mv.py",".py","244","14","import sys, os import numpy as np a=np.arange(5.0,8.5,0.5) b=np.arange(2.0,2.8,0.1) for i in a: print i os.system('cp apo_mb_ph7_input/Nc_all/x%.1f/*npy Nc'%i) for j in b: print j os.system('cp apo_mb_ph7_input/Nh_all/xh%.1f/*npy Nh'%j) ","Python" "Conformation","vvoelz/biceps","docs/examples/Tutorials/Prep_Rest_Post_Ana/ensemble.ipynb",".ipynb","16390","425","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Ensemble\n"", ""========\n"", ""\n"", ""
\n"", ""\n"", ""This tutorial shows the user how to appropriately use the `biceps.Ensemble` class to construct the ensemble and apply data restraints that were prepared from the previous tutorial ([Preparation](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Prep_Rest_Post_Ana/preparation.html)). **Please note that in order to compute the relative free energies, one must perform sampling for at least two lambda values.** \n"", ""\n"", ""
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 24, ""metadata"": {}, ""outputs"": [], ""source"": [ ""import numpy as np\n"", ""import pandas as pd\n"", ""import biceps"" ] }, { ""cell_type"": ""code"", ""execution_count"": 25, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Possible input data extensions: ['H', 'Ca', 'N', 'J', 'noe', 'pf']\n"" ] } ], ""source"": [ ""print(f\""Possible input data extensions: {biceps.toolbox.list_possible_extensions()}\"")"" ] }, { ""cell_type"": ""code"", ""execution_count"": 26, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Input data: ['J', 'noe']\n"" ] } ], ""source"": [ ""####### Data and Output Directories #######\n"", ""energies = np.loadtxt('cineromycin_B/cineromycinB_QMenergies.dat')*627.509 # convert from hartrees to kcal/mol\n"", ""energies = energies/0.5959 # convert to reduced free energies F = f/kT\n"", ""energies -= energies.min() # set ground state to zero, just in case\n"", ""\n"", ""# Point to directory that contains input files \n"", ""#input_data = biceps.toolbox.sort_data('cineromycin_B/J_NOE')\n"", ""input_data = biceps.toolbox.sort_data(\""J_NOE\"")\n"", ""print(f\""Input data: {biceps.toolbox.list_extensions(input_data)}\"")\n"", ""\n"", ""# Make a new directory if we have to\n"", ""outdir = 'results'\n"", ""biceps.toolbox.mkdir(outdir)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Another key parameter for BICePs set-up is the type of reference potential for each experimental observables. More information of reference potential can be found [here](https://biceps.readthedocs.io/en/latest/theory.html).\n"", ""\n"", ""Three reference potentials are supported in BICePs: uniform ('uniform'), exponential ('exp'), Gaussian ('gau'). \n"", ""\n"", ""As we found in previous research, exponential reference potential is useful in most cases. Some higher level task may require more in reference potential selection (e.g [force field parametrization](https://pubs.acs.org/doi/10.1021/acs.jpcb.7b11871)).\n"", ""\n"", ""**(Note: It will be helpful to print out what is the order of experimental observables included in BICePs sampling as shown above.)**\n"", ""\n"", ""The order of the parameters below must follow the order of `biceps.toolbox.list_extensions(data)`. Therefore, our parameters will be a list of dictionaries e.g., $\\text{[{'J'}, {'noe'}]}$. Recall, in the last section we saved J coupling files as `*.pkl` files and NOE distances as `*.csv` files. **If the default (`*.pkl` files) is not being used, then we need to specify this inside the corresponding dictionary...**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 27, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
refsigmafile_fmtgamma
0uniform(0.05, 20.0, 1.02)pickleNaN
1exponential(0.05, 5.0, 1.02)csv(0.2, 5.0, 1.01)
\n"", ""
"" ], ""text/plain"": [ "" ref sigma file_fmt gamma\n"", ""0 uniform (0.05, 20.0, 1.02) pickle NaN\n"", ""1 exponential (0.05, 5.0, 1.02) csv (0.2, 5.0, 1.01)"" ] }, ""execution_count"": 27, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""n_lambdas = 2\n"", ""lambda_values = np.linspace(0.0, 1.0, n_lambdas)\n"", ""options = [\n"", "" dict(ref='uniform', sigma=(0.05, 20.0, 1.02), file_fmt=\""pickle\""),\n"", "" dict(ref='exponential', sigma=(0.05, 5.0, 1.02), gamma=(0.2, 5.0, 1.01), file_fmt=\""csv\"")\n"", "" ]\n"", ""pd.DataFrame(options)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Let's print out the allowed $\\sigma_{J}$ space when `sigma=(0.05, 20.0, 1.02)`."" ] }, { ""cell_type"": ""code"", ""execution_count"": 28, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""allowed_sigma[:5] = [0.05 0.051 0.05202 0.0530604 0.05412161]\n"", ""allowed_sigma[-5:] = [18.27347693 18.63894647 19.0117254 19.39195991 19.77979911]\n"", ""len(allowed_sigma) = 303\n"" ] } ], ""source"": [ ""allowed_sigma = np.exp(np.arange(np.log(0.05), np.log(20.0), np.log(1.02)))\n"", ""print(f\""allowed_sigma[:5] = {allowed_sigma[:5]}\"")\n"", ""print(f\""allowed_sigma[-5:] = {allowed_sigma[-5:]}\"")\n"", ""print(f\""len(allowed_sigma) = {len(allowed_sigma)}\"")"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""

Quick note on lambda values:

\n"", ""\n"", ""We need to specify what lambda value(s) we want to use in BICePs samplings. Briefly, lambda values are similar to the parameters used in free energy perturbation (FEP) and has effect on the BICePs score. The lambda values represent how much prior information from computational modeling is included in BICePs sampling (1.0 means all, 0.0 means none). As we explained in [this work](https://pubs.acs.org/doi/10.1021/acs.jpcb.7b11871), one can consider BICePs score as the relative free energy change between different models. More lambda values will increase the samplings for [multistate Bennett acceptance ratio (MBAR)](http://www.alchemistry.org/wiki/Multistate_Bennett_Acceptance_Ratio) predictions in free energy change and populations. However more lambda values also will slow down the whole process of BICePs (as more samplings need to run), so balancing the accuracy and efficiency is important. To successfully finish a BICePs sampling, lambda values of 0.0 and 1.0 are necessary. Based on our experience, three lambda values of 0.0,0.5,1.0 are suggested."" ] }, { ""cell_type"": ""code"", ""execution_count"": 29, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""lambda: 0.0\n"", ""Saving ensemble_0.0.pkl ...\n"", ""lambda: 1.0\n"", ""Saving ensemble_1.0.pkl ...\n"" ] } ], ""source"": [ ""for lam in lambda_values:\n"", "" print(f\""lambda: {lam}\"")\n"", "" ensemble = biceps.Ensemble(lam, energies)\n"", "" ensemble.initialize_restraints(input_data, options)\n"", "" # Save each ensemble as a pickle file\n"", "" print(f\""Saving ensemble_{lam}.pkl ...\"")\n"", "" biceps.toolbox.save_object(ensemble, outdir+\""/ensemble_%s.pkl\""%lam)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""

Let's take a look at the ensemble (lam=1.0)...

\n"", ""\n"", ""The ensemble consists of a list of 2 restraint objects for each state. Here we are showing the first 10 states."" ] }, { ""cell_type"": ""code"", ""execution_count"": 30, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""[[, ], [, ], [, ], [, ], [, ], [, ], [, ], [, ], [, ], [, ]]\n"" ] } ], ""source"": [ ""print(ensemble.to_list()[:10])"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""

Conclusion

\n"", ""\n"", ""In this tutorial, we explained how to construct an [ensemble](https://biceps.readthedocs.io/en/latest/biceps.html#ensemble) (for each lambda) of [restraints](https://biceps.readthedocs.io/en/latest/biceps.html#restraint) for each state, which we saved as a pickle file. In the next tutorial, [PosteriorSampler](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Prep_Rest_Post_Ana/posteriorsampler.html) we will Sample the posterior distribution by using the `biceps.PosteriorSampler` class."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
# NOTE: The following cell is for pretty notebook rendering
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 31, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"" ], ""text/plain"": [ """" ] }, ""execution_count"": 31, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from IPython.core.display import HTML\n"", ""def css_styling():\n"", "" styles = open(\""../../../theme.css\"", \""r\"").read()\n"", "" return HTML(styles)\n"", ""css_styling()"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""Python 3 (ipykernel)"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.8.13"" } }, ""nbformat"": 4, ""nbformat_minor"": 2 } ","Unknown" "Conformation","vvoelz/biceps","docs/examples/Tutorials/Prep_Rest_Post_Ana/preparation.ipynb",".ipynb","30280","859","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Preparation\n"", ""===========\n"", ""\n"", ""\n"", ""\n"", ""
\n"", ""\n"", ""\n"", ""This tutorial will explain how to properly prepare input files for `biceps` using Python. Each experimental observable requires its own method from the `biceps.Preparation` class to prepare the input data (datapoints of theory and experiment). For example, `biceps.Preparation.prep_noe` will be used to prepare data of NOE distances and `biceps.Preparation.prep_J` for scalar coupling constants. Our goal is to prepare input data for the next step, which is constructing the ensemble of experimental restraints. All data from this tutorial can be found from this work ([DOI:10.1002/jcc.23738](https://onlinelibrary.wiley.com/doi/full/10.1002/jcc.23738)).\n"", ""\n"", ""\n"", ""
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 1, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""BICePs - Bayesian Inference of Conformational Populations, Version 2.0\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""Warning on use of the timeseries module: If the inherent timescales of the system are long compared to those being analyzed, this statistical inefficiency may be an underestimate. The estimate presumes the use of many statistically independent samples. Tests should be performed to assess whether this condition is satisfied. Be cautious in the interpretation of the data.\n"" ] } ], ""source"": [ ""import mdtraj as md\n"", ""import numpy as np\n"", ""import pandas as pd\n"", ""import biceps"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""In this tutorial, we have two experimental observables: (1) [J couplings](https://en.wikipedia.org/wiki/J-coupling) for small molecules and (2) [NMR nuclear Overhauser effect (NOE)](https://en.wikipedia.org/wiki/Nuclear_Overhauser_effect) (pairwise distances).\n"", ""First we need to perform conformational clustering on our MD simulations data. In this case, 100 metastable states are clustered. Now we need to prepare prior knowledge we learned from computational simulations. Normally, we used potential energy for each metastable state. In the [original work](https://onlinelibrary.wiley.com/doi/full/10.1002/jcc.23738), Zhou et al did Quantum Mechanical (QM) calculations to refine each state and B3LYP energy was used as priors in BICePs calculation. Instructions of QM calculations are beyond the scope of this tutorial. Alternatively, we can estimate the potential energy using $U = -ln(P)$ where $P$ is the normalized population for each state. We also have built-in functions ([toolbox](https://biceps.readthedocs.io/en/latest/api.html#toolbox)) to conduct this conversion. \n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Next, we need to compute pairwise distances and J coupling constants for each clustered state. \n"", ""To compute pairwise distances, we recommend to use [MDTraj](http://mdtraj.org) (`biceps.toolbox.compute_distances`) which is free to download. \n"", ""To compare simulated conformational ensembles to experimental NOE measurements, we normally computed $^{-1/6}$. For convenience in this tutorial, we assume the cluster center of each state is representative enough and simply compute pairwise distances for the cluster center conformation. In practice, we still recommend users to compute ensemble-averaged distance."" ] }, { ""cell_type"": ""code"", ""execution_count"": 2, ""metadata"": {}, ""outputs"": [], ""source"": [ ""# Compute model_data for NOE\n"", ""data_dir = \""../../datasets/cineromycin_B/\""\n"", ""states = biceps.toolbox.get_files(data_dir+\""cineromycinB_pdbs/*\"")\n"", ""nstates = len(states)\n"", ""ind=data_dir+'atom_indice_noe.txt'\n"", ""outdir = \""NOE/\""\n"", ""biceps.toolbox.mkdir(outdir)\n"", ""model_data_NOE = biceps.toolbox.compute_distances(states, ind, outdir)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Next, we need to convert computed distance to Pandas DataFrame. The default file format for saving prepared input data is `fmt=\""pickle\""`. `biceps` currently supports `*.csv` and `*.pkl` file formats and possibly other [input/output file formats from Pandas](https://pandas.pydata.org/pandas-docs/stable/reference/io.html)."" ] }, { ""cell_type"": ""code"", ""execution_count"": 3, ""metadata"": {}, ""outputs"": [], ""source"": [ ""# Now using biceps Preparation submodule\n"", ""model_data_NOE = str(outdir+\""*.txt\"")\n"", ""exp_data_NOE = data_dir+\""noe_distance.txt\""\n"", ""preparation = biceps.Preparation(nstates, top_file=states[0], outdir=\""J_NOE\"")\n"", ""preparation.prepare_noe(exp_data_NOE, model_data_NOE, indices=ind, write_as=\""csv\"", verbose=False)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Now, let's take a look at what's inside the newly generated files."" ] }, { ""cell_type"": ""code"", ""execution_count"": 4, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
expmodelrestraint_indexatom_index1res1atom_name1atom_index2res2atom_name2
02.52.864866123UNK1H325UNK1H5
12.54.400116223UNK1H327UNK1H7
22.54.045793325UNK1H527UNK1H7
32.53.481033424UNK1H426UNK1H6
42.52.566673525UNK1H526UNK1H6
..............................
282.53.8372841436UNK1H1639UNK1H19
292.52.6016451436UNK1H1640UNK1H20
302.52.8100591437UNK1H1738UNK1H18
312.54.2235441437UNK1H1739UNK1H19
322.53.6344431437UNK1H1740UNK1H20
\n"", ""

33 rows × 9 columns

\n"", ""
"" ], ""text/plain"": [ "" exp model restraint_index atom_index1 res1 atom_name1 atom_index2 \\\n"", ""0 2.5 2.864866 1 23 UNK1 H3 25 \n"", ""1 2.5 4.400116 2 23 UNK1 H3 27 \n"", ""2 2.5 4.045793 3 25 UNK1 H5 27 \n"", ""3 2.5 3.481033 4 24 UNK1 H4 26 \n"", ""4 2.5 2.566673 5 25 UNK1 H5 26 \n"", "".. ... ... ... ... ... ... ... \n"", ""28 2.5 3.837284 14 36 UNK1 H16 39 \n"", ""29 2.5 2.601645 14 36 UNK1 H16 40 \n"", ""30 2.5 2.810059 14 37 UNK1 H17 38 \n"", ""31 2.5 4.223544 14 37 UNK1 H17 39 \n"", ""32 2.5 3.634443 14 37 UNK1 H17 40 \n"", ""\n"", "" res2 atom_name2 \n"", ""0 UNK1 H5 \n"", ""1 UNK1 H7 \n"", ""2 UNK1 H7 \n"", ""3 UNK1 H6 \n"", ""4 UNK1 H6 \n"", "".. ... ... \n"", ""28 UNK1 H19 \n"", ""29 UNK1 H20 \n"", ""30 UNK1 H18 \n"", ""31 UNK1 H19 \n"", ""32 UNK1 H20 \n"", ""\n"", ""[33 rows x 9 columns]"" ] }, ""execution_count"": 4, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""pd.options.display.max_columns = 12\n"", ""pd.options.display.max_rows = 10\n"", ""pd.read_csv('J_NOE/0.noe', index_col=0)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Now let's move on to J couplings. Model predictions of coupling constants from dihedral angles θ were obtained from Karplus relations chosen depending on the relevant stereochemistry. "" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Again, we need to convert computed J coupling constants to Pandas DataFrame. "" ] }, { ""cell_type"": ""code"", ""execution_count"": 5, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Karplus relations ['Allylic' 'Karplus_HH' 'Karplus_HH' 'Karplus_HH' 'Karplus_HH'\n"", "" 'Karplus_HH' 'Karplus_antiperiplanar_O' 'Karplus_antiperiplanar_O'\n"", "" 'Karplus_antiperiplanar_O' 'Karplus_antiperiplanar_O']\n"" ] } ], ""source"": [ ""# Compute model_data forJ coupling\n"", ""ind = np.load(data_dir+'ind.npy') # atom indices of J coupling constants\n"", ""\n"", ""outdir = \""J/\""\n"", ""biceps.toolbox.mkdir(outdir)\n"", ""\n"", ""# Karplus relations for each dihedral angles \n"", ""karplus_key=np.loadtxt(data_dir+'Karplus.txt', dtype=str)\n"", ""print('Karplus relations', karplus_key)\n"", ""states = biceps.toolbox.get_files(data_dir+\""cineromycinB_pdbs/*.fixed.pdb\"")\n"", ""biceps.toolbox.compute_nonaa_scalar_coupling(states=states,\n"", "" indices=ind, karplus_key=karplus_key, outdir=outdir)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Next, we need to convert J coupling to Pandas DataFrame. Let's use `fmt=\""pickle\""` to show off how we can import various file formats for different restraints..."" ] }, { ""cell_type"": ""code"", ""execution_count"": 6, ""metadata"": {}, ""outputs"": [], ""source"": [ ""indices = data_dir+'atom_indice_J.txt'\n"", ""exp_data_J = data_dir+'exp_Jcoupling.txt'\n"", ""model_data_J = data_dir+\""J_coupling/*.txt\""\n"", ""\n"", ""# Now using biceps Preparation submodule\n"", ""preparation = biceps.Preparation(nstates, top_file=states[0], outdir=\""J_NOE\"")\n"", ""preparation.prepare_J(exp_data=exp_data_J, model_data=model_data_J,\n"", "" indices=indices, write_as=\""pickle\"", verbose=False)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Now, let's take a look at what's inside the newly generated files."" ] }, { ""cell_type"": ""code"", ""execution_count"": 7, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
expmodelrestraint_indexatom_index1res1atom_name1...atom_index3res3atom_name3atom_index4res4atom_name4
05.03.279128125UNK1H5...10UNK1C726UNK1H6
11.513.336870230UNK1H10...15UNK1C1232UNK1H12
21.50.600845331UNK1H11...15UNK1C1232UNK1H12
36.013.877749432UNK1H12...20UNK1C1638UNK1H18
46.03.339372432UNK1H12...20UNK1C1639UNK1H19
56.01.828765432UNK1H12...20UNK1C1640UNK1H20
61.50.464738532UNK1H12...16UNK1C1333UNK1H13
77.02.956672633UNK1H13...21UNK1C1735UNK1H15
87.010.805575633UNK1H13...21UNK1C1736UNK1H16
97.01.232210633UNK1H13...21UNK1C1737UNK1H17
\n"", ""

10 rows × 15 columns

\n"", ""
"" ], ""text/plain"": [ "" exp model restraint_index atom_index1 res1 atom_name1 ... \\\n"", ""0 5.0 3.279128 1 25 UNK1 H5 ... \n"", ""1 1.5 13.336870 2 30 UNK1 H10 ... \n"", ""2 1.5 0.600845 3 31 UNK1 H11 ... \n"", ""3 6.0 13.877749 4 32 UNK1 H12 ... \n"", ""4 6.0 3.339372 4 32 UNK1 H12 ... \n"", ""5 6.0 1.828765 4 32 UNK1 H12 ... \n"", ""6 1.5 0.464738 5 32 UNK1 H12 ... \n"", ""7 7.0 2.956672 6 33 UNK1 H13 ... \n"", ""8 7.0 10.805575 6 33 UNK1 H13 ... \n"", ""9 7.0 1.232210 6 33 UNK1 H13 ... \n"", ""\n"", "" atom_index3 res3 atom_name3 atom_index4 res4 atom_name4 \n"", ""0 10 UNK1 C7 26 UNK1 H6 \n"", ""1 15 UNK1 C12 32 UNK1 H12 \n"", ""2 15 UNK1 C12 32 UNK1 H12 \n"", ""3 20 UNK1 C16 38 UNK1 H18 \n"", ""4 20 UNK1 C16 39 UNK1 H19 \n"", ""5 20 UNK1 C16 40 UNK1 H20 \n"", ""6 16 UNK1 C13 33 UNK1 H13 \n"", ""7 21 UNK1 C17 35 UNK1 H15 \n"", ""8 21 UNK1 C17 36 UNK1 H16 \n"", ""9 21 UNK1 C17 37 UNK1 H17 \n"", ""\n"", ""[10 rows x 15 columns]"" ] }, ""execution_count"": 7, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""pd.read_pickle('J_NOE/0.J')"" ] }, { ""cell_type"": ""markdown"", ""metadata"": { ""collapsed"": true }, ""source"": [ ""

Conclusion

\n"", ""\n"", ""From this tutorial, we learned how to use the `biceps.Preparation` class to prepare input files. Currently, BICePs supports the following restraints:\n"", ""\n"", ""**NOE, J couplings, Chemical Shifts, Protection Factors and more to come...**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 8, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""['Restraint_cs', 'Restraint_J', 'Restraint_noe', 'Restraint_pf']\n"" ] } ], ""source"": [ ""print(biceps.toolbox.list_possible_restraints())"" ] }, { ""cell_type"": ""markdown"", ""metadata"": { ""collapsed"": true }, ""source"": [ ""In the example above, we showed how to deal with NOE and J couplings (non-natural amino acids). \n"", ""\n"", ""\n"", ""\n"", ""Chemical shifts can be computed using different algorithm. We recommend to use [Shiftx2](http://www.shiftx2.ca) which is also available in MDTraj library. We offer methods in `biceps.toolbox` to easily compute model data (chemical shifts, J coupling, NOE distances).\n"", ""\n"", ""\n"", ""\n"", ""Protection factors is a special observables which asks for extra work. We provide a [full example](https://biceps.readthedocs.io/en/latest/examples/full_examples/apomyoglobin/apomyoglobin.html) that includes **HDX** (protection factor) restraints in biceps.\n"", ""\n"", ""Now that the input files are ready, we can move on to constructing the conformational [Ensemble](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Prep_Rest_Post_Ana/ensemble.html) and applying our restraints."" ] }, { ""cell_type"": ""markdown"", ""metadata"": { ""collapsed"": true }, ""source"": [ ""
# NOTE: The following cell is for pretty notebook rendering
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 14, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"" ], ""text/plain"": [ """" ] }, ""execution_count"": 14, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from IPython.core.display import HTML\n"", ""def css_styling():\n"", "" styles = open(\""../../../theme.css\"", \""r\"").read()\n"", "" return HTML(styles)\n"", ""css_styling()"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""Python 3 (ipykernel)"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.8.13"" } }, ""nbformat"": 4, ""nbformat_minor"": 1 } ","Unknown" "Conformation","vvoelz/biceps","docs/examples/Tutorials/Prep_Rest_Post_Ana/preparation.py",".py","7597","182","#!/usr/bin/env python # coding: utf-8 #

Preparation

# #
# # This tutorial shows the user how to properly use methods in the `Preparation class` to prepare input files for the next step, which is constructing the ensemble via the `BICePs` `Restraint class`. The data from this tutorial can be found from this work (DOI: [10.1002/jcc.23738](https://onlinelibrary.wiley.com/doi/full/10.1002/jcc.23738)). # #
# In[1]: import sys, os import biceps # In this tutorial, we have two experimental observables: (1) [J couplings](https://en.wikipedia.org/wiki/J-coupling) for small molecules and (2) [NMR nuclear Overhauser effect (NOE)](https://en.wikipedia.org/wiki/Nuclear_Overhauser_effect) (pairwise distances). # First we need to perform conformational clustering on our MD simulations data. In this case, 100 metastable states are clustered. Now we need to prepare prior knowledge we learned from computational simulations. Normally, we used potential energy for each metastable state. In the [original work](https://onlinelibrary.wiley.com/doi/full/10.1002/jcc.23738), Zhou et al did Quantum Mechanical (QM) calculations to refine each state and B3LYP energy was used as priors in BICePs calculation. Instructions of QM calculations are beyond the scope of this tutorial. Alternatively, we can estimate the potential energy using U = -ln(P) where P is the normalized population for each state. We also have built-in functions ([toolbox](https://biceps.readthedocs.io/en/latest/api.html#toolbox)) to conduct this conversion. You can find tutorials using functions in `toolbox.py` [here](https://biceps.readthedocs.io/en/latest/tutorials/Tools/toolbox.html). # # Next, we need to compute pairwise distances and J coupling constants for each clustered state. # To compute pairwise distances, we recommend to use [MDTraj](http://mdtraj.org) which is free to download. # To compare simulated conformational ensembles to experimental NOE measurements, we normally computed $^{-1/6}$. For convenience in this tutorial, we assume the cluster center of each state is representative enough and simply compute pairwise distances for the cluster center conformation. In practice, we still recommend users to compute ensemble-averaged distance. # In[2]: import mdtraj as md import numpy as np data_dir = ""../../datasets/cineromycin_B/"" # atom indices of pairwise distances ind=np.loadtxt(data_dir+'atom_indice_noe.txt') print(""indices"", ind) # make a new folder of computed distances for later os.system(data_dir+'mkdir NOE') # compute pairwise distances using MDTraj for i in range(100): # 100 clustered states #print('state', i) t = md.load(data_dir+'cineromycinB_pdbs/%d.fixed.pdb'%i) d=md.compute_distances(t,ind)*10. # convert nm to Å np.savetxt(data_dir+'NOE/%d.txt'%i,d) print(""Done!"") # Next, we need to convert computed distance to BICePs readable format. # In[3]: ######################################### # Lets' create input files for BICePs ############ Preparation ################ # Specify necessary argument values # REQUIRED: raw data of pre-comuted chemical shifts path = data_dir+'NOE/*txt' # REQUIRED: number of states states = 100 # REQUIRED: atom indices of pairwise distances indices = data_dir+'atom_indice_noe.txt' # REQUIRED: experimental data exp_data = data_dir+'noe_distance.txt' # REQUIRED: topology file (as it only supports topology information, so it doesn't matter which state is used) top = data_dir+'cineromycinB_pdbs/0.fixed.pdb' # OPTIONAL: output directory of generated files out_dir = data_dir+'noe_J' p = biceps.Preparation('noe',states=states,indices=indices,exp_data=exp_data,top=top,data_dir=path) # 'noe' scheme is selected p.write(out_dir=out_dir) # This will convert pairwise distances files for each state to a BICePs readable format and saved the new files in ""noe_J"" folder. # Now, let's take a look at what's inside the newly generated files. # In[4]: fin = open(data_dir+'noe_J/0.noe','r') text = fin.read() fin.close() print(text) # Now let's move on to J couplings. Model predictions of coupling constants from dihedral angles θ were obtained from Karplus relations chosen depending on the relevant stereochemistry. # In[6]: # atom indices of J coupling constants ind=np.load(data_dir+'ind.npy') print('index', ind) # Karplus relations for each dihedral angles karplus_key=np.loadtxt(data_dir+'Karplus.txt', dtype=str) print('Karplus relations', karplus_key) # compute J coupling constants using our built-in funtion (compute_nonaa_Jcoupling) in toolbox.py for i in range(100): # 100 clustered states J = biceps.toolbox.compute_nonaa_Jcoupling(data_dir+'cineromycinB_pdbs/%d.fixed.pdb'%i, index=ind, karplus_key=karplus_key) np.savetxt(data_dir+'J_coupling/%d.txt'%i,J) # Again, we need to convert computed J coupling constants to BICePs supported format. # In[7]: ######################################### # Lets' create input files for BICePs ############ Preparation ################ # Specify necessary argument values # REQUIRED: raw data of pre-comuted chemical shifts path = data_dir+'J_coupling/*txt' # REQUIRED: number of states states = 100 # REQUIRED: atom indices of pairwise distances indices = data_dir+'atom_indice_J.txt' # REQUIRED: experimental data exp_data = data_dir+'exp_Jcoupling.txt' # REQUIRED: topology file (as it only supports topology information, so it doesn't matter which state is used) top = data_dir+'cineromycinB_pdbs/0.fixed.pdb' # OPTIONAL: output directory of generated files out_dir = data_dir+'noe_J' p = biceps.Preparation('J',states=states,indices=indices,exp_data=exp_data,top=top,data_dir=path) # 'J' scheme is selected p.write(out_dir=out_dir) # This will convert J coupling constants files for each state to a BICePs readable format and saved the new files in ""noe_J"" folder. # Now, let's take a look at what's inside the newly generated files. # In[8]: fin = open(data_dir+'noe_J/0.J','r') text = fin.read() fin.close() print(text) # ### Conclusion### # In this tutorial, we briefly showed how to use [Preparation](https://biceps.readthedocs.io/en/latest/api.html#preparation) class to prepare input files for BICePs using precomputed experimental observables. As of 2019, BICePs supports the following observables: NOE, J couplings, Chemical Shifts, Protection Factors. # # In the example above, we showed how to deal with NOE and J couplings (non-natural amino acids). # # For J couplings for natural amino acids, please check this tutorial. # # Chemical shifts can be computed using different algorithm. We recommend to use [Shiftx2](http://www.shiftx2.ca) which is also available in MDTraj library. # # Protection factors is a special observables which asks for extra work. We provide a [separate tutorial](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Prep_Rest_Post_Ana/protectionfactors.html) that includes protection factors in BICePs sampling. # # Now that the input files are ready, we can move on to [Restraint](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Prep_Rest_Post_Ana/Restraint.html), where we construct a conformational ensemble. # #
# NOTE: The following cell is for pretty notebook rendering
# In[9]: from IPython.core.display import HTML def css_styling(): styles = open(""../../../theme.css"", ""r"").read() return HTML(styles) css_styling() ","Python" "Conformation","vvoelz/biceps","docs/examples/Tutorials/Prep_Rest_Post_Ana/posteriorsampler.ipynb",".ipynb","11330","346","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""PosteriorSampler\n"", ""==============\n"", ""\n"", ""
\n"", ""\n"", ""In this tutorial, we will perform sampling when given an ensemble. Previously, in the [Ensemble](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Prep_Rest_Post_Ana/ensemble.html) tutorial we constructed ensembles for two lambda values and saved them to pickle files. Please read the section [lambda values](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Prep_Rest_Post_Ana/restraint.ipynb#Quick-note-on-lambda-values:) in the previous tutorial for more information.\n"", ""\n"", ""
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 13, ""metadata"": {}, ""outputs"": [], ""source"": [ ""import pickle, os\n"", ""import numpy as np\n"", ""import biceps"" ] }, { ""cell_type"": ""code"", ""execution_count"": 14, ""metadata"": {}, ""outputs"": [], ""source"": [ ""outdir = 'results'\n"", ""n_lambdas = 2\n"", ""lambda_values = np.linspace(0.0, 1.0, n_lambdas)\n"", ""ensembles = []\n"", ""for lam in lambda_values:\n"", "" with open(outdir+\""/ensemble_%s.pkl\""%lam,'rb') as file:\n"", "" ensemble = pickle.load(file)\n"", "" ensembles.append(ensemble)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Next, we need to specify number of steps for BICePs sampling. We recommend to run at least 1M steps for converged Monte Carlo samplings. Checking the convergence of the MCMC trajectory can be done simply using the submodule, `biceps.Convergence`.\n"", ""\n"", ""\n"", ""Using the first ensemble of the list of ensembles...\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 15, ""metadata"": {}, ""outputs"": [], ""source"": [ ""nsteps = 100000 # number of steps of MCMC simulation\n"", ""sampler = biceps.PosteriorSampler(ensembles[0])"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Then, we sample for 100 k steps..."" ] }, { ""cell_type"": ""code"", ""execution_count"": 16, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Step\t\tState\tPara Indices\t\tAvg Energy\tAcceptance (%)\n"", ""0\t\t[87]\t[196, 127, 195]\t\t7.150\t\t56.94\tFalse\n"", ""10000\t\t[67]\t[235, 150, 184]\t\t8.713\t\t69.42\tFalse\n"", ""20000\t\t[67]\t[267, 141, 202]\t\t8.858\t\t73.08\tTrue\n"", ""30000\t\t[68]\t[243, 137, 196]\t\t9.303\t\t72.81\tTrue\n"", ""40000\t\t[27]\t[229, 150, 199]\t\t7.451\t\t72.53\tTrue\n"", ""50000\t\t[25]\t[230, 134, 197]\t\t9.089\t\t72.14\tTrue\n"", ""60000\t\t[65]\t[276, 129, 182]\t\t9.437\t\t72.21\tFalse\n"", ""70000\t\t[18]\t[224, 147, 198]\t\t11.604\t\t72.58\tTrue\n"", ""80000\t\t[21]\t[302, 117, 182]\t\t11.992\t\t73.06\tTrue\n"", ""90000\t\t[79]\t[241, 135, 199]\t\t7.123\t\t73.16\tTrue\n"", ""\n"", ""Accepted 72.88811881188118 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [32.68811881 31.30891089 31.30891089 8.89108911] % \n"", ""\n"" ] } ], ""source"": [ ""sampler.sample(nsteps=nsteps, burn=1000, print_freq=10000, verbose=True)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Now, process and save the results for the next step, [Analysis](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Prep_Rest_Post_Ana/analysis.html)."" ] }, { ""cell_type"": ""code"", ""execution_count"": 17, ""metadata"": {}, ""outputs"": [], ""source"": [ ""lam = lambda_values[0]\n"", ""filename = os.path.join(outdir,'traj_lambda%2.2f.npz'%(lam))\n"", ""sampler.traj.process_results(filename)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Then, we will do the same thing for the second ensemble in the list of ensembles. **Note that we separated them for simplicity of the tutorial.**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 18, ""metadata"": {}, ""outputs"": [ { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ "" 99%|██████████████████████████████████████████████████████████▍| 100000/101000 [00:01<00:00, 61468.68it/s]"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted 65.55940594059406 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [32.73762376 31.24950495 31.24950495 1.57227723] % \n"", ""\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""\n"" ] } ], ""source"": [ ""lam = lambda_values[1]\n"", ""sampler = biceps.PosteriorSampler(ensembles[1])\n"", ""sampler.sample(nsteps=nsteps, burn=1000, verbose=False)\n"", ""filename = os.path.join(outdir,'traj_lambda%2.2f.npz'%(lam))\n"", ""sampler.traj.process_results(filename)\n"", ""biceps.toolbox.save_object(sampler, filename.replace(\"".npz\"", \"".pkl\""))"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""

Conclusion

\n"", ""\n"", ""In this tutorial, we used the `biceps.PosteriorSampler` class to perform MCMC sampling given the ensemble Python object. In the [next tutorial](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Prep_Rest_Post_Ana/analysis.html), we will analyze our trajectory data."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
# NOTE: The following cell is for pretty notebook rendering
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 7, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"" ], ""text/plain"": [ """" ] }, ""execution_count"": 7, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from IPython.core.display import HTML\n"", ""def css_styling():\n"", "" styles = open(\""../../../theme.css\"", \""r\"").read()\n"", "" return HTML(styles)\n"", ""css_styling()"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""Python 3 (ipykernel)"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.8.13"" } }, ""nbformat"": 4, ""nbformat_minor"": 2 } ","Unknown" "Conformation","vvoelz/biceps","docs/examples/Tutorials/Prep_Rest_Post_Ana/analysis.ipynb",".ipynb","122564","435","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Analysis\n"", ""=======\n"", ""\n"", ""
\n"", ""\n"", ""In this tutorial, we show the user how to instantiate the `biceps.Analysis` class which uses [MBAR](https://pymbar.readthedocs.io/en/master/index.html) to get predicted populations of each conformational states and compute a BICePs score. We also provide a short description of the output data from analysis and embed the figures of posterior distribution of populations & nuisance parameters. Please refer to the [documentation of Analysis](https://biceps.readthedocs.io/en/latest/biceps.html#analysis) for more specific details. \n"", ""
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 6, ""metadata"": {}, ""outputs"": [], ""source"": [ ""import biceps\n"", ""import warnings\n"", ""warnings.filterwarnings(\""ignore\"", category=UserWarning)\n"", ""warnings.filterwarnings('ignore', category=FutureWarning)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 10, ""metadata"": { ""scrolled"": false }, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Loading results/traj_lambda0.00.npz ...\n"", ""Loading results/traj_lambda1.00.npz ...\n"", ""not all state sampled, these states [ 0 3 4 5 8 9 11 13 14 15 16 18 19 20 21 22 23 24 25 26 27 28 29 31\n"", "" 34 40 41 42 43 44 48 49 51 52 53 54 55 57 60 61 62 64 69 71 72 73 74 76\n"", "" 77 78 81 82 83 86 87 88 89 95 96 97 98 99] are not sampled\n"", ""Loading results/traj_lambda0.00.pkl ...\n"", ""Loading results/traj_lambda1.00.pkl ...\n"", ""lam = [0.0, 1.0]\n"", ""nstates 100\n"", ""Time for MBAR: 0.077 s\n"", ""Writing results/BS.dat...\n"", ""Writing results/populations.dat...\n"", ""Top 10 states: [46, 85, 92, 45, 39, 80, 65, 90, 59, 38]\n"", ""Top 10 populations: [0.01001833 0.0212999 0.02792732 0.03482791 0.07746092 0.07924925\n"", "" 0.08826894 0.09715671 0.20440265 0.32912632]\n"" ] }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAAxUAAAPeCAYAAAB6Mjd9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD9tElEQVR4nOzde1xT9f8H8NcYY2xc5eIVTU0p8FqmVppZWWalqGh4C7ybzvJSWlZ4w0uZpobT4Os1rbwrWXZXf5ppaVmpMxIvqaDjogLbuOz2+4M4gVyEMTgbvJ6Pxx6PnbOzc16gzvPe5yaxWq1WEBERERER2chF7ABEREREROTcWFQQEREREVGVsKggIiIiIqIqYVFBRERERERVwqKCiIiIiIiqhEUFERERERFVCYsKIiIiIiKqEhYVRERERERUJSwqiIiIiIioSlhUEBGR6C5fvgyJRCI8evbsKXYkIiKqBBYVRERERERUJSwqiIiIiIioSlhUEBERERFRlbCoICIiIiKiKnHIoiItLQ3vvPMOOnfuDF9fX7i6ukKhUKB58+YYNGgQvv/+e7EjEhFRDdi5cycee+wxeHl5wdfXFz169MDGjRthtVrFjkZEREVIrA72yfzHH3/g6aefRlpaWrnHzZo1C4sWLaqhVEREVJ0uX76MFi1aCNuPP/44QkNDsWbNmlKP79OnD3bu3AmlUllTEYmIqBwOVVQYjUaEhoYiKSmpQscfO3YMDz/8cDWnIiKi6nZnUSGVSmE2m8t9z6hRo7B+/frqjkZERBXgUN2ftm/fXqygePzxx/Hdd9/hjz/+wBdffIEuXboUO/7AgQM1HZGIiGqA2WyGq6srZs+ejZMnT+LQoUMYOHBgsWM2bNiAM2fOiJSQiIiKchU7QFEdO3bEsmXL8Pvvv+P8+fNISEiAj48PAKB9+/YICAgo1jKRkpIiVlQiIqpmarUa48ePF7Z79OiBF154Afv37xf2bdmyBe+++64Y8YiIqAiHKiratGmDNm3alNhvMpnw+++/Y9euXcX2GwyGmopGREQ1qF69ehg9enSxfRKJBNOmTStWVPz88881HY2IiErhUEVFIZPJhO+++w4HDhzA0aNH8ccff5RaQFgsFhHSERFRdQsNDYWra8n/oh588MFi22yxJiJyDA5XVOzYsQNTpkzB9evXi+13d3dHmzZt8Ouvv4qUjIiIaopCoSh1f2GX2EJssSYicgwOVVR89dVXiIiIEOYfb9u2LcaMGYPHHnsM7du3x7Vr19CyZUuRUxIRUXW7efNmqft1Ol2xbW9v75qIQ0REd+FQRUVMTIxQUDRq1AjHjx+Hh4eH8HpWVpZY0YiIqAadPXsW2dnZ8PLyKrb/jz/+KLZddBpaIiISj0NNKVv0PwuFQlFiUaNt27YV2+aYCiKi2ikvLw8LFy4ssX/FihXFtrt161ZDiYiIqDwO1VKhUCiE/rEXL17EyJEjMWnSJBgMBmzatAmbNm0qdnx+fr4YMYmIqAa89957yMzMRGRkJAAgNjYWe/bsEV53dXXFSy+9JFY8IiIqwqFW1I6MjMTmzZsrfPxTTz2F77//vhoTERFRTbhzRe1GjRqVmLDjTu+88w5iYmKqOxoREVWAQ3V/Wrx4MZo2bVrm6y1atEBwcLCw/ccff7ALFBFRLfTKK69g5MiRZb4eGRmJuXPn1lgeIiIqn0MVFU2aNMHJkyfxyiuvoEWLFpDJZPD09ESHDh0QHR2NX3/9tVhTd3p6OlsqiIhqIYlEgg0bNmDHjh3o2bMnvL294eXlhccffxzbt2/Hpk2bIJVKxY5JRET/cqjuT9XBYrFg7NixSExMhLe3NzZv3oyAgACxYxERERER1RoO1VJRHfbs2QN3d3ccPXoUI0eOxOLFi8WORERERERUq9T6ouLo0aN45plnAADPPvssDhw4IHIiIiIiIqLapdYXFVlZWfDx8QEAeHl5ITs7W+RERERERES1S60vKry9vYVCIjs7WygwiIiIiIjIPmp9UfHII4/g22+/BQB89dVXePTRR0VORERERERUu9T62Z/MZjPGjRuHxMREuLm5YevWrWjQoEGZx+fl5SEvL0/YtlgsuHnzJvz9/SGRSGoiMhGRw7FarcjOzkbjxo3h4lLrv4+CxWJBSkoKvLy8+NlPRHVahT//rU4mNTXVeu+991oPHjwo7NNqtdawsDCrj4+P1d/f3zplyhSr0Wi06fxz5syxAuCDDz744KOUx9WrV+30ae7Yrl69Kvrvmg8++ODDkR53+/x3qpaKo0ePIioqChcuXMDBgwfRs2dPAMATTzyBJk2aID4+Hjdu3EC/fv0QFRWFGTNmVPoad7ZUZGZmolmzZrh69Sq8vb3t9aMQETk8k8mE8PBwHDp0SNh3+/btOjE2LTMzE76+vrh06RL8/PzEjuM0jEYjvv32WzzzzDOQyWRix3EK/J1VHn9ntrH195aVlYWmTZve9fPf1R4ha8KmTZswe/ZsLFmyBEOGDBH2JyUl4dChQ0hOToZSqUTLli0RHR2NmTNn2lRUyOVyyOXyEvu9vb1ZVBBRnTJt2jShoPD390dGRkad6QpU+HN6eXnxs78SjEYjlEolvL29ebNXQfydVR5/Z7ap6u/tbp//TtMxtnfv3rhw4QIiIiKK7T979iz8/PzQuHFjYV9oaCiuXLmC27dv23w9tVqN0NBQdO7c2eZzEBE5q40bN2LFihUAAJlMhi1btogbiIiIHJrTFBUNGzaEq2vJhpXs7Gx4eHgU26dUKgEAOp3O5uupVCpoNBqcOHHC5nMQETmjn3/+GRMmTBC2V61axZnziIioXE5TVJTFw8MDBoOh2L7CbS8vLzEiERE5rZSUFAwYMAD5+fkAgIkTJ2L8+PEipyIiIkfnNGMqytK2bVtkZGRAq9UKU8VqNBoEBQVVaTChWq2GWq2G2Wy2V1QiIoeWm5uLAQMG4Pr16wCAHj16YOXKlSKnIqLaymw2w2g0Vvp9RqMRrq6uyM3N5X1aJZT1e5PJZJBKpVU+v9MXFa1bt0b37t0xdepUxMfHIz09HTExMRgzZkyVzqtSqaBSqZCVlVUnZjohorrNarViwoQJ+OWXXwAAzZo1w86dOzkIkojszmq14saNGzaPfbVarWjYsCGuXr1aZyaPsIfyfm++vr5o2LBhlX6fTl9UAMDOnTsxefJktGjRAi4uLoiMjER0dLTYsYiInMaKFSvw8ccfAygYl5aQkIDAwECRUxFRbVRYUNSvXx9KpbLSN7IWiwU6nQ6enp51YjFOeynt92a1WmEwGJCamgoAaNSokc3nd8qi4s6lNRo0aIAdO3aIlIaIyLl99913eP3114XtjRs3omPHjuIFIqJay2w2CwWFv7+/TeewWCzIz8+Hu7s7i4pKKOv3plAoAACpqamoX7++zV2h+CdRBk4pS0R1QVJSEiIiImCxWAAAb7/9NgYPHixyKiKqrQrHUBTO1EmOofDPw5YxLoVYVJSBU8oSUW2XlZWFfv364datWwCAvn37Yv78+SKnIqK6gGMhHIs9/jycsvsTERFVjcViwUsvvYRz584BAEJCQrBlyxZ2JSAi0WRmZpZYJqA0FosF2dnZ0Ov1Nn9mKZVKTsRjZywqiIjqoDlz5uDzzz8HUDDrR0JCAry9vUVORUR1VWZmJmJiViE9/e7db6xWK4xGI2Qymc3fsAcEyBAdPZmFhR2xqCAiqmN27NiBBQsWAABcXFywbds2tG7dWuRURFSXGQwGpKcboVAMhFJZ/sxzVqsV+fl5cHOT21RUGAxpSE/fDYPBwKLCjlhUlIGL3xFRbfT7779j5MiRwvb777+PZ555RrxARERFKJWB8PIqf1pTq9WKvLw8yOW2FRUAkJNj09uoHOw8WwYO1Cai2iYtLQ39+/cX+iy/9NJLmDZtmsipiIicw4ULF9C3b18EBATgnnvuwdtvv438/Hy8/PLLuPfee6HT6QAUfDEdGBiI5ORkbNy4EQ8//DAmTJgAb29vNGrUCAsWLCixPEJtwKKCiKgOMBqNGDx4MP755x8AQOfOnREfH88ZWIiIKkCv1+Opp55C27Ztce3aNfz444/4/vvvMWfOHCxfvhwKhQIzZ87En3/+iRkzZmDz5s1o0qQJAODnn3+Gh4cHUlNTsW/fPqxYsQLr168X+SeyPxYVRER1wNSpU/F///d/AICGDRtiz549cHd3FzkV1QaZmZm4fv06rl+/Dq1WCwDQarXCvuvXryMzM1PklERV8+WXXyI/Px+LFi2Cu7s7mjZtipiYGKjVaigUCmzduhWbNm3CCy+8gGnTpuHZZ58V3uvv74/33nsP7u7ueOihhzB+/Hhs3rxZxJ+menBMBRFRLRcfH4/Vq1cDANzc3LBnzx7hGzSiqsjMzMSqmBgY09MBAC6urujQty/Wz50Li8kkHCcLCMDk6GgOiiWndfnyZaSmpqJevXrCvoIB4/lITU1F27Zt8fjjj+Obb77B6NGji723efPmkMlkwnazZs2wa9euGsteU1hUlIEDtYmoNvjxxx8xefJkYfujjz7Cww8/LGIiqk0MBgOM6ekYqFAgUKmEWSrFrwBG+/lB+u//n2kGA3anp3OmHXJqQUFBaNWqFf766y9hX3Z2NrRaLQIDA7F9+3YcP34cAwYMQGRkJA4fPgypVAoASElJgdVqFbqbXrp0Cc2aNRPl56hO7P5UBg7UJiJnd+XKFYSHh8NoLJj3fcqUKRg1apTIqag2ClQq0cjLCw08PQEADTw90cjLC428vBCoVIqcjpyJwZCG7Ozrd33odHc/pqyHwZBW6VwvvPACsrOz8f777yMvLw+3b99GZGQkIiIicOXKFUyYMAGrVq3C+vXrkZycjHnz5gnvvX79Ot59910YjUb88ssv+N///oexY8fa89fmENhSQURUCxkMBgwYMACpqakAgKeeegpLly4VORURUemUSiUCAmRIT9991+le7bX4nbISBa+3tze+//57vPbaa1iyZAnMZjOeeOIJfP7554iIiECvXr0wbNgwAMCGDRvwzDPPoFevXgCARo0a4dKlS2jUqBG8vLywYMECRERE2JTbkbGoICKqZaxWK8aMGYPffvsNANCyZUts27YNrq78yCcix+Tj44Po6MnClNflsVgsyM7OhpeXF1xcbOt0o1QqK90dLyQkBPv37y+x/8cffyy2/cQTTwgtxBcvXoSbmxvi4+MRHx9vU1Znwf9hiMjhHLh0ALN+mIVzaeeglCkxOHQwljy9BAqZAlvPbMW8/5uH5KxkNPRsiOmPTMfLD70sdmSHsmTJEmzduhUA4OnpiYSEBPj7+4ucioiofD4+PhW60bdYLPDw8IC3t7fNRQXZH4sKInIoafo0PP/p81jz/BpEdoiEVqfFM1uewbs/vovBbQZjzOdj8EPkD3g46GH8dPUnPLHpCbQJbIPH7nlM7OgOYf/+/Zg1a5awvXnzZrRt21bEREREVBewvCuDWq1GaGgoOnfuLHYUojol0CMQqa+nYmTHkZBAgoycDOSachHoEYi/M/6GyWKCxWopmEkDEkglUri7cr0FAPjrr78wdOhQYaXWefPmoX///uKGIiKqw0aOHInLly+LHaNGsKWiDCqVCiqVCllZWZwCj6iGecm9AABNlzdFcnYyHmv2GEZ1LJi16OGgh9FtfTdIJVKYrWYsfXopOjdh8X/79m2EhYUhKysLABAeHo533nlH5FRERFRXsKWCiBzW+VfOI3l6MqQuUgzaMQh55jy08G2B7176Djlv5+CLoV9gzqE5+PbCt2JHFZXZbMbQoUPx999/AwDatWuHjRs3sq8xERHVGLZUEJFDuHbtGs6fP4/WrVsjKCgIAKCQKaCQKfBer/fQdW1XzDk4B+6u7ujVsmCavueDn8fQtkMR92scnrn3GTHji+qtt97C119/DQDw9/dHQkICPP9dL4DIWWVmZt51JiBbZvAhourBooKIRLdu3TqMHz8eFosFkmYSNBjfAP+8+Q/cpG4AgDxTHtykbki6lYSGng2LvVcmlQnH1UWffvoplixZAgCQSqXYsWMHWrRoIXIqoqrJzMxETMwqpKcbyz0uIECG6OjJLCyIHACLCiIS1bVr14SCAgCsN6y4kXEDqj0qqAeocT37Ol7/7nWMeWAMOjXqhFe+egVD2gzBM/c+g8P/HMaWP7fg0/BPRf4pxHHy5EmMGTNG2F6xYgWeeOIJERMR2YfBYEB6uhEKxUAolYFlHJOG9PTdMBgMLCpqiYq0TgH/rVOh1+trdJ0KKh+LCiIS1fnz54WCAgCQD2AL8Hvz39FgaQP4yH0wov0IRPeIhtxVDoPRgFe/fhXXs6+jmU8zrHl+DV4IfkG0/GK5ceMGBgwYgNzcXADAmDFjoFKpRE5FZF9KZSC8vBqV+frdVl4m55GZmYlVMTEwpqff9Vh7rKgtCwjA5OhoFhZ2xKKCiETVunVruLi4FCsspDel2DNwjzC2oqhXur6CV7q+UpMRHU5eXh7Cw8Nx7do1AMCjjz4KtVpt83+uRERiMxgMMKanY6BCgUClstxjrVYr8vLzIXdzs+lzL81gwO70dLZy2RmLCiISVVBQEOLj4zFhwgSYzWZIpVLExcWVWlBQwX+mkydPxk8//QSg4Pe3a9cuyOVykZMREVVdoFKJRl5e5R5jtVqRl5cHuVxu+5cpdmrmOnLkCPr06QOdTmeX8zkzFhVlUKvVUKvVMJvNYkchqvXGjBmD3r17IykpCa1atWJBUY7Vq1dj7dq1AAB3d3fs2bMHDRs2vMu7iIioOjz22GN2KSgkEgkuXbqE5s2bVz2USDiJeRlUKhU0Gg1OnDghdhSiOiEoKAg9e/ZkQVGOgwcPYsqUKcL22rVr8dBDD4mYiIio7pg7dy6aNm0KPz8/dO7cGZ9//jkOHToktJZcvnwZEokEH3/8Me655x54eHhg1KhR+PHHH9GhQwd4enriqaeeQnoFxo0U2rp1K9q3bw8fHx906tQJ335bsC5TRkYGgoKCMHPmTACAyWTCo48+iqFDhwIAevbsiddeew2dOnWCh4cHOnXqhB9//NHOv5Hi2FJBROQELl26hMGDBwutpzNmzMDw4cNFTkVUMbn5+dBqteUew9l4yJEdPHgQ8fHx+PXXX9GwYUPEx8djzJgx+PTTkrMP7t+/H+fOncPFixfRsWNHnDp1Cvv374dcLscjjzyC1atXY/bs2XjhhReK3ei3b98eLi4uaNasGf7880/s378fL7/8Mj7//HN069YNX331FcLDw3H8+HG0adMGW7ZswTPPPIMBAwZg3759yMjIwDfffCOcLz4+Xnjv+++/j7CwMPz666/w9vault8RiwoiqtW2ndmG4buHw93VXdg3IGQANg/YjP3n9+PtA28j6WYSWtZribmPz8WAkAEipi2dTqdD//79kZGRAQB49tlnsXjxYpFTEVVMVl4eTv/5JyyLFkFZzgBczsZDjszd3R03b95EfHw8+vbti7Fjx2L8+PH4v//7vxLHvv7661AqlWjbti0aNWqEqKgoNGnSBADwyCOP4PLlywCAL774QniPRCLBn3/+Waz706pVqzBx4kT06NEDAPDCCy+gb9+++OijjxAbG4uePXti5syZePHFF3Hr1i389NNP8CoyHmX06NHCNONvvfUW1qxZg6+//hovv/yyvX89AFhUEFEtdyLlBF7q8BI2hG0otv+367+h/9b+WP38aozsOBLHrh7D858+j3qKeujZvKc4YUthsVgwcuRI/PnnnwAKZsv67LPPIJVKRU5GVDE5RiNkubkY4O6O5v7+pR7D2XjI0T3yyCPYtWsXPvzwQyxZsgRKpRKvvvoqunXrVuJY/yJ/z6VSKerVqyds3znbYXkuX76MQ4cOYc2aNcI+k8mEp556StieNGkS3nvvPTz66KNo3759sfe3bt1aeC6RSBAUFIQbN25U6Nq24JgKIqrVTqScwEONSo472H52O7o3646xD46Fq4srHrvnMQxvNxxrTq4p5SziWbhwIXbt2gUA8Pb2xueffw5fX19xQxHZIEChQCMvr1Ifd5tClEhsV65cQYMGDfDNN9/g1q1b2LRpExYuXIicUmaRstf03kFBQZg9ezZu374tPDQajTBZBwCMGzcOffr0QWJiYrHiAwCSk5OF5xaLBVeuXKnWcYtsqSCiWstiteC367/BQ+aBJT8tgdlixnOtn8N7vd6D2WKGh5tHseNdJC74K/0vkdKWlJCQgNmzZwMo+E/q008/xf333y9yKiKi6pNWgRW1hXUq8vNtXqeisk6cOIEJEybghx9+QIcOHdCgQQMAwJkzZyp9rtJYrdYS+8aPH49XX30VTz31FDp37oyTJ0+iT58+iI6OxquvvoqVK1fit99+w5kzZ3D06FEMGTIEPXr0QJs2bQAUTOYxaNAgtGvXDosWLYLFYkHv3r3tkrc0LCqIqNZK06fhgYYPYFDoIOxsuxPphnRE7Y3CiD0j8PZjb+OJTU9gl2YXwu4Pw8/XfsbWs1vhryi9e0ZNO3PmDEaMGCFsL1q0CM8//7yIiYiIqo9SqYQsIAC709PvuoaEvVbULm+Mz53Cw8Px999/o1+/fkhPT0eDBg2wYsWKav2iZ9CgQdDpdBg1ahSuXLkCPz8/TJs2Da+88gr++OMPvPHGG9i5cyf8/f3Rr18/REREYOjQofjll18AFMwAVTib6QMPPIBvvvmmWrsXsqggolrn2rVrOH/+PFq3bo3Dow4L+5v5NMOSXkvQdW1XbA3fis0DNmPu/83F+C/G47Fmj2FUx1E4cuWIiMkL3Lx5E2FhYcLc50OGDMEbb7whcioiourj4+ODydHRMFSgFcFisSA7OxteXl5wcbGtJ78ts43NmjULs2bNKrG/sJWhefPmJVocCgdlF9q4cWOlrjly5EiMHDmyxP4OHTogNze32L4NG4qPHWzTpg127NghbFssFmRlZVXq+pXBooKIapXVq1dDpVIBACQNJeg9ozf2T9svfJuVZ86Di8QFBqMBbQLb4PTE08J7I3ZGlDr+oiaZTCZERETg4sWLAIAHHngA69ats1sfXSIiR+Xj41OhG32LxQIPDw94e3vbXFSQ/fFPgohqjWvXruGVV14Rtq0GK77O+BrvfPUOTBYTrmRewYzvZmBkx5G4fPsyuq7tij9u/AGTxYRtZ7ZhX+I+TOo8ScSfoGD9ie+//x4AUL9+fezdu7dSTfRERERiYEtFGdRqNdRqtbDQFBE5vvPnzxefqi8LwCdAQkACYv+IhburO4a0HYIlTy+Bu6s7lj6zFP239Ue6IR33B9yPfUP3oU39NqLl37hxI1asWAEAkMlk2LVrF5o1ayZaHiIick6HDh2q8WuyqCiDSqWCSqVCVlYW58wmchKtW7cuMQe49JoUXw/+utRp9F5+6GW8/FD1LAJUWcePH8eECROE7VWrVqF79+4iJiIiIqo4dn8iolojKCgI8fHxwsJwUqkUcXFx1Tovtz2kpKRg4MCByM/PBwBMnDgR48ePFzkVEVH1qegCcFQz7PHnwZYKIqpVxowZg969eyMpKQmtWrVy+IIiNzcXAwYMwPXr1wEAPXr0wMqVK0VORURUPdzc3ODi4oKUlBQEBgbCzc2t0hNRWCwW5OfnIzc3lwO1K6G035vVakV+fj7S0tLg4uICNzc3m8/PooKIap2goCCHLyaAgg/z8ePHC3OK33PPPdi5cydkMpnIyYiIqoeLiwtatGiB69evIyUlxaZzWK1W5OTkQKFQcGa8Sijv96ZUKtGsWbMqFWksKoiIRLJixQps3rwZQMEH+t69exEYGChyKiKi6uXm5oZmzZrBZDLZNCGO0WjE4cOH0aNHD34JUwll/d6kUilcXV2rXKCxqCAiEsG3336L119/XdjeuHEjOnbsKF4gIqIaJJFIIJPJbCoKpFIpTCYT3N3dWVRUQnX/3tgRjYiohiUlJSEiIkIYGPf2229j8ODBIqciIiKyHYsKIqIalJWVhX79+uH27dsAgL59+2L+/PnihiIiIqoiFhVERDXEYrFgxIgROHfuHAAgNDQUW7Zs4ewlRETk9Pg/GRFRDZkzZw727dsHAPD19UVCQgK8vb1FTkVERFR1LCqIiGrAjh07sGDBAgAFUypu27YNrVq1EjkVERGRfbCoICKqZr///jtGjhwpbL///vt45plnxAtERERkZ3WuqNi7dy9GjRoldgyiWuOv9L/Qe0tv+L7ri2bLm2Hh4YWwWAtmNfr52s/ourYrPBd5osXKFlj32zqR09a8tLQ09O/fHwaDAQAQGRmJadOmiZyKiIjIvupUUfHmm2/izTffhNVqFTsKUa2gy9eh95beaObdDMnTk3Fk1BFsO7sNMf8Xg1s5t/Dcp88hsn0kbr95G+v6rcO0b6bhl+RfxI5dY4xGIwYPHox//vkHANC5c2fExcVxBVgiIqp16lRR0blzZ6xZs0bsGES1xo9XfkSqPhXq59XwcPPAPb734O3H3saak2uwU7MT/gp/qLqo4OriiidbPInh7YZDfUItduwaM3XqVPzf//0fAKBRo0bYs2cP3N3dRU5FRERkf7WuqNiwYQM6duxY7JGSkgIACA8P5zeERHZktpjhJnWDzOW/lTldJC7Q6rX46dpPaNegXbHjQwND8ceNP8o8382cm4jcEwn/Jf6o91499N/aH9ezrwMAJn4xEfIFcngu8hQe8b/GV88PZgfx8fFYvXo1AMDNzQ27d+9GkyZNRE5FRERUPVzFDmBvo0aN4pgJohrSrVk3KFwVmPXDLMx+fDbS9Gl4/6f3AQASSOAh8yh2vFKmhC5fV+b5wreHo557PVx49QKkEilGJozEuH3j8MWwL3Ai5QTiX4hHVMeoav2Z7OHHH3/E5MmThe24uDg8/PDDIiYiIiKqXrWuqCCi6nft2jWcP38erVu3xlfDv8L0b6ej6fKmaOXXCpEdInEi5QSkEimyjFnF3mcwGuAl9yr1nL+m/Irj145D+7oW3vKCtRv+1/d/uJ59HXmmPJxOPY2HGj9U7T9bVV25cgUDBw6E0WgEUNAFqujMT0RERLVRrev+VFV5eXnIysoq9iCqK367/ht6bOgB33d90WhZI0z5agryTHkA/pvJST5PjqZLm+LJ155EsxbNsHX7VhyIPICMmRn4eezPkEqkCA0MRZcmXXA27Wyx82vSNGhbv22p1/4l+ReEBobif7/+D60+bIVGyxrhtW9fQyOvRvhD+weMZiNmH5qNBksbIDg2GO/9+J4wy5SjMBgM6N+/P9LS0gAATz31FN5//32RUxEREVU/hy8q0tLS0KpVKxw6dEjYl5qaiv79+8PX1xcBAQGYOnUqTCZThc7Xs2dPbNy4sczXFy9eDB8fH+HRtGnTKv4ERM7BYrXghU9fwKDQQbj5xk2cGHcC31z4BkuOLhFmcurbrC/y5+cDnwN4FrA2smLJ9SVYdmAZrFYrfk35FQuPLMTUrlMxMGQgbuhuYMXxFTCajVh2bBnif4vHLs0uNFzaEK/sfwU5xhwAwP7z+zH/8Hz8dv03LPpxEeb3nI/fJ/yO5KxkRO6JRGZuJno274lXu7yKa9OuYcvALfjwlw+x7Kdl4v7SirBarRgzZgxOnToFAGjZsiW2bdsGV1c2CBPZS25uJrKzryM7+zp0Oi0MhmxotVpcv3692CMzM1PsqER1jkP/b3f06FFERUXhwoULxfZHRESgSZMmSElJwY0bN9CvXz8sX74cM2bMqPI1Z82ahenTpwvbWVlZLCyoTriVcwvXdddhsVqEaZddJC5QypTYdW4X/BX+6CbrBlgAXALwJ4BOALYC8YHxmPfLPNT3qI83ur2BcZ3GAQC+e+k7TPl6CqIPRkOfr8foB0Yjvm88tDotntnyDOYfnI93R74LjAWebf4svjd8j23h2zBw+0B8PvRzLHxyIbqu7Yqtg7biQNQBIWuXJl0wtetUbDu7DTO6Vf3fvT0sWbIEW7duBQB4enri888/h7+/v8ipiGqP3NxMnD4cA5khHQBgNBqQl/c3Pl10FUqlstixsoAATI6Oho+PjxhRieokhy0qNm3ahNmzZ2PJkiUYMmSIsD8pKQmHDh1CcnIylEolWrZsiejoaMycOdMuRYVcLodcLq/yeYicjb/SH9MenobXvn0Nr3/7OsxWM8LuC8O0R6bhtW9eQ7sG7dC6dWu4uLjAYrEAaQAeBKTXpDgQcQBBQUElzvlQ44dwdPRRAEB2Xja85F6wWq3IyMlATn4OEk8lAm0AXAG+2fYNMAzoEtQFw9sNx5qTazDt4YJF4vac2wOD0YAJD00Qzp1nzoNCpqiJX81dffnll5g1a5awvXnzZrRp00bERES1j9FogMyQjr6uCvjKlMiTypELBR6rVw+enp7CcWkGA3anp8NgMLCoIKpBDtv9qXfv3rhw4QIiIiKK7T979iz8/PzQuHFjYV9oaCiuXLmC27dv2+36arUaoaGh6Ny5s93OSeTILFYLFK4KrOqzCvq39Dgz8Qw0aRrMOTgH2fnZ8JB5ICgoCLGxsQVvMAJwK5jZqLSC4k6FA7SbLm+Kdmva4cIfF7Aneg8gAZAPWJOssGZYMXTrUJgtZpxJPYO3D7yN/vf3h6ebJ6Z9Mw0/XPwBVqsVx64ew8qfV2JCpwnlX7QG/PXXXxg2bJjQujNv3jz0799f3FBEtZivTAl/uRf83TzhJ5OjoacnGnl5CY/AO1otiKhmOGxR0bBhw1L7ImdnZ8PD445pKv/9ANHpyp6qsrJUKhU0Gg1OnDhht3MSORq9Xg+JRAKJRAL1ATV2nduFiZ0nQu4qR5v6bTDn8TlYfXI1PGQeMBgNAIBJkybh6tWreOW1V9CmVRuMGTOmUtc8/8p5JE9PLuhG9SKAvwDcC+A+AJuAG7dvYO2ptfgr/S8EeQdhfdh6DAgZgOW9l2PS/knwXOyJEXtGYF7PeRjRfoSdfyOVc/v2bYSFhQkTOoSHh+Odd94RNRMREZEYHLb7U1k8PDxgMBiK7Svc9vIqfapKIipJr9cjPv6/xeOmRE+BXx+/YsfIpDK4Sd3Qtn5bfHvxW2F/UFAQjD5GPKB84K7XKOyWkJiYiODgYChkCihkCuyYsAODvx0M7AKwB0BPAF5AgHcApodMx5ErR7Cp/ybhXBMemlCs+5PYzGYzhg4dir///hsA0L59e2zcuBEuLg77XQ0REVG1cbr//dq2bYuMjAxotVphn0ajQVBQEPtOElWCp6dnsUkJrElWZORn4I0v3oDZYsbFWxex4PACjGg3osRMTgcvHcQnpz/B6I6jyzx/saKlKXBf7H2IWxsnvN6gcQO4whWQAkgFpPFSrA1ei29GfYOrWVfxUCPHXpPirbfewtdffw0A8Pf3x969e4v16yYiIqpLnK6lonXr1ujevTumTp2K+Ph4pKenIyYmptJdMO5GrVZDrVbDbDbb9bxEDisNwKfAvnr7EHcmDj7uPhjRbgTm9JwDN6mbMJPT7IOzEegRiA/7fIgnWjxR5umK3WBrAciAibsm4umnn4bUR4rXv3sd4x4ahz6H++DFL19EQr8EPNnuSWw7sw37EvfhxDjH7Xr4ySefYMmSJQAAqVSKHTt2oEWLFiKnIiIiEo/TFRUAsHPnTkyePBktWrSAi4sLIiMjER0dbddrqFQqqFQqZGVlsQWEaqXExESEhIQUzOT0L+k/Unz74rd3ncmp0vIBbAGsz1rRYUsH+Hv4Y0T7EYjuEQ25qxzLLcsx4dAEpO9Px/0B92Pf0H1oU98xZ086efIkxo4dK2yvWLECTzxRdnFFRERUFzhFUVE4q0qhBg0aYMeOHSKlIaodgoODERsbC5VKBaDgG/eKzuRUESWKljRA+qkU5y6fK3GNlx96GS8/9LJdrludbty4gQEDBiA3NxcAMHbsWOH3R0REVJc53ZgKIrKfwpmcDh48iMuXL9u1G2Fh0VLI3kVLTcvLy0N4eDiuXbsGAHj00UexatUqSCQSkZMRERGJzylaKsTAMRVUVwQFBVXbjf6kSZPQr18/JCUloVWrVk5bUFitVqhUKvz0008ACn5nu3bt4kKZRERE/2JRUQaOqSCyj+osWmqKWq3GunXrAADu7u7Ys2cPGjZsKHIqIiIix8HuT0RE5Th48CCmTp0qbK9btw4PPeTY090SERHVNBYVRERluHTpEgYPHix0g5w5cyaGDRsmcioiIiLHw6KiDGq1GqGhoejcubPYUYhIBDqdDmFhYcjIyAAAPPvss1i0aJHIqYiIiBwTi4oyqFQqaDQanDjhuAtwEVH1sFgsGDlyJE6fPg2gYCarzz77DFKpVORkREREjolFBRHRHRYuXIhdu3YBALy9vZGQkABfX19xQxERETkwFhVEREXs3bsXs2fPBgBIJBJ89tlnuP/++0VORURE5NhYVBAR/evMmTN46aWXhO3FixfjueeeEzERERGRc2BRUQYO1CaqWzIyMhAWFgadTgcAGDJkCGbOnClyKiIiIufAoqIMHKhNVHeYTCZERETg4sWLAIAHH3wQ69atg0QiETkZERGRc2BRQUR13owZM/DDDz8AAOrXr489e/ZAqVSKnIqIiMh5sKggojpt48aNWLFiBQBAJpNh165daNasmbihiIiInAyLCiKqs44fP44JEyYI26tWrUL37t1FTEREROScWFQQUZ2UnJyMAQMGID8/HwAwadIkjB8/XuRUREREzolFBRHVObm5uRgwYABu3LgBAHj88ceFLlBERERUea5iB3BUarUaarUaZrNZ7ChEVEl6vR6enp4AAJ1OBw8PD+E1q9WK8ePHCzO73XPPPdixYwdkMpkoWYnqotzcXBiNRmFbp9PBYDBAq9UCALRardCKSETOgUVFGVQqFVQqFbKysuDj4yN2HCKyUXJyMoKDg4Xt5cuXY/PmzQAApVKJvXv3IjAwUKx4RHVObm4uDh/+BQaDRdh305iH3/JycHnRZiiVXjAYsnH27EX4+eXCy0vEsERUYez+RES1il6vR3x8vLAdEhKC1atXAwC+/fZbzJgxQ3ht48aN6NixY01HJKrTjEYjDAYLXF1DoFB0gkLRCe7u7SGXB6NevZfg7z8B7u7PIS/PCqPRJHZcIqogtlQQUa1S2O2pkMVigUqlQrt27RAREQGLpeDb0XfeeQeDBw8WIyIRAZDJlJDLC5oh5ABk5jx4ejaAl1cj6HRaccMRUaWxpYKI6oQRI0bg9u3bAIC+ffti3rx54gYiIiKqRVhUEFG59Ho9JBIJJBIJ9Hq92HHuKjExES4uJT/arly5AgAIDQ3Fli1bSj2GiIiIbMP/VYmoVgkODkZsbKywLZFIhOe+vr5ISEiAt7e3GNGIiIhqLRYVRFRhycnJYkeokEmTJuHq1auYPXs2rFYrAMDFxQXbtm1Dq1atRE5HRERU+7CoKINarUZoaCg6d+4sdhQiUej1+jJnUnKGblDp6elYunSpsL106VI888wzIiYiIiKqvVhUlEGlUkGj0QgLZBHVNZ6envD09MT06dOFfYUzKd05w5KjSUtLQ//+/WEwGAAAkZGRmDp1qrihiIiIajEWFURUqxiNRgwaNAj//PMPAKBLly6Ii4srNraCiIiI7ItFBRGVSqfTlTqTklQqRWJiokip7m7q1Kk4fPgwAKBRo0bYs2cP3N3dRU5FRERUu7GoIKpl7DUFrIeHR4mZlKRSKeLi4hAcHGyPqHYXHx8vrJ7t5uaG3bt3o3HjxiKnIiIiqv1YVBBRuaKiooTnGo0GY8aMETFN2Y4cOQKVSiVsx8fH4+GHHxYxERERUd3hKnYAInIeTZo0ETtCqa5cuYLw8HCYTCYABV2gihZDRFSzdDodXM1mAIDeYIDJZILBYEB2djb0ej3M/75GRLUHiwqiWiw5ObnKXZU8PDyEtR4ckcFgQP/+/ZGWlgYA6NWrF95//32RUxHVTXl5eQCA//u/34G8fADARUM2MjKy8PPPGlxSXoXRmIfU1Fto0cIkYlIisjd2fyJycoXrSTj7uhK2sFqtGDNmDE6dOgUAaNmyJbZt2wZXV35fQiQGo9EIAJBKg6FQdIJC0Qly91BIpd6Qu4dCoegEV9fWMJsBs9kicloisif+z0vk5MpbM6JwXQmVSuXQrQ22eu+997B161YABb+Hzz//HH5+fiKnIiKZTAm5RAkAkOfr4OLiWrBP7oX8/Nr5JQdRXceWCiJySl9++SXeeustYXvLli1o06aNiImIiIjqLhYVRE5Op9MJD2dcV8IW586dw7Bhw4TWl/nz5yMsLEzkVERERHUXi4oyqNVqhIaGonPnzmJHISqXh4eH8HC2dSVscfv2bYSFhSErKwsAEB4ejrffflvkVERERHUbi4oyqFQqaDQanDhxQuwoRJXiLOtK2MJsNmPo0KE4f/48AKB9+/bYuHFjidYZIiIiqlkcqE1UiznquhK2mjVrFr7++msAgL+/P/bu3VvuQHUich5Gcz50Oi0AwGBIg8mUC4MhFdnZBf/GdTotzOZ8MSMSUTlYVBCRU/jkk0+E9SekUil27NiBFi1aiJyKiOxBb8pDqvZP4MdFkMmUMBhuwitDA+3Py5Ct9AYA5BoN0KWehamFHwAvcQMTUQksKohqGUdfrM4WJ0+exNixY4XtlStX4oknnhAxERHZU77FCIUpFy9I3VFf4Q+dxYwrUjc0c/eFp6IeAOCy1YIEcx7MZqPIaYmoNCwqiMih3bhxA/3790dubi4AYOzYsZg0aZLIqYioOvjIFPCXe8EtX49MF1f4yTzgJS9olbiVrxM5HRGVh6Mbichh5eXlITw8HMnJyQCARx99FKtWrYJEIhE5GRERERXFooKIHJLVaoVKpcJPP/0EAAgKCsLu3bshl8tFTkZERER3YlFBRA5JrVZj3bp1AAB3d3fs3bsXDRo0EDkVERERlYZFBRE5nIMHD2Lq1KnC9rp169CpUyfxAhEREVG5WFQQkUO5dOkSBg8eDLPZDACYOXMmhg0bJnIqIiIiKg+LCiJyGDqdDmFhYcjIyAAA9OnTB4sWLRI5FREREd1NnSgq8vLy8OKLL6JHjx54+OGHcfz4cbEjETkUvV4PiUQCiUQCvV4vSgaLxYKRI0fi9OnTAIDg4GB8+umnkEqlouQhIiKiiqsTRcXGjRsRHByMw4cPY9OmTZg2bZrYkYjoDgsWLMCuXbsAAN7e3khISICvr6+4oYiIiKhC6sTid8OGDRPmtTebzZySksjB7N27F3PmzAEASCQSfPbZZ7j//vtFTkVEREQVVauKig0bNmDlypXF9u3fvx+NGzcGAKSnpyMyMhLLly8XIx4RleLMmTN46aWXhO3FixfjueeeEzERERERVVatKipGjRqFUaNGlfra+fPnER4ejgULFuCxxx6r4WREziM5ORnBwcE1cq2MjAz069cPOp0OADB06FDMnDmzRq5NRERE9lOrioqyJCcno1+/fti4cSO6du0qdhwi0ZQ1CDs+Pl54HhISgtjYWERFRQn7PDw87J7FZDIhIiICly5dAgA8+OCDWLt2rdBVkYiIiJxHnSgqFi5ciOzsbLzxxhsAgMDAQOzYsUPkVEQ1z9PT867HWCwWqFQqqFQqYZ/VarV7ltdffx0//PADAKB+/frYs2cPlEql3a9DRERE1c+hZ39KS0tDq1atcOjQIWFfamoq+vfvD19fXwQEBGDq1KkwmUzlnmf16tW4du0aDh06hEOHDpVbUOTl5SErK6vYg4jsq+j4J5lMhl27dqFZs2YipyIiIiJbOWxRcfToUTzyyCO4cOFCsf0RERHw9PRESkoKfvnlF3z//fd2HXi9ePFi+Pj4CI+mTZva7dxEYtPpdCUeiYmJcHEp/lEglUqRmJgoHGNPx44dw8svvyxsq9VqdO/e3a7XICIioprlkEXFpk2bMGzYMCxcuLDY/qSkJBw6dAhLliyBUqlEy5YtER0djVWrVtnt2rNmzUJmZqbwuHr1qt3OTSQ2Dw+PEo/g4GDExsYWO+7DDz9EcHCwcIy9JCcnY+DAgcjPzwcATJo0CePGjbPb+YmIiEgcDllU9O7dGxcuXEBERESx/WfPnoWfn58wRSwAhIaG4sqVK7h9+7Zdri2Xy+Ht7V3sQVTbFR2UXdq2PeTm5mLAgAG4ceMGAODxxx/HihUr7H4dIiIiqnkOWVQ0bNgQrq4lx5BnZ2eX+Na0cGCnvbtoqNVqhIaGonPnznY9L5EzSE5Otuv5rFYrxo8fjxMnTgAA7rnnHuzYsQMymcyu1yEiIiJxOGRRURYPDw8YDIZi+wq3vby87HotlUoFjUYj3AQR1QZ6vb7MR1EhISFYvXp1ma9X1vLly7F582YABV8EJCQkIDAwsErnJCIiIsfhVEVF27ZtkZGRAa1WK+zTaDQICgqCj4+PiMmInIOnp2epjwYNGhQ7rnBa2aLH2Orbb7/FjBkzhO2NGzeiQ4cONp+PiIiIHI9TFRWtW7dG9+7dMXXqVGRnZ+PSpUuIiYnBmDFj7H4tdn8iqrrz588jIiICFosFAPDOO+9g8ODBIqciIltlZmbi+vXrwkOr1cJgMECn0yE7Oxv6O3oTEFHd4XSL3+3cuROTJ09GixYt4OLigsjISERHR9v9OoWLf2VlZbEVhGqNssYenT9/Hg888ECxfVKpFBqNBk2aNLHpWllZWQgLCxMmUejXrx/mzZtn07mISHyZmZmIiVmF9HSjsM9gyMbN3/7GEbkCfjI5jC5WuD39NMxmkxPeYRBRVTj8P/k7V/Jt0KABV8MmslFZ08O2bt262LZUKkVcXByCg4Ntuo7FYsGIESNw7tw5AAWztG3evLnEehhE5DwMBgPS041QKAZCqSwYEyWXa6GXX4W7ez0o3DxhNd8CAJjNFie4wyAie+I/eSKCh4cHdDqdMHZCo9HYXFAAwOzZs7Fv3z4AQL169ZCQkMDpmYlqCaUyEF5ejYRtmUwJuZsn5HIv5OXlwVrOe4mo9uLXhmXgmAqqy2zt8gQA27dvFxaudHFxwbZt29CqVSt7RSMiIiIHxKKiDJxSlqjyfv/9d4waNUrYXrp0KZ5++mkRExEREVFNYFFBRHaRlpaGsLAwYe2YyMhITJ06VdxQREREVCNYVBBRlRmNRgwaNAhXrlwBAHTp0gVxcXGQSCQiJyMiIqKawKKiDBxTQVRxU6ZMweHDhwEAjRo1wp49e+Du7i5yKiIiIqopLCrKwDEVRBUTFxeHNWvWAADc3Nywe/duNG7cWORUREREVJM4pSwRASiYVvbOdWHu5siRI5g8ebKwHR8fj4cfftje0YiIiMjBsaWCiGxy5coVhIeHw2QyAQCmTp2KqKgokVMRERGRGFhUEFGlGQwG9O/fH2lpaQCAXr164f333xc5VdXp9XpIJBJIJBL8/fffYschIiJyGiwqysCB2kSls1qtGD16NE6dOgUAaNmyJbZt2wZXV+fuTanX6xEfHy9sh4SEYPXq1SImIiIich4sKsrAgdpEpXvvvfewbds2AICnpyc+//xz+Pn5iZyq6jw9PTF9+nRh22KxQKVS4dq1ayKmIiIicg4sKoiowr744gu89dZbwvaWLVvQpk0bERNVv6SkJLEjEBEROTybiwqNRoN33nkHjzzyCBo2bAiFQoGmTZuie/fuWLhwIf766y975iQikZ07dw7Dhg0TZoiaP38+wsLCRE5lP4mJiXBxKf6RKJVK0apVK5ESEREROY9KFxWJiYno378/2rVrh48//hiNGjXCsGHD8PrrryMsLAz+/v5YsWIF2rRpg4EDB0Kj0VRHbiKqQbdv30ZYWBiys7MBAIMGDcI777wjcir7Cg4ORmxsrLAtlUoRFxeHoKAgEVMRERE5h0qNrFy6dCkWL16MIUOG4Mcff8QjjzxS5rE///wzPvroI3Tr1g2zZs3CzJkzqxyWiGqe2WzG0KFDcf78eQBA+/btsWHDBkgkEpGT2V9UVBRUKhWAgtbY4OBgkRMRERE5h0oVFb///jtOnz5dodVyu3btiq5du2LevHl48803bQ5IROKaNWsWvv76awCAv78/9u7dC09PT5FTVb8mTZqIHYGIiMhpVKqo2LJlS6Uv0KxZM3z66aeVfp/Y1Go11Go1zGaz2FGIRPPJJ58I609IpVLs3LkTLVq0EDlV9bFlVXEiIiLi7E9l4pSyVNedPHkSY8eOFbZXrlyJnj17iheIiIiIHFaVV6v66quvcOTIEdy6dQv169dHr1698Nhjj9kjGxGJ5MaNG+jfvz9yc3MBAGPHjsWkSZNETkVERESOyuai4ubNm+jTpw9OnDgBmUwGf39/pKenY8GCBXj22Wexe/duyOVye2YlohqQl5eHgQMHIjk5GQDQrVs3qNXqWjkwm4iIiOzD5u5PU6dOxYULF7Bnzx7k5uYiJSUFubm52LFjB44fP17rppskqgusVitUKhWOHTsGAAgKCsKuXbvg5uYmcjIiIiJyZDYXFV9++SXee+89hIWFCd9guri4YODAgVi0aBE++eQTu4UkopqhVquxbt06AIC7uzv27t2LBg0aiJyKiIiIHF2VBmqXdbPRrFkz6HS6qpyaiGrYgQMHMHXqVGF73bp16NSpk3iBiIiIyGnYXFSMHDkSCxYsKFE8mEwmxMbGIioqqsrhiAjQ6/WQSCSQSCTQ6/XVco1Lly5h8ODBwhTKM2fOxLBhw6rlWkRERFT72DxQW6lU4u+//0bz5s3Rt29fNG7cGBkZGfj6669x7do1DBkyBKNHjwYASCQSoUuFs+A6FVRX6HQ6hIWF4ebNmwCAPn36YNGiRSKnIiIiImdic1GxZcsW+Pj4AAAOHTok7JdIJGjatCmOHj1abJ+zUalUUKlUyMrKEn5OotrGYrEgKioKp0+fBgAEBwfj008/hVQqFTkZERERORObi4pLly6V+3peXh6nlCVycAsWLMDu3bsBAN7e3vj888/h6+srbigiIiJyOjaPqRg1alSZ/btPnDiBBx54wOZQRFT99uzZgzlz5gAoaE387LPPcN9994mcioiIiJyRzUXF9u3b0aFDB2E+e6BgkPbbb7+NRx99FPn5+XYJSET2d/r0abz00kvC9uLFi/Hcc8+JmKhmBqQTERFR9bC5qDh16hQCAwPx+OOPY86cOThx4gQefPBBvP/++5g2bZrQR5uIHEtGRgbCwsKEG/ehQ4di5syZIqciIiIiZ2ZzUREcHIyjR49iwYIFWLRoER5++GFYLBacPHkSS5YsgUKhsGdOIrIDk8mEiIgIYUzUgw8+iLVr1zrlZApERETkOKq0+F1SUhK+/vprmM1mBAUF4cKFC/j8889hMpnslY+I7Oj111/HDz/8AACoX78+9u7dC6VSKXIqIiIicnY2FxXz589Hhw4dcP78eXz11Ve4cOECXn/9dcyfPx+dOnXCiRMn7JmTiKpow4YNWLlyJQBAJpNh165daNq0qcipSpecnCx2BCIiIqoEm4uKuXPnIiIiAmfOnEHv3r3h6uqKmJgY/PTTTzCZTHj00UftmZOIYPvN9rFjx/Dyyy8L22q1Gt27d7dXrErR6/WlPuLj44VjQkJCsHr1auE1IiIicmw2r1ORkJCAvn37ltj/0EMP4bfffsPs2bOrFIzI2dnrZvjOm+3Y2FhERUWV+x4PDw/heXJyMgYOHCjMyDZp0iSMGzfOLtls4enpeddjLBaLsAAlAFit1uqORURERFVgc1FRWFCcO3cO3333HVJSUvDKK6/g0qVL6NChA9577z27hSRyRhW5ea6sO2+27yYtLQ0DBgzAjRs3AACPP/44VqxYYfdchfR6vfBz63S6YsUNERER1V42FxVmsxkvv/wy1q9fD6vVColEghdffBHz5s3DxYsX8X//938ICgqyZ9YapVaroVarYTabxY5CZLNXXnlFGN90zz33YMeOHZDJZKJm0ul0JfYlJycjJCQEFotF2CeVSqHRaNCkSZOajEdEREQ2sHlMxYIFC/DJJ59g7dq1uHHjhtA9YdmyZTCbzXj77bftFlIMKpUKGo2GA87JZjqdrsqPxMREuLgU/2cqlUqRmJhY5nu0Wq1w7NatWwEASqUSCQkJCAwMrNHfQVGFi9sVtmR4eHgIj+DgYMTGxgrHSqVSxMXFITg4mK0dRERETsDmlor169dj/vz5GDVqVLFv89u3b4/58+fjzTfftEtAImdlj5vhwpvtwu5ORW+2K2Pjxo3o0KFDlfNUp6ioKOHn1Gg0lf4Z7YHdt4iIiGxjc0uFVqtFx44dS30tKCgIt27dsvXURFRE0UHZGo0GY8aMKff4pKSkYtvvvPMOBg8eXC3ZqosjdHnitLaOy2KxwGAwiB2DiIiKsLmoaNWqFfbv31/qa4cOHUKrVq1sDkVEBYp+cw7c/WY7KysLERERwvbzzz+PefPmVVu+2qK8aW1JfLm5udi4cSMGDx6Mxo0bw83NDV5eXlAqlXjooYcwc+ZM/PHHH2LHJCKq02zu/jR16lRMmDAB+fn56Nu3LyQSCc6fP4+DBw9i6dKl+OCDD+yZk4juwmKxYPjw4UhMTBT2/e9//ysxJqOmJCcni9KFyRalzdRVONNWv379nHrSCWeWk5ODJUuWYOXKlcjMzMT999+Pp556CvXr14e7uztu3ryJixcv4n//+x+WLVuGRx99FEuWLMEjjzwidnQiojrH5qJi7NixSEtLw8KFC7FmzRpYrVYMHToUbm5umDlzZrGFtoio+s2ePRtffPFFsX3e3t52vcbd1t4ob02Nou91poIjKSmJRYVIWrduDQ8PD7zzzjsYPnw4GjRoUOpxVqsVBw8exIYNG/DEE09g1apVGDt2bA2nJSKq22wuKgBg1qxZUKlUOHbsGDIyMuDr64uHH34Yfn5+9spHRBWwfft2LFy4EADg4uJSbGpWe6rM2hvlralR0UX8aopOpytzWlt25RTP/PnzERUVBalUWu5xEokETz75JJ588knMmzcPV65cqaGERERUqEpFBVDwTWjv3r3tkYWIbPD7779j5MiRwvaiRYuKzb7miDMalVZwWK1W0VbOLjqt7Z0zbbGVQjyjR4+u9HtatmyJli1bVkMacia5+fnFptcujVKphI+PTw0lIqr9qlRUWCwW9OrVC3FxcWjdurW9MhFRBaWlpSEsLAw5OTkA/puWtbqmdC5t4bpCycnJuO+++6rlujXFEaa1pfLl5+fDzc1N7BjkwLLy8nD6zz9hWbQISqWyzONkAQGYHB3NwoLITqpUVFitVhw6dAjZ2dn2ykNEFZSfn49BgwYJXT26dOmCjz76qNi6McnJyXadnrW8Vo7g4GB88MEHmD59OoCCb/o//PBDREVFOc2K2R4eHqK1llDFFLYqtWvXDu3atUP79u3Rrl07NG/eXOxo5CByjEbIcnMxwN0dzf39Sz0mzWDA7vR0GAwGFhVEdlLl7k9EZB+lDYK+c1/R7alTp+Lw4cMAgIYNG+KTTz6B2WwuMVh66dKl5V4DsM9CfQAwfvx4oago+k2/vRbxI0pMTMSZM2dw+vRpnD59Gp9++inOnz8Pd3d3tG3bFu3bt8fjjz+O559/3u4TFdR2mZmZJdb/yMrKElpC09LSkJl5E3L5f92KdDotzOb8Gs1ZUQEKBRp5eZV9wL8/FxHZh01Fxfz58wFA+NYxPj4ejRs3Fl6fPXu2HaIR1S0VGQRd1uw3N27cKLULosViEW7yy3u/Pb6dv9uaGuxaRPZQOGaiX79+wj6j0Yhz584JhUZcXBymT5+OnTt3olu3biKmdR6ZmZmIiVmF9HSjsC8/PxdX/jwM99yCQsNkMuL27WzkNEyGu3vBzXqu0QBd6lmYWvgBKOcGnohqPZuKig0bNhTb3rdvn9DHVSKROFxRYTKZ8NJLL+Hq1avw8vLCJ598whmqiETkSF2eyDk0b94c8+bNK3XGMJlMhvbt26N9+/bCvu+//x6TJ0/GqVOnajKm0zIYDEhPN0KhGAilMhBAQSuEj/UiXlC6w0emQE5OBlJu/45mbj7wVNQDAFy2WpBgzoPZbCzv9ERUB9i0KtalS5dw6dIlnD9/HkBBUVG47+LFi3YNaA87d+5EgwYN8OOPP2LIkCFYsWKF2JGIStDpdCUed85e8uuvvyIgIEDYnjx5crHjExMTSyx2V3Q6Tq1WW+p1iBzdlStXcPr0aezfvx9btmzBoUOHyp06uVevXpWaApkKKJWB8PJqBC+vRvD0bACZTIn6HoFo7NUI9RUB8HFxhZ/MA/5yL/jLveDjqhA7MhE5iCottSuRSOyVo1oNGTJE6Fd+5coV9rMlh+Th4VHqo6jRo0cjPT0dQMFN0/Lly4sdWzh2oVDhYOnKXIPIUS1fvhx9+/ZFZGQknnrqKTRq1AiLFi0q8/gjR47UYDoiorqtSkWFo9mwYQM6duxY7JGSkgIAcHV1xfPPP4/Y2Fg888wzIiclss0ff/wBALj33nuxbds2uLqW7MFYtHuIRqNxmAXmiKqqfv36WL9+PY4fP44dO3bgmWeewZw5c9C3b99qW/CRiIgqpkqzP0mlUly6dKnYIG0xjRo1CqNGjSrz9S+//BJJSUl44YUX8Ndff9VgMiL78fT0REJCQoXGBTnD2AVHXJyPHNOSJUvw0ksvASiYQnngwIGYOHEievfujQ8//BBTp04VNyARUR1W5Sll77nnHnvkqFb/+9//kJOTg1dffRVeXl4l+pwTVVZZU7PaW9HpYQutXbsWzZs3LzNDedmSk5M56xI5JXd391JnL3v00Ucxa9YsbNiwgUUFEZGIbC4qbt26hdmzZ+Po0aO4fft2idclEgkuXLhQlWx2ExERgZdeegm7du2CxWJBXFxcmcfm5eUhLy9P2M7KyqqJiORkxBwAOmTIkAofq9fr8cknnwjbISEhiI2NvWuXqKKtBRUtoO4sgOLj4zF+/PhKn4eoNK1bt8Z3331XavfVrl27IiYmRoRUzqO0NSiK0mq1yM93zPUmiMg52FxUjBs3DgkJCejTpw86dOhgz0yCtLQ0PPLII1i7di169uwJAEhNTcX48eNx6NAhuLq6YsSIEVi6dGmpfcsLeXt7IyEhoULXXLx4MebNm2eP+ESiu/ObXYvFApVKJawXUZai61bYWkBNnz692BoZd56XqDJGjBiBt99+GyEhIRg9enSx13755RcolUqRkjm+0taguJPBkI2zZy/Czy8X5a0XR0RUFpuLiu+//x5Lly7FlClT7JlHcPToUURFRZVo7YiIiECTJk2QkpKCGzduoF+/fli+fDlmzJhhl+vOmjWr2I1QVlYWmjZtapdzU+1R3dOwms1m+Pj4VOs1HBG7Z1FZpk+fjjNnzmDs2LH44IMP8Nxzz6Fx48Y4d+4cNm7ciMGDB4sd0WGVtgbFnSwWDfLyYmE0mmo4HRHVFjYXFV5eXrjvvvvsmUWwadMmzJ49G0uWLCnW1SMpKQmHDh1CcnIylEolWrZsiejoaMycOdNuRYVcLodcLrfLuaj2qu7BxDNnzix1/wcffFCsS1Fp9Hq90EJx6tQpdOrUqdjMOFKpFBqNpsKDuCtSQCUnJyMkJKTc6+j1+lK7QBXtNlVa9ywO3Cag4O/Tpk2b0Lt3b8TFxWHZsmVCy1ePHj24/lAFFK5BURqdTlvqfiKiirK5qJg8eTKWLVuG7t27271/ee/evTF8+HC4uroWKyrOnj0LPz+/YrNNhYaG4sqVK7h9+zZ8fX3tlkGtVkOtVsNsNtvtnEQVsWXLFrz//vsACm6kiv4dHD9+fKVuslu3bo3Y2Fihu5NUKkVcXFylWgMqcr3g4GAsXbpUaOUr7ToV+ZworXsWu0xRUcOGDcOwYcNw+/ZtXL16Fb6+vmxNJiJyADZPgzR58mRcu3YNQUFBePjhh/Hkk08Wezz11FM2h2rYsGGpYySys7NL3OAU9qO1d3cUlUoFjUaDEydO2PW8ROU5efIkxo4dK2wvWbKkyue8c92KMWPGVPmcpRk+fLjw/OTJk9V2HSIA8PX1Rbt27VhQEBE5CJuLigkTJiAxMRGNGjWCQqGA1Wot9qiOhYg8PDxKzF5RuO3FkWXk5K5fv47+/fsLs4+NGzeuWFcne6zhUFPrVpS2do1OpyvxSExMLDHFs1QqRWJionAM1V1t27bFnj17Knz89evX8eqrr+Ldd9+txlRERFQam7s/ff7551i8eDHeeOMNe+YpV9u2bZGRkQGtViv0GddoNAgKCrL7oFZ2f6KalJeXh/DwcCQnJwMAunXrhlWrVsFoLHu2FkeWkpKC+vXrF9tXWkEUHBxc5e5ZVHu9+OKLiIyMRL169TB8+HD07NkTDz74IAICAiCRSJCTk4MLFy7g+PHjSEhIwDfffIPOnTvj5ZdfFjs6EVGdY3NLhVwuR+fOne2Z5a5at26N7t27Y+rUqcjOzsalS5cQExNTLd0s2P2JaorVaoVKpcKxY8cAAEFBQdi1axfc3NxETvafwkHW5T3Wr18vHN+pUyesXr261OPuVFPds8j5zJ49G3///TeGDh2KtWvXok+fPmjYsCFkMhkUCgU8PT3RoUMHjB8/HllZWdi6dSuOHj2K0NBQsaMTEdU5NrdUREZGYs2aNejZs2eNrlC9c+dOTJ48GS1atICLiwsiIyMRHR1dY9cnsrdVq1Zh3bp1AApWDd67d2+pKweLqbKTMZS3HkZ5A69rqnsWOY9GjRrhvffew4IFC3D8+HEcP34cKSkpyMnJQUBAAO6//3707NkTQUFBYkclIqrTbC4qfHx88N1336F58+bo0qULvL29i70ukUiEG6WquPMGpEGDBtixY0eVz0vkCA4cOIBp06YJ2+vXr0enTp1ETETkmGQyGR577DE89thjYkchIqJS2FxUbNiwAfXq1QMA/PrrryVel0gktqdyABxTQdXt0qVLGDx4sPB37I033sDQoUNFTlW6uw2Yrsg6FUSVlZ2djSlTpmDfvn3Q6/Xo0qUL5s+fjx49eogdjRyE2Wwq0a1SbzDAZDLBYDAgOzsbQEFR6u7uLkZEojrD5qLi0qVL9szhcAq7bmRlZdXJlY2peul0OoSFheHmzZsAgD59+mDhwoUipyrb3Wadqsg6FUSV9dZbb2Hjxo0ICQmBt7c3fv31Vzz99NP49ttv8fjjj4sdj0RmNudBq9XiyBErZDKZsP+iIRsZGVn4+WcNLimvAgCUShf06NGFhQVRNaq5wRBEBKBgvEFkZCROnz4NALjvvvvw6aefQiqVipysarhOBdnbvn37oFKpcPbsWRw7dgwXL17EQw89VKOzDpLjMptNMJmkcHW9HwpFJ+Ehdw+FVOoNuXsoFIpOcHUNgcFgcdrZ9IicRaVaKkaPHo3o6Gi0aNECo0ePLvdYe42pIKptYmJihLn3vb29kZCQYNfV4B1BaetUEFXWtWvXMHjwYGE7MDAQH3zwAR599FHcunVL6IJLdZurqxJy+X9rVcnzdXBxcYVM9t9+k0msdER1R6WKioMHD2LKlCkACgaYljdugmMqiEras2cP5s6dC6Dg38hnn32G++67T9xQIvPw8Ch3RiiquywWS4nuKu3atYPVakVycjKLCiIiB1KpoqLoOIrLly/bO4tD4ZgKsrfTp0/jpZdeErbfffddPPfccyImsq+i4y4Kn+v1emE6WnusCE51z/Xr14tty+VyAEB+fr4YcYiIqAw2D9QGCmbmyMrKQpMmTZCfn4+VK1fi2rVrCA8P5+wcREVkZGQgLCxMmKVk6NChmDFjhsipiBzfwIEDoVQq0a5dO3Ts2BFt2rRx+pZwIqLayOai4pdffsGzzz6L8ePH491338Wrr76K+Ph4+Pr6Qq1WY/fu3ejXr589sxI5JZPJhBdffFFo6XvwwQexdu3aarsxurM7UWmrWBM5gy+//BK//fYbfvvtN/z66684fvy48Npjjz2G9u3bo1OnTujUqRMefPBBdOjQQcS0RER1m81Fxdtvv437778fEyZMQE5ODrZs2YJJkyZh1apVmDBhAhYuXMiiggjAa6+9hgMHDgAA6tevj71790KpVIqcqnoVdnnSarUiJyFn1qdPH/Tp00fYvnnzplBgFBYba9asgdVqhUQi4Rg4IiIR2VxU/Pzzz9i2bRtatGiBL774Ajk5OUJ/8SFDhmDLli12C0nkrNavX48PP/wQQMHiS7t27ULTpk1FTkXknPz8/NCrVy/06tVL2JeVlYVff/0Vp06dEjEZERHZvE6Fi4uLMGBu//798PX1RZcuXQAUfMg7+zexarUaoaGh6Ny5s9hRyEkdO3YMEydOFLbVajW6d+8uYiJxJScnix2BaiFvb2888cQTwsKLREQkDpuLioceeghr167FsWPHsG3bNrzwwguQSCRITU3Fu+++i4ceesieOWucSqWCRqPBiRMnxI5CTig5ORkDBw4UZqhRqVQYN26cyKlK0uv1kEgkkEgkNo290Ov1xR53Wr9+vfA8JCQEq1evvut7iIiIyPnY3P3p/fffx7PPPoutW7ciMDAQ77zzDgCgbdu2sFgs+Oabb+wWksiZ5OTkoH///rhx4wYAoGfPnli+fLnIqapH4diJssyaNUt4brFYhKmai+IaFURERM7P5qLigQceQFJSEjQaDdq2bSvMP79mzRp069YNDRs2tFtIImdhtVoxfvx4nDx5EgBwzz33YMeOHZDJZCInIyIiIqo+VVqnwsvLC127di22Lzw8vEqBiJzZBx98IExSoFQqkZCQgICAAJFTVR+dTldin16vR4MGDQAUjL2yWCzCa1KpFBqNBk2aNLH5mlxQj4iIyPFUakxFZGSk0KWjoq5du4bhw4dX6j1Ezuibb77BzJkzhe1NmzY5xLz5hetWWK3WKt+AV2Q8xCeffCI8L9q1SSqV4sMPP0STJk3g4eEhPIiIiMj5Vaqo6NChA9q0aYPJkycXW4SoNCdPnsS4ceOEVVCdDWd/oso4f/48hgwZInwrHx0djUGDBomcyv48PT3v+ig6C0/RosJsNkOlUt11HAYRERE5n0p1f3rttdfw/PPP44033kC3bt3QuHFjdO7cGS1atICHhwdu376Nq1ev4qeffkJ6ejpeeOEFHDlyBG3btq2u/NWmcEBpVlYWfHx8xI5DDiwrKwv9+vXD7du3AQBhYWGYO3euqJkqKjU1tdjzFi1aiJim8pKTkxEcHCx2DCIiojqv0mMq7r//fiQkJODMmTP45JNPcPDgQfz444/IzMxEQEAA7rnnHkycOBHh4eFo165ddWQmchgWiwXDhw/HX3/9BQBo06YNNm/eDBcXm2drdmiljaEoKjk5GSEhIcXGURTSarU2dXe6s5tVfHy88DwkJASxsbGIiooCAHanIiIiEonNA7Xbtm2LxYsX2zMLkdOJjo7GF198AQCoV68eEhIS4OXlJXKq6nO3m/bg4GDExsYK08ZKpVKYzWbhvbbc9JfXXerOaWo5PS0REZE4aufXqUQ1YNu2bVi0aBGAglmOtm3bhnvvvVfkVJVjMBhKfV4Vha0GAISpdYmIiKh2Y1FBZIPff/8do0aNEraXLVuGp59+WsREVVfZmd0qonHjxlU+h06nEx6JiYklupZJpVIkJibetWsWERERVZ8qrVNBVBelpqYiLCwMOTk5AAq+mZ8yZUqNZihrOtfK+uyzz4TnzzzzTLHxCaURY8xC0WuW1r0qLi6Og7WJiIhExqKCqBLy8/MxaNAgXLlyBQDQtWtXfPTRR5BIJDWaozqmZb1zfEJpHGHMQlRUlJBRo9GwoCAiInIAVe7+lJ2dbY8cDofrVFBppkyZgiNHjgAAGjVqhN27d8Pd3V3kVHVXVVbmJiIiIvupckvFfffdh5SUFIwbNw7t27cXHvXq1bNHPtFwnQq600cffYSPPvoIACCXy7Fnzx67jBkoT+Fq2Heyx/iB0qZ/lUql0Gg0vFknIiKiSqlyUXH58mUAQLt27fDHH39g8+bN0Gg08PX1FQqMd999t6qXIRLVkSNH8Morrwjb8fHx6Nq1q2h57DG2ITg4GHPmzMGcOXMAFMxgZe/xCWUVRURERFS7VLmocHNzAwC8+uqrwj6r1YqkpCT8+eefOH36dFUvQSSqf/75B+Hh4TCZTACAadOmITIyUuRU9hEeHi4UFR9++CHGjBkjciIiIiJyRlUqKtavX4+EhASkp6ejadOmeP755zF06FC4urqidevWaN26NcLDw+2VlajGGQwG9O/fH2lpaQCAp59+GkuWLBE5VcEMVPbw+uuvC88nT56Mw4cPIzY2ttz31K9f3y7XthVbP4iIiByPzUXF3LlzMX/+fDRs2BCtWrXCyZMnsX37dsybNw87d+5Ex44d7RiTqOZZrVaMHj0av//+OwDg3nvvxdatW+HqKv6kaQ0aNKiW827fvh3bt28v9xje0BMREdGdbJ79af369Rg6dCiuXLmCw4cPIykpCceOHUNQUBAef/xxJCYm2jMnUY179913sW3bNgAFU7gmJCTAz89P5FREREREjsfmr1zT09MxevToYt/adu3aFQcOHECvXr3w1ltvYdeuXXYJSVTTvvjiC7z99tvC9pYtW9CmTRsRExV38eLFKp/jjz/+wIABA0rs37NnDzp06ACgoPtX27ZtAQBnzpyBUqm863nZPYmIiKjusbmoCA4OhlarLbHfxcUFr776KkaOHFmVXESiOXfuHIYNGybcGMfExCAsLEzkVMW1bNmy2s5dWqEBQCguWDAQERHRnWzu/jR58mQsWrSo1PnyFQpFja8wTGQPt27dQlhYmLCo46BBg4q1WFDdoNfrIZFIIJFIoNfrxY5DRETk8GwuKuLi4nDlyhU8+OCD+PTTT5Gfnw8AyMrKwrJlyxzum12iuzGbzRg6dCjOnz8PAGjfvj02btzokAWyTqer8iMxMREuLsU/AqRSKRITE4VjirZGarVauyy652ySk5PFjkBEROTwbC4qGjZsCC8vLyQlJWHEiBHw9vZGUFAQAgMDcf78eUycOJHdJMipvPnmm/jmm28AAP7+/khISLDLInPVwcPDo8qPwsXvChVd/K7ocXdeszbT6/XQ6/WIj48X9oWEhGD16tUipiIiInJ8NhcV+/btQ3JyMq5du4Y9e/ZgxowZaNeuHby9vfHPP//g0UcfhY+PD3r27IkZM2bYM3ONUKvVCA0NRefOncWOQjVgy5YtWLp0KQDA1dUVO3fuRPPmzcUNVQOKriPz7bff1vnF7zw9PeHp6Ynp06cL+ywWC1QqFa5duyZiMiIiIsdmc1FRqHHjxggLC0NMTAy++uorpKWl4eLFi9i2bRsmTpwIqVSKdevW2SNrjVKpVNBoNDhx4oTYUaianThxAmPHjhW2V65ciZ49e4oXSCQNGzYUO4JDS0pKEjsCERGRw6qWVbyaN2+O5s2bY9CgQdVxeiK7uX79Ovr374+8vDwAwLhx4zBx4kSRUzmm5ORkBAcHix2jWul0OiQnJyMkJAQWi0XYL5VK0apVKxGTERERObYqt1QQOau8vDyEh4cjJSUFANCtWzesWrXKIQdmV1XhWIE7HwaDQTjGYDCUeL20sQVlnas2KBxrEhsbK+yTSqWIi4tDUFCQiMmIiIgcW7W0VBA5OqvVikmTJuHYsWMAgKCgIOzatQtubm4iJ6senp6edz2mS5cu5b5eOLZApVKV+nptmpghKipK+Dk1Gk2tb6EhIiKqKhYVVCetWrUK69evBwC4u7tj7969aNCggcipyFFwVXAiIqLKYVFBdc6BAwcwbdo0YXv9+vXo1KmTiImqX1nrS2g0GqGF4pdffkFoaKjwWlljCzQaDZo0aVK9gYmIiMipsKigOuXixYsYPHgwzGYzAOCNN97A0KFDRU5V/cpaX0KpVBZ7XvS4wrEFhd2ACscWsCsQERER3YkDtanO0Ol0CAsLw82bNwEAzz33HBYuXChyKscWFRUlPNdoNHV+HQsiIiIqHYsKqhMsFgsiIyNx5swZAMB9992HTz/9FFKpVORkzoNdnoiIiKgsLCqoToiJicGePXsAAD4+PkhISICPj4/IqYiIiIhqBxYVVOvt2bMHc+fOBQBIJBJ89tlnuO+++8QNRURERFSLsKigWu306dN46aWXhO13330Xffr0ETERERERUe1Tp4oKrVaLevXqiR2DakhGRgbCwsKE1Z6HDRuGGTNmiJzKsdw5+xMRERGRLepUUfHGG28gPz9f7BhUA0wmE1588UVcunQJAPDggw9i7dq1kEgkIicjIiIiqn3qzDoVBw4cQEBAAAIDA8WOQjXgtddew4EDBwAA9evXx969e6FQKERORUREjiI3Px9arbbcY5RKJSf1IKqgWlVUbNiwAStXriy2b//+/QgICMDChQuRkJCAnTt3ipSOasr69evx4YcfAgBkMhl2796Npk2bipzK8bVs2RJAwXoeZS2WR0RUG2Tl5eH0n3/CsmhRuV0/ZQEBmBwdzcKCqAJqVVExatQojBo1qsT++fPn4+WXX4anp6cIqagmHTt2DBMnThS21Wo1unXrJmIiIiJyNDlGI2S5uRjg7o7m/v6lHpNmMGB3ejoMBgOLCqIKqFVFRVm+//57HDhwAGq1Gjdu3MALL7yAL774QuxYZGfXrl3DgAEDhHEzKpUK48aNEzkVERE5qgCFAo28vMo+ICen5sIQObk6UVQcPnxYeN68efNyC4q8vDzk5eUJ21lZWdWajewjJycHAwYMEPrH9uzZE8uXLxc5leOrX7++2BGIiIioFnDo2Z/S0tLQqlUrHDp0SNiXmpqK/v37w9fXFwEBAZg6dSpMJlOFz3n58uVyX1+8eDF8fHyEB/viOz6r1Yrx48fj5MmTAIB77rkHO3bsgEwmEzkZERERUd3gsEXF0aNH8cgjj+DChQvF9kdERMDT0xMpKSn45Zdf8P3339v1G+lZs2YhMzNTeFy9etVu56bq8cEHH2DLli0ACmbqSEhIQEBAgMipiIiIiOoOhywqNm3ahGHDhmHhwoXF9iclJeHQoUNYsmQJlEolWrZsiejoaKxatcpu15bL5fD29i72IMf1zTffYObMmcL2xx9/jA4dOoiYyLl4eHjAarVCp9OJHYWIiIicmEMWFb1798aFCxcQERFRbP/Zs2fh5+eHxo0bC/tCQ0Nx5coV3L59264Z1Go1QkND0blzZ7uel+zn77//RkREBCwWCwAgOjoa4eHhIqciIiIiqnscsqho2LAhXF1LjiHPzs4uMX9+4fzS9v6mVaVSQaPR4MSJE3Y9L9lHVlYWwsLCkJmZCQAICwvD3LlzxQ1FREREVEc51exPHh4eMBgMxfYVbnuVNyUc1SpmsxnDhw/HX3/9BQBo06YNNm/eDBcXh6yRnVph9ygiIiKi8jjVXVjbtm2RkZEhTBsKABqNBkFBQXZfmIbdnxzX7NmzhWmB69Wrh4SEBBaVdpScnCx2BCIiInIyTtVS0bp1a3Tv3h1Tp05FfHw80tPTERMTgzFjxtj9WiqVCiqVCllZWVxJ04Fs27YNixYtAgC4uLhg+/btuPfee0VOJQ69Xm+3c8XHxwvPQ0JCEBsbi6ioqDKPv7MbIhEREdVtTlVUAMDOnTsxefJktGjRAi4uLoiMjER0dLTYsagGnDp1CqNGjRK2ly1bhl69eomYSFyenp7Vcl6LxSIU1WVhlygiciZms6nYFzF6gwEmkwkGgwHZ2dkAAJlMBnd3d7EiEjk9hy8q7rx5adCgAXbs2CFSGhJL4aKHOTk5AICoqChMmTJF5FREROTozOY8aLVaHDliFRZFvWjIRkZGFn7+WYNLyoL1qJRKF/To0YWFBZGNHL6oEItarYZarYbZbBY7Sp2Xn5+PQYMG4cqVKwCArl274qOPPoJEIhE5mbjsNeNZcnIyQkJChKl5AUAqlUKj0aBJkybQ6/Vo0KABAECr1bLrExE5FbPZBJNJClfX+6FQ+AIA5JZUSKUZkLuHQqGoD6PRAIPhHIxGI4sKIhuxqCgDx1Q4jilTpuDIkSMAgEaNGmH37t115kNfr9cL3Zx0Ol2xG3p73dwHBwcjNjZW6O4klUoRFxeH4ODgEsd6eHiwqCAip+TqqoRcXjCphzxfBxcXV8hk/+0zmcRMR+T8nGr2J6p7PvroI3z00UcAClY737t3b7HFD8k+ig7K1mg01TL5AREREdVebKkgh3X48GG88sorwnZ8fDy6dOkiYiLnU15LR1maNGlS3bGIiOqUzMzMEutsFSrsZq3VauHl5cXeEeS0WFSQQ/rnn38waNAgmP5tj542bRoiIyNFTuV8is12otez6xIRUQ3LzMzEqpgYGNPTS33dxdUVHfr2xfq5cyH19cXk6GgWFuSUWFSUgQO1xWMwGNC/f3+kpaUBAJ5++mksWbJE5FRERESVZzAYYExPx0CFAoFKZYnXzVIpfgXQz90de9PTYTAYWFSQU2JRUQYO1BaH1WrF6NGj8fvvvwMA7r33XmzduhWurvyr6shs6WZFRFSXBCqVaOTlVWK/0aVgeGuAUgnYaVY/IjFwoDY5lHfffRfbtm0DULC4W0JCAvz8/ERORYWSk5PFjkBEREQOiF//ksPYt28f3n77bWH7k08+QZs2bURMVLvo9fpiYyzufK2050DBAPlCISEhiI2NLTZbVGnvYcsFERFR3cKighzCuXPnMHz4cGEF9ZiYGPTr10/kVLVLy5YtK3Rc4UJ3pbFYLELXQCIiIqJC7P5UBrVajdDQUHTu3FnsKLXerVu3EBYWhuzsbADA4MGDi7VYEBEREZFjY1FRBpVKBY1GgxMnTogdpVYzm80YOnQozp8/DwBo3749NmzYAIlEInKy2ufixYvQ6XSlPrRarXCcVqsV9icmJsLFpfjHhFQqxdGjR4udt+j7iYiIqO5hUUGievPNN/HNN98AAAICApCQkMD+99XEw8Oj3EdpxwUHByM2NlZ4TSqVIi4uDq1atSpxPBEREdVdLCpINJs3b8bSpUsBAK6urti5cyeaN28ubigqoeigbI1GgzFjxpR7PGeIIiIiqns4UJtEceLECYwbN07YXrlyJR5//HERE1Fp7pwxytfXt8Q+vV6PTz75RNgOCQkRikUAOH/+PFq3bg0AbNEgchC5uZkwGg3CtsGQBpMpFwZDKrKzC2du08JszhcrIhE5GRYVVOOuX7+O/v37Iy8vDwAwbtw4TJw4UeRUtV9KSgrq169fqfcUTgtbqLSZoe6cVcpisWD69OnC9gMPPCA81xVZ2IkFBpE4cnMzcfpwDGSGdGGfwXATXhkaaH9ehmyld8FxRgN0qWdhauEHoOSibURERbGoKINarYZarYbZbBY7Sq2Sl5eH8PBwpKSkAAC6deuGVatW1bmB2WWtF1HecRV9T1Hr168Xnnfq1KnUNSbKuk513PQXLVIKpw8mopplNBogM6Sjr6sCvjIlAEBnMeOK1A3N3H3hqagHALhstSDBnAez2ShmXCJyEiwqylA4F39WVhZ8fHzEjlMrWK1WTJw4EceOHQMANG3aFLt27YKbm5vIyWrenS0AFVHe+hEVUdE1JgqvY7VaodPpoNfrhX1arbbKOYjIMfjKlPCXF7RAuOXrkeniCj+ZB7z+3XcrX1fe2+ukzMxMGAyGco9RKpW8b6A6iUUF1ZhVq1Zhw4YNAAB3d3fs3buXN6gO7s7WCg8PD+h0OqSmpgrdnvbs2YNLly4JXZ5cXFxgtVqLtURIpVJoNBo0adKk5sITEdlRZmYmYmJWIT29/JabgAAZoqMns7CgOodFRQXp9XpIpVKxYzitgwcPYtq0acL26tWrcd9999nUpYdqRmpqKoDiXaNSU1Ph4eGBqVOnCvsGDBiAgQMHCttHjhzB4cOHMWvWLAD/TUMbHBxcM8GJiKqBwWBAeroRCsVAKJWBZRyThvT03TAYDCwqqM5hUVFBjRs3FjtCrTJ69GiMHj1a7BhUjooMyi60e/du4Xm3bt2KvabRaFhQEFGtoVQGwsurUZmv5+TUYBgiB8KigqgOKasbki1jPCqKXZ6IiIhqPxYVFZSSkgJvb2+xYzgVi8WC4cOHY9++fQCA1q1b49ChQ2wSrqDk5GSEhITAYrEI+yo7NiE2NrZC3ZAuXrwotEJcvHix2FgKvV5f7LW///4bzz77bJnXvHjxIoCyWzWqSq/XC0XQRe1FTDswDYcuH4KriytGtB+Bpc8shasLP9qIiIhqEv/nrSAPDw/Oq19J8+bNEwoKHx8f7Nu3j93IKiE4OBixsbHCbE22jE0YPXq0UFScPHkSHTt2LPW4on+3PTw8iq1nUXRMRf369dGiRQu8+OKL2L59u7B/+PDhwgJ4lV0LoyqivohCM99mSHktBTd0N9Dvs35Yfmw5ZnSbUWMZiIiICHAROwDVTrt378bcuXMBABKJBJ999hnuu+8+cUM5oaJrSmg0GowZM8bmc5VX0N1ZVNxNbGys8Pzrr79GXFyczbkqo2grBfyAI1ePYMnTS6CUKdGyXktE94jGqhOraiQLERER/YdFRRnUajVCQ0PRuXNnsaM4ndOnTyMyMlLYfvfdd9GnTx8RE9UOjjo2oeiK2RWl1+shkUggkUhsnwEsEPB180Vjr/+KpdDAUFzJvILbubdtOycRERHZhEVFGVQqFTQaDU6cOCF2FKeSkZGBsLAw4UZx2LBhmDGDXVEcXVVX7q5Oer2+2EMgB26n3cbq1auF15SFqwNz0S4iIqIaxaKC7MZoNOLFF1/EpUuXAAAPPvgg1q5dC4lEInIycmaenp7Co9g0t/kAZAVfABS+bjAWrHTr5eYlTlgiIqI6ikUF2c3rr7+OAwcOAChY42Dv3r1QKBQipyJnVm6rSSoAJYAiQ0A0aRoEeQfBx50zjBEREdUkFhVkF+vXr8eHH34IAJDJZNi1axeaNm0qcipyBsnJyWW+Vu76GTcB/APgWQBuwJlrZxBzOAZjHrB9MDsRERHZhkUFVdlPP/2El19+WdhevXp1iVWVyTaOMNbBw8MDVqsVVqvVpmmVU1NThUHZqamp0Ov1iI+PF14PCQkpNi6ixNiJ8mxHwafYVOCJT5/As62eRXSP6EpnJCIqTW5+PrRaLa5fvw6tVguDIRs6nRbZ2deFR25uptgxiRwC16mgKrl27RoGDhwIo9EIAJg8eTLGjh0rciqqaYWFR2mKLoJXbEzEvywWC1QqlbAeRyGr1Qqd7r8B16UtBuiS44JzC86hSZMmXEeGiOwqKy8Pp//8E5ZFi6BUKmEwGHDzt7+hl1+F7N9JIQDAqAxAux7RcGe3S6rjWFSQzXJycjBgwABotVoAQM+ePfHBBx+InIpqk6KFwp2LAQIF62VUZjHAmlB0LY3ExESHy0dEFZNjNEKWm4sB7u5o7u8PnVyOI3IF3N3rQe5W8G/8ttGAfYZ0GI0GFhVU57H7E9nEarVi/PjxOHnyJACgefPm2LFjB2QymcjJqKpSUlLsch6dTgedTicUnQCg1WqRmJgIF5fiHz1SqRSJiYnCe4q2UBRVdDHA0rYdwZ1du9atWydiGiKqqgCFAo28vNDQ0xN+Mjn83TzhL/eCv9wLvkVaLIjqOrZUkE2WLVuGLVu2AACUSiUSEhIQEBAgcqq6525jD+4ck1HW8evXrxeed+rUCbGxseXesFdkzENp3ZE8PDxQv379Yi0OUqkUcXFxteIb/WvXrmH69OnCtsViwYQJE9C7d28EBQWJmIyIiKh6saigSvv666/xxhtvCNsff/wx2rdvL2Kiuqvc2ZHuUHRsQ3nKGuNgT1FRUcL5NRpNrSgoAOD8+fMl9pnNZiQlJbGoICKiWo1FRRnUajXUajXMZrPYURzK33//jSFDhgiDZaOjoxEeHi5yqtorLS2t2PP69euLmKbqkpOTSxQQTZo0selcOp3O4QZnt27dGi4uLsUGk0ulUrRq1UrEVFTbZWZmwmAwlPm6VqtFfn5+DSYie7jbnytQ0FPAx4djOcgxsKgoQ+E3tVlZWfwH+6/MzEyEhYUhM7Ng+rywsDDMnTtX3FB1XNHxCqVJS0tD27ZtAQBnzpxBYGBgiWNSUlLw4IMPFpu9SSKR4LfffkPjxo3vet7SulXp9XphpqfFixcL+0NCQhAbG4tBgwYVO9bRigNbBQUFldq1i60UVF0yMzMRE7MK6enGMo8xGLJx9uxF+PnlwouLzTuFivy5AkBAgAzR0ZN5n0IOgUUFVYjZbMbw4cPx119/AQDatGmDzZs3lxhwSzWrtClay1JYBFSE1WrFAw88cNdjgIICpDyzZs0SnpfWtapBgwZlTkd7p/KmrnUUkyZNQr9+/ZCUlIRWrVqxoKBqZTAYkJ5uhEIxEEplyS8NAMBi0SAvLxZGo6mG09VN+fm5JSaoMBgM0MnlyP53n0wmg7u7e5nnqMifq8GQhvT03TAYDCwqyCGwqKAKmT17Nr788ksAQL169ZCQkAAvfuVFVKqgoCAWE1SjlMpAeHk1KvU1na78Fk2yn7y8LPz552ksWmSBUlkwM5TBkI2bv/2NI3IF/GRyAIBS6YIePbqUW1gUHFf2nysA5OTYLztRVbGooLvatm0bFi1aBABwcXHB9u3bce+994qcigCUOfVqodTUVGGA9sWLF0sdk1HaonJSqRQajaZC4x1Ky1C0+1NpYwxOnjwptITcrQsXEZGzMBpzkJsrg7v7APj7NwcAyOVa6OVX4e5eDwo3TxiNBhgM52A0Gu9aVBA5ExYVVK5Tp05h1KhRwvayZcvQq1cvERNRUXcbi1D0dQ8Pj1KPDw4OxsKFC4VuSpWd4vVuGZYuXSpMs1p47tatW1f4/UREjsxozhdagwyGNJhMubBaLcWOcXFxhdzNE3J5QQu/iT3RqBZiUUFlSk1NRVhYGHL+bV8dOXIkpkyZInIqqg4RERFCUXH48GE8+uij5R5fdNXou83CNHz4cKGoKJw+tiLrXBAROTq9KQ+p2j+BHxdBJlPCYLgJrwwNtD8vQ7bSGwCQazRAl3oWphZ+ANhtmGovFhVUqvz8fAwaNAhXr14FAHTt2hVr1qy566Bccn6NGpXdf9cWRVfoLuxO5QwDromI7ibfYoTClIsXpO6or/CHzmLGFakbmrn7wlNRDwBw2WpBgjkPZnP5MzkROTsWFVSqKVOm4MiRIwAKbjJ3797Nvp8EoOQUsqW1OsTHxwvPO3XqVOqx7PZERLWFj0wBf7kX3PL1yHRxhZ/MA17/dnW6lV/+2Dei2oJFBZXw0Ucf4aOPPgIAyOVy7N27t8z1CqjuuXMV77tNa1t0kHbRY9lSQUREVHtwkQEq5vDhw3jllVeE7fj4eHTp0kXERERERETk6FhUkOCff/7BoEGDYPp3Worp06cjMjJS5FR1m8FgEJ5funRJxCT/0el0JRZ20ul0wiMxMbHMRRGLHktERES1B7s/VZBer4dUKhU7RrXR6/Xo168f0tLSAABPPvkkZs+ezVl6RLZz507heVhYGGJjYxEVFVXh99vjz+9uMz3dOVVtcHAwYmNjhVWzpVIpzGZzqccSERFR7VBniop27drB398fANC9e3csWLCgUu+va2MKDhw4AF9fX7FjUBEWiwUqlUq4WXcUycnJJda0iIqKEnIWXeiuOlVmmlsiojuZzabik1AYDDCZTDAYDMjOzoZerxe+ICGikupEUZGVlQU/Pz8cOnRI7ChEDqloNyuDwVDm7E6Fz4vO7hQSElKiBaXoe+paQU5EzsdszoNWq8WRI1bIZDIAwEVDNjIysvDzzxpcUl6F0ZiH1NRbaNGCK9cRlaZOFBWnTp1CRkYGnnzySbi7u2PlypXFVvStiJSUFHh7e1dTQvHs378fERERsFqtkEgk2Lp1K55//nmxYxEKWgBCQkKKzZ4klUqh0WiE9R7uJjU1FS1btrzrcW3bti31+Z1Km+npbi0oYqxJUVrrCRFRWcxmE0wmKVxd74dC4QsAkFtSIZVmQO4eCoWiPqzWNJjNv8BstpR/MqI6qlYVFRs2bMDKlSuL7du/fz+8vb3x+uuvIyoqCj/99BNGjhyJo0ePVurctbEv+Llz5zBmzBjhhi8mJgYvvviiyKmoUHBwMGbNmoWFCxcCAFxcXBAXF1fsZrkyYybuXF+iNij685TVelLb/t0SUfVxdVVC/u/6EvJ8HVxcXCGTFezLz69dn59E9lariopRo0Zh1KhRJfb7+fkhNDQUEokE3bp1K7bCb11169Yt9OvXD9nZ2QCAwYMH46233hI5Fd0pLCxMKCref/99jBkzptjrd64ZUZ6KtFjY6s4WFL1ef9f1K+yhrJ+/aOsJ18MgIiKqfrWqqCjLRx99hJSUFCxZsgSnTp1Cs2bNKn2OtLQ05ObmVkO6mmcymTB8+HAkJSUBANq0aYP33ntPmPmJHEfRQu+1117Dzz//jNjYWBETlSSVSku0oBAREVHdUieKigkTJmDEiBHo0aMHXF1di3WTuFNeXh7y8vKE7aysLABAq1atqj2nWM6ePVut32KT/Wzfvh3bt2+v9PvKWxfibmM3irY6aLVaeHh4FNun0WhEKygKf67yfgYiIiKqfg69+F1aWhpatWpVbNam1NRU9O/fH76+vggICMDUqVOFxdrKolAosGvXLhw+fBgHDhzAfffdV+axixcvho+Pj/Bo2rSpvX4cItEUjgkq7REcHCx0sQKKtzzcOZao6PsKVXTQeHUo+jMUbcFh6wkREVHNctiWiqNHjyIqKgoXLlwotj8iIgJNmjRBSkoKbty4gX79+mH58uWYMWOGXa47a9YsTJ8+XdjOyspC06ZNkZSUBC8vL7tcQyynTp1CWFiY0BLz7rvvljoGhRzDqVOn8Oyzz5bY//XXX9t93YeIiAjMmjULAHD48GE8+uijpR7nyLMqFV0bQ8zWEyIiorrIIYuKTZs2Yfbs2ViyZAmGDBki7E9KSsKhQ4eQnJwMpVKJli1bIjo6GjNnzrRbUSGXyyGXy0vsDwwMdOopZa9fv47Ro0cLBcX48eMxc+ZMSCQSkZNRWXr37o3nn38eX375pbAvKioKvXv3tul85c38VHSdCh8fn7vOqjRo0KBSz+soMy2J2XpCRERUFzlkUdG7d28MHz4crq6uxYqKs2fPws/Pr9hiWqGhobhy5Qpu375t1xWg1Wo11Gp1rVg9My8vDwMHDhRmverevTtiY2NZUDiBOXPmCEXFhg0bMHLkSJvPVdGZospbp6K0NSmKzvLEmZaIiIjqJoccU9GwYUO4upasd7Kzs0t8E6pUKgGUPxDVFiqVChqNBidOnLDreWua1WrFxIkTcfz4cQBA06ZNsXPnTri5uYmcjCqrTZs2YkeosMIF76xWq8O0XhAREVH1cciioiweHh7FumkA/3XbcPbxDtUlNjYWGzZsAAC4u7tj7969NbJ+ADkenU5X5uPixYvCcRcvXhT2JyYmwsWl+MeEVCrFqVOnhG2tViscLyYWMkREROJxqqKibdu2yMjIgFarFfZpNBoEBQXBx8dHxGSO6Ycffig26Hz9+vV48MEHRUxEYipvBqiyZngKDg7G0qVLhdcKZ1Vq3bp1qccTERFR3eSQYyrK0rp1a3Tv3h1Tp05FfHw80tPTERMTU2KVYXtw9jEVFy9exIsvvijkf/PNNzF06FCRU5EzGj58uFCcnjx5Eh07dix30DcREZXPbDYJn6MmqRQAoNPrYTAYhC9O8/Pz7Xa9zMzMEj097qRUKvkFLVWJUxUVALBz505MnjwZLVq0gIuLCyIjIxEdHW336xQORs3KynK6f2TZ2dno168fbt68CQB47rnnsGDBApFTUVUVbaGztztbKspSdJIEIiKqPLM5D1qtFkeOWCGTyQC5GyTduuHYsTP4LSsTlxdtBgCcPXsRfn65qGrv7szMTMTErEJ6urHc4wICZIiOnux09zzkOBy+qLhzNpkGDRpgx44dNZ5Dr9dD+u+3CY7MYrFg+PDhOHv2LICC1p3//e9/yM3NFTkZ2WLnzp3C87CwMMTGxiIqKsqmc7F7EhGR+MxmE0wmKVxd74dC4QurmxR5AOTytpDL01Cv3kvIyclAXl4sjMbyF/etCIPBgPR0IxSKgVAqA8s4Jg3p6bthMBhYVJDNHL6ocBTO+g3t+fPnOWd/LVHadK6VweleiYgch6urEnK5F6xuLgVFhZsHZDI9PD2rZzIVpTIQXl6Nynw9J6daLkt1iFMN1K5JarUaoaGh6Ny5s9hRiIiIiIgcGlsqynDnmIqUlBSHXlH7zJkzeOqpp4SBXwsWLMDUqVPFDUVVkpycjJCQEFgsFmGfVCqFRqNh6xMREZWp6MBsrVYLgyEbcnnxcXkymRLu7uzqRPbDoqKCHHnKzPT0dAwdOlQoKIYNG4a33nqLK2Y7ueDgYMyaNQsLFy4EALi4uCAuLg7BwcGiZUpJSUH9+vWFNSGIiMixZGZmYlVMDIzp6QAKxlTc/O1v6OVXIZMpheOMygC06xHNwoLshkWFkzMajXjxxRdx6dIlAECnTp2wdu1aFhS1RFhYmFBUJCQk4IUXXrD5XOVNA1v0tTuPW79+vfC8U6dO5Q4Wd9TCm4iorjAYDDCmp2OgQoFApRI6uRxH5Aq4u9eD3M0TAHDbaMA+QzqMRgOLCrIbFhVlcJZ1Kl577TUcPHgQQMHMWHv37oVCoRA5FVWHqq6E7unpWeXr3G2wOFsviIgcQ6BSiUZeXsgG4CeTQ+HmCbm8yPy0Jo7MJvviQO0yqFQqaDQanDhxQuwoZVq3bh1iY2MBADKZDLt27UJQUJDIqYiIiIiormFLhZP66aefMHHiRGF79erV6Natm4iJyNHpdLoyX9Pr9UILhVarFboxcbA4EZFjyc3NhNFogE5XMAD7zoVRtVqtXVfjJqooFhVO6Nq1axg4cCCMxoLVMSdPnoyxY8eKnIqqQ06RicNzqjiJeEXHOxSdlCA4OBhLly7F9OnTARQUFGIPFiciqqtyczNx+nAMZP+Oh8jL+xufLroKpfK/AdjZBgMunj2LXD8/VHk5bqJKYFHhZHJycjBgwADhm4knnngCH3zwgcipqDYbPny4UFScPHkSHTt2FDcQEVEdZTQaIDOko6+rAgqpHLlQ4LF69YqNmdNYLIjNy4Pp3y8eiWoKi4oyOOJAbavVinHjxuHkyZMAgObNm2P79u2QyWQiJ6O6wllXliciqk18ZUp4Asgxy9HQ0xNeRVoktOV0dSWqThyoXQZHHKi9bNkyfPLJJwAApVKJhIQEBAQEiJyKiIiIiOo6FhVO4uuvv8Ybb7whbH/88cdo3769iImIiIiIiAqw+5MT+PvvvzFkyBBhBp7Zs2cjPDxc5FRUm3CFbCIiIqoKtlQ4uMzMTISFhSEzMxMA0L9/f8yZM0fkVFSXFJ01iitmExERUWnYUuHAzGYzhg8fjr/++gsA0KZNG3z88cdwcWEtSERU22VmZsJgMJR7DNckICJHwaLCgUVHR+PLL78EANSrVw8JCQnFZnggIqLaKTMzEzExq5CeXv60oAZDNs6evQg/v1wuSUBEomJRUQaxp5Tdtm0bFi9eDKBgwbHt27fj3nvvFSULERHVLIPBgPR0IxSKgVAqA8s8zmLRIC8vFkajqQbTERGVxKKiDCqVCiqVCllZWfDx8anRa//2228YNWqUsL1s2TL06tWrRjMQEZH4lMpAeHk1KvN1nU5bYl9ubiaMxv+6TRkMaTCZcmEwpCI72xM6nRZmM7tM1QZmswl6vb7YPr3BAJPJBIPBgOzsbOj1+lK/IDWa84W/PzqdFgZDtrCwbiGlUlnj90DkvFhUOJjU1FT0798fOTk5AICRI0fi1VdfFTkVERE5g9zcTJw+HAOZIV3YZzDchFeGBtqflyFb6Y1cowG61LMwtfADwD5TzspszoNWq8WRI9Zii+BeNGQjIyMLP/+swSXlVRiNeUhNvYUWLf5rzdKb8pCq/RP4cRFkMiWMRgPy8v7Gp4uuQqlUCsfJAgIwOTqahQVVCIsKB5Kfn49Bgwbh6tWrAICuXbtizZo1kEgkIicjsRQWl3c+F5ter4enpycAQKfTcVYoIgdhNBogM6Sjr6sCvrKCm0OdxYwrUjc0c/eFp6IeLlstSDDnwWwuf7wGOTaz2QSTSQpX1/uhUPgK++WWVEilGZC7h0KhqA+rNQ1m8y8wmy3CMfkWIxSmXLwgdUd9hT/ypHLkQoHH6tUTPtvTDAbsTk+HwWBgUUEVwqLCgbz66qs4cuQIAKBx48bYs2cP3N3dRU5FRETOxlemhL+8oBXCLV+PTBdX+Mk84CX3wq18ncjpyJ5cXZWQy/9rcZLn6+Di4gqZrGB/fr6+zPf6yBTwl3shD0COWY6Gnp7FJ4RxoC+zyPFxblIH8dFHHyEuLg4AIJfLsWfPHjRqVHY/WiIiIiIiR8GiwgEcPnwYr7zyirAdHx+PLl26iJiIiIiIiKjiWFSI7J9//kF4eDhMpoIBVNOnT0dkZKTIqYici16vh0QigUQiKTETChEREVU/FhVlUKvVCA0NRefOnavtGnq9Hv3790d6esEsHU8//TTee++9arseObe0tDSxIxARERGVigO1y3DnOhV6vR5SqdRu57darYiMjMTvv/8OALj33nuxfv165OXlIS8vz27XIee2e/du4XlkZCSysrIQFRVl07lsnaHJw8MDVqvVpvcSERHZU2ZmJrKzswEAWq221Huziq6vkZmZCYPBUO4xXKuj4lhUVFDjxo2r9fwXLlxA06ZNq/Ua5NysVqtQ7Nr6/rogOTkZwcHBYscgIiI7y8zMxKqYGJhv30aHvn2xfu5cWEwlV5OvyPoahecypqeXeUxFz0UFWFQQUZWIdRNfdOxEfHy88DwkJASxsbGIiori+hlERLWIwWCAMT0d/T098Q+A0X5+kN6xWnhF19coPNdAhQKBRRb8s+VcVIBFRQWlpKTA29u7yuc5d+4cnnzySaHpbvbs2Zg5c2aVz0u1T3JyMu6///5iLQxSqRQajQZNmjSx67UqO7i5rJv40lTXjX3hAk13slgsQotOXWmdIaLawWjOh06nhcGQBpMpFwZDKrKz//us0+m0MJvzRUzoGAKUSvwDoIGnJ2QWS8kDKrG+RqBSiUZe5awsz7U6KoxFRQV5eHhU+ebo1q1bGDp0qFBQDB48GHPnzuWK2VSq4OBgTJo0CWq1GgDg4uKCuLi4amkVKOsGvSKK3sSXhjf2RER3pzflIVX7J/DjIhiNufDK0ED78zJkK//7QjPXaIAu9SxMLfzgJmJWotKwqKghJpMJQ4YMQVJSEgCgQ4cO2LBhAwsKKtfTTz8tFBXx8fEYM2aMyIkch05XsCpwcnIyQkJCYCnybVVhiw4RkbMwWkxQmHLxgtQdSqkcV6RuaObuC09FPeGYy1YLEsx5MJuNAHj/QI6FU8rWkDfffBPffvstACAgIAB79+5lf2+qlICAgGo7t1arLfZcp9OV+UhMTISLS/GPDqlUisTExFKPry6FrYfBwcGIjY0tlqW6WnSIiKqbj0wBP5kHfFxc4SfzgL/cS3j4uCrEjkdUJhYVNWDz5s1YtmwZAMDV1RU7d+5E8+bNxQ1FVETRArfwZr2sR3k38aUdXxOKjufQaDRs0SEiIqph7P5UzX755ReMGzdO2P7www/x+OOPi5iIqOqioqKEMRQajcahWgXsPYidiIgqjms/lK4u/F5YVFSj69evY8CAAcJiduPHj8fLL78scioi++JNPBERAQU3zjExq5Cebiz3uIAAGaKjJzv1DXRl1JU1MVhUVJO8vDwMHDgQKSkpAIDu3bsjNjaWA7OJqgFX/SYiEp/BYEB6uhEKxUAolYFlHJOG9PTddWrth7qyJgaLijKo1Wqo1WqY71hUpSKsVismTpyI48ePAwCaNm2KnTt3ws2NE8CR7dLv8g0HERGRPeXm5xebyKMsd3bbUSoD4eXVqMzjy1r64W5dhLRaLfLznXedDnuvieFoXapYVJShcN79rKws+Pj4QK/XQyqVVui9q1evxoYNGwAACoUCn332GTw9PSu9wBjR/v37hefjxo1DXl5emYvM3Q1nGyMioorKysvD6T//hGXRIijL+Ha9UGG3naqoSBehbIMBF8+eRW5g6a0gdYkjdjVjUVFBjRs3tul9OTk56N69u53TUF1ktVrLXWSuIu8nIiKqiByjEbLcXAxwd0dzf/8yjyvabacqKtJFSGOxIDYvDyaTqUrXqg0csasZiwoiKiY5OdmhZnMiIiLxBCgU5XfZASrdbac85XUR0lbj2kfOytauZtWBRUUFpaSkwNvbu8zXs7Oz8eSTT+LcuXMAgGeffRbbtm2rcJcpojslJyfj/vvvL9bCULhSdOGMS5XpUlfesfHx8cLzkJAQxMbGltvNil35iIiIqCgWFRVU3kJeFosFI0aMEAqK++67D1u3bi23CCG6m+DgYEyaNAlqtRoA4OLiUmKlaE9PT7tf12KxVKmbFREROR+z2VTsCyO9wQCTyQSDwYDs7GwAgEwmg7u7e4n3Fh3QbTBkQy4vObhbJlPC3d05ZzUSgzMOWmdRYQfz58/H3v9v787jm6ry/4+/0zRtk7a0dGETyqKgbOICLigM7qDAV3EHFXF3dFTUcR0ERBkHxdFxGwUVdcZhfjruOug46iDjggIjUEQUVBahbQqkaW+z398f2NhAgZa0vUn6ej4efTyae2+Sz0lvbvPOPfec116TJOXl5emNN95I2uHAkFhOOumkaKi47777mCkaANDswmG/ysrK9PHHphwOhyRpneFVZWWVPv98lb53bZAkuVxpGj78iJhgUf+CbknaunSNajI3yOGIvS4i6CrSwOHxXczdVjTmImzD8Kq0dJ0KCnzaW++01kKoaKTdjf70+uuva/r06ZJ2fJM8b9487bfffnQPQbOoP/rTrbfequzs7JhuSY0Z6q/O7s60bdq0SX379lUkEoku27mb1c5qamrUsWPHRj83ACBxhcMhhUJ2pacfJKczX5KUGSmX3V6pzKx+cjo7KBg0ZBhfKxgMxoSK+hd0Fzmd+jjTqays9srM+OVM+vagoTcNt4LB+C7mbisacxF2JLJKfv8jCgYT56J1QkUjNWb0p0gkojPOOKMVqkFb1FKjP/Xp00ePPPJI9HHtdvsu3awAAKkvPd2lzMwdX3tnBqqVlpYuh+OXZX5/aJcvTeu6SblMU7k2m/LS0pWTkRO9T52g36Pq6l+6SO38pVhzdudpzPwajX2+xjxWc80FsWs3skiD2zkcLjmdux+RyyqECgCaOHFiNFSsWrWKQAEAiNFQFykptptUe0eGysu3qWfP2G/Pa0J+lZctlxbt6CLl96/RizM3xMx/EZ2DoqBA8fTnaez8Go15vsY+Vt08HfEEi8Z2I5N2dCXrcOD/7fNztRRCRSPVH/0pGAzq//7v/7Rw4UJJ0qGHHqr33ntPTqfTyhKRYhoz+lNLaMnHBgAkp4a6SEmx3aTSbTaFw4sVDsd+wx6IBOUM+TTanqU8h1M+OTWsffuYwUaic1AE9zyZ2940dn6NxjxfYx6r/jwd8YSKxnQjk37pShYK+fb5uVoKoaKR6o/+dN1110UDRceOHfXGG2+oqKjIyvKQghoz+pNVsrOzmUwPANqg+l2kpNhuUumy7fG+eQ6nCjNyVBvOVKecHOXWO0OwL3NQ+P1++XyxH67rd8eq+zgeiUSUlpYWs12WacaMbrW7ka2kX+bq8Pl8Cu4UQqojERmGEe22FG9XqCKnU51yclTgyJSzgW5kkqRQK04+0QRtJlTcc889WrBggfx+v6ZNm6bTTjttnx7n6aef1iOPPCJpx9Bq//jHP9S1a9fmLBWIqj/601NPPcXoTwAA/Oy//12i2u2xoWLnUavC4ZAqK8tVWNgxZsCdnbdraGSr+nw+nxYuXCzDiD0LszXo11J/rX6Y+YJcrlwVFTk0Zcq1bXIU0DYRKj788EN99dVXWrRokcrLy/XXv/51n0LFJ598oquvvjp6+4knntAxxxzTnKUCu8XZMAAAflFbG1F6et+Y6w52HrXKMCrk87mVltZn99220nPk9a7Q9u3bY0ZKrD9Xx3abTV5vUJmZA2KeL8terbRwuTIzRyoSSdPata9q8eLFKi7+ZdSmiooKeTweVWdmyqvdz/eR7NpEqHjvvfdUUlKiMWPGKBAIRM80NMWmTZs0bty46Gmva6+9lm+NAQAALFR/dCpp11GrAoEdo1XtqdtWWpq9CRehZ8Q8Tijk17at38qxdI7C4aC2bPlC9y77SOnpv3zE9oeC8m8vV/9OPVWU5drrWZFklVKh4tlnn9XDDz8cs+ydd95RRUWFysvL9eqrr2rZsmW69NJL9fHHHzfpscePHx/tL3fcccfpwQcfbLa6AQAAYI3mugjdZc/UemWpi2ugnM520W3WG5V6a3uNHBkHKj09p8H5PlJBSoWKSZMmadKkSbssLyws1KGHHqr09HQNGTJEGzZsaPJj/+9//5Mk9ejRQ//v//2/mCQLAACAxgmHdz/fRd2F0w1dXF23Ta1h/Pw4YSl2k7jEexF6rmzypKWrg7NIubm/jBZlSNHHcThce5zvwzAM1dhsO9qWZFIqVOzOMcccozlz5uiaa67Rt99+G9PPrSmys7P1+uuv07cdbV5NTU10KMDq6urdztYNAEB9jZnv4rvM7/d4cfWXX65Wh9OlsjK3nJ0TZ0bpxohnvo9E1yZCxZgxY/TRRx/pyCOPlGmaevzxx/fpcZ577jkdfPDBzVwdAABA29CYrkZpNtseL67OyDro58fSLt2REl08Xa0SXUKHioqKCh199NGaO3euRowYIUkqLy/XFVdcoY8+2nERzAUXXKAHHngg5oKYndlstkZfA+H3++X3+6O3PR6PJOmGG27QSSedpKqqqn1vENBExs+neOt+b6n9r/5p2Kqqqr2edm3q9kh+dfteW5mfpK6ddePXtzav16tAwK/t27+X3+/d7XYez3pFIkF5PD/K4TBVU1Muw+fRj0Gftjl2TMjqq92qsnBAadWblRWu1kZjqwLhgDZ6y2SEAw1uI2mX7RqzjT/iVYFhaGvNZmXWevb5cfZ1m9Z+vmbZxpGubKO3NlWXRbdz2cy9tq0x27T2692kun0eZdl++dBc4atSyIyozOeVd6/bVCvDMFQe8su2D+2Pq+7WbP9OjyNJVcFaGWG/zKpNMe/9htTWuhUI+OX1epWdna1gMBj9LNGU41qjj/9mglq0aJG5//77m5LMDz/8MLp8xIgR5oQJE8yamhpz7dq1Zv/+/c1Zs2Y12/NOnTrVlMQPP/zww08DP2vXrm22420iW7t2reWvNT/88MNPIv1s2LBhj8dNm2km3tdOzz33nO666y7NmjVL5513nj788EONGDFC3333nXr37q1NmzapS5cukqS///3vuuWWW/Tjjz82y3PvfKZi+/bt6t69u9avX7/PE5kMGTJEX3zxxT5v09C6vS3b2+9VVVXq1q2bNmzYoHbt2mlf0K59b9eebu/8+7///e+427S3mhuzDe1q2+16//33VVJSom3btik/P39fmpRUtm/frvbt28d17G+LmuMY3NbwmjUdr9m+2dfXzTRNeb1edenSZZeL5+tLyO5Pp5xyiiZMmKD09HSdd9550eWlpaUqKCiIBgpJ6tevn9avX6/t27c3yz+6zMxMZWZm7rI8Ly9vn3dcu92+1/vuaZuG1u1tWWN+l6R27drRribU3JhtGtOuPd3e3e/xtGlvNTdmG9rVtttV98F6T/9QUkldO+M59rdl8e7/bRGvWdPxmu2bfXndGvPlSkL+d+jUqVOD10jU9Qmrz+XaMathdXX1LtsnimuuuSaubRpat7dljfk9XrSr8et2Xran27SraWhX49clQrsAAKkpIbs/1Wez2aLdn1599VVdfvnlcrvd0fUrVqzQwQcfrO3bt7fIKeqqqirl5eXJ4/GkVBqmXckjFdsk0a5kk6rt2p221t7mwuvWdLxmTcdrtm9a+nVLyDMVuzNgwABVVlZGZ7aWpFWrVqlr164t1uc1MzNTU6dObbBLVDKjXckjFdsk0a5kk6rt2p221t7mwuvWdLxmTcdrtm9a+nVLqjMVkjRs2DB17dpVTz31lNxut8aMGaOzzjpL06ZNs7ROAAAAoK1KqjMVkvTyyy8rFAqpZ8+eOvLIIzVy5EhNmTLF6rIAAACANivhz1QAAAAASGxJd6YCAAAAQGIhVAAAUE95eblOP/105efnq6ioSDfccINCoZDVZSW0v//970pPT1dOTk7058ILL7S6rIRVUVGhAw44QB999FF02eeff64jjzxSOTk56tmzp55++mnrCkxADb1mV199tTIzM2P2u6eeesq6IhPIV199pZNOOkkFBQXq1KmTLrrooujoqS21rxEqmsE999yjY489VkOGDNHbb79tdTnNZuDAgRoxYoRGjBih3/3ud1aX06zKysrUvn17q8toNqFQSOeff76OPfZYjRo1Slu3brW6pGbh9/t1zjnnaPjw4TrqqKP02WefWV1Ss3vttdc0adIkq8vYZ5FIRJdccomOOeYYjRo1KmbI72R17rnnKicnRz/99JMWL16s999/X3/84x+tLiuhffHFF7rwwgtVXV0d/XnhhResLish/fe//9XRRx+ttWvXRpdt27ZNp556qi666CJt375dTz/9tCZPnqzFixdbWGniaOg1k3bsd0899VTMfnfFFVdYVGXiqK2t1ahRozR06FBt2bJFpaWlqqys1KRJk1p2XzMRlw8++MA866yzTNM0zbKyMvPBBx+0uKLm4fF4zOHDh1tdRouZOHGi6XK5rC6j2fztb38zr7/+etM0TXPevHnmlClTrC2omfz5z38277zzTtM0TXP16tXmUUcdZXFFzevWW281DzzwQHPixIlWl7LPXn75ZfPqq682TdM058+fb954440WVxSfb7/91pRkbtq0Kbps/vz5ZklJiYVVJb7hw4ebjz76qNVlJLx58+aZJSUl5vz5801J5ocffmiapmnOmTPH7N27d8y2V111lXnRRRdZUGVi2d1r5vP5zIyMDHPlypXWFpiAVq9ebY4cOdIMhULRZa+//rrZrl27Ft3XOFMRp/fee08lJSUaM2aMLrzwQp122mlWl9Qsli1bpsrKSh1//PE69dRT9e2331pdUrP54IMPVFRUpOLiYqtLaTbnnXeeHnjgAUnS+vXrU2YyoPHjx+u2226TJIXD4ZQbk3zIkCF64oknrC4jLv/973918sknS5JGjhypDz74wOKK4lNaWqqCggJ16dIluqxfv35av369tm/fbl1hCSwSiWjp0qV6++231b17d3Xt2lVXXHGFtm3bZnVpCeeUU07R2rVrde6558YsLy0t1cCBA2OW9evXT1999VVrlpeQdveaffXVVwoGg7rrrrvUsWNH9enTR3/4wx8UiUQsqjRxHHjggfrnP/8pu90eXfbyyy/r8MMPb9F9jVDRSM8++6wOOeSQmJ+ffvpJFRUV+vbbb/Xqq6/qnnvu0aWXXmp1qU2yu3a1a9dON998s/7973/rzjvv1MUXX2x1qU2yu3YFAgHde++9STuvye7aJUnp6ek67bTT9Mgjj0Q/5CWL3bUrNzdXOTk5crvduuiiizRjxgyrS22yPf3NzjzzTNlsNosrjE/dDK2SlJubK6/Xa3FF8fF6vcrOzo5Z5nK5JEnV1dVWlJTwKioqdOihh+qss87S119/rU8++UTffvutLrjgAqtLSzidOnVSenr6Lst3t9+xz+3+NfN4PBoxYoSuu+46bdy4UX/5y1/0pz/9SbNnz7agysRlmqZ+97vf6c0339TDDz/covvarn8lNGjSpEkN9nsuLCzUoYceqvT0dA0ZMkQbNmywoLp9t7t2FRQUqF+/frLZbDrmmGOiH4KSxe7adffdd+uqq65STk6OBVXFb3ftqvP222/ru+++0+jRo7V69epWrCw+e2rXt99+qzPPPFP33HOPhg0b1sqVxW9vf7Nk165du2iQ8Hq90YCRrLKzs2UYRsyyutu5ublWlJTwOnbsqIULF0Zvl5SUaNasWTryyCPl9Xp53RohOzt7lzNhhmHw2u3BSSedpJNOOil6+4gjjtANN9ygv//97/rtb39rYWWJo6qqSpMmTdKSJUu0cOFCDRw4sEX3Nc5UxOmYY47RggULJO348JMqXWr+/Oc/RycVXLZsmUpKSiyuqHm8//77euyxxzRixAht2bJFo0ePtrqkZjFnzhz96U9/krTjg09aWmq8tTdt2qSxY8dqzpw5Gjt2rNXloAFHH3203nvvPUnSP//5Tw0dOtTiiuIzYMAAVVZWqqysLLps1apV6tq1a9IHppayfPly3XbbbTLrTXvl9/uVlpamjIwMCytLHgMGDFBpaWnMslWrVmnAgAEWVZT4XnvtNT355JMxy/x+v5xOp0UVJZa1a9dqyJAhqqqq0pdffhnt8tSi+1rcV2W0cZFIxJw8ebJ5xBFHmEOGDDEXL15sdUnNwjAMc9y4ceawYcPM4447zly9erXVJTW77t27W11Cs/F4PObYsWPN4cOHm8cee6y5cOFCq0tqFldffbW53377mb/61a/MX/3qV9FBEVLJhx9+mNQXaodCIXPSpEnm0KFDzREjRphbtmyxuqS4HXvsseZ5551nVlVVmevWrTP79+9vTp061eqyEtaGDRvM7Oxs8w9/+IMZDAbNH3/80TzqqKPMSy+91OrSEprqXXTsdrvN/Px8849//KMZCATMDz74wMzNzTU/+OADa4tMMPVfs1deecV0Op3m+++/b0YiEfOTTz4xi4qKzBdeeMHaIhPA1q1bzZKSEvPiiy82w+FwzLqW3NfabKgoLy83999//+jOaZo7Rm/6v//7PzMvL88sLCw0r7/+ejMYDFpX5D6gXbQrEaRqu0wztdtmmqnfvsbYsmWLedZZZ5mFhYVmcXGxedNNN8WMooJdffTRR+bRRx9t5ubmmsXFxeZvfvMbs7a21uqyElr9D8imaZpffPGFOXToUDM3N9fs1auX+eyzz1pWW6La+TX785//bPbp08d0uVxmr169zMcee8y64hLI7NmzTUmmy+Uys7OzY35Ms+X2tTYZKhYtWmTuv//+u+ycI0aMMCdMmGDW1NSYa9euNfv372/OmjXLukKbiHbRrkSQqu0yzdRum2mmfvsAAC2nzYWK3Y13nOxjk9Mu2pUIUrVdppnabTPN1G8fAKBlpcbVnE2wpzGik3lsctpFuxJBqrZLSu22SanfPgBAy2pzoaKpY0RLyTE2Oe2iXYkgVdslpXbbpNRvHwCgZbW5ULE7qTo2Oe1KLrQr+aRy26TUbx8AoHkQKn6WqmOT067kQruSTyq3TUr99gEAmgeh4me9e/fWscceqxtuuEFer1fff/+9ZsyYoUsvvdTq0uJCu5IL7Uo+qdw2KfXbBwBoHoSKel5++WWFQiH17NlTRx55pEaOHBmdVTqZ0a7kQruSTyq3TUr99gEA4mczTdO0uggAAAAAyYszFQAAAADiQqgAAABIAKFQSPfff78OPvhgOZ1O2Wy2mJ+SkhKrSwR2i1ABAACQAC699FLdfvvtOvHEE/Xqq69q3rx56tChgyRp8uTJmj59usUVAru360xHAAAAaFUvvviinn/+eT311FO6/PLLo8tN09SkSZN0/PHHa/To0Vq7dq0OPPBAVVdXKysry8KKgVicqQAAALDYk08+qb59+8YECknq27evJGnr1q2SpJUrV6p3794ECiQcQgUAAICFtm3bpo8//linnnrqLus2btwoSerataskacWKFRo4cGCr1gc0BqECAADAQhs2bJBpmurSpcsu61577TUVFRVp+PDhkggVSFyECgAAAAvl5+dLkr7++uuY5Z988on+9re/6brrrlN6+o7LYFesWKGDDz64tUsE9orJ7wAAACz2q1/9Sp988ommT5+uI444QosXL9bMmTM1fPhwvfXWW0pLS1MgEFB2dra++eYb9erVy+qSgRiECgAAAIuVl5frhhtu0D//+U8ZhqE+ffro4osv1vXXXx89S/HVV1/pmGOOkdfrlc1ms7hiIBZDygIAAFisQ4cOevHFF/e4zYoVKzRgwAACBRIS11QACWL27Nm64IILLHnuCRMm6P7777fkuQEAjcP1FEhkdH8CEsDq1as1dOhQrVixQvvtt1+rP/+mTZs0cOBA/fe//42OiQ4ASCy/+tWvdMUVV2jChAlWlwLsglABJICxY8eqa9euevzxxy2r4de//rU2bdqk119/3bIaAAANe//99zVhwgR988030dGigERC9ycgDmPGjNHgwYM1Z84cDRo0SE6nU926ddPUqVMViUQa9RgrV67UW2+91eA3T3PnzlX//v2VmZmpkpISTZs2TaFQSJL0xhtvyGazadq0adHt16xZo+zsbE2cODG6rEePHvrd736nG2+8UQUFBSooKNCFF16oysrKmOe64IIL9Oabb2rlypX78EoAAFrKscceq5tuukkvvfQSgQIJizMVQBy6dOmiqqoqlZSU6I477lDHjh31zDPPaP78+ZozZ44uu+yyvT7G7bffrueff14bN26Mufju97//ve6880795je/0Wmnnab//e9/mjp1qsaPH6+nn35akjRx4kTNnz9fX331lXr37q1jjz1WW7Zs0VdffaV27dpJ2hEqPB6PevfurTvvvFPl5eW67bbb1KtXL33++edKS9vx3YJpmiopKdGFF16omTNntsCrBQAAUhWhAthHmzZtUteuXdWrVy8tXbpUeXl5kqRgMKiSkhINHjxYb775pvx+v7p3765vvvkmuk19Rx55pDp37qzXXnstuszj8ahLly666KKL9MQTT0SXP/3007rsssu0cuVK9e/fX9u3b9eAAQPUu3dvjRw5Unfeeac++ugjHXvssdH79OjRQ1VVVfr++++jz//aa6/pjDPO0FtvvaXTTjstuu0ZZ5yhn376SZ9//nlzv1wAACCF0f0J2EdffPGFJGnatGkxYcHhcOiAAw6Q2+2WJGVmZmrLli0NBgpJWrdunXr27Bmz7NNPP5VhGBo7dqxCoVD0Z8yYMZKkf/3rX5J2zMI6d+5cffTRR7rjjjt02223xQSKOmPGjIl5/rFjx8rhcOjjjz+O2a5Hjx76/vvvm/pSAACANo5QAeyjL7/8Ug6HQ2efffYu63766Sd169ZNkvTwww/vsRuUx+NRdnZ2zLK66x1OPfVUORyO6E/Hjh2jj1/nhBNOULdu3RSJRKKhY2ddunSJuZ2WlqbCwkJt27YtZnl2drY8Hs9uawUAAGgIk98B++jLL79UUVGRsrKyYpZ//vnnWrdunaZMmSJJWr58+R7HFS8qKtL27dtjltVdiPfXv/5Vffr02eU+deFCku6++26VlZWpb9++uuyyy7RkyRJlZGTEbL/zRdnhcFhut1sdOnSIWb5t2zYVFRXttlYAAICGcKYC2EdffvmlKioqYgJBOBzWrbfeqh49emj8+PGS9h4qunfvrg0bNsQsO+qoo5SRkaFNmzZp8ODB0Z+MjAzddttt0S5KX375pe677z7dcccdevHFF7V69WpNnTp1l+dYsGCBAoFA9Pbrr7+uUCikE044IWa7DRs2qHv37k1+LQAAQNvGmQpgH3z//feqrKxUSUmJzj77bN10003y+Xz605/+pCVLluijjz5SRkaGIpGIVq1atcdQcfLJJ+vxxx+XaZrR0Z8KCwt1yy23aMqUKaqqqtKIESO0adMmTZkyRTabTYMGDZLf79fEiRN14IEH6vbbb1dGRoZuuOEG3X///Tr99NN15JFHRp9j48aNGjt2rK677jpt2LBBt99+u0455RSNGDEiuo1pmvrkk0903XXXtdjrBgAAUhNnKoB98OWXX0qS5s+fr86dO+vcc8/VRRddpHbt2mnx4sU6/PDDJUnfffed8vLyVFhYuNvHOvPMM+V2u6MXfteZMWOGHnzwQb3yyis69dRTdcstt2jYsGFauHCh8vLyNGXKFK1evVpz586NdneaPn26SkpKNHHiRPl8vuhjnXfeedp///117rnnaurUqbr44ov16quvxjzf4sWLVVlZqbPOOqtZXiMAANB2MKQssA9uueUWPf744/J4PLLb7bvd7uWXX9bcuXO1YMGCPT7emDFj1KFDh+j8E82pR48eGjFihObNm7fH7SZNmqRt27bFDG0LAADQGJypAPbBl19+qcMOO2yPgUKSVqxYsceuT3Vmzpypl19+WevXr2+uEptk/fr1euWVVzRjxgxLnh8AACQ3QgXQRKZpaunSpRo8ePBet50+fbpmzZq11+0GDhyoO+64Q7feemtzlNhkt956q2677TYNHDjQkucHAADJje5PAAAAAOLCmQoAAAAAcSFUAAAAAIgLoQIAAABAXAgVAAAAAOJCqAAAAAAQF0IFAAAAgLgQKgAAAADEhVABAAAAIC6ECgAAAABxIVQAAAAAiAuhAgAAAEBcCBUAAAAA4kKoAAAAABAXQgUAAACAuBAqAAAAAMSFUAEASBoXX3yxbDZb9Oejjz6yuiQAgAgVAAAAAOJEqAAAAAAQF0IFAAAAgLgQKgAAAADEJWFDxbfffqvrrrtO/fv3V7t27ZSZmalu3brpzDPP1D//+U+rywMAtJD58+frhBNOUEFBgbKzszVkyBDNnTtXpmlaXRoAYDdsZgIepR966CH99re/VSgU2u02F110kZ555hnZ7fZWrAwA0FL8fr/Gjx+vV155pcH1p59+ulwul1588cXosg8//FAjRoxopQoBALuTbnUBO5s7d64mT5681+2ef/559ejRQ9OnT2+FqgAALe2mm27abaCQpNdee40vkgAgQSVU96ft27fvEijqujt9/vnn+t3vfqe0tF9KnjVrlrZs2dLaZQIAmtnatWv1+OOPxywbNWqU3n//fS1dulS///3v5XQ6FQ6HLaoQALAnCXWm4oUXXlB1dXX09vjx4/XXv/41evuII45QVVWV/vSnP8lms2m//fbTsmXLNGrUKCvKBQA0k7/+9a8x10wMHTpUb731VvSLpEMPPVS9evXSueeea1WJAIA9SKgzFTvPjHr11Vfvss0tt9yiTz75RFVVVfruu+8IFACQAj777LOY23fccUfMmWlJOvvss9WtW7fWLAsA0EgJdabi+++/j7ndt2/fXbbZb7/9tN9++7VWSQCAVrBp06aY2/37999lG5vNpkGDBmnDhg2tVRYAoJES6kyF1+uNue10Oi2qBADQmgzDiLldXFzc4HZ5eXmtUQ4AoIkSKlTk5OTE3PZ4PBZVAgBoTY09/te/7g4AkDgSKlT06tUr5vZXX321yzbfffedTjnlFE2ePFlz5szRihUrWqs8AEAL6dGjR8ztZcuW7bKNaZpasmRJK1UEAGiKhAoVO09gtPPwgpI0b948vffee3rooYd0xRVX6NVXX22l6gAALWXYsGExtx944AFFIpGYZc8//7w2btzYmmUBABopoWbU3r59u7p16xZzevvss8/WNddco+zsbC1YsEDTp0+PzrRtt9v17bffqmfPnlaVDABoBuXl5SopKZHf748uGzVqlG666SYVFBTonXfe0d13361AIBBzP2bUBoDEkFChQtoxo/bll1/eqG1vvvlm3X///S1cEQCgNfz+97/XHXfcscdtunTpop9++il6m1ABAIkhobo/SdJll12m2bNny26373G7iy++WPfdd18rVQUAaGm33Xabrrnmmt2uHzlypGbOnNmKFQEAGivhQoUk3XjjjSotLdWvf/1r9enTRy6XS5mZmSopKdG5556rf/3rX3r22Wf3GjwAAMnDZrPp0Ucf1dtvv62TTz5Z+fn5ys7O1lFHHaW5c+fqnXfeUWZmptVlAgAakHDdnwAAAAAkl4Q8UwEAAAAgeRAqAAAAAMSFUAEAAAAgLoQKAAAAAHEhVAAAAACIS7rVBSS6SCSin376Sbm5ubLZbFaXAwCWME1TXq9XXbp0UVpa6n8fxbEfAHZo7PGfULEXP/30k7p162Z1GQCQEDZs2KCuXbtaXUaL49gPALH2dvwnVOxFbm6uJOn7779XQUGBxdXELxgM6r333tPJJ58sh8NhdTnNgjYlB9qUHHbXpqqqKnXr1i16TEx1yXzsT9b9MlnrlpK3dupufclYe2OP/4SKvag77Z2bm6t27dpZXE38gsGgXC6X2rVrlzQ7897QpuRAm5LD3trUVroCJfOxP1n3y2StW0re2qm79SVz7Xs7/qd+x1gAAAAALYpQAQAAACAuhAoAAAAAceGaCgCWCofDCgaDVpexT4LBoNLT0+Xz+RQOh60uJ24ZGRlWl5B0EnH/Tdb9Mt66MzIy2sRwx0CiIlQAsIRpmtqyZYu2b99udSn7zDRNderUSRs2bEiJC5jT0tIYRrWREnn/Tdb9Mt6609LS1LNnT8IxYBFCBQBL1H0g69Chg1wuV1J9+KkTiURUXV2tnJycpP+GtG6yt7KyMqtLSQqJvP8m634ZT911++/mzZtVUlKSUH8PoK0gVABodeFwOPqBrLCw0Opy9lkkElEgEFBWVlZSfXjbneLiYm3atCkl2tKSEn3/Tdb9Mt66i4uL9dNPPykUCiXdUJ1AKkieow2AlFHXB93lcllcCeqr6zaSTB9ErcD+m5jq9t9kuo4ESCX85wBgGbooJBb+Hk3D65VY+HsA1qL7E4CE4vF4ZBhGqz2fy+VSXl5eqz0fUhv7L4C2ilABIGF4PB7NmPGo3O7WG6KzqMihKVOu5YMZ4sb+C6AtI1QASBiGYcjtDsrpHCeXq7gVnq9CbvcrMgyDD2WIG/svgLaMUAEg4bhcxcrN7dwqz1Vb2ypPgzaE/RdAW8SF2gDQBGvXrtWYMWNUVFSknj17asaMGQoEArrqqqu0//77q7q6WpL02GOPRYdonTdvno466ihdeeWVateunTp37qx77rlHpmla3Bq0NfX33+7du+vOO+9k/wXQLAgVANBINTU1OuGEEzRgwABt3LhRCxcu1H/+8x9NmzZNf/zjH+V0OnXLLbdo+fLl+u1vf6sXXnhB++23nyTp888/V3Z2tsrLy/Xmm2/qoYce0jPPPGNxi9CW7Lz/Llq0SO+//76mTp3K/gsgboQKoJE8Ho82b9682x+Px2N1iWhhb7/9tgKBgGbOnKmsrCx169ZNd9xxhx5//HE5nU7Nnz9fzz33nEaPHq3Jkydr5MiR0fsWFhbqD3/4g7KysjR48GBdccUVeuGFFyxsDdqahvbfGTNm6LHHHmP/RcJq6H9vVVWV1WWhAVxTATRCY0Z1YRSW1PfDDz+ovLxc7du3jy6rmwW4vLxcAwYM0K9+9Su9++67uuSSS2Lu26NHj5hZfktKSvSPf/yj1WoHGtp/TdNk/0XC8ng8enTGDAXd7pjlmR07qt/QoRZVhd0hVACNsLdRXRiFpW3o2rWrDjjgAK1evVrSjkCxadMm1dbWqri4WP/v//0/ffbZZzrjjDN00UUXaeHChbLb7ZKkn376SaZpRifo+v7771VSUmJZW9D27Lz/SpLX61VZWRn7LxKSYRgKut0a53Sq+OcZ7CsMQ69VVlpcGRpCqACaYE+jujAKS/MxjIqEfJ7Ro0frt7/9re6//35dd911qqmp0dVXX63NmzfrlVde0ZVXXqnHHntMo0eP1sEHH6zp06fr7rvvliRt3rxZ9913n26++WYtW7ZMc+bM0RNPPNESzYLFkmX/ra2t1aRJk7R+/Xr2XyS0YpdLnXNzf1lAd+OERKgAkDBcLpeKihxyu19ptZBWVOSQ6+dvwPamXbt2ev/993XTTTdp1qxZCofDOvbYY/Xaa6/p/PPP14knnqjx48dLkp599lmdfPLJOvHEEyVJnTt31vfff6/OnTsrNzdX99xzj84999wWaxdaXzLuv8cdd5zeeOMNnXvuuey/AOJCqACQMPLy8jRlyrUyDKPVntPlcjWpy1rfvn31zjvvSNrR/amqqkrt2rXTokWLYrY77rjjFAzuuAZn3bp1ysjI0FNPPaWnnnqq+YpHQkm2/bc+9l8A8SJUAK3I4/Hs8QNHUz8gpKK8vLw2/xogebH/AmirCBVAK2nKCFKN7c4AAACQCAgVQCtpyghShIrUcvHFF+viiy+2ugxgn7D/AmgMQgXQyhhBCgAApBpm1AYAAAAQF0IFAAAAgLgQKgAAAADEhWsqACSUvQ2729wYxhfNif0XQFtFqACQMDwejx6dMUNBt7vVntNRVKRrp0zhgxnixv4LoC0jVABIGIZhKOh2a5zTqeJWGFa3wjD0itstwzD4UIa4sf8CaMsIFQASTrHLpc65ua3zZM0wju/HH3+s0047TdXV1c1QEJJdMu6/o0aNYv8FEBcu1AaAOA0bNqxZPpDZbDb98MMP8RcENAH7L4DmQKgAgCaYNm2aunXrpoKCAh155JF655139NFHH8lms0mSfvjhB9lsNj3//PPq3r27srOzNWnSJC1atEiDBg1STk6OTjjhBLmb0O9+/vz5Ovjgg5WXl6fDDz9c7733niSpsrJSXbt21S233CJJCoVCGjp0qM4//3xJ0ogRI3TTTTfp8MMPV3Z2tg4//HAtWrSomV8RJJP6+++QIUP0xhtvJNT+e/LJJ2v8+PGS2H+BZEOoAIBG+vDDD/XUU09p8eLFqqys1CWXXKLrrrtOwWBwl23feecdff311/r888/1wgsv6Nprr9U777yjH374QevXr9fjjz8uSRo9erTy8/OVn58vSTr44IOVn5+vgw8+OPo4V111lR599FFt3bpV06dP15lnnqnS0lIVFhbqL3/5ix566CF9+umnuuuuu1RZWamnnnoqWsdTTz2lBx54QNu2bdO4ceM0ZswYVVZWtvyLhYSz8/572WWX6dJLL02Y/Xfq1Knatm2bnnzyyWgd7L9A8iBUAEAjZWVlaevWrXrqqae0bNkyXXbZZfr222/lcDh22fbmm2+Wy+XSgAED1LlzZ02cOFH77befioqKdPTRR0e7ibz11lvavn27tm/fLklavny5tm/fruXLl0uSHn30UV199dUaPny47Ha7Ro8erTFjxujPf/6zpB3f5t5yyy0655xz9Kc//UkvvfSScuv157/kkkt03HHHKSMjQ3fccYeys7P15ptvtuwLhYTU0P5bXl6eMPvvI488omeffZb9F0hShAoAaKSjjz5a//jHP/TJJ59o2LBh6tKlix544AFFIpFdti0sLIz+brfb1b59++jttLS0Bu/TkB9++EEPP/xw9Nvg/Px8vfHGG1q/fn10m1//+tfasmWLDj/88Og3xHV69+4d/d1ms6lr167avHlzo9uM1LHz/tupUyfdc889CbX/DhgwIOb+7L9A8iBUAEAjrV+/Xh07dtS7776rbdu26dlnn9Xs2bNV28AIPHV91OPVtWtX3XXXXdFvg7dv365Vq1Zp7ty50W0uv/xyjRo1St98842eeOKJmPtv2rQp+nskEtH69etVUlLSLLUhuey8/z733HO69957E2r/ffrpp2Puz/4LJA+GlAWQcCpaaUbipj7PF198oSuvvFL//ve/NWjQIHXs2FGSVFpa2iz1mKa5y7IrrrhC1113nU444QQNGTJEX375pUaNGqUpU6bouuuu08MPP6ylS5dq5cqV+u9//6vzzjtPw4cPV//+/SVJc+fO1VlnnaWBAwdq5syZikQiGj16dLPUi4Yl2/67cuXKZqkn3v33448/1vjx43XyySdr4MCBkth/gWRCqACQMFwulxxFRXrF7W6W8fcbw1FUJFcjJyo788wztWbNGo0dO1Zut1sdO3bUzJkzdcghh7RYfWeddZaqq6s1adIkrV+/XgUFBZo8ebJ+85vf6KuvvtKtt96ql19+WYWFhRo7dqzOPfdcnX/++Vq8eLGkHX3Wr7nmGq1atUqHHnqo/vWvfzFRWgtJxv33oYce0kEHHdRi9TV1/z3jjDM0YcIE9l8gCREqACSMvLw8XTtlioxW+qZX2vFBsCkfUm6//XbdfvvtknZ0x6iqqlK7du2i39L26NFjl29sdx67f968eU2q8eKLL9bFF1+8y/JBgwbJ5/PFLHv22Wdjbvfv318vvfRSk54P+ybZ9t/6EmX/feyxx9SuXTulpe3onc3+i0Tm8Xh2eb839T2ZSggVABJKXl5emz0gI/mx/wJtg8fj0YwZj8rtjh2SuajIoSlTrm2TxwFCBQAAANAEhmHI7Q7K6Rwnl6v452UVcrtfkWEYhAoAQOr46KOPrC4B2Gfsv0gGLlexcnM7R2+30uVUCYlQAQAAANTT0PUSwWAwOllkWVmZAoGAFaUlLEIFAMs0NAQlrMPfo2l4vRILfw80l4aulwgEfFqzplR9+gxURkaGDMOr0tJ1Kijwqd4k8G0aoQJAq6v7pscwDDmdTourQZ26b90aO1tyW8X+m5jq9l+73W5xJUh2DV0vUVGxStu3r1Z6+hgVFvZQJLJKfv8jCgZDFlebOAgVAFqd3W5Xfn6+ysvLJe0Ygq+5ZvBtTZFIRIFAQD6fLzoEZrKKRCKqqKiQ0+kkVOxFou+/ybpfxlN33f7rcrmUns5HGzSP+tdLVFeXSZKcziLl5naO3sYveOcBsESnTp0kKfrBLBmZpqna2lo5nc6E+lC5r9LS0tSlSxery0gKibz/Jut+GW/daWlpKikpSao2A6mEUAHAEjabTZ07d1aHDh0UDAb3focEFAwGtXDhQg0fPjzaJSaZZWRkKBwOW11GUkjk/TdZ98t4687IyEiqMzNAqiFUALCU3W5P2j7QdrtdoVBIWVlZSfXhbU8IFU2TiPtvsu6XyVo3gB2I9AAAAADiQqgAAAAAEBdCBQAAAIC4ECoAAAAAxIVQAQAAACAujP4EJJBAwKeysrLoCDxlZWUxI8u4XC7l5eVZVR4AAJbz/zx7ev3/kY35/+jxeGQYRvQ2/1ObF6ECSBB+f5WWL1+hmTMjatcuR2PGDNK0ac8oFPplduOiIoemTLmWgyAAoE2q8vtVWlqqI848U89Mm6ZIKCRJchQV6dopU3b7/9Hj8ejRGTMUdLujy/Z2HzQNoQJIEMFgrXw+h7KyzlBBQTdJS1RQcInC4R3fwhhGhdzuV2QYBgdAAECbVBsMyuHzSZIuKSiQPRxWhWHoFbd7j/8fDcNQ0O3WOKdTxS5Xo+6DpiFUAAnG6SxSTk5HSVJOTkdFIr9MAlVba1VVAAAklo45OXJEfj6b38h/kMUulzrn5jbpPmgcLtQGAAAAEBdCBQAAAIC4ECoAAAAAxIVQAQAAACAuhAoAAAAAcWH0J2AnO0+OI+2YYMcwvMrJqVJubmeLKgMAAEhMhAqgnoYmx5F2jG+9dekabc03NPjE+5SVxZjWAAAAdQgVQD07T45TpzozU2/b0/Wv2koFgwahAgAAoB5CBdCAmMlxJHkltUt37P4OAAAAbRihAgAAAG2Gz+dTdXW1DMNQWVmZJMnlcikvj14I8SBUAAAAoE3w+f1a+OkybfTUaqm/Vj/MfEEuV66KihyaMuVagkUcCBUAAABoE0LBoAwjovT03sqUT+3bX6i0tDS53a/IMAxCRRwIFQAAAGhT0tOdctjSlJPTUZJUW2txQSmAye8AAAAAxIVQAQAAACAuhAoAAAAAcSFUAAAAAIgLoQIAAABAXBj9CQAAACnJ4/FEJ7kzDENGOKxwOCzZra4s9RAqAAAAkHI8Ho9mzHhUbndQhuHV1qVrdECaXcFtNcrbL2x1eSmHUAEAAICUYxiG3O6gnM5xysyMqCZzg+xmRL7wSoUjES4CaGaECgAAAKQsl6tYkuRwuJQe4QxFSyGjAQAAAIgLoQIAAABAXAgVAAAAAOJCqAAAAAAQF0IFAAAAgLgQKgAAAADEhVABAAAAIC6ECgAAAABxIVQAAAAAiAszagMAACCp+QIBlZWVRW+7XC4Lq2mbCBUAAABIWlV+v1YsX67IzJnRMOEoKtJZl19ucWVtC6ECAAAASas2GJTD59MZWVnqUVioCsPQK263amtrrS6tTSFUAAAAIOkVOZ3qnJu74waBotVxoTYAAACAuBAqAAAAAMSFUAEAAAAgLoQKAAAAAHEhVAAAAACIC6ECAAAAQFwIFQAAAADiQqgAAAAAEBdCBQAAAIC4ECoAAAAAxIVQAQAAACAu6VYXAKB5eTweGYax2/Uul0t5eXmtWBEAAEh1hAoghXg8Hs2Y8ajc7uButykqcmjKlGsJFgCAlOULBFRRUSHD8Cozs0ySFA4HJJvd4spSF6ECSCGGYcjtDsrpHCeXq7iB9RVyu1+RYRiECgBASqry+7Vi+XIZjzyiravWqyZzg8KSqstLFe4wwOryUhahAkhBLlexcnM7N7iutraViwEAoBXVBoNy+Hw6PTNTh2Q6lZXVXptDtXo97JcZCVldXsoiVAAAACDlFGZlqcqRKWdGjnZ/pSGaC6M/AQAAAIgLZyoAC/h8HgWDsd+bGEaFQiGfAgGvRVUBAADsG0IF0Mr8/iqt/nS2HIY7ZrlhbFVu5SqtW/qYunSZZVF1AAAATUeoAFpZMFgrh+HWmHSn8h2u6PLqSFirbGlaVrtNwSBXUwMAgORBqAAsku9wqTAzN3o7I1CjnDTekgAAIPlwoTYAAACAuBAqAAAAAMSFUAEAAAAgLoQKAAAAAHEhVAAAAACIC6ECAAAAQFwIFQAAAADiQqgAAAAAEBdCBQAAAIC4MH0v0II8Ho8Mw5AklZWVyTC8CocrFA4HLK4MAACg+RAqgBbi8Xj06IwZCrrdkiTDMLR16RqZaWvk37ZOoZ4FknKtLRIAAKAZECqAFmIYhoJut8Y5nSp2uVSdmamPM50qj2TqnbBf4XDQ6hIBAACaBaECaGHFLpc65+bKK6nAkanaiNPqkgAAAJoVF2oDAAAAiAuhAgAAAEBc6P4ENEEwHFR1ddkuy/3+KguqAQAASAyECqCRjHBI7opVciyaKYfDFbOuOt2pDn3yLKoMAADAWoQKoJECkYhcYb9G27PUwVkYXb49aOiV2kqFQq493BsAACB1ESqAJspzOFWYudP8ErWV1hQDAACQALhQGwAAAEBcCBUAAAAA4kL3J6AZBMNB1dZWq6zsl5GhysrKFAgELKwKAACgdRAqgDjVhPxyV6xSO98avThzm1yuHRdsew1D60pL5SsokHJz9/IoAAAAyYtQAcQpEAn+PCpUpv6vfXvl5ORIklZFInrE71coGLS4QgAAgJZFqACaSTu7Q51ycpT781mJsurqfXqcYDiomppySVJ1dZnCYbskJtgDAACJi1ABJBCfGda2rau16dMHpJPP1ff/maagPySJCfYAAEDiIlQACSRomnKF/Rppz5IknZdVIKWFmWAPAAAkNEIFkIDapTslSQWZObLZIjsWMsEeAABIUMxTAQAAACAuhAoAAAAAcSFUAAAAAIgL11SgTfB4PDIMY4/b1E1aBwAAgKYhVCDleTwezZjxqNzuPU9CV1Tk0OWXn9VKVQEAAKQOQgVSnmEYcruDcjrHyeUq3s02FXK7X1FtbW0rVwcAAJD8CBVoM1yuYuXmdt7tevIEAADAvuFCbQAAAABxIVQAAAAAiAuhAgAAAEBcCBUAAAAA4kKoAAAAABAXQgUAIGlFIpG9TmwJAGh5hAoAQNLw+XyaN2+ezj77bHXp0kUZGRnKzc2Vy+XS4MGDdcstt+irr76yukwAaHOYpwIAkPBqa2s1a9YsPfzww/J4PDrooIN0wgknqEOHDsrKytLWrVu1bt06zZkzR7Nnz9bQoUM1a9YsHX300VaXDgBtAqECAJDwevfurezsbP3ud7/ThAkT1LFjxwa3M01TH374oZ599lkdd9xxevTRR3XZZZe1crUA0PYQKgAACe/uu+/WxIkTZbfb97idzWbT8ccfr+OPP17Tp0/X+vXrW6lCAGjbCBUAgIR3ySWXNPk+vXr1Uq9evVqgGgDAzggVSHlVVVUyDK8yM8tiljscLmVl5VlUFQAAQOogVCCleTwezXvoIW1d+qlqMjfI4XBF1wVdRRo4fArBAkhQ33//vQoKCpSXt+M9+sILL2jBggWSpNGjR+v888+3sjwAQD2ECqQ0wzAUrqzUaHu6OmS1V2ZGjiRpe9DQm4ZbwaBBqAAS1OjRo/Xmm28qLy9Pd999t/7617/qyiuvlLTjGot169bpzjvvtLhKAIBEqEAb0S7docKMHGVm5v6yMFRrXUEA9mr9+vXRayKee+45ffDBB+revbsk6ZxzztHQoUMJFQCQIJj8DgCQkDp16qRvvvlGkhQIBFRQUBBdl5+fr6qqKqtKAwDshFABAEhIt99+u8477zx9+OGHuummm3T++edr0aJFWrRokcaPH69zzjnH6hIBAD+j+xMAICFdcsklKi4u1m233aZly5YpFArpnXfe0X777aeJEydq6tSpVpcIAPgZoQIAkLDGjBmjMWPGKBKJqKysTE6nU/n5+VaXBQDYScqEikgkIp/PJ5fLtfeNAQAJb+jQoRo1apRGjhypIUOGqHPnzlaXBKCFeTweGYYhSSorK1MgELC4IjRW0oYKn8+n+fPn6+2339Z///tflZeXyzRNZWZmql+/fjr++OM1YcIEDRo0yOpSAQD74PHHH9eCBQv029/+Vt9++61GjBihkSNH6pRTTlGHDh2sLg9AM/N4PHp0xgwF3W5JktcwtK60VL6CAik3dy/3htWSLlTU1tZq1qxZevjhh+XxeHTQQQfphBNOUIcOHZSVlaWtW7dq3bp1mjNnjmbPnq2hQ4dq1qxZOvroo60uHQDQBIcccogOOeQQ3Xbbbaqurtb777+vBQsWaOrUqWrfvr1GjhypkSNHaujQobLb7VaXCyBOhmEo6HZrnNOpYpdLqyIRPeL3KxQMWl0aGiHpQkXv3r2VnZ2t3/3ud5owYYI6duzY4HamaerDDz/Us88+q+OOO06PPvqoLrvsslauFgDQHHJycnT66afr9NNPlyStXr1aCxYs0L333qsTTzxRN998s7UFAmg2xS6XOufmqqy62upS0ARJFyruvvtuTZw4ca/fStlsNh1//PE6/vjjNX36dK1fv76VKgQAtLQ+ffpo8eLFWrBggdWlAACUhPNUXHLJJU0+zd2rVy+NGDGiZQoCALS6YDCoSZMmWV0GAOBnSXemAgDQNtx99927XRekjzUAJJSUChWhUEhz5szRkiVLlJ+frwceeMDqkgAA++iee+7RGWecoXbt2u2yLhwOW1ARAGB3UipUXH755dq4caPOO+883XjjjXrggQf07rvvasWKFVzEhxYXjoRVU1MTvV1jGAqFQjIMQ16vVzU1NTs+CNksLBJIIgMHDtRFF12k0047bZd1Pp9P8+bNa/2iAAANSqlQ8cYbb2jDhg1yuVzREDF48GBde+21hAq0KNOMqLKyUh9/vEIOh0OStM7wqrKySp9/vkrfuzYoGPSrvHybzA7dLK4WSA6XX375bs9IOBwOTZ06tZUrAgDsTkqFiqKiIlVVVcXMql1YWKiysjILq0JbYJqmwmG70tMPktOZL0nKjJTLbq9UZlY/OZ0dZJoVCocXy4xErC0WSBJXXXXVbtfZ7XZCBQAkkKQb/WlPrrzySp1//vnasmWLbLYdfUxWr16t/Px8awtDm5Ge7lJmZu6OH4dLaWnpcjh2LEtPd+39AQAAAJJQSoWKyZMn65hjjlGfPn1UXV2tSy+9VCeeeKKuv/56q0sDADQDzk4AQGJKqVBhs9l0zz33aM2aNXrmmWc0aNAgzZ8/XzfddJPVpQEAmsH9999vdQkAgAak1DUVkjR//nwtWbJEHTt21FFHHaVjjz3W6pIAAM3ENE2rSwAANCClzlRMnjxZs2bNUmZmptauXasLL7xQY8aMkWEYVpcGAGgGddfLAQASS0qdqfjLX/6itWvXRidKCgaDuuqqq3TzzTfr8ccft7g6AAAAIDWlVKjIyMiIOTXucDg0e/Zs9e7dm1CBlBAM+vc4RHJZWZkCgUArVgQAAJBioeLSSy/VxIkT9fzzz0fPVhiGobS0lOrlhTYqHA5q1aqvNXPmizFzsdRnGF6Vlq5TQYFPubmtXCDQCrimAgASU0qFiqlTp+rGG29U9+7ddfTRRys/P18LFy7UDTfcYHVpQNwikbD8AYeyss5QYWGP3WyzSn7/IwoGQ61bHNBKjjnmGKtLAIAm8Xg80et7w+GwxdW0nJQKFXa7XQ8//LBuueUWLVy4UJWVlbr++ut15JFHWl0akkAg4FNFRYUMw1B1Zqa89dbV1NQokiAzYTudRcrN7dzguupqZo9Hanv//fetLgEAGs3j8WjGjEfldgclSenpaRozZpCqqqpUWFhocXXNK6VCxbp16zRnzhyZpqmDDjpIQ4cOVf/+/a0uC0nA76/S8uUr9Kc/Van26zX6ONOpAkdmdH0w6Je7chtdLwAAQKMZhiG3Oyinc5xcrmL5/WWSflRtba3VpTW7lLrYYOzYsdq4caOysrL09ttv6/zzz1e7du0IFtirYLBWPp9DmZmjlJnZR1lZB8vpPDz6k57eW5Ew/bmBRBUKhfTEE0/osssu080332x1OQAQw+UqVm5uZ7lcRVaX0mJS6kzFpk2btHLlyphltbW1Ki0ttagiJBuns0Ahh0uZGTnKzPzlSudAoMbCqgDszeWXX66NGzfqvPPO04033qgHHnhA7777rlasWEHIAIBWkFJnKsaNG6fFixfHLHM6nRo8eLBFFSGRBcMBVVeXyevdLMOoUCjkk2G4FQ4zJCuQbN544w29/vrruvTSS6Mj/g0ePFhPPvmkxZUBQNuQUmcqamtrddZZZ2n69OkaNWqUOnXqZHVJSFA1Ib/Ky5ZLi2bK4XDJMLYqt3KV3MueVNj7o0I9CyQxJiuQLIqKilRVVRUz3HJhYeEe53UBADSflDpTMXjwYJ1wwgl67LHH1KtXL3Xq1EkjR47UrbfeanVpSDCBSFDOkE+j7Vm60FmoCVl5OseeoRPtGUoL+xUOB60uEUATXHnllTr//PO1ZcsW2Ww2SdLq1auVn59vbWEA0Eak1JmKG2+8Mfp7JBLRd999pxUrVmjFihUWVoVEludwqjAzVxmBGnnS0mWmZ1ldEoB9MHnyZG3dulV9+vSRz+fTpZdeqnfffVeTJ0+2ujQAaBOS+kxFjx499NxzzzW4Li0tTX369NGZZ56padOmtW5hAIBWZbPZdM8992jNmjV65plnNGjQIM2fP1833XST1aUBQJuQ1Gcq1q9frxUrVuidd97R1q1b1bVrVw0fPjx6kR4AoO2YP3++lixZoo4dO+qoo47Ssccea3VJANBmJP2n7z/+8Y8aM2aMLrroIp1wwgnq3LmzZs6caXVZQLMLhoMKhfwyjHJ5vZujPz6fx+rSAMtNnjxZs2bNUmZmptauXasLL7xQY8aMkWEYVpcGAG1CUp+pkKQOHTrovvvuU9++fbVx40a9+uqrmjp1qj799FO9/vrrnLVASqgJ+bVt6xrlB30q+3y2vK520XVBV5EGDp+irKw8CysErPWXv/xFa9euVbt2O94bwWBQV111lW6++WY9/vjjFlcHAKkv6T9xz5o1SxMnTtQRRxyhcePG6YUXXtB//vMfffTRR/rTn/5kdXlAswhEgnKFAzrVlqYJWfm60FmoC52FGpPulMNwKxjk21i0bRkZGTEz3jscDs2ePVsvvfSShVUBQNuR1KEiKytLHTt23GX50KFDdfvtt+vZZ5+1oCqg5WTb7CpwZKswM1eFmbnKd7j2fiegDbj00ks1ceJEVVVVRZcZhsHZagBoJUl9tO3du7f+9a9/NbjuyCOP1Jo1a1q5IgCAFaZOnaru3bure/fuOvXUUzV+/HgdccQRuuGGG6wuDQDahKQOFRdccIEefvhhPfPMM7usW7x4cczMqgCA1GW32/Xwww9r5cqVuvDCCzV06FD94x//0O233251aQDQJiT1hdo33nijVq5cqcsuu0wPPvigTj31VHXp0kVff/215s2bp7PPPtvqEgEArWDdunWaM2eOTNPUQQcdpKFDh6p///5WlwUAbUZShwq73a7nnntOp5xyip588knNnj07eqHe8OHD9dBDD1lbIACgVYwdO1aHHnqo9t9/f7399tv6/e9/rx9++EEHHHCASktLrS4PAFJeUoeKOuPHj9f48eO1fft2bdiwQfn5+erWrZvVZQEAWsmmTZu0cuXKmGW1tbUECgBoJSkRKurk5+crPz/f6jIAAK1s3LhxWrx4sY444ojoMqfTqcGDB1tYFQC0HUl3ofaAAQP06quvNnr7zZs367rrrtN9993XglUBAKxUW1urs846S88++6y2bNlidTkA0OYkXag455xzdNFFF6mkpES333673n33XVVUVESvpaitrdXKlSs1d+5cjRkzRt27d9eSJUs0duxYiysHALSUwYMH64QTTtBjjz2mXr16qVOnTho5cqRuvfVWq0sDgDYh6bo/3XXXXbr88sv10EMPae7cufrDH/4gm80mm80mh8OhQCAgSTJNU8OGDdP8+fM1btw4i6sGADSXf/3rXzrppJNilt14443R3yORiL777jutWLFCK1asaO3yAKBNSrpQIUmdO3fWH/7wB91zzz367LPP9Nlnn+mnn35SbW2tioqKdNBBB2nEiBHq2rWr1aUCAJrZKaecogkTJujBBx9UcXHxLuvT0tLUp08f9enTR2eeeaYFFQJA25OUoaKOw+HQsGHDNGzYMKtLAQC0kldeeUXXXXed+vbtq1mzZumSSy6xuiQAjeDxeGQYRvS2y+VSXl6ehRWhOSXdNRVer1eXXHKJiouL5XK5NGLECC1cuNDqsgAAreT000/XqlWrNGHCBF1xxRUaMWKEvvnmG6vLArAHHo9Hj86YoSdvvz368+iMGfJ4PFaXhmaSdKHijjvu0Lx589ShQwcNGjRIS5Ys0UknnaT//Oc/VpcGAGglOTk5evjhh/XZZ5+pqqpKhxxyiKZNmxa9rg5AYjEMQ0G3W+OcTl1ZWKhxTqeCbnfMmQskt6QLFW+++aauueYalZaW6tNPP9W6des0ePBgRvgAgDZo8ODB+vLLL3Xvvfdq9uzZGjRokN5///3oiIAAEkuxy6XOubkqdrnkCwRUVlamzZs3a/PmzSorK7Psi4FAwBetxco6klnSXVOxceNGnX322dHbxcXFevDBBzV06FBt27ZN7du3t7A6AEBr8Xg8WrVqlVauXKn169erR48eKi0t1SmnnCKXy6XDDjtMRxxxhO6//36rSwWwkyq/XyuWL1dk5ky5XC5JktcwtK60VL6CAik3t9Vq8furtHz5Cs2cGZHL5ZJheFVauk4FBb7WLCPpJV2oiEQiysrKilk2cOBAmaapTZs2ESoAIMXNnTtXM2bM0MaNG2Wapmw2m7p27ap+/frp5JNPVp8+ffTjjz/qyy+/1Lx58wgVQAKqDQbl8Pl0RlaWehQWSpJWRSJ6xO9XKBhs1VqCwVr5fA5lZZ2hwsIeikRWye9/RMFgqFXrSHZJFyqkHbNk15eZmSlJnKoCgDbglltuUZ8+fXT33XerX79+6tevn7Kzs60uC8A+KHI61fnn0wFl1dVxP57P51ONYSgUCskwDIXD4Ubf1+ksksPhkmlGFAr5ZBjl8vk6KCuLEaoaIylDxbhx4+RyuTRw4EAdcsgh6t+/v2w2m9VlAQBawemnn64bbrhBBx98sNWlAEgg/kBACxcu1kq3R5WVVVq67FvJG1DPno074xAIeLVi4ZMKutcot3KVyj6fra1FvTRw+JQWrjw1JF2oePvtt7V06VItXbpUS5Ys0WeffRZdN2zYMB188ME6/PDDdfjhh+uwww7ToEGDLKwWANDcnnnmGatLAJCAwqGQDCOi9PSestsrlW4vkT/8ncLhSKPuHwrVymG4dYo9Ux57hvLsmfrAcCsYZISqxki6UDFq1CiNGjUqenvr1q3RgFEXNp544oloP9umnPYCAABAcrOnO5WWlq709Ez59+H+eY4sKS1deQ6npMYFkqYqLy+X3W6P3k6FiQCTLlTsrKCgQCeeeKJOPPHE6LKqqiotWbJEy5Yts7AyAEBzGTBggGbMmKEzzjijUdtv3rxZv//979WlSxfddtttLVwdADSO318lSXrggZeUkZEZXV5U5NCUKdcmdbBI+lDRkHbt2um4447TcccdZ3UpQIsLhgOqri6TJBlGRfTiMq83Rw6HiwvMkBLOOeccXXTRRWrfvr0mTJigESNG6LDDDlNRUZFsNptqa2u1du1affbZZ3r99df17rvvasiQIbrqqqusLh0AokIhnyQpK2u02rfvJWnH/263+xUZhkGoAGCNmpBf5WXLpUUz5XC4ZBhboxeXeV3tFHQVaeDwKQQLJL277rpLl19+uR566CHNnTtXf/jDH2Sz2WSz2eRwOKKj/5mmqWHDhmn+/PkaN26cxVUDQMOczkLl5naO3q6ttbCYZkKoAJJYIBKUM+TTaHuWOjgLVR0Ja709QyVZ+QqlZ+rNny8wI1QgFXTu3Fl/+MMfdM899+izzz7TZ599pp9++km1tbUqKirSQQcdpBEjRqhr165WlwoAbQ6hAkgBeQ6nCjNzlRGokSctXQWObAUcGVIoBb76AHbicDg0bNgwDRs2zOpSAAA/S7O6AAAA9sbr9eqSSy5RcXGxXC6XRowYoYULF1pdFgDgZ4QKAEDCu+OOOzRv3jx16NBBgwYN0pIlS3TSSSfpP//5j9WlAQBEqAAAJIE333xT11xzjUpLS/Xpp59q3bp1Gjx4sG699VarSwMAiFABAEgCGzdu1Nlnnx29XVxcrAcffFBffPGFtm3bZmFlAACJUAEASAKRSERZWVkxywYOHCjTNLVp0yaLqgIA1CFUAACSwubNm2NuZ2bumI22bo4KAIB1GFIWAJAUxo0bJ5fLpYEDB+qQQw5R//79ZbPZrC4LACBCBQAgCbz99ttaunSpli5dqiVLluizzz6Lrhs2bJgOPvhgHX744Tr88MN12GGHadCgQRZWCwBtD6ECAJDwRo0apVGjRkVvb926NRow6sLGE088IdM0ZbPZFA6HLawWANoeQgUAIOkUFBToxBNP1IknnhhdVlVVpSVLlmjZsmUWVgYAbROhAgCQEtq1a6fjjjtOxx13nNWlAECbQ6gAUlgwHFB1dVn0dnV1mQzDq6qqKnXu3NnCygAAQCohVAApqibkV3nZcmnRTDkcLklSMGjI71+jeQ8Zuu2++5SXl2dxlQAAIBUQKoAUFYgE5Qz5NNqepQ7OQkmS356p8lC6fqqslGEYhAoAANAsCBVAistzOFWYmStJ8kvypTv0k7UlAQCAFEOoANqYSDgsn8+nsrKyBte7XC7OYAAAgCYhVABtSDjsV0VFhZb7DM2c+YJcrtxdtikqcmjKlGsJFgAAoNEIFUAbEg6HFArbZbeXqH37C5WT0zFmvWFUyO1+hestAABAkxAqgDbIbs9STk5H5ebuOqxsba0FBQEAgKSWZnUBAAAAAJIboQIAAABAXAgVAAAAAOJCqAAAAAAQFy7UBgAAAJpBIBA7D1RZWZkCgYCFFbUeQgUAAAAQJ7+/SsuXr9DMmRG5XC5JkmF4VVq6TgUFPuXuOjVUSiFUAAAAAHEKBmvl8zmUlXWGCgt7SJIikVXy+x9RMBiytrhWQKgAAAAAmonTWRSdB6q6umwvW6cOLtQGAAAAEBdCBQAAAIC4ECoAAAAAxIVQAQAAACAuhAoAAAAAcSFUAAAAAIgLQ8oCiLHzbKANcblcysvLa6WKAABAoiNUAIhqaDbQhhQVOTRlyrUECwAAIIlQAaCehmYD3ZlhVMjtfkWGYRAqAAApLRgOqLq6TIZRoVDIJ8Mol8/XweqyEhKhAsAu6s8G2pDa2lYsBgAACxjhgMorlkuLZioY9Cm3cpXKPp+trUW91OHA/7O6vIRDqEDKKCsrk91u32VZMBi0qKLEFQwHVV2963UTgYDXgmoAAEg8gUhIzpBPo+1Zctkztd6eoTx7pj4w3AqFfFaXl3AIFUh6VVVVkqRnpk1TJBSKWec1DH23apX62+imU8dnhrVt62ptXDRTDkfsdRPbzIjCYUIYAAB18hxO5comT1q68hxOSRGrS0pIhAokvdqf++KMzcpSx8zMmHWrIhF94/crkhG2orSEFDRNucJ+jbZnqYOzMLp8e9DQ36s2yTR5rQAAQNMQKpAyilwudd5pxKKy6mqLqkl8eQ6nCjNzrS4DAACkACa/AwAAABAXQgUAAACAuBAqAAAAAMSFUAEAAAAgLoQKAAAAJB2/3y+v16saw1AoFJJhGAqHW34Ew2A4IMOorDfDtqfFnzMZMPoTAAAAks5//7tEtdt9Wmd4VVlZpaXLvpW8AZkdurXYc9bNsp1b41Zu5eroDNsDh09psedMFoQKAAAAJJ3a2ojS0/sqM6tadnul0u0l8oe/kxlpucnpfpllO0M19WbYDgaNFnvOZEGoAAAAQFJyOFzKNCNKS0tXenqm/K30vHnpmUpnhu0YXFMBAAAAIC6ECgAAAABxIVQAAACgzQmGA6quLpNhVPw8kpNb4XDA6rKSFtdUAAAAoE2pG8VJi2YqGPQpt3KV3MueVNj7o8IdBlhdXlIiVAAAAKBN+WUUpyy57Jlab8+Q7Bn6V9gvMxKyurykRKgAAABAs/J4PDKMX4ZZLSsrUyAQX9cin88XnehO0o6J7uLsyJ/ncCpXNnnS0mWmZ8X3YG0coQIAAADNxuPx6NEZMxR0u6PLvIahdaWl8hUUSLm5TX5Mn8+nhQsXa6Xbo63bvZKksjK3nJ05q5AoCBUAAABoNoZhKOh2a5zTqWKXS5K0KhLRI36/QsHgPj1mMBiUYUSUnt5T9rRqSVI4LIXDzBGRKAgVAAAAaHbFLpc6/3xWoqy6ulke057uVFoaH18TEUPKAgAAAIgLoQIAAABAXAgVAAAAAOJCqAAAAAAQF0IFAAAAgLgQKgAAAADEhVABAAAAIC6ECgAAAABxIVQAAAAAiAuhAgAAAEBcmOccQLPzeDwyDCNmWTgcliSVlZUpNzdXeXl5VpQGAABaAKECQLPyeDyaMeNRud3BmOXp6WkaM2aQpk17Rvn5dk2Zci3BAgCAFEGoANCsDMOQ2x2U0zlOLldxdLndHpa0RFlZY+V2vybDMAgVAACkCEIFgCYLBHwqKytrcF1ZWZkCgYAKC4uVm9s5ujwtbceZC5erSNXVrVImAABoJYQKAE3i91dp+fIVmjkzIpfLtct6w/CqtHSdCgp8ys21oEAAANDqCBUAmiQYrJXP51BW1hkqLOyxy/pIZJX8/kcUDIZavzgAAGAJQgWAfeJ0FsV0b6pTXd1wt6j69tR9qo7L5eKaCwAAkgShAkCr2lv3qTpFRQ5GiAIAIEkQKgC0qlDIt8fuU5JkGBVyu19hhCgAAJIEoQKAJXbXfapObW0rFgMAAOKSZnUBAAAAAJIboQIAAABAXAgVAAAAAOJCqAAAAAAQF0IFAAAAgLgw+hOAhLS3CfKYHA8AgMRBqACQcBozQR6T4wEAkDgIFQASTjBYu8cJ8pgcDwCAxEKoAJCw9jRBHpPjAQCQOLhQGwAAAEBcCBUAAAAA4kKoAAAAABAXrqlAyqiuqZE3HI5ZVmMYCofDCkciFlUFAACQ+ggVSHpVVVWSpE8/Xan2EVvMunWGV9u2eVXpsKt7QciK8gAAAFIeoQJJz+fzSZLs6fvLaW8fsy4zUi6bbbPCYSkc5mwFAABASyBUIGWk253KzMyNWZYZqJbNZreoIrQkZtwGACBxECoAJB1m3AYAILEQKgAkHWbcBoDE4vF4ZBiGJKmsrEyBQMDiitDaCBUAkhYzbgOA9Twejx6dMUNBt1uS5DUMrSstla+gQMrN3cu9kSoIFQAAANhnhmEo6HZrnNOpYpdLqyIRPeL3KxQMWl0aWhGT3wEAACBuxS6XOufmqtDptLoUWIAzFQAAAEACqX+NSp1EH9WQUAEAAAAkCI/HoxkzHpXbHdt9LNFHNSRUAAAAAAnCMAy53UE5nePkchX/vCzxRzUkVAAAACCh+Hw+1RiGQqGQDMNQjc2mcDgs2ayurPW4XMUxIxwm+qiGhAoAAAAkDH8goIULF2ul26PKyip9/vkqtXdkqLx8m8wO3awuD7vB6E8AAABIGOFQSIYRUXp6T9nt7ZSZ1U/p6b0VDkvhSMTq8rAbnKkAAABAwrGnO5WWli6Hw6X0JOv35PN5FAwaMowKhUI+BQJeq0tqcYQKAAAAoJkEAl6tWPikHIZbhrFVuZWrtG7pY+rY8UGrS2tRhAoAAACgmYRCtXIYbo1Jdyo9K0+rbGlaVrtNwaCx9zsnMUIFAAAA0MzyHS5lmKZy0trGx20u1AYAAAAQF0IFAAAAgLgQKgAAAGCpnSe7C4fDVpeEJmobnbwAAACQkHw+X8xkd0uXfSt5A0x0l2Q4UwEAAADLBIPBmMnu0u0lTHSXhAgVAAAAsFzdZHfp6ZlWl4J9QPcnAHtVNzOopOjsoIZRLq83Rw6HS1lZeRZXCAAArESoALBHPp9HKxbOkMNwS1J0dtCyz2fL62qnoKtIA4dPIVgAANCGESoA7FEwaERnBs13uFQdCWu9PUMlWfkKpWfqTcOtYNAgVAAA0IYRKgA0Sr7DpcLMXGUEauRJS1eBI1sBR4YUqrW6NAAAYDEu1AYAAAAQF0IFAAAAgLjQ/QlJxePxyDCMmGVut9uiagAAACARKpBEPB6PHp0xQ8GdQkRlVZVOnDhRkUjAosoAAADaNkIFkoZhGAq63RrndKrY5You/8LvlykpHAlZVxwAAEAbRqhA0il2udQ5Nzd6u31WlrZaWA8AAEBbx4XaAAAAAOJCqAAAAAAQF7o/AQAAoNF2HomxrKxMgUDbHSwlGA6ourpMhlGhUMgnw3ArHG57rwehAgAAAI3S0EiMXsPQutJS+QoKpHrXPLYFRjig8orl0qKZCgZ9yq1cJfeyJxX2/qhQzwJlWF1gKyJUAAAAoFEaGolxVSSiR/x+hYJBi6trfYFISM6QT6PtWXLZM7XeniHZM/SvsF/hcFCSzeoSWw2hAkBUMBxUKOSXYZTL682RJFVXl7XJ07gAgN2rPxJjWXW1xdVYL8/hVK5s8qSly0zPavL9AwGfysrKJO2+O1n9bSTJ5XIpLy9v34tuZoQKAJKkmpBf27auUX7Qp7LPZ8vraidJ8gUNVZeXKtSzQFLbOq0NAEBL8/urtHz5Cs2cGZHL5ZJheFVauk4FBb5ob7Kdt5GkoiKHpky5NmGCBaECgCQpEAnKFQ7oWFua+mflK8fZXpL0gxnR69HTuAAAoDkFg7Xy+RzKyjpDhYU9FImskt//iILB0G63MYwKud2vyDAMQgWAxJRts6vAka3czB1fj2wLcFobAICW5nQWKTe3s6qry/a6jSTV1rZWZY1DqACQknbue7qzROuLCgBAMiNUAEg5DfU93Vmi9UUFACCZESoApJyd+57uLBH7ogIAkMwIFUgKHo9HZWVlMgxD1ZmZ8tZb50u0ToVIGPX7nu6M3QYAgOZDqEDC83g8mjHjUa1fv1Vbl67Rx5lOFTgyo+vX+mt0wPlSJBy2sEoAAIC2i1CBhGcYhtzuoLKyTlVm5gZlZbWXMyMnut4WWitJMiMRq0oEAABo0wgVSBpOZ6EcDpcyM3KUmfnLJGzptU2fuRLNJxgOxAx/ZxgVCoV8CgS8e7gXAKCt8vl8qjEMhUIhGYahGptN4XBYslldWcsJhoOqri5TIOCWtON/pc/XWVlZqXNdH6ECwD6rCflVXrZcWjRTDseOUZYMY6tyK1dp3dLH1LHjgyl1wAQAxMcfCGjhwsVa6faosrJKn3++Su0dGSov3yazQzery2sRPjOsbVtXa+OimVJaWDr9IpV/+ajKc7tp4PApVpfXbAgVAPZZIBKUM+TTaHuWOjgLJUnVkbBW2dK0rHabgkGDUAEAiAqHQjKMiNLTe8pur1RmVj+l22wKhxenbDfmoGnKFfZrtD1Lrky7JGmkPUP/NtwKBg2Lq2s+hAoAcctzOFX4c5e0jECNctI4tAAAds+e7lRaWrocDpfSU7nfUz15Dqdy0h0yJbVzOKVgIGZ9IOCV17s52o3YMMrl83XY7ZdzDU3yauXErvznBwAAACwUDge1bulj2mYLR7sRl30+W1uLejXYRWp3k7xaObEroQIAAACwkGmGlVm7TWPadVR6Vp7W2zOUZ8/UB7vpItXQJK9WT+xKqADQqgKB6uhpXa83J2adw+FKqGswPB6PDGP3/V0zMjJasRoAQKrLd7iUYZrypKUrz+GUtOfrTHae5NXKiV0JFQBa1Q9fzYue1vW62sWsC7qKEmYkjLpJF93u4G636dgxU0OH9mvFqgAASEyECgCtKqPWo1NtaeqXla8cZ/vo8u1BQ28m0EgYdZMuOp3j5HIVN7C+QpWVr7V+YQAAJCBCBRJS/W4nZWVlMgyvwuEKhcOBvdwTiaJuop86dntYkhSJBJWTlq4CR7Zy601iKEkKNe28bd1IGTurrt68xy5WTeFyFcecWq7P42nSQwEAkLIIFUg4Ho9Hj86YoaC7btZJQ1uXrpGZtkb+besU6lkgKXfPDwJL1Z/op+5DvCMzXcccM0bVW79TJBKO+znqj5RRXzAc0PotXymn1rPbLlY9D7s87ucHAAC/IFQg4RiGoaDbrXFOp4pdLlVnZurjTKfKI5l6J+xXOLz7Pu5IDPUn+qmbFE8ZOyb8sYeDksy4n6P+SBn59c4+/GBU6B/+Kh1rs6n/brtYWXglGwAAKYhQgYRV7HKpc26uvJIKHJmqjTitLglNVH9SPDMjTVV72T4YDqi6uixm4h+vN2ePo0LlO1zR55CkbYFqSVK2zd4sXawAoK3buUtyILD7rsg+n081hqFQKCTDMOTz+ZSVldVapcJChAoACaEm5Fd52XJp0UwFg76YEaLqRoVKpOFmAaAt2LlLstcwtK60VL6CAik39ksbfyCghQsXa6Xbo8rKKn3++SqVFW3S8OFHWFE6WhmhAkBCCESCcoZ8Gm3PksueqfX2DJVk5SuUnhkdFYpQAQCta+cuyasiET3i9ysU3LUrcjgUkmFElJ7eU3Z7pezpPWUYbgUb2Baph1ABIKHkOZzKlU2en0eICjgymrXLUjAckGFUyO/3qqzsl9GpXC6XJTOQAkAyqOuSXFZdvddt7elOpaWlKz3dqXA4pJqampguUeFwWLK1QtFoVYQKAG1GXRer4OePKBJZrxdnbpDL9fPoVEVFunbKFIIFADSTcDigsooyffyxqQ1Bnyorq7R02beSNyCzQzery0MzI1QAaDN+6WKVqRyHU8Pat1dOTo4qDEOvuN0yDINQAQDNxIyEFArZlZ5+kDLtAdntlUq3l8gf/k5mJGJ1eWhmhAoAbU6eI0t5aZnqlJOj3LoLDWsZFQoAWkJ6ukuZSv+5S1Sm/FYXhBZBqACAfRQI7PjXWFZWJrvdHl1eVVWl2tpaOZ1OtWv3y+R7XLcBINHVHz5W2vsQsth3scOo+xVJd8T9mIGAL+Z6QWnf/vfU3w+8Xm+j7kOoAIB94PdXqbS0VGeeeYSmTXtGodCOU/mBgE/rly9Uls9QZqZNgwb1VUZGhiSu2wCQ2HYePlba8xCy2He14UDMMOo529bIm+FSqKC7MvbxMf3+Ki1fvkIzZ0ai1wtKUlGRQ1OmXNvo/z0ej0czZjwqt3vHqF11X6DtDaECAPZBMFgrn2/Ht0oFBZcoHN5xpqK6ukx55jqNzJCytUHDcnO5bgNAUth5+FhJexxCFvsuEAnFDKO+2GbTsrBf4XBQ+zo0Vt3/paysM1RY2EOSZBgVcrtfadL/HsMw5HYH5XSOk8tVLL/fK+m+vd6PUAGgTaob5lCSqqurZRhGzCnjulP+fn/D84AHAr+cDs7J6ahI5JfT1g6HS4X2TLnC5Y26bmPn7gb1BYNBORy7nhKnKxWAptr5WBMOhxvcrtjlUnuHQ8FgUFmmGR0K1uPxMFt2M6sbRj07LV3Srhevx3aR8skwyuXzddjjYzqdRcrN7Ry97fHEdolq6P9K/WV1//8KC4uVm9tZGRnZjWoLoQJAm1N/mEOHw6GtQb+W+mv1w8wX5HLtCACG4dXy5d+os/MB5Zm7fkO3zYz8/I1SfBrqblDHFwiodM0aDezTJ9qFqg5dqQA0RUPHmrT0dA0aM0ZVVVUqLCyMLvf5/Vr46TIZRkTrDK8qK6v0yacr9LlhqMqVzWzZrcQIB1Re8UsXqdzKVSr7fLa2FvVShwP/r1GPsXOXqEDApzVrStWnz8Do/5WdlxmGV6Wl61RQ4GtSjzdCBYA2p/4wh05nvrLs1crUNrVvf6FycjpKkiKRVfL5SuWIVGpMu47Kd/zSP3V70NDfqzbJtJlx19JQd4M6qyoqtHr7do1JT1ePev/w6UoFoKkaOtaU+f36UVLtTmdRQ8HgzzNj91VmVrXs9kql2brK5/tOtuzustu3MVt2K9i5i9R6e4by7Jn6wHArFPI16jF27hJVUbFK27evVnr6mGgXqZ2XRSKr5Pc/omAw1KR6CRV7YZo7PjR4vd4GuyAkm2AwKMMwVFVVlbDt8Xq98gcC+n77dnn9ftXU1GiTr0abgxUKhAPa6C2TEf5lJIoyo1LFhqHNRqUiim3TRmOrgpGgtiqiH6s3KytcHV1e/7F8tVtVFg4oUlvZ4HP4ardqWzigoM3cZV2LPEd1uboZhiq2bZCCoSY/R1r1ZrnN4C7P05ztaPJzONKVbfTe8RyRYMxz7Pw8LpsZfY5Aerq8gWpt3Pi5XK4iSdLWrd8pEKhRrRnQj1WbtM3h3Gs76j/HT7Vb5QsHlObzKMsWUVWwVr6Aoe3bf1AgsGN7j2dD9Dk8tRky6x3Aq4K1qvFvV9DukGEY2rDhU4VCaZIkw3CruqZSG9PSlW2r0Xdbtyrb75e7tlZVhqG1a9fGjKRRXl6uasNQtd2urHojSElSTSCgYCSimkBAXv8vF8pVBwLyBwLyer3Kzm7caenG2t0xoqpqRzewumNiqkvmY38yHOcbkqx1S8lRe93/1vrHmupAQIZhaN26dTIMI3o8+tHn0yZfjdLTt6kiUKuQGVF5sEa+cECRYM2O2/5qGUGvlm/cqI0+n2oDAa0pL9eWmmqVRSpij7X1/l/ULav/v7DumF+3bK/bhPw76g35ZdvDY7fY8zdym7pl9f8nZmelq8AwVGbsfpudH8frq1LYZspnRpQe8MowfTKrNikSCcrj+VEOx47jlcezfrfLAoEa+f1eBQI1Mbcl7bKs7nbd49T9X9zb8d9mtpX/EPto3bp12n///a0uAwASwoYNG9S1a1ery2hxHPsBINbejv+cqdiLgoICSdL69etToptBVVWVunXrpg0bNsSMn5/MaFNyoE3JYXdtMk1TXq9XXbp0sbC61pPMx/5k3S+TtW4peWun7taXjLU39vhPqNiLtLQdXRry8vKS5o/fGO3atUup9ki0KVnQpuTQUJuS7cN1PFLh2J+s+2Wy1i0lb+3U3fqSrfbGHP/TWqEOAAAAACmMUAEAAAAgLoSKvcjMzNTUqVOVmZlpdSnNItXaI9GmZEGbkkMqtmlfJPPrkKy1J2vdUvLWTt2tL5lr3xtGfwIAAAAQF85UAAAAAIgLoQIAAABAXAgVAAAAAOLSJkNFeXm5Tj/9dOXn56uoqEg33HCDQqFQg9u+8847GjhwoLKzs9W3b1+99dZbMetnzZqlrl27Kjs7WyNGjNA333zTGk3YRVPa9Oc//1kHHnigcnNz1adPHz3++OPRdZFIRDk5OcrOzlZOTk70p6amprWaIqlp7Rk1apSysrJi6l2wYEF0fbL9jUaNGhXTlpycHNlsNl155ZWSEudvVF9FRYUOOOAAffTRR7vdJlneS3Ua06ZkeC/V15g2Jcv7aV8k87E/WY/xyXwsT/ZjdrIel5P52NvWj7Ey26ARI0aYEyZMMGtqasy1a9ea/fv3N2fNmrXLdmvWrDGzsrLMV1991QwGg+bf//530+l0mhs3bjRN0zTnzZtn7rfffubKlSvN2tpa88YbbzT79+9vRiKR1m5So9v06quvmvn5+eann35qRiIR85NPPjHz8/PNl19+2TRN01yxYoWZkZFh+v3+1m5CjMa2xzRNs6ioyPzoo48aXJeMf6OdPf3002a3bt3Mn376yTTNxPkb1Vm0aJG5//77m5LMDz/8sMFtkum9ZJqNa1OyvJfqNKZNppk876d9kczH/mQ9xifzsTyZj9nJelxO5mMvx1jTbHOh4ttvvzUlmZs2bYoumz9/vllSUrLLtnfeead50kknxSwbOXKkedddd5mmaZrHHHOMee+990bXBQIBMzc31/zggw9aqPqGNaVNjz32mHnffffFLDvjjDPM6667zjRN03zmmWfMwYMHt2zBe9GU9qxbt85MS0szq6qqGnysZPwb1bd69WrT6XSaCxcujC5LhL9RnXnz5pklJSXm/Pnz93ggTZb3kmk2vk3J8F6q09g2Jcv7aV8k87E/WY/xyXwsT+ZjdrIel5P52Msxdoc21/2ptLRUBQUF6tKlS3RZv379tH79em3fvn2XbQcOHBizrF+/fvrqq68aXO9wONS7d+/o+tbSlDb9+te/1q233hq9XV5eroULF+rwww+XJH3xxReqra3VkCFDVFxcrOHDh+uTTz5plXbUaUp7vvjiC+Xm5urcc89VcXGxBgwYoGeeeSbmsZLtb1Tfr3/9a02cOFHDhg2LLkuEv1GdU045RWvXrtW55567x+2S5b0kNb5NyfBeqtPYNiXL+2lfJPOxP1mP8cl8LE/mY3ayHpeT+djLMXaHNhcqvF6vsrOzY5a5XC5JUnV1daO2rdtub+tbS1PaVN+WLVs0atQoHX744Ro/frwkyel06sgjj9Rrr72m9evXa+zYsTrllFP0/ffft1wDdtKU9vj9fh199NG699579dNPP+nBBx/U9ddfr5deemmPj5UMf6NFixbps88+09SpU2OWJ8LfqE6nTp2Unp6+1+2S5b0kNb5N9SXqe6lOY9uULO+nfZHMx/5kPcYn87E8mY/ZyXpcTuZjL8fYHdpcqMjOzpZhGDHL6m7n5uY2atu67fa2vrU0pU11PvvsMw0ZMkQHHnig3njjjeibYfbs2Xr66ae13377yel06uabb1ZJSYnefvvtlm1EPU1pz4UXXqh//vOfOvTQQ+VwOHTyySfroosu0t///vc9PlYy/I2efPJJnXPOOerUqVPM8kT4GzVVsryX9kUiv5eaKlneT/simY/9yXqMT+ZjeVs4Zifaft5UibCPN1Wi7efNrc2FigEDBqiyslJlZWXRZatWrVLXrl2Vl5e3y7alpaUxy1atWqUBAwY0uD4YDOrbb7+Nrm8tTWmTJD3zzDM64YQTdMMNN+jFF1+MmSr+zjvv1LJly2K29/v9cjqdLdeAnTSlPc8880w04depX2+y/o1CoZBef/11XXjhhbusS4S/UVMly3upqRL9vdRUyfJ+2hfJfOxP1mN8Mh/L28IxO9H286ZIlH28qRJtP292Vl/UYYVjjz3WPO+888yqqipz3bp1Zv/+/c2pU6fust3XX39tZmVlmX//+9+jIyNkZWWZ33zzjWmapjl37lxzv/32M//3v/9Fr9I/4IADzEAg0MotanybXn75ZTMjI8NcsGBBg48zduxYc9iwYebmzZtNn89nTp8+3SwuLjYrKytbuAWxGtueBx980OzQoYO5dOlSMxwOm2+99VbMRXLJ+DcyTdNcsmSJmZ6ebtbW1u6yLlH+RjvTHi5OS6b3Un17alOyvJd2tqc2JdP7aV8k87E/WY/xyXwsT4VjdrIel5P52NuWj7FtMlRs2bLFPOuss8zCwkKzuLjYvOmmm8xQKGSapmlmZ2ebf/nLX6LbLliwwBw0aJCZk5Nj9u/f33z77bej6yKRiPnAAw+YPXv2NHNycszjjjsu+mZsbY1t08CBA820tDQzOzs75ufKK680TdM0KysrzYsvvtjs0KGDmZ2dbR533HHmV199lbDtiUQi5owZM8zu3bubTqfT7N+/v/nSSy9FHycZ/0amaZovvfSS2aFDhwYfJ1H+Rjvb+UCarO+l+vbUpmR5L+1sT21KpvfTvkjmY3+yHuOT+VieCsfsZD0uJ/Oxty0fY22maZrWnCMBAAAAkAra3DUVAAAAAJoXoQIAAABAXAgVAAAAAOJCqAAAAAAQF0IFAAAAgLgQKgAAAADEhVABAAAAIC6ECgAAAABxIVQAAAAAiAuhAgAAAEBcCBVAKwuFQrr//vt18MEHy+l0ymazxfyUlJRYXSIAIEk98cQTOuyww+RwODRt2rQGt1m2bJmOPvro6O1nnnlGBxxwgHJyctS3b1+tXbu2lapFKiFUAK3s0ksv1e23364TTzxRr776qubNm6cOHTpIkiZPnqzp06dbXCEAIFl17txZ06dP1+mnn77bbRYsWKCRI0dKkt588009/PDDeuONN+T1evXmm2+qoKCglapFKkm3ugCgLXnxxRf1/PPP66mnntLll18eXW6apiZNmqTjjz9eo0ePtrBCAEAyqwsTr7/++m63WbBggWbNmiVJmjFjhh588EH169dPknTAAQe0eI1ITZypAFrRk08+qb59+8YECknq27evJGnr1q1WlAUAaCO8Xq/WrFmjIUOGKBwOa9myZVq+fLm6du2qnj17avr06TJN0+oykYQIFUAr2bZtmz7++GOdeuqpu6zbuHGjJKlr166SpNmzZ+v888/XJZdcovz8fPXr10/fffedpB3XZNx1113q0qWLCgsLdf3118f8A4hEInrwwQfVp08ftW/fXhMnTlQgEGiFFgIAEt3777+vESNGKC0tTWVlZQqFQvrXv/6llStX6sMPP9Rf//pXPf/881aXiSREqABayYYNG2Saprp06bLLutdee01FRUUaPny4JGnFihX6+OOPdfnll2vr1q067LDDNGfOHEnSTTfdpP/9739auXKl1q5dq4ULF+pvf/tb9LHuuusuvf766/rwww+1YcMGbdy4MXpfAEDyOuGEE5SVldXgz5QpUxr1GPWvp3A6nZKkW2+9Vfn5+erRo4euvPJKLViwoMXagNRFqABaSX5+viTp66+/jln+ySef6G9/+5uuu+46pafvuMxpxYoVmjZtmo4++milpaVp//33l2ma2rhxo5577jk999xzKigoUH5+vk499VQtWbJEkrR582Y9/PDD+tvf/qb99ttPOTk5Ov/886PrAQD7btKkSWrfvr2eeuqpXda99tprstlsevfdd1vs+f/973/L5/M1+DNjxoxGPcZ7772nU045RZLUvn17denSRTabrcVqRttBqABaSUlJiYYPH6558+Zp5syZev/99zVz5kydfPLJOvnkk3XnnXdKksLhsFatWhXTTaq0tFQHHXSQFi5cqKOOOkrt27ePrqusrFTHjh0l7Tit7fP51K9fP+Xn5ys/P1+TJ09WXl5e6zYWAFLQ9ddfrz59+uzyAd7r9eo3v/mNzj///OgHdquEQiH5fD6Fw+GY36UdX2rl5+erU6dO0e0vvvhizZo1S16vN3pm+7TTTrOqfCQxQgXQil566SWdffbZuv/++3Xaaafpb3/7m6ZPn6433nhDaWk73o7fffedcnNzY7pJLV++XAcffLAqKyujZzwkKRgMasGCBTrqqKMk7bjQ+4ILLtD27dujP16vV3/84x9btZ0AkIoOOeQQXX311dq4caO2bdsWXf673/1ONTU1CXGsveeee+R0OjVv3jzde++9cjqdeuGFFyTFdn2qM3XqVHXu3Fldu3bVUUcdpfHjx+uCCy6wonQkOZvJJf5AQnn55Zf11FNP6b333pMkGYah/Px8eTweffXVVxo3bpy++OILZWdn68Ybb9SWLVv0zjvvSJI+/vhjnXvuufr3v/+tvn37qrKyUl988cUu/0QAAPtm8eLFOvLII7Vo0SIdc8wx+vLLL3XkkUfqz3/+8y4j+yWaU045RXfccYd+9atfWV0KUhBnKoAEs2LFCg0aNCh6u7S0VPvvv7+cTqeOOuooXXPNNTr00EO1//77y+Fw6P/9v/8X3XbYsGGaPHmyTj75ZOXk5OiII47Q8uXLrWgGAKSkfv36yWazaeXKlQqHw7riiis0dOhQXXbZZVaXtlcnnHCChg4danUZSFGcqQAAAGiCkpISnX766erRo4duv/12LVu2LDp53OzZs/Xll1/K6XTqlVdeUZcuXfTGG29EJ5ULhUK6++67NXfuXPn9fl1wwQV66KGHZLPZFIlE9NBDD+nPf/6zKioqNHbsWM2ZM0cZGRlWNhdoFM5UAAAANEG/fv30wQcf6K677tItt9wSDRTSnocEl/Y8LDhDgiOZpVtdAAAAQDLp16+f3n33XfXu3Ts6cl+d+kOCS9L++++v2tpaSYoOC/79999HR/GrGxb8uOOO08MPP6xvvvkmOlDH+eefr08++aQVWwbsO0IFAABAE/Tp00eS9MgjjygrKyu6fHdDgtfd3t2w4L169YoZErz+4yXDtRqARPcnAACAJvnxxx/lcrl04oknxizf05DgkvY4LDhDgiPZESoAAACa4Msvv9Rhhx0mu90es3zFihU65JBDorcNw9APP/yg/v37S5KGDBmihQsXatOmTdq+fbuuvPJK9evXT8OHD9dhhx2md999V19//bWkHQFkwYIFrdYmIF6ECgAAgCZYunSphgwZssvyPQ0JLmmPw4IzJDiSHUPKAgAAAIgLZyoAAAAAxIVQAQAAACAuhAoAAAAAcSFUAAAAAIgLoQIAAABAXAgVAAAAAOJCqAAAAAAQF0IFAAAAgLgQKgAAAADEhVABAAAAIC6ECgAAAABx+f9kibyuUi7TZgAAAABJRU5ErkJggg==\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""%matplotlib inline\n"", ""A = biceps.Analysis(outdir=\""results\"", nstates=100, verbose=True)\n"", ""fig = A.plot(plottype=\""hist\"") # plottype=\""step\"")"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ """" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""The output files include: population information (\""populations.dat\""), figure of sampled parameters distribution (\""BICePs.pdf\""), BICePs score information (\""BS.dat\""), which are shown above.\n"", ""\n"", ""Now, let's take a look at the populations file:\n"", ""\n"", ""There are 100 rows corresponding to 100 clustered states. 4 columns corresponding to populations of each state (row) for 2 lambda values (first 2 columns) and population change (last 2 columns). "" ] }, { ""cell_type"": ""code"", ""execution_count"": 11, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
\n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
0123
00.0179752.496320e-050.0041955.931122e-06
10.0099772.292886e-050.0031387.283074e-06
20.0026933.068112e-040.0015531.773218e-04
30.0009901.008111e-050.0009891.008553e-05
40.0000000.000000e+00NaNNaN
...............
950.0060001.247277e-110.0024415.105694e-12
960.0009936.847524e-060.0009936.850553e-06
970.0049881.150700e-050.0022255.157574e-06
980.0040004.474545e-110.0019962.241289e-11
990.0029995.949074e-070.0017293.439323e-07
\n"", ""

100 rows × 4 columns

\n"", ""
"" ], ""text/plain"": [ "" 0 1 2 3\n"", ""0 0.017975 2.496320e-05 0.004195 5.931122e-06\n"", ""1 0.009977 2.292886e-05 0.003138 7.283074e-06\n"", ""2 0.002693 3.068112e-04 0.001553 1.773218e-04\n"", ""3 0.000990 1.008111e-05 0.000989 1.008553e-05\n"", ""4 0.000000 0.000000e+00 NaN NaN\n"", "".. ... ... ... ...\n"", ""95 0.006000 1.247277e-11 0.002441 5.105694e-12\n"", ""96 0.000993 6.847524e-06 0.000993 6.850553e-06\n"", ""97 0.004988 1.150700e-05 0.002225 5.157574e-06\n"", ""98 0.004000 4.474545e-11 0.001996 2.241289e-11\n"", ""99 0.002999 5.949074e-07 0.001729 3.439323e-07\n"", ""\n"", ""[100 rows x 4 columns]"" ] }, ""execution_count"": 11, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""import pandas as pd\n"", ""import numpy as np\n"", ""pops = np.loadtxt('results/populations.dat')\n"", ""df = pd.DataFrame(pops)\n"", ""df"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ """" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""

Conclusion

\n"", "" \n"", "" \n"", ""In this tutorial, the user learned how to call on the `biceps.Analysis` class in order to analyze the trajectory data, which automatically plots the posterior distribution of populations & nuisance parameters.\n"", ""\n"", ""We now conclude the series of tutorials: [Preparation](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Prep_Rest_Post_Ana/preparation.html), [Restraint](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Prep_Rest_Post_Ana/restraint.html), [PosteriorSampler](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Prep_Rest_Post_Ana/posteriorsampler.html) and [Analysis](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Prep_Rest_Post_Ana/analysis.html)\n"", ""**To learn more about BICePs, please check out our other examples & tutorials** [here](https://biceps.readthedocs.io/en/latest/examples/index.html)."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
# NOTE: The following cell is for pretty notebook rendering
"" ] }, { ""cell_type"": ""code"", ""execution_count"": 12, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"" ], ""text/plain"": [ """" ] }, ""execution_count"": 12, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from IPython.core.display import HTML\n"", ""def css_styling():\n"", "" styles = open(\""../../../theme.css\"", \""r\"").read()\n"", "" return HTML(styles)\n"", ""css_styling()"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""Python 3 (ipykernel)"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.8.13"" } }, ""nbformat"": 4, ""nbformat_minor"": 2 } ","Unknown" "Conformation","vvoelz/biceps","docs/examples/Tutorials/Convergence/convergence.ipynb",".ipynb","842853","598","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""\n"", ""Convergence\n"", ""===========\n"", ""\n"", ""
\n"", ""\n"", ""\n"", ""Massive amounts of care is involved with setting up simulations. We should also take great care in determining how much we can trust our simulations. This tutorial shows the user how to use the convergence submodule within `biceps` to determine if MCMC sampling has converged. \n"", ""\n"", ""\n"", ""\n"", ""
"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Typically, massive amounts of care is involved with setting up simulations. Thus, it is essential that we attempt to objectively uncover the validity of our simulations. Despite there being no single clear best practice to quantify MCMC sampling quality$^{1}$, `biceps.Convergence` possess methods that suit our needs e.g., autocorrelation, block-averaging, bootstrapping, Jensen-Shannon divergence (JSD) and more. Previously in BICePs 1.0, trajectory convergence was measured by comparing populations and BICePs scores from sets of trajectories with varying number of steps differing by an order of magnitude. For converged results, the populations and biceps score should be similar regardless of the trajectory length.\n"", ""\n"", ""We stress that users should check that their MCMC simulations satisfy the following items before checking convergence: 1) All states are sampled at least once over all $\\lambda$ values. The MBAR algorithm estimates conformational state populations and the states not sampled for any lambda value will be considered to have infinitely high potential energy and the corresponding predicted population will be infinite small. 2) The MCMC acceptance percentage of sample space is high. Low acceptance percentage is a sign of inefficient sampling and implies that many more steps are required to adequately sample parameter space."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ """" ] }, { ""cell_type"": ""code"", ""execution_count"": 1, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""BICePs - Bayesian Inference of Conformational Populations, Version 2.0\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""Warning on use of the timeseries module: If the inherent timescales of the system are long compared to those being analyzed, this statistical inefficiency may be an underestimate. The estimate presumes the use of many statistically independent samples. Tests should be performed to assess whether this condition is satisfied. Be cautious in the interpretation of the data.\n"" ] } ], ""source"": [ ""import biceps"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""After consideration of the latter items, the `biceps.Convergence` class should be used to give a statistical evaluation of convergence in MCMC trajectories. To get started, the class only requires the `filename` of a biceps MCMC trajectory (including its relative path) for initialization. In this step, the trajectory is read into memory and stored as the local variable convergence object `C`. "" ] }, { ""cell_type"": ""code"", ""execution_count"": 2, ""metadata"": {}, ""outputs"": [], ""source"": [ ""%matplotlib inline\n"", ""C = biceps.Convergence(filename='../MP_Lambdas/results/traj_lambda0.00.npz')"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""To view the trajectory of 1M steps, we plot the time-series of sampled nuisance parameters ($\\sigma_{J}$, $\\sigma_{NOE}$ and $\\gamma$)."" ] }, { ""cell_type"": ""code"", ""execution_count"": 3, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""iVBORw0KGgoAAAANSUhEUgAAA3kAAAJOCAYAAAAK+M50AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd3wT5R/HP0n3oC1QNmXvVZAlS5C9BFygqAiC4OKnCCIqU1EQBRcqKsoQFXDhQDZllL13oWW0jEJboIvu5H5/pJc+d7m73KWX0fb7fr140SSXy5PL3XPPd32+Bo7jOBAEQRAEQRAEQRClAqO7B0AQBEEQBEEQBEHoBxl5BEEQBEEQBEEQpQgy8giCIAiCIAiCIEoRZOQRBEEQBEEQBEGUIsjIIwiCIAiCIAiCKEWQkUcQBEEQBEEQBFGKICOPIAiCIAiCIAiiFEFGHkEQBEEQBEEQRCnC290DKGuYzWbcuHED5cqVg8FgcPdwCIIgCIIgCIJwIRzHISMjA9WrV4fR6JyYGxl5LubGjRuIiIhw9zAIgiAIgiAIgnAjV69eRc2aNZ2ybzLyXEy5cuUAWH7UkJAQN4+GIAiCIAiCIAhXkp6ejoiICKtd4AzIyHMxfIpmSEgIGXkEQRAEQRAEUUZxZukWCa8QBEEQBEEQBEGUIsjIIwiCIAiCIAhCMzsvJOOrHXHgOM7dQyFEULomQRAEQRAEQRCaefaHgwCAJlXLoWeTKm4eDcFCRh5BEARBEARBEA5zOSVL8XWTyYT8/HwXjcb9+Pj4wMvLy61jICOPIAiCIAiCIAiHySswSz7PcRxu3ryJ1NRU1w7IAwgLC0PVqlXd1hebjDxCF9Ky8xHk6wVvLyrzJAiCIAiCKEuYZWryeAOvcuXKCAwMdJrBU2A2w8tgcJtBxcJxHLKyspCUlAQAqFatmlvGQUYeUWxupuXg/nnb0LRaCDa82s3dwyEIgiAIgiDcjMlkshp4FStWdNrn5BWYcOlmBgJ9vdCgsvP6zmkhICAAAJCUlITKlSu7JXWTwi5Esdl89iYA4FxiuptHoh1eDYpUoQiCUAvNFwRBEPbha/ACAwOd+jlp2ZbPycozOfVztMJ/b3fVIlIkjyg27g+MO8a93AIM+nw3svJMMHMcPn+yDTrXD3f3sAiC8GDGrzyMW+k5+OOlLvAyltTZjyAIQl9OXUuTfc3ZKZSs243jOI9I2QSc/73tQZE8ovh4yMWklb9P3MCV21lIyshFSmYenlp6wN1DIgjCw9l89hZOXEvD6evyCxqCIIiyxsYzN9322azoC+VZFEFGHlFsSqaJZwtlYBEEoYTZXDRJFJhpwiAIgnA12XkmxCVlICOnKAUy38TMxzQ1WyEjjyg2JTSQB6+SOnCCINyCifEEmcjIIwiCcDnxt+8hK8+Eyyn3rM+xBp+ZrDwrZOQRxcZQQmN5RqqnIQhCAyZBJE+6JxRBEAThPOxmUehs4+3fvx+9evVCeHg4DIUtGvh/nt77j4w8osxCNh5BEFpg+0CRjUcQBOF56Fl6c+LECfTo0QORkZHYtWsXNm7ciAoVKuDBBx/EmjVrEBYWpt+HOQFS1ySKzekbJVOAgGrw3ENaVj7eXncKj95XAz2bVHH3cAhCNQUUySMIgigWHMchO9/xVgc5+Sarwy0rr8D6HM+9vHz4mm170gX4eGlWu/zf//6HoUOHYtGiRQCAZs2a4cknn8SBAwcwfPhwfPjhh8jOzsbs2bMd/DbOpcwZeatWrcLu3btx5MgRnDp1Cnl5eVi2bBlGjx5ts+3s2bMxZ84cyf34+fkhJyfHyaMtGfx8IMHdQyBKEAs2xWD9yUSsP5mIK/MHuXs4BKEagfCKibxEBEEQPH7e6pIDs/NNaDZzk5NHY8vZd/sh0Fe92XPr1i1ER0dj+/btgueDgoKsxuLp06cxbNgwPYepK2XOyJs+fTri4+MRHh6OatWqIT4+3u57nn32WdSpU0fwnLd3mTt0BKELiWnkHCFKJqxMN6lrEgRBFDGoZTV3D0FXjhw5ArPZjMjISJvn27VrBwA4deoUZsyY4Y7hqaLMWSpLly5Fw4YNUbt2bcyfPx9vvfWW3feMHj0aPXr0cP7gCJdCSzT3wFGeLFFCWXf8uvVvStckCIIoQu2dPcDHC2ff7efw55y9kW5N12xRIxQAEJ+ShYxci8Jm/UpBCJCI2AX42KZwKmEunOOzs7OttXenTp3Crl278O6778JkMiEhIQENGjRw9Ks4nTJn5PXu3dvdQyhVJNzOEjzmOE5zzjNBEERJICUzz/r30fhUDG5V3Y2jIQiC8BzUrvwMBoOmtEkx/j5eViOP3094OT/kFxplAT7exdo/T8eOHREQEICpU6finXfewcWLFzFx4kS88MIL6Ny5M86dO4f69evDaPRcDcsyZ+Q5wu7du3Hw4EF4eXmhSZMm6N27N/z8/Nw9LI/g1TXHBI9NZg7eXiXDyKOIknugo06UVNgWCj/suYyZDzVz42gIgiAIMXqtMSpVqoS1a9di8uTJaNWqFSIiIvDCCy9gypQpACz1eK1atdLp05wDGXkqmDlzpuBxtWrVsGLFCvTp08fue3Nzc5Gbm2t9nJ6ervv43EliqrC+ispUCHuQbU2URDiOw/fRlwXP5ZvM8PHyXC8uQRBEaUM6jFC0sNDTgT948GAMHjxY8rVTp06hZcuWun2WM6C7kwKtW7fGihUrcOXKFWRnZyM2NhbvvfceUlNTMWTIEJw4ccLuPubNm4fQ0FDrv4iICBeM3H2YS8gKnqJ4BEFoQUowaMvZW24YCUEQhGfgKWspTuZvZ3L8+HGrAIunQpE8BcSyqA0aNMD06dNRpUoVjB8/HnPnzsWvv/6quI+33noLr7/+uvVxenp6qTb0TCUglBcdm4Knvz/g7mEQBFGCkHJg5ZtIfIUgiLKLYM3nIZU6rrA7b968iTNnzqBjx47O/7BiQJE8B3j22Wfh7e2NPXv22N3Wz88PISEhgn+lGZMTr67M3ALkFjjeQJOHDDyCILRCglIEQZRVUrPyBH1CeZy55tMEMwxnRxe/+uorDBgwAF999RV8fHyc+lnFhYw8B/D19UW5cuWQlZVlf+MyBuckx3ZmbgFazNqEzvO229+Y8Gg85JZAEJqQWuCQ4UcQRGnnXGI6Wr+7Bc8uO2jzWuytTJePR2oN4cp0zZdeegnHjh1Dv36Ot4FwFWTkOUBsbCzu3r1r0yCdcJ5X59S1NADA7Xt5drYkPB1PyeEnCC1IpWaSiUcQRGnnl4MJAIDdsSk2r605dNX6t8FDZsQSUDXkMsjIkyEjIwMnT560ef7u3bsYO3YsAODJJ5909bA8Dk7kM3FWTR4ZBgRBuBOpuc1IkTyCIEo5SvOcx6RrMojXpWWZMie8snTpUkRHRwOwyJ/yz+3YsQOARWxl2LBhuH37NiIjI9GuXTu0bNkSlStXxvXr17Fhwwbcvn0bffr0waRJk9z1NTwWZ6lr6rnX3k2rYOs5UsUjCEI9+SbbWSjqfBIGtarmhtGUDXbHJuNS8j0827mOu4dCEA6xNy4Fo344iM2THkC9SsHuHo5DKBl5Umns7oCTfVC2KXNGXnR0NFasWCF4bs+ePVYRlTp16mDYsGGoUKECXn75Zezfvx///PMPUlNTERQUhJYtW+Lpp5/GuHHj4OXl5Y6v4NE4zcjTcbd+3hTAJghCGwVm23TN345cw8ePR7phNGWDZ7631AA1rRaCDnUruHk0BKGdkUstQm89F+7ElfmD3DwaxzAqJCx4jKI6MwxPGZInUOaMvOXLl2P58uV2twsJCcHixYudP6BShtPSNUWNLh0VPPhx3xWsP5Uo+3pSRg4ql/NXta/EtGxMWnMcozvXRf8WVR0aT1nEA7M7CMIu1+9mu3sIZZZrd7PIyCMIN2FUsPLYdE13pkkmZRT1MaV0zSIopFHGyMorcGpvJwlntz771clLM+OvM4qvj1l2SPW+Zv99Bvsv3cELq444PqAyCE3ARElkxl+n3T0EooTDcRwycvLdPQyC0ITadE0lB67ZWYtDCTzJkezK7y1FmYvklWXu5Rag+axNqFUhELumPqjLPsUXk7OKcNk0UDPHwctJKk6pWepvwHfv0c2aIMoKKZmk7OsuPGnRVhzGrTiMbTFJ2Da5O+qX0PoswnFyC0zw8y55ZT5K6ZqsASiVyeXr6wuj0YgbN26gUqVK8PX1LXbrGXNBnlWMLyfHEsHjCorm55t38hDqW6yPKDYcxyEvLw/JyckwGo3w9XXPgMjIK0OcuJoKAEi4o19/P/El7ayaPPaD8k1m+HgpB6ET07KxJ+42hkRWh6+GGrwAXw0TMAnrOcQ1SnsjShHFSR8n1FFKbDxsi0kCAPxyIAHTBzdz82gIV5NwOwsNq5Rz9zA046Vg5TWrHoI/jl0HAByJv2vzutFoRN26dZGYmIgbN27oMp6k1Gyr48c3O8DynGhdwT/vbgIDA1GrVi0Yje5JnCQjrwzhjHI5cWsDZyktsSl+K/bG48Ue9RW37//pbqRl5yMxNRsTezVU/TmNNUzAtKxzjPjb+jkZCMJVVA3xx830HJvnVx1IwDP313bDiMoO1EKHKA38dfwGpvRr7O5haEbJiVXArPmup0o7cH19fVGrVi0UFBTAZDIVezwvfrrLWna0bXIPcByHcX/sFGyzbXKPYn9OcfHy8oK3t7dbnYBk5JUh9KiFWnfsOn4/eg1fPNkGYYG+NuF5Z6VrsrvdezHFrpGXlm1JpdxxIVmTkdezSWXV25LzniDKDiPaR+CzbbFoWi0E5xLTrc/PWHfapUYex3F447eTqBLihzf6NXHZ57qTkm7iLdx8XiDcQ/eOskFOvtCg2XsxBUDJM/KU0jULRBoPI7/bj3mPtETtikGC5w0GA3x8fODj41Ps8dzIMCGv8HP9/f2RV2DG9YyiY12vUhD8/dUJ6JV2SHilDKGH/fXamuPYHZuCT7fGArCNDjpLXZPdrTMaEAcVpmlqGb2BYnkEUWbgp537aoW55fNTMnORkZOP87cy8NuRa/gy6qJbxkFYMJk5XFVZ+vDF9jhrShtRdth8VtiPN8+JonfOhF1ziaPqeaL+oXsv3sb/Vh936njEx1Hc3iY82M+pn1+SICOvDMFeisVNf0nNshS5imvw/jzqnBsZO157Nh4rpavWDOMnMS01heSNJYiyA5+KrlSf4izSsvPRbu5WtJy9GXkFRQua0pzGKEj998Cv+dJPR9BtQRQ2KLTkAaR/I6rhLBt8FRUneFxSHcNLdhY5lPJFRp2UWnuSRFq7XkiVBInH5CkN2j0BMvLKEEKFyuLti3+7+GJaGn25eDuWQUsk72h8qvVv1fdSfjsNx4Xu09o5eyPd/kYE4YF8Ubhg8zIaMLpzHZd9LsdxeOmnojYt9tTsSgv5jHfeE9uubDpjidJ8s+uS4nYlNXrjyeQWmDDvv3OF6Y+exffRl/Hr4asAgJibGW4eTfHJKzAjK68oFVIcNROnawLOVcOVup7EhmZBKZ4XtUJGXlmCOe+LuzjgL2LXXUtFH2TPke7NbKDWc8YvnLQsJlIyiiR7ndl7sDQx8PPd7h4CQWjm+NVU65znZTBgUKtqLvvsqPNJ2BN32/qYdS6V5sXMhlM3rX978tc8XqhaLYc4ykAUnx/3xeObXZcw8rsD7h6KgITbWXjv37N447eTkhHcfJNZ0ijyZJbvFTrubSN5tt/T1U6ZAtEYSrPzSytk5JUh2AuvuK0O+Hc7S2hFDHvN2kt1YdOp1EbbeMNQy9fJzC2w/k2TCkGUXg5dvmP928tocGk60HPLD8u+VpqdS6xSX0nOSs0vsP2NVu2Pd8NISg+eGiFLzsy1/i01RcTczED3j3aUqDTrD/6LETwWG6lSkTVnfj2pfYvnQVqPFUFGXhmCjbIX18g7fvVu4T5dczGxHmt7dhtr5Kn9npERYQDUZ2veyy0QLEJK82KLIMo6S6OLUvKMRoPNAs4Zi7bsPBNazt5k8zy7gNl5IVn3z/UUSstCTWoRzKa/Edo5dOWO/Y3cALvemL/hnOQ211OzkZNfctcL4uwByXRNJ36+1JqOjDx5yMgrQ7CnfXEvgqt3LAaOq9KFWGPSXk0ea+Sx41NaiFnTNVV+nY82nRc8FqcLEARRevBi5hwvgwE1woSNdp0xDT7x7T5k5BTYPM/Oaa/8fEz/D/YQ2MWcJ9bkqSVPIpLnbHLyTaVafKJeeJD9jdwAuzL5bre8PoGrMqCcgdigkkrXTM7ItXmuOHAch+w8E7LzTJLHTrwOLcnHV2+oT14ZgjVyzDrcd5btcY7IihTsRezlpWzkbY9Jsv7NGrNyhm2gr5c1rVPtYmL53iuCxxTJI4jSi5+Pl/Vvo9GAWhUDBa+bOQ5eOivnnbiWJvm82KF0L7cAQX6l71YuENcswWs2VwuvpGbloe3crWhXuzzWTOjk0s92BReTMxF13jMj2GrLQ0pypEls1Lni/H519XH8feIGAOCvl7tIjIkieXJQJK8MwZ72xU3XBIA5/5y1ee6R+2oUe79SsF7J1jXDFLf9nlH4ZCckuajjZ0+0sYq5OHpYMnJtPe6EfUpSbQJRdnm8XU3r314SKzlXLirE6nZH4u+67LNdCTvnT1932o0jUaZt7fKKr0s5AAN9vSS21Iet55JgMnM4cNkzUxqLy1JRhMyzIpbqrDxPFF/558QNLN4ea3e73AJhqrErvgtv4AG2DnbLGEQppHpEMUoJZOSVIe6xQiFOWlwH+TrHo8waaJdv31NtHJiYi11uIdawcrBVhdPRo/KdHRltArh217ZxsEfdnwlCBnZek/LWO2M6FaeE8ogXNPbS10sq4ntUtofWsZUP9FV8Pb/A9uRoWDnYWcMR3PM8ywDSB/Hpnu9RC3q16xLP+10m/nIMH2++gKMJyk6jW+nCVExXq8dKzXdiR4pHnRJuhoy8MsTra09Y/9YjkieFszwo7I3r5wMJ+JppzqmEt7HoFJeL5Jk4rujG4eBx0TsHvbSRlpWPrh9G2TzvrPOQIPSEXVd4S6SLO+M87tG4kuTz4gXN1nO3dP9sT0B8TD1pMR+XVKTuaLIzrjyTrXHqzJoh9j73/n/S4h8lGfHV50n18GqDWmc8uF/s7cw8+xsxuLpUxUtktazaH49le64InqNIXhFk5JURrqTcEzx21jWQJ+G11AOx52vBxvMyWwqJZW7Gcp5gk5mzeq/OqZBmlooi9mtRVdV4yipxydLHlYw8oqThLdGo89+TN/D00gNIydTP2SN3ZYxdIWypsGLfFd0+05MQR6E4D1q38Y3QAfviY1L3RGcaJjGJRXMtW7pQWvGkXpFqI3T/MOmHngC7phHPbl6i+c6mhYIThYVSMnNRZ9p6xfF8uvUC1p9KFDzngdmwbqPMGXmrVq3ChAkT0K5dO/j5+cFgMGD58uWy26enp+P1119H7dq14efnh9q1a+P1119HerrnemKk6PHxDsHjuKRMp3yOszwojk7kbCpBVp503VyBibOmIPx8IMHuPqUmch87YjBlnQAf6TRecrgRJQ02O4Dnzd9PITouBR9uiJF4h2OoTUkvjTNPRk6+TS80T1LMS7hdlHqea0cOX0qYwpnpej+W8h584mw9T6pvU+u0zPcgwxQAEu4Unc/iNZzYpyVOz3Smkf3M9wdtnhP3SU6RiDzq6Wwr6bjdyJs8eTJWrlyJkydPoqDA+eIV06dPx7fffov4+HhUq1ZNcdt79+6he/fu+OSTT9C4cWNMmjQJzZo1wyeffILu3bvj3r17iu/3ZJ7+/oCu++vaIByA80L3ekR85G6sWm+4UpOaJ6WMeCJSKW4ARfII5yLn2CkOYk8yy5172lKdlFDrAPGw9aIuTPn1BHbHpgie86QULDZ1NCtf+RyTaobuiTVZJZWSGMmrFOzn5JFog61zExtRBpEbSXwdyq359BBVi79tu8aWEr6SojTWozqC2428Tz75BGPGjEGbNm0QHByMNm3aYMyYMfjss8+wc+dOpKam6vp5S5cuxZUrV5CcnIwXXnhBcdsFCxbg+PHjmDp1KjZv3oz58+djw4YNmDlzJo4fP44FCxboOraSTKVylknLWUW4ekzkSp7ggS0t6ZZq1EGlJjUyVpSRNbDpuBFO4qNNMWg2cxP2xKXY31gDSo2s9ZwH1hy+qmo7JaOzpMKmQ/LsuqDv71gcfJnCIHuCMFL3C08yTEoafx69LnjsSe2L1N7P7CmyuhojM4eE+PsIXhNHosXHWy5dU49TXGrfauc7V7cu8VTcbuSdOnUKP/74I6ZMmYIePXrg5s2bWLFiBSZNmoSePXuiYsWKqFOnDoYNG4ZZs2bhr7/+wu3btx3+vN69e6N27dp2t+M4DkuXLkVwcDBmzpwpeO2tt95C+fLl8f3335cpCXglz4h/YR8pZ024Jg3GY//mwvq4Mzcs/abkom3Nq4egUZVyAIAAH/vS1lL7oZu2MnJGnifV2RCliy+jLOJM7/1r2+pFK+w0f+Cy/P3HHdPA+Afquf5D3cDMvzynjcIDjYpEcaqFSqug8rg6XdNR3vv3LD7cqF+6sbO4JzKqfz9yXWZL16M2euRpTmF23KevC/tzVggSqseyjvw79/Js0qp5iht5j72VIbmuUqsm7EnGvztxqZG3bNkyHD16FPn5+dbnmjdvjpEjR+LDDz/Exo0bkZiYiMTERGzcuBHz58/HE088geDgYKxfvx7vvfceHnnkEVStWhVDhgzBuXPOU46KjY3FjRs30KVLFwQFBQle8/f3xwMPPIDr168jLi7OaWNwlLikTKzYewU5+fpKTit5qXjjyFlpi0ka1CsrBAsnpSe+2Q9A/sZqNBqsKQBqJl8plTdKDVBG7rh62s2O0EZ2ngk/7ruC66nZsttcvZOFOf+cwfI9lz1ycasGdtz1K8nL37vj24UG+NjfqBTgSSnx7DKTNeLMZg6/HEzAhVtFC1+paISnXQdJ6Tn4Pvoyvt5x0WNbVcjxydYL7h6CFTlnbwNRywwt9z2O47D28FWcdaIiJ3s+ihVZ+dfqV7Ksg9nrcOFmeQG84p7j41Yelnz+54Pqak5d3drBU3FOUzMZxo4dC4PBgGXLlmHUqFGy21WpUgV9+/ZF3759rc/l5ubizJkzOH78OHbv3o0///wTHTp0QHR0NCIjI3Ufa2yspSlkw4YNJV/nn4+NjZXdhh93bm6RgeIMwRaO43Ap5R7qhQfBYDDglZ+PIuamxQsytmtd3T5H6aL197H4C9gCXj25k6W+1kVscPGNypWMVD5dQc3EJLXY8LSbtqchN+FSumbJ5uPN5/F99GUs2nIBx2b2ldym18Kd1oWwj7cRT3W0n0mhJ3qcYuyirJ1CqpU7MjvKytzjSelXuYzhlsI4IH87eg1v/XEKAHBl/iAA0nOfKzM/zGZOkI4nBSsEYonAOK9Ze2lGztkrVuTVMk1sPnsLU387CaDonNIbpfswL2zDZ2uxEbqT19Ik3wMUf166dlfacZhjR+jIy2iAycxRJK8Qt6Zr3rp1C9euXVMluOLn54f77rsPzz33HJYtW4a4uDhUq1YN06dPd8rY0tIsJ29oaKjk6yEhIYLt5Jg3bx5CQ0Ot/yIiIvQdKIAFm86j18KdWLjZ4tHiw+e7Y5N1/ZzzCu0F/LwtE0DCnSxcdYKhJ84TV0K2H57CpMNPwmpuvlL7oXRNZR79eq/k81IezbKUAl3S2XXBMsfczcqX3YZdnB+JV26066mw13d/hXYpHKff+VsvPMj+RvCsCFdZgOM4vLbmuPXxpZR71t/8qMT5nVcg0SfPhSIyahxpX0YVZSR5kL6NJHxESQ2uvpfIHWtfb+FSW0skzxU99aSMU/7Y8Q6AAGtJTtG2dxWc78U18qRa1aiBVzp3ZmuHkoRbjLwlS5agcuXKqF69OmrXro2AgAC0bdsWM2fOREKCfQl7AAgPD8eECRMQHR3t5NEWj7feegtpaWnWf1evqium18LXOyy1J4ujhKmjes9vSk13+UgeAOy4oK9xCWi7KcpNLkqLIb6YV03aJQmv6EdmjtDBk5qVh24LovBBKWziWxqJ1diK5Y+jnlM/owV+ThnerqaN+hxLdFwKhizegxdXHSn2Z5Zj0jB9xR2ABWOjxYyr4DgOY5Yfsnm+wMzhy6g4rD5ke393dyTPnhOA4zhB6yBPajovRbCfugS0/04lou5b/6GnqH2UM5Fbe4gNFi0/vytklcRR8h/3x6PDB9vw1NL9VmNJSneBjbZFVBDWphb3HPfzdsw88SmcKymSZ8EtRt6BAweQkpICjuPAcRxMJhOOHTuG999/Hw0aNMAbb7whSHGUo3PnzmjevLlTxshH8OQidXzapVykj8fPzw8hISGCf86ENVL07oWndNH6M4Ilzuhbo3bCyC0w4c9j0gtJJc8SX8yrxikuNRaaTxxjw+mbgser9sfj2t1sfLvrksvGMPffs/hki3Rdx517eRi34jD+Ol4yjRM9WbnvCiavPVEi0gNZRU1Oh0o5fl5lld1mDm4mue2p62k257UjsMZbk2rlZLf7fHscLWjskFdgxv9+OYbVB9U5keXIN3HYcd7WiZlvMuOjTdL1Sa4UXklMs01x23ruFupMWy/bGD1ZVO/u6ZFhtaN76aejACyRVlch5+z19nI8kucKxL3mZqw7jeSMXOyJu81sYzlP9l6UFp5KyRDuo7jnuJ8KETwx7w1tbnWIaTUyv9t1CW/9carUZRK5xcjjOA4jRozAqlWrsGHDBqxYsQLPPfccKlasiIKCAixatAh9+/ZFZqaykdKpUyenRfLYmjsp7NXsuQv2xObFEJSiUz8diEedaevx/nr7CnRNqsovNNhInjOuEbUTxm9HrsnvQ2FgxY3kudObfiT+Lr6MivO4xXeByYwvo+JwLEE+Ra+hqCD94JWibQ9cclxFVy3XU7OxNPoyPtsWK5ne8X30JWw9dwuvrj7u9LGoJd9kRs+Pd2Da7yfxyZYLuOKiRczMv87g96PXFCP6YqT6HLmCp5ZK9wHNyTfhi22xVsVdtfBzB2vkPWen3rm4YkzsYjszV7mk4a/jN4r1WSWB9nUcl51ffSgBf5+4gWl/nML7689ixDf7JA0ie8jNsfkF8r+11LzirEjetN9P2Tw38ZdjAORVZsWS9Ho6DNKy8nWfoxwxkFwljHYuUbqkRRyJ9zRDIiNHPt2ehy8D2iWTqfW8SOXX3nrkw40x6PvJTtm5jV1T2qOcvyW626VBuDWSpzVd8/3/zuGXgwk4qrBeKYm4xcj79NNP8csvv2DkyJHo168fnnnmGSxduhQ3b97E4sWLERgYiOjoaIwZM8YdwwNgMd6qV6+OPXv22DQ9z8nJwa5du1C9enU0aNDATSOURurCUkq/eOdPiyz1d7ulvXwsYildFr4mz1lcuKUuKnlXoRkx/5pUmwSvYguvqBqeU3j06734aNN5TPv9pPsGIcEvBxPw0abzePirvdY8eTFiZUD2BjLi2/1OHR8gjDpLST7H33aOkFBxWLj5Ai6l3MPqQ1fx2bZY2XpHteyJS0FckvTiZMf5JFwWLdAyctQ3GM+VuNG6OurEzh3f7LyEhVsuYNDn2pyD/LygthEvUPy0N3YxeylZeZGcqkGYqqTSrJr9LJh8kxkbTiXidqYwOsUev+92X8aBy3fw7A8HNY9BThZeSRRG2inonEW+Ut08IB3pS8sWLvD1NEA/3BSDz7bFooeOKZOO2EdZOiuNS5GckSubgSKeNjSla7ogX1PrT77pzE0bw/mJ9kK9CSUjKyUzF1/vuIgLtzLx/nrp0gylFHUx/DnhZTTAx9tywBy9z9zLLVnqsvZwuZHn7e0t24TcaDTipZdewqFDh1CxYkX88ccf2LZtm4tHaMFgMGDcuHHIzMzEu+++K3ht3rx5uHv3LsaNG6dYn+EOUjJt01z1Sr9QmgiCmDx5PVMROI7DucR0nEu0LT6W8gDJ/R5JGTnWYvlsiQnfSyS8cuFWhmwLCqkbvclsxtU7WbijYGQ6m1+PXMO1u55jlJxlvJr9mkuLVbg7+sim0UjdlNhz2VMKufddFDaFvn0vD7kFJpxLTNfsIY69lYGnlh5A70W7bF47cOk2Ri87hAdFC7TiXt9LVTiUnMXZRG0RPB7+PLWnUsiy/9KdYqWua1lse1hgwCnkqzgeE38+hhd/OopHRI4PqfoetY5DFtl6bwWDXq6FgjOiOTfTcxRf775gh81zY1cIpeqLW26RcDvL6lBl06b1wpH1jDNKSMQM/mK37GvitYTaOfTOvTxs1CH12x5aj8+EH49gzWFh/Wn1sAAsH9Pe+njZHvl5nnUUHom/I7mNjwYjj18LGg0Ga+mNlINRDRvPOP94uxKXGnkBAQEIDg6Gr698RAgAmjRpgoULF4LjOHz//fe6jmHp0qUYPXo0Ro8ejV9//dXmuXXr1lm3nTp1Klq3bo0FCxagb9++eOuttzBw4EC8++67aN26NaZOnarbuNKy83WZ9LstiLJ5TsqjoabptxjlZuhFp5JYAKY4rNofjwGfSU+eLWZtsnlO7hh2eF/oLKgW6g+gyLhj++RtO3cLfT/ZhYe+iJY09KQK6ZMzc9FtQRTue2+LwrdxPvY8/q4klukVJf5ZeK+8vYXb8aupeg9LALtklzLQ2QXFyz8f1bRvjuOcojSbJ3H+vfDjEQz4bDd+PSyfrizFWcZ5sjfOUiedVqiUKRdJXSMhLqGFTW68iYprY9TCz6FaInnP/nDQmikBAOk5+TCbOdzOzLWbfgnYzrc/jesoPz4PF8vQA3sL0aiYJOsCTRyB18uckjO8ldI1+cVmn2ZV8Fjbmtbn3eHfkoo4iiP1WvuLpTHKurfSc/DAR1FoU3gfdEYmhNpznb1U9eqZprROu5Wuvpev2t/+vve2yDYb1xNHol7bJNL2ezSubP37PwXjlDVy5Rwnlcr5aR6TwVB0zn2xPdYhp/s+mZrDkopLjbzKlSsjLS0NKSn2vTvDhw+Ht7c39uzZo+sYoqOjsWLFCqxYsQJHj1oWbXv27LE+d/z4ceu2QUFB2LFjByZNmoSYmBgsXLgQp0+fxqRJk7Bjxw6bJumOcuDSbUTO2SyZT68H7MT+bKfaAKTr0+zlrStFXdh0zVQFOXWtLJUpFpdD7WS+8rkO6NWkMv56uQsAYZ88vq4vNikTzWdtspkA2YV/76ZVAEDQqNSdjdGNHhRZLs+k97LH8L1hLazpm/ZqGdce1l+NloU9p3su3ClYsACWHkU8W86qr0UDgM7zt6PbgigM/2Zf8QYpQiqqHVUoBvGDgvdUClaee93x65j99xlEvrtZsf2KXBsEtVFZB5WxdcHR64NPZ09MU46UiOG93VfvZKHV7M2o9/Z/aDt3K1rM2mQ3xVJsUHRpEC677YKN8k2JSwv25nYl54NeUTO5c1zKeOKbiv+439K8uZy/N2Y+VCTWoxT9cydaxvXX8euIfHczPttq0ShQ6pumFxUCbYMEUeeTbJ4bElnd+rceGSNH4u8gcs5mTF57QvN7DSKNTEfPx5ibzmmn4IgRbC9SJhb0YWG/v57LJba+dE/cbdz33hZZsSX2nGAdSJ6zgtIHlxp57du3B8dx+PLLL+1u6+fnh+DgYCQl2V68xWH58uVWVU+pf7NnzxZsHxoaikWLFiEhIQF5eXlISEjAokWL7KpqauHTwglSHP7WC94o8fU24qUHLTWEUpOevYtWzov5aq+GTisk1pKXnXA7C59tkxbKEdOwSjl8P7o9WtSw/I78x5jMnGAhaDJzNtEx3pPYokaItWfPCebm5s5wvzsX0GLYc4I3lj54uCWeub+2dTLWy8PqKOK0mYNXpFNHHIE3CA5e1m+fesPWkJg5YMU+y4L0Y5FSoJrru/WczZj99xnBc5slrgVXp7jz4j7HEu7inxPFEyhZfyrRofe9KyF6sStW2dnJOovaKjRgL+3ULG+RZrcXbVCad/W6PcndA09IZBxcuCWMwPx57LpASt/dqepyfL5NfSYO3/j9k60WdWL2/uOsNYFU9seHG2IEjzmOE4gR6VEHvHi75bj8IaPerYi4Js/B3/7HwvlZb9Skaw5rXV3wmP15J/bUpk3Bfn01ToVWNdWtt8XGNGARDBPz4/54RM7ZjKMJd3E55R5azdlctA8PWkPpgUuNvGeffRYcx+H999/H8uXLFbe9evUqUlNTERgY6JrBuRE9JL6lCPQV9jXx9TIWtQqQqAnIlWjayiJ3MU7q00jwDVrVDMV7/55F/093Wb2ZjhKosicOACzc4rg3278wEpmTb7K5yPt9ugu9F+20Lnx5o9nbaJSs0eGlm12B+DdUEgBwNVL3eN6Y9jZa/rC30FEz32blFaD/p7tk1eOUEH++t4xAjFaiYvR1TqlFa73ciHZFxfLse8XGt5r6hozcAizfe0Xw3MebbVtTuFo+nG9E/MZvQmGiBxZEIaGY6WR1VTYsl4oC50scU47jMOqHgxi34rDAoCjLRh5f0/bvyURNhpEzogUmGafU5F9toztig9DP2yhwILqyV54WtKjniq/lGeuK0pOddS/iDZJFwyOtz4nPi/RsYTq0HsdaT+eUo8Nx1typ5vhUCxP2wTNzHGpXtKzPezSupPqz8grMGPxFkfCV3BqxPBOx/evlLvjg4ZZ29y2VoSZ1Hs5YdxqZuQWYvPYEHvx4B7KYMTzKpFSXBlxq5A0aNAgPPfQQCgoKMHbsWDz22GPYt882lSk9PR1jx44FAERGRtq8TqiDv3B5I8/by6DoSczJtxPJU4i6sNdWk6rl8H30ZcTczEDTmRvxys9HVXn1Os3bhjrT1gtquYJ8navayRNcKMF7OP6uZMpJXFImFkfF4aEvopGUYYnQ+IiOJ8vei/oXnEshnpwdLTZ2BlK/OF9wzRtT9jys99eraPdz/j5+AzE3M2z6QHEch0lrjuPln+TPP6032wGf7ZZVomSRapjsCrSuAdiUWva94rlBbhHgSG2vqyMYvJEgrqdLuJOFmX+flnqLatQuujrWraBqu1vpudh1IRlbz90SqB6OKkyzLwuIF31JTNrX6evq0wGHfbUXWXmW+UYvR6qWVEbxeR7s5y28/zo5iyE8WFn74I+j11Bn2vpifYb4Ur7BpDNnalDh1QK/DmGFOWJFPYG/2C7M6HFmi6O8AjM6zVMWCOwqSrXe52B7oMNMiyE9UZNRM7hVNcFjjiv6LbyM6k2Jw/F3BGJE4h59PPzcOuuhZjAYDKocsFKOMzGswqy4HhUAyvn72DxXknG5uuaaNWswdOhQcByHP//8E127dkWNGjXw8MMP4/nnn8cjjzyC2rVrY9u2bTAYDBg/fryrh+hy2HXC70eu4bGv9yrmMwPAkp0X8fTSA7IKkECRxyuvoGhSZCNPQ78U1jsq7QtQXpCzN1GxofHvyUQ88vVe5BaY8NGmGDy/8rBkugKf3tafEVpxVY1ZMBMxTFAQyzh1Pc2aXuttNMqOb+R30n269OZGqlAS2xUKkP+cuIFHv95rt8+UlGFllaJX2bJCricPi5zHODkjF38eu471pxJl60S1ekbPJabjdQdqMlyF1u/DXreCSJ5oUSRXh8cLGGnB1Sm6sUmZyDeZcf6WrXEu1dhaC2qPt1KPUTl4w3r9/7qiZnmLx7ychsyGkopSSq2W28GJq6nWWkW9AiBaHBTibd/o11hQM6TUt1UP5Eod+HlZl3lM4Suc0mCQa4Gfm5SOnriWX485R+rUS87IRaPpG+zW6oqdYWrqu6XEmbRkNmlBTbpmeVEtJAfO6vSQc3ZLoVY189+TltR4Xg1drg0TS7Uw+/cjvn5UllImVexyI8/f3x9//vknVqxYgYYNLbVciYmJ+Ouvv/DDDz/gr7/+QlpaGjiOwyuvvIInnnjC1UN0OewpNfnXEzgcfxfz/pPuHcIzf0MMouNS0PXDKNltzJwl95u/EH29jIKLkRVdAByvyQOA5tWLcqZzJSKCxxJS8efR6/gy6iK2nL2F/QqeLFZgINqOBLNeef98M0018I1DxZFRdyBOUXQ0kpeRk4+nlu5HnWnrsWBjjOK2E385hiPxdzHnb+X0SKlfhk+L4Cd6e2kivyo0t+eRq29g1c7kPsVm0abidNLSJ05v7DlitF4OrCrgFSZ10WTm0LdZFetjuZ5ijqRBqZXrnr7ulLXmp7hIKfE6gnjhPKVvY1Xvk/J0Sx05djrhz81A36K5aZWCwqan8feJGxjxzT5r5oNaxE4bXtwK0O70E6cPFxct5zvvAOAX+J3qhcNgMGjqyVocvGQWxVIthBxFycnhrLUyHz2qrEF9Ua82UmIWb7evAeBlNODAZe2Ru3UStX99mlaW2LL4qGlPEh4sPN5mrugc1lLmoPka3nMFgLpooZ+3F94b2lxxG3tpxO7WCdAbtzRDB4BnnnkGMTEx2LNnD9599108/vjj6NSpE7p164bx48dj586d+Oyzz9w1PNcicU4l2Ynk8Uj1xWMpMHOCdE0vBaPE3gJSaXEWGuCD6YOaApCv7WMXx0qTSp2K6usw9cr7D/BVb+TxE5s4MuoOtp4T1n5NkagNUcM3Oy9hT5zlRvTVjouSv3VWXgGe+b4oQnlXQh0wMS0bI77Zh42nEyVv8r0Kb1LWvoQ6TKhypxKb7iaXZiVeaKmRdnZnYfZvdozeSxLpJ0rkMNcqm+pSYOJURanY1ilqEadWSXEvtwCr9ifgl4MJuKlR0VJq/pFzfnRrKK9YKcXU/kKjbmjrGqre5yvRp00SiXNLS9sGT+J/vxzDgct3ZJsdy8HOPSuf64CBLYt6bCrdv5TQy9jTYpiJyyX4c0Dck9VZ+Mgsiu2VZWiBnSPEDldnfT/+eAYypRzsmuHsDVsFyhPXUp0ylkwVjbM5jnPI+frTAVtVyGqhARJbFg+O4/C5HcG6J9pHwNfbKEwB5op+Y9bZzWYbSM3dWq9h3imh1qHuZ6eEwJ6RqVa8r6TgNiOPp1OnTpg+fTrWrFmD6Oho7NixA0uWLEG3bt3cPTSXIaXop5fxMOzLPbiZZjEEfbyMxTLy7Hk4+L4mcobXTib1Lj1bvs0Cn64jtVjbMukBwWNHJk8pJSgfDcc731Q0sSkdz+Hf7MOP+65oHl9x0eo5B4DUbKHBJuVkWLU/HrvtKALO+fssDly+gxdWHZWMVLSqGQYAsi0UtC66AXlvMmvYyZVkiN/LLuKu35VOR3XnkpuvMVLCnjQ/S7WQovSWyIiiaHyB2axqkeboOs6+yFPRjtX0lGOR8oDLEVl4PirBLl6HiBTm1KK6dlHieLIRmfqFSqE8vCCLaiPSDVzRKG7D3j861K0gcASJ09PtoUWdWQ3seVnbjjOywGSGycxZ38M3ZOfvNWrqh4qD3L1JT/EO9vq/JpovxesJNXOXGvIZ4bMn2luEowa0tNSL5RaYMPBz276609cVr/YWEPYUfeHHI5j771kE+No/vxydI6Va5TgjxVeNY/D1Po0AABXYGm5wkjV5fxa2pQKADyQy0rQubY1MD2M1+NmZC+3V9aZl56POtPUeq36rFc+9M5RxdBL5w9nEdCzYZEm/8/EyKnqFc+zcdOyJZBgY5U4p2NTLr3dclN3P3cL6KVYCmad2RaGa3Znr6dh05ib6f7oL55mmoU92iBC/1Qo/YbE44iG2l6558PIdzJCQ73U2rEHzx9FrGPDZbrtNucU/mVQTUTVeyzuMgaGUSsvfFMSOA0cWIDtl6vYEfXDMZry+9jheXHVEMC7xucqOR85ZYU9lTW06Ik9OvgnDl+yzaVsghZpUF7VZAIDQOGBrUQtMnKqbXJxEVE6ufo/l8SX78O4/8um+Wo8hi5rzlEfNdZ/BGJly0RH7n6NuO6lDzhoqwX7eODajD87M6Yc903risydaA7DU4jpLst4R2PlDqr2AEhWDitLCfL2MgvTC2f9om0/tqf7xqfdq4Z1Svt5GbHu9OzooCOr4eBkFNdL8tXavMGVdSvRBT+SuX7k5ll8cV3egzhawddyIHbAr9krL/y/afB6Pfb3XrpOZh3fe+XgZrLX0/Hqi7ye7NI3ZUTaeuYml0ZcFqdR6Ildbr9R6Ye2hq6gzbT0m/nJM9/HwfZDZeroCM2d1wLHroAAmwprOXF8pmbkY/MVurNTYBoKfo9WIsAGAvx2HmtrsL0fb5XgaZOR5KEqLOa1NmeMLPam+XgbFCKG9xRnvkWRTI2YMLmruyu9ajfhHuoqbq7gxNWBbfPvkd/sx4ccjiLmZgRjGyBMXCfNUCfGTXKR7O7B4++/UTbc2H5eTHmYjWK+vPYFziemYY2dxJF4gSq0DxCIoUrcb9mgoRf18ZOpS1IqgvfLzUQxfsg8mMyf4HKFhJ4wG/XH0OjacvinwOIuVvd799wzzfhkjz87YxIsbe/We/5y4gYNX7mBxlP3+VGqMkh9EogOA5fcdu/wQRv1wUFZank/XBSzHzp6Rd1smVfyppfvtjvHktTSbxu3s58n9rTdqUoBeZlqi+DgYMftiu7reY1ILcNZ7DlgUUYP8vFEjLEDglDh2NdXmWJ26loYu87fj78LsiEWbz6PHR1G4K+HEUYua3+NWelE2gZbaKaAoHbpd7fIwGg0YwKRralVs5ERjEfPOn9oiPHzkomb5AHh7GfGYHbl1KSOPR8lgdeScZw2AV3s1tIn68Oe6nC9gYWFLAjX1WVKInSviuvvMXNv7Ocdx+Hx7HA7H37Weo/awtjDyMmLD6aLeiGYzZ13rOINeEvVwau//4jXHI/cVpXnP/vsM+n2yS2Dkbj4r3fNRKZI39XdLixitvUDVpIPz9zBWx+FYQqr1b7Ymj82KYo3Cz7bG4vT1dJuSgy4NLMZb/O176DJ/O1aKsp/4Yxwe7IejM/oIXpOav6WMPPae1795VZvXpfhki237n5IIGXluguM4XFdIPamoIH/8/MrDDn2mtx13sr28bD6S17lBOE7M7IsTM/tibNe61tf5i1FNCqUap7OUZ89gMOC+WmF23+tlNKCeRA8rVoxDMB4HJbb16qvmCFN+k66/kzKys+z0KxTbM1I3k+Mij7xU5ECtzWtthi76YDXpKCYzh39PJuLglTuIFbUzYKPN7EKp/6dFKTzCujvh57PnBytKwmLvxi4+b+1dD/ZSYFnULGKkHCjpOQXYFpOEXReSBd9RzqufnW+SXWi2qBECAFaVWTFyNT/jH6gnO+ZXVx9Dtw+3Wz3D7EJTj0bGcsiJU7Cwv48ahTcxvx+5JnkOKKnPsigZ9uyxeeSrvXhgQZTA+fPq6mO4npqN/xV69z/fHocrt7Pw9PeOqf/uv3Qb9d/+D2sO2dYLsbCGcVWNkSH+O4UGWKTMK5crer/WtNQtZ28p1tjIGRZpMuUE1nrsQqeg0vlw4mqqNbplNNguSOU+46NNMbjvvS12sy/EsKlxFYN9kSKK6PPTltw1z0fFHHWqbBP11xMv5qXSv9koefxtdZFNq8aA0SBYQykJYj3QSH0fNzlCJKT11ag/AxanAAtrkC/fewXnb2VYa1fzTWZ5NWiVv40WJ46a7Bl75UPsHOUlMPKK/pZLu+edi2/8ehLXU7NtmpdP7VdUBy12ePFzBIu/xBzx2JJ9uHMvD4lp2apqwgFLXXhpgIw8N3H/vG3oMn87nnNhPy17C5T+zavih+jL2HfxtuRkYu1PYzQgNNAHoYHCC4y/ttUYefaMowKTWVZU5rcXOtvdv9FgwA+j29vdjkdqslCDmknXWWlU609KpxNIpSPYM0zExpaaiV+qZk2tZ5P//cW9otQcT/ZmIa65YRe9cjVlBy4X1cDmKdSZio8Jj72vKD7/7aXSqfVgA/brDdTA/rZyxzuvwCyIjLPw88A9jTU2bw9savMcbxD/dfwGbqTlYEuhB5tN19Rq5GnpiaVVHVcqXfOF7vVRMUjeKSfVKBuQvsa0ThX1Kwlr9K6nZmMLs9iWO4fFyspqeeJbS5T2zd+VVU/ZOh+tbV3yJPqg8fBpY1pQMpZqVwxEXFKmYIzzN8Qgcs5myYwZfk7hF7Ll/OTvGwu3XLDOBb7eRptojpyU/JdRF5GWnS/rRJGDbRvwcJsa1rRQAHgosro16huTKH1d80ae2utNnNIvZ7TyZEmkUQt7c6r6WOtvID5+Kffk09SraIwmSyHlvCofZPv7/0+i5l8cLZO67fy435LG2GfRTtkaQqX7FctNheh1gcmMC7cyrPckPTIl2Ps+G0xgz3l7awqxNgWv8dCyZqjU5gCkryGpbIsj8Xdx33tb0GnedtWZcA+3USeq5emQkecm7hVOeNtjkiRfX3vYvnS8Vuz1J9l45ibe/fcsnvxuPz7Zahuq5hcMchFB/oKWqtMRM8yOKt2UX09ghUzuthpRGi+jQZPX12AwKNZXSNGsWghuykQGWX51wm+phFQLC3vH7I+jQrEKtR5DMWqVEPn02KSMXESdT7J+nppIHmvk2TTtZm6Ccot9Ng1DyeMpp/xpryZPKgKttg7AnlpujfL21dW6S3it2d+T/VZKP7Pcoo03/tQYSHx/OF4gRKzGeSlZ6L3nFwtsKtDei7cRK9HjTg57i00WrUaV1HU0bUATHJ7eW3MPOyknhJZm24B0lI8V9JBaWLuaptVCNG1fwKhBi+nDtPUQI46W8IQoOPDCAnzQe9FOQYuQJTst9V1s6jaPWDK+u52aP/66lxKAeapjLcX3aj0XWMQNndloiDhNmieo8PzNyClQTHHlue+9LYLHUvcdFqkaRHb+bqWwmOfhOM7mN+CRK18A9MkGyJEQi5K630mpO9oKfPE9jG3HpSRUJG6ZdD01G3sl2kwpGVRv/XEKfT/ZhVWFRqVcTTvPIKYJutS9BRCWMLDBBAMsmSWz/jotK2QmBfs7i+c4XsSqQpAvfLxt5wi91IjtqXSWFMjIK0No8VpL1ZAUKHhYAW39T+yNZZ2E6IoWvIwGzVGPF3vU17R9boFJlaDC1N9PChbZe+JS8OexIsNv38XbgsfFhV9Y7L1YNPlrjViosfGkNlEr4c8b4D/uj8eYZYfwS2H6l6pIHpOWI66pYxXJZI005u9Zf9su5PgxyIl/2DuSUueuWhVYNq1UCjUtJ/hDuOZQAo7EW7yjrEHBf7+UzFx8u0teAEmJb3ddVOWI4g3C0Z3rALC9Aafn5AuinPwc8u/JomP40abzGPrlHtVj+zJK/XfSS63OYDBgjp3+TDafLXGu69GjiV3g3WacGMcS7AviOAN7SqpipO4zL3S3PzfLRSQebCzfW+zENYvS3j6Jvq3iLAPANpLn42VEzyby+998xhI1SJdIJbQXqdOzBUFEhaI6+t2xKTCZOdQIExrFwYyT4v552zR/hjizR4zU/Zg1ZO05uADh9eHjZRQYHVK///Pd6tq8z1GknHcXk23vd61qhtpEgcSffviK5VrU4pCSosv87Ri59ABe+umI8PMUvi7fe3bGX2eQcDsLu+yUC7AzttwSj42esfoGoQE+aDV7M1bsi8dhBc2HU9eEipe/H70ua+StndAJ3RtVwk/jOkquRfXqA5lF6ZqEs+EXPymZuZj2+0mbmiit2KvJEyOW8C2weiWL7ymR8oppoXN9ZaUlg0G7J0arIZRv4lQLtvxTuGg1mTk8tfQAJq05YU0jevK7/Zi05gRibgqPN8dx+GhTDNYevmp3/+wNm/cO7jxf5KHTKhCj1OKCp0qIsNZGSvJZDnFEZ2NhAb2aHk5sAb+4/iyZWSjI97lTPha8QqhcSpu9n3yrRDqIPS83j72FjprUmtx8E/ZeTMGbv5/Co1/vAyBcTPFOgAk/HhGkdGlhyc5Ldrdhvef87ySOhE1ac1wQ5eRv6HVF9bRZeSanpD2r2WVDUdsCObSm90gtPPWIOMh9p9fX2qaNxt7KwBu/nlBV/6W1XyHPf6eEIhJ37uXhzd9Oygp9WTNGmHOFv+fIpX5yHIdEmfGpve2Jrz0pARKTxNjkRL4A4MONMeo+XILiKMzaY+W+K/ATzcGsYIUjl9oFO9F2qXs+qygsrsWSgp3HfLwM+PjxSMFr4mh6hSDltk5qWLj5PFYfTFDtqKsWGoBPRrQWPCc+nrwCsnjJcSlZXb2YGPE1plaluv9nuzA0UrktDLt2kLtzsvWKbAZVxWB1abIPLY4WPH77j1NFEVvRQWpZMxQrnuuAptVCJCPkWsWZ5FC7ZPrz2DW8v/6sw9lPzoaMPA8m6rwllXP232ew+tBVDNPgzZZCqxHDe8/zCsz4ZudFa/qknLG4O1ZdETIgXMyvP5mIIaKL3B6DWylPTL5eRs09krSG+fMKzKqPKd/e4RCTdy72OCWmChcpx66m4suoi5j620m7C9wgv6IbNL8QYm9sWjtEfL1TGA35VCJ9l1VZ3Xr2FgZ8phyFYvEX1dbwDoysfMsEPXdYC+tr4oUdW2AvNkZ5Y/f09TRM+0O6bqhdnfKKY/tsayzyCsx4nxEyEBsdSkjVaWiNZvDk5JsENw813v3cArONh5kV3uENCTWtDuSQarEhhi1c51MIxddLYlqOYC7gFxSREWE2+yvOQk0OJaP5w40xGLPsoLUmxJ4cv8FgQIc6lpTvN/o1VtzW8tm23+fbXfaNZ3v8dFBaFIWN5vA88/1B/HrkGrotiLKeZ3L9zLREd6REr6z7+WAb1hy+ike/3mt9LjkjF3WmrUebdzcL1BN5+IUjOxewfyuJKUg5WKRqKMWpcFLnBj9ns9EFZ/UolIra5+SbMPK7/fhShRIvnyotxb6Lt23uj1pEhaSOzY7zyvd/sZjIucR0zWUpB5l6am+jEZXK+aFeJcu5VmDi0LS6MDWYvy9qrQvlWXfsOr7YHodpf5xS3dewgaRTyPZ4JWfk2mQSLJJRdOTbPqktKVFrb2Tlmawjk03FZE4LKWdx/Uq21zqfuaGlPprF19toNeiVHNRSKd3FFcMLLGwBobb+d9KaE/hu92Ws2HcFQxdHa1a/dzZk5HkwSYX1Xv/KCGxoRc44G9SymuTzeQVm7LqQjEbTN2DehiKPpFy65j0N9R9s6sPLPx/FSVG43h721DCD/Lzh42WwWZwrpdZo7ZXnZTSojo7yk/mkNcetz2XkFAgac44TqaayTa0v2vHwTXigKJ1pzPJDiDqfhGV7rlif0+pkaiNaZEulFvGL7tl/n7EZuxSsMpZY5pg33LLzLPusw/RDbD5ro6Ceg63JEyuq8WNSEjQSi1WI2XkhGS1mbxI8x95nTl9XjliyrQh45LzAUsY7X9P62dZYNJmxEfXe/s/6mhrvfm6BWeA6/nrHRfRauNP6WE41VE9MZg6nmHObv7akrrFcgbPDMjapiJbahVr7QiP+uS51JRe6A1oUSWgrRcm/3nERUeeTrfWqnVT0afphTHusGtsRExSURHmkDHYtIjxysH3pWAOkB7OI69fcUtvGCjScuJaKBz/egWYzNxVbPlwpIi1lrD+91KL2eTcr3/rbsxkj/Pc4cS0V2XkmXLiVgeazNlojZUr1WFLKwrclnBQbTt0U7Ed8Dn694yImrbFEQ9kMjuL0Wz+rIIAjpZL778lE7L14Gx+p6KlZT2LxzZNTYBYYak2rhQjSNe3hSMRZnBkhdhRVCbEf9Rm9rGhe541SXgzJZOZsoil8/ZajEfLXmPu10j6WPH0ffn6+o43EP4/UvDfvv3M2xrLcWo9XqGW/37W78tF3Lf1m+XuKnJHPG2yAdBaMpPhJ4b7UlBdIkZlbYFX8VjLapBzz9jJ17PHM/bUBaHfMzvnnLE5cS3NY/d5ZkJHnwWipF5n1UDO72/Be9OmDmqJGWAA2vtYNZ+b0w9uDbFXveEYxBek8cpPBhO72FzY8UjUQWrBntHgZDTAYDPh3YleM6VLH+rxSzyatHqDFI9uo9n7yqU5so+pHv96LwV8URTCVU/GUP0fs4ZuwUpijv1Ukb307Mxe9F+3EvovSv8Ou2GS7N8bjheIYy/deUdyOZ/OkB6x/i1OFeLILowjBTG+5fBMn8FyzYh0bTwvTVPgUOKWG4Ly3lK0DeJzpd5VwJ8vGoBC3LtCaOniI8UCzbDht2w+p96KdiEvKEIgfWesEC//vVK8iqslI0+cWmASNzcUpY3KKi3qyOzYZz3xfNHfwp7aUV5atV+J/PymDTq2Rx0cGuzasiGYSoh9fPXWf9e9rGsQA1DiBgv280bVhuCrnj1TNl96w1zBb/yO1+DJznNWZotR2wB7v/XtW8JvyC+0TV1NljWo2jTfPKrxSdAz5hWTMzQw88vVeLNh4HvkmztoEm/2er/ZqKNj3u6II3c/jOkpmNgT7e+OJb/dZH4vnY/Y6Ys+F/ZeE1zbbVkiKSb0bWf9+/7+zstsdumIbaZdz8kj1lK0aIi/SVGAyW+eSb59pi79f6SJ5zuYVmLFy3xWbNMKfDii30FCDuP0AL6pz4NJtgbPj0JU7+Ou4UBgMKFrM8+dLwp0sG8cJ35hbjzRo5VovAzrXD7eR+Of5X8+GqFk+QHBuXkvNVmUEvfJgA2smEF/XxnEcun4YJfseLfenfJnaNwA4PL032tQqynyRum6k1k3877DxjHS/PzXwkTyleZedNxaPbANAnTNODrbMR03piKemaLKQkefBaDmBejWRVx3j4Y28cd3qYc+0nmhSNQRBft6oHuqvKZ1PLpInLuRW4lLyPRy/murwRWLvfbULU5OC/LwF2yqlmWmtW2tTq7zNe4bI5Lf/dbyoJk8J9iZeMajIIBUP7WfRTVY80dpLbWs7dyvikjLx5Hf7rT20WC7cypRsqs1yIy0HkyXqfORgo3fidE3AcmPib6TiBuLs+cmmtIhll/PttCtgYesA+tlpkCr+3fJNHDiOs/ksNjLLIpc6Kv4deT7ZIlxk878nP47GVcth31u9JN979kY6vtst/9s56l3VAutxB4o8y1I37N6LmCijyYybaTmSEv1qa2L41g5Bvt6SqXQGgwGDGcW4F1cdUexZ6izUpN6+PbCJ3W3YyKSYdrWLFmhs1FvqWIrnMkdqIJfuvoTvRfMGn3Ux9Ms9mPrbScn3jWhX5GQ5WriQ9ZaI5AF87W/R2C4lZ1qvj0ZVgjGpTyOcn9tf8nOuzB+Ezg3CJWupa1cMtAqxAMqLejbtmFWTXvdyF4RJqHk+fX+RkiZbm8ZH/dUea9vjYOHN322P66u9G2JQq2r49pm2AIBuDcOtr5k5zmr4VCrnJ3lPX7nvChpN34CZf51BTyYTAIDivUGtyuw3otRk3okz4lvLPYmv8Xt8yT68uvq4Tc06D++YmMbUcfHw34s3mJMycvDyT0cFomRqUcpUsrd0qBzij+g3e2JSnyIDv2qIv6o2NPfXqyhIdU3OyMWEH48ovENb5s6ZwnvWlRTbyGC4qKZOao0k5Sjjs4js9XVVOm78d1Aqo2HHw5fwOJo+3a95Fax7qYtVICg2KQMv/HgE41YcxjymdINFzmH64qojdrOvXAUZeSqoU6cODAaD5L8XXnjBaZ8r5S1bIFPIzRYky6lEynlEDAaDTfqcEnIRryCNEuLDvtyD3RLyv2pQMpYeaVNDENliWzFsVsiXZm/8b/RrjE9GRGLlcx0kt133chcAtp4tOU+eWj7afB4JhRMj+5uKPZFv/ylcBNurJwzxl/9t5FLE9quItv5+VH1NBbswkork5Zs468QuTh2SM8DZhYtlH2bslYlOsogXVb7eRoxoFyG5bS+JFN/EtGx0/GAbei7cKXAisDe14czCledKyj0kM1FGubS29aeEaTt8qpOUKIWYKDu1Mc5sLi4Hf4ikFOpY8k1mvPOntEGsNpLHR3otKdvSt7jWTDryhtM3BWnUgPSiW6nZsiPw1/fF5EwkZUiLhnSuHy75PMtMhSwO9rphpfNzC0x4U2Rwia8xe0JfMyR6ec1db7sYyjdxOHNDOR2fvf/wi2m2J6G4foyd/qPOJ1tbbvC/t1Q9jSAdUOLyYdt2AMriIzdkRF7KB/qgv4TRzY6Hjz7yfLzpPDp8sE2VsA07L7KRWXGmBmBRNvxy5H3oW+jAui1SIi4StpC+RpSEUJTaO4gddFL8d8o2LVHsgE0QGQjix1KI1wV7mPXFjvNJmLnuDNafSsTI7w4ItuM4Dqevp+FmWg5WH0ywzumsk0SpObYW93BEBYszvFn1EKRkKNc2T+zZAF0aVMSoTrWtz7V/f6viOgaQblchx+pDluj6+VsZ2PhaN8VtpdaQco3b7fHVU/ch2Nf+uaIkbqdVa0CJb55ph8iIMOtctP/SHWw8cxNbz93CN7suSabHyqm2bjh906U9sJUgI08loaGhmDVrls2/wYMHO+0zefnxAOYG+JXoBsFTm6lh6lCnApaOaodgP29BUazSIkmqbkEOLQIuwX7eeP/hFrKvs3VncjSvbptypZRz/vHjkYK87JdUtkZg55IHG1fGw21q4gGmjoU/liM71rIuEsXXuJIxpYZvdl7CAx9Z0jDYCcReHZU975WUhLc95CIN8x9pqer9netXxLjC1KVK5fwEEtpip4KX0SAwPvg0Gx7292SVOcW1OPlmTpWgyO+ivoD5JrPNZ/J0klBy7f7RDiRl5OJyyj2BoidbK5osShlNyshBj493oP37W63PyTUcF/PWH5YFOX8NSzV8VYveRl77OuURHuyLRxTUJXmj6a6dBUFegVnWA6pGeIU1mqWMPH4uEj9/UJROKyXkobe6Z4GZw9U7Wei1cCcGyLTOaKwgnsFTLVQ+g0JunszON2GNKHVSLK5kz6jmmzfbw2TmMOhzZWEtdq6x1lpJCK9Ije29f89aa9SUesG+P6xo3lLbAHqPjBOyTa0w699snbe3lxENq9j+ZmxUUKwsvDgqDskZufhut33RHXYeZH9a9vj9NK6j3f3czsyzqpE6IlRxS6E/rLhH3zeFkUR/HyOGLI7Goi0X8NJPR23et1sk5V9gFmZlqPnFzjLRzQcbV8LQ1kWZNaOXHRKksbP8eew6Bn8RjfvnbcO0P07hqcIa0baMkafUHkjqGH77TFsE+3lbI6k83Rpa1hR5BWY8/f0Bm/exPNOpNgwGgyrDmWW1jPiSvTqzJlWVe1q+1ruhqjWOlINTzP31KiJDRZsCL4XzU2v2FQt7DbOIr08eKQelkhiPvSimqyjeirQMERYWhtmzZ7vls+0ZVUem94aX0YCZg5shNikT3RtVgtFowMlZffHptlh8XlhfoVffHS29XU7O6guj0YB3/rT1+gLKjWp5ejapjDM30gXHQTwZ1a4YiN5Nq6BCkK+NTHuLGqGqxsp6jAIlFvxVQ/2xZVJ3wf7FCz8pVUCWhpWDFZXgWNgbUp7JhE+2XMDRhLtY8rTwplEjLABhgb6Y/0hL2bRAtQT6elkNfrmFUHWVabnlA30xfXAzvDmgCbwLayR5xEaeycwJFujidE52Lu9Qt6K1nkPsnJBKPRUT6OuF70SpQimZubJ1gl5GA7yMBlULQ3YTcXuCc4lFBl2daetxek4/hAf72vT6kyIxNQc5+Sartz+gGI1a800cklQ0O1bLoSt3cemDgZY553qaIH2NR60QQL6Jk23rYM/oSErPwVUmdaiCSNp+99QHrQqTSsYAAPT9ZJfNc/beoxWTicOOQgVlKSGQeY+0VP2Zsx5qhjn/2NZ3yZ2zd+/ZzuHiCHBSRi44jiu2kIEaWMcDbxAJ0jVFxyFaxvhSauPC1vkG+nqpisw+tfQArswfZPM8m5L5ep9G2B5j+R3larTZKN28R1paBVxYfL2NikIsgFCtUK4NkdS9CwCqhfpbjSD2HsSeY1VC/GQNuMS0bFQNka4DZmENkgtzB+DktVTLePPNOHktTVZkzc/bKDgP8kycYM2ixcfy8/Md0aleRZu5lTUCfzoQj9+PXMPSZ9vbpLfzmgFq++uxQmE8fZtXxclZVWzWI/y5rEbYg49ma8m0AoCjCak4cyMNzasXrX2y80x4bY39+2OvJpWxLSZJ4ODmaVilHI7P7CsQA5OqDe/eqLJd5VS1fYyVspTkstN2TOmBHh/vULV/MXKqmj/suYIPHhY6uN2RFaMViuSVAOx5O/heJM91rYt5j7S0TipGowFPdihKQdPrhFS6OYYyN7/JfRpZx9K3mXTNoBqv0Lhu9bDgsVaImtLD+lyXBhURxjRf9TYaMGNwM7z8YAOb97NpFgsebSX7Oew6gr1R8v2vXuzewGbCFtdynbyWplibqKTuKeZdZtGWV8Dhs22x2B2bgldXCyfqqf0tcu1dGthP7bIHazTxtVtiQ1Zt2hyfNuzjZbRZKPpLTPB82ofBYLtYYg87W7DvSOPTrDwTzot6Ovl4GSXrBC2frWzgdfxgG36Ivow1hxJwnqkbea6LUIBBLJqwLPqyKgMPsMwBTWZstAq1SHkbW9RQ9sLyrNx3BR0+kJfDl5PSVkJ8XYjp31xawVeMyczJnl/8QlqKk9dS0eGDbQJZ/tBAH2w8XZQWxi4+HUnzsdfsWcxCpoeXFAVmTrCgFp8fT3aoJX6LLGNE5xp/zcqdtmqum4m/HMP8YvR50wJbJ8rPQT4yNXlKKNVtBjGpYVKLciU2iQQkWIVf1kjykUktY50yNcJsW1kAwIZTiRj4uXIbGtboyJX5DeUWvhNFgjQ8bDuJdwbJp/52mrcdH28+jxdX2UbhWNjrzNfbqNpASc8pQCemTUd+gVkwFyTckY6kzRhsO2bfwnuOnMELAO/8eRpHE1LxyZYLNs4BXrBJ7Zqpnoxis9S8yDsT1Qh78Gg18gBgvEh8rdP8bdh0Rj7Nk297smh4a8x7pCW+eKKN5HZGowH/vNLV+nhKX9t2MWqiw2qvaSXhFbk+fHXCgySdMyzi9GweuUhedGwKfoi+jMS0IkeiVC9Nluup2fgh+rJiqq+zISNPJbm5uVixYgU++OADfP311zhxQr3ghKNUCfErdooQm8qj1itlD6UhTexZZGSNZ9Q2m0qo3AHSN2Xxxe/nbcTwdhGCPk8Gg0GgiKjk8Wa/9/D20nVXgDDSyabuLXw8Eofe6Y2uDW2NKHHvqafvr40nFD5DbZpQgcmMmuWLfjt2khCnAfKToNIxqMSoiqo9p/i6i39Ess5qbnzvDm2uGEGValTPF6HzRiEbuTXAgGMJd/HwV8JekVpqD5SoGx4km64pNgilePffs3jz91P4MqoondrXW9jCQyyPnami6F4OqUjeeKaNhhLitCgx7w0tSq9+RcJpIoYVMZGqK+rbrApqFfZU7N1U2cmRbzbL1u0tVugN9pmoxQdff5XHXPtszXCmxE2XvTalHDUjNRhdAHC/RJovS4HZLPhOcqlkalk+pr31b37Ok4ugyvXCE/MN0/T+Ppn0puLAz0WbzxYZUXwKNptZoUcUNZDpJSpuVm2PDzcIjd0YJirPrkHl0qhZh6Tcb3JFIr1L3HuWrYXjjQTxfCyXwtY6IkyytQdrlMkJh/F8GXXRRjFRPEc0Ed3rtRgorNMrp8AkMPL+YFLs+zBOY6nWC7xxpSZaJJV2zBspSvc6vlb7fz3tz5EsfKRITtma57G2NVG+0AB3JHPjLlMKw3Gc3dq5JYVppaGBPniyQy1Fp1b9ykX3NSmDzp4w3rOdaqu+ppUy2ab2a4y2tcsLFJMd4ZMRRQ45uWOdcCcL7/57FkMXF61B5NJiebrM3453/z2LbguikJVXgKeW7rcraKc3ZOSp5ObNmxg9ejTeeecdvPTSS2jdujUGDBiAlBTlBVNubi7S09MF/9RyKz1X17xevSJ5SuIiAnENJjIilwon5bVfP7Gr4LGcJ4f1kil5jpSKxFnYprmBjNfXaDQIjCQlKpXzw/ju9TBjcDNsm9zd2hSZr+FTmzKbZzLj0fuKjFi2D504ncbbauQpHAPmt1cbPeLr+KKZhcbSUe3QXkVD1oEyvRd5pLxlz6+wfEc+nYU9VkYDMOr7g7LeNyUOvC2tQsnSOiJMMroIWM5RtvG7WjgO+HJk0c1H7C1mF9BaERvJkTVDBVF0LXSoW0GQchNRIQBrxt+Pjx5rhcl9Gym808KHTHRcagxVmBQve20ICkycbDQmr8AsK06xTRTl4w0ENlOAXVRIrbNZoaGOEue42p6YPFKG4hv9GuO13paIisnMCa4DVsFQqb5Rjo51i4zKfJEaqxgtUQSeow5ce/bg+5Cx7QL4KKMjkTwl2Eheg8rB1loxe1xKzrSpx6pVUehw5JFbkLLpkUrRRnE6JNuGBIC1jg4oqhESR2WV7oVSqXXi81op+iWFOHumabUQLBoeiV+evx+AfGTEHu/8eVpwrNj6Zfb6kBLm4H8Hrb1veXinqpJj/LG2NXFl/iC8LhHJUoI3PNnUUXGmk5fRgI+ZTAC1qY0srLF/Skb1mcVe/1gWNn1a6vjbW+XMYRyJ9lDKEomoEIjfX+xsd70hRYc6RXP8w22K1lr2nBJ8e6a9F1PwxXZ5xyPLnXt5+GTLBeyJu23T0sXZkJGngueeew47duxAcnIy0tPTsX//fgwYMAAbN27EkCFDFCMj8+bNQ2hoqPVfRIR8lEcKVl68uCgZO2pveA80qoSRHeU92nILIXFNBY+UkSdOT5XLyb6P6d+i5BVSm17IGnKO3hwAi3E7tmtd1K8UbBVrOX41FedvZqiO5OXmm2UNwpuieiqvwklWSYyDvVkpna9sTWFcUmah6ljRzahVRKiNrLIU9raRSo28J5GmxaKmSFvMtAFNUCXEH10ayEdVTszqC4PBIBvJe613Q6tCnRY4TujBVyuyooZ0UV2smRPW66ilZvkArJ3QSbB4NBgM6FivIh5vFwGDwYCTs/uiW8NwfPhoSxvDpU7FQEGETOq6YZ9i/Ux7pvW0ERSw5wS5f942gbPqUnKmteaHhV/odpTpmSQl4vJD9GUMX7IP5xLTbRbibG8zLYj7V47rVtfq/ErOyJU1tuYrpJXLwS7uC6yRPM27kUTOM692PpODby3DUmTkyQuvyMErF0rBRvIA4KrKyOl6iQbVrPODTXeUuw+xwj5KjdubSYiMsSzYWNQEnTfyckT7U6phUiPYpOXe91BkdZt5Myk9B4/cV9MqWFWce6ncvZsVcPL1tt0//5mO1pPyv5GSY/yqQjNyJaT2KV5/ia8re+nwPOy9k81WOCDq5SgmwMdL0+/ErvOknApKyUJsOxG7n1NM+czWChoJQ9tIR63VCHzdyy2wUWi1B1v3KZVJ4izIyFPBzJkz0b17d4SHh6NcuXLo2LEj/v33X3Tt2hX79u3Df//9J/vet956C2lpadZ/V69KN4OVQ2nR8/Hjkdj1xoOa9idH32ZV8NkTrbH19QcUoxYrn+ug6OkY1LIa/H2MNrVncikqUheUuIGx3ATHer/kaiEAYFibGvD1NgpSPKSoHhaAH0a3w+8vdlbcTg4pCX72pt/v012aInlqjVN+IpQzpAHhpKI0ho8eEy4uP9x4XjD587377Ekt20PpHAqWqNNU2yPNZl+FBshXI9vK3lz46JPcmGqEBeD1Po0U6zml4ABUVhkB1oo4pbFepSCHJP7b17GNWIkJ8ffBj2M7YkT7Wvjjpc6C49BIpCQodamypxs7D9QICxB4UwFg/8XbuL+e8phe+ukoUjItoiCDPo/GkMV7bLbhr4UXu9eHl9FgU98mtdDaFpOEg1fuYMBnu20WcIMjtXuKAVtpdW+jEUGFxsbWc/I1hkpReTnYBdG+S5YMk+I26+UXSZdvS6dFs/UpgH3hKTXwpwi7kFSa21i6MC0nxLVagaLrW+0CUkoUhy2DKB/ki5XPdcCa8fdb50o+g4OH/T07N6gomw2jpTyDd4qJI3lKBsHJq/YjOlpSYwMkonRDWwuj0JXL2RdrkWPDaVsDGxDOf1KRJDaLyJE5uHtjy/pFychzNIW4BSOGwuOoMdpVVIcvJWg29bcTeF+mzxuP1vZXgMWBVT7QB/fXtXWkidd77G/wv57StaEA8OdLnQXXilrjVo4fRrfHnCHN4eNlQGREGPo1L1oDyokIiecJKV5Ypdyn0B5rD2mzA4oDGXkOYjQaMWbMGADAnj22iwwePz8/hISECP7xlA/0wciOtQS1FFp4rG1NQdqIPZSktg0GA4a2roEGlcth9fhOgtdGd66j+jPKB/nixKy++P7ZdoLn5eZKKUNGbQ4/OzEqpZCGB/vh5Ky+NlLGUvRsUkUgm6yGhY9HYnTnOpj/qG1rAfFNQm20JTffjDyTOlERfiK0d9x4z7VcM+zRnevYLNqX7Lwo+A78Ikasbrrk6aK0xLcG2G/gLOWZL18Y9Qrxt0350yp6wcMfk9BAHzzRXtmDKKeqxfeRVKrnlMLHywBvL6NqQRQpBrWSNi743/z3FzvjifYRmPVQc0TWDNO8f60pnlVC/DG8fQT+erkLRrSLwPsitTGpxQrrVBB7qMWLi4NX7lh/h/ES9UMAsOXsLbSbuxWT156QFRDh08NrVQzEmTn98IGojYvcb80jVgBUa2SIER8OL6PBpgek9Pu0L27Y97yw6ij6fbILGTmO9bDi8fU2wmzmZI0P3nnEcRzMZg4O2KayOJKuyTqz6oULxVXEWSZqr+fKEjVfYh5oVEkQNX75wQaIea+oIfsXTxaJWIT4+2DfWz1tHByA/R6XLHzbCPE1oPQTiFVJpeYXLREdPotkGNOqQFza4GVUFkBRQlz/x1M+qGjekjK22PN16+Tumj/3l8JaK6V0Tan7lBr0bMRiMnOCbAGxo29XbLJdlUsAVseTFlY/fz/2vdVL8t4svl4n9myAJzvUwtJR7VBZQaG1Ta3ygrlZraNbjgpBvni2cx2cmdMff77YGR8/HoknO0Tg5+c7omeTyhjXtS4+e6K14D3i7AsppOra64arF3NyRDDOUcjIKwbh4RYvSlaWY2H7ID9vfPBwS/RorF5xkeftgfYX0jwLHm2FyIgwqwqjPUICihYh9SsF2Y2AifHz9rJZpMgZN0cThD3NXuiuTjyC55MRkYiMCMOsIfKqYIBlse8sKfBH29bE7CHNJfcvTsfi1RFZpPq15BaYVAvl+DA3ZSX1Tl7aXi4dYfaQ5gCEXrcaYQGyDZlZ44WduNVMkuxNn+9lxKfgSNUfyClfKtGpXkU8xERg7P38cumaLPYUE1l4L+uL3e0X5n8yIhJPdayFliKxmk+Gt5bcvnWhQde2dnnMf7QVKgT5oo6GmwwP/53ZwnM1REaE4cPHWtks6KSOMXujFnt4pdJ6eWlxe4vNP45dl32NNcqkrn0tKUOAvu0THF0cauX8rQzZpt1qSc3KwwMfRWH8j9Kea35R+dqa4+i2IMrhxshS4hlshEZtPyzWIdVNQiiLJdDXG7unPoi/Xu6iuN3FJMfEnfx9vHBmTj/8O7GrjQqzn7cXfCTSDO3B9r3lEad/Kt3napQXOnpnSKhpakmR46Pu9u6tWvrwssjVYA9qWWRUiqPevZtWEdSXlXMgSgVYDEWpSN6j99VE5/oVHY7uq20nowYvowErn+tgfTy2q1BlV07VsbYoOOBI2rXRaJB1LIvXIcH+3pj3SEv0VrGWdLSGUwlfbyOMRgPK+ftg3iOt0Ll+OAwGA6YPbmYTeXZ0nRg1pQc6yZQHiHEk68ZRyMgrBgcOWHJy69Sp49D75SbTRlXsF8CKJbOV4D3vatMmWNGRi8n30KVBOL566j5sff0B1Z8pZkik5UIKDfARGJur9gvViVrVVNfTjufhNjXx18tdFKOU7kTsiRJf3GO71sWfL9kuMnILNKRrshLeohse66X6rLBfolJNCAB8/2xRZNlgKOrHxAtG8HSoU9G6DWuEqYlU+Pt4Yc34+/HL8/fbSPZL3Tjs3YQmihTOBreqhl/G3y/wCtpr9ConvMLyKKPoqsT3z7az/i5qvNgPt6mJ9x9uiX8mdhWkPMpFMDrLtMvY+UYPyecHyRSm80piQyNr4NMRrYud/i01o7H9oMS/o1QkMS3bco1E1gxFExXNwKWwF6kTN2y2hyMNowGLKiwPLwCktbGxnoSpjIjzkZkLtzJx7W42LiVbDJ2a5QPwLyOMxUcK/zp+A9dTsxUbRsthFrWS4GGdPWoMj0BfL0GapBqhnIgKgTYKyWJ+P2o/EiJHkJ83WtQIlVw4SqUZSvHxpqI6PPFYC0xmQVSgbe3yqK3wfcSqouI6RcC23leODnUrWNU41failUOLQmWAj5dgXmR/56n9G2Pps+0EaX6OLtpzC8zYecE2svrmgMb4+fn77c4xcvRpat/QeVWm3QVL+UAfvDOoKfx9vHBl/iBcmT/IpofxKz9L98V75v7agsfX7mZLbucoYqfYbZVib4D9udvVqDk3+cy1Wyr7z6YXM8NCC2Tk2eHs2bNITU21eT46OhqLFi2Cn58fHnnkEYf2zXqq2cX4yuc6Kr7PYCh+QapWBrashgaVHVtwAZa0qUsfDMSJWX0le+b1aVYF0wc1xYAW2gUuPBl7UVC5dLnJa09g+d4rqj6DXYCyk+um1x4QeKmOX01FnWnrJVMFPmRSTdmI1rW72finUBxBbLxN6dcIb/RrjC2TugvUU9Xm93esVxGd6lcUOBWAopoc9hS3pwwbGuAj2F5qMetlNOB/optnb+aGK2VQibdXSy9mv1qV0cT2rFRalxy1mf5fA1sWXUsfPNISq8ffb7M9PwcZjQYMa1NDU/q3FFLRN9ZZITby2KwBHl6FNMjPGxte7SYZ6baHmvS+tRM6qe6X52gkjx97eLCfVWVULzEULURN6YEpfRvZjVrxyPXoM5s5tKgRis6FohpaPdKjOtXGOwObCp7rJSMuxs5D7DwpJ+p0clZfh+5RWtITB7Soih/HdrC/oQqUIjqsscq22cgVZYYcv5qKzYW9z5pWC8FvL3RSrGMSCydJ1R/dY5yA5fy8sU7mnPnl+futBtSoTrXxZv8mAgcAi9J9/fMn2+CVng1VZwyJ5xDWsanVeSOGVbRmxXJYilNjCKirM+N7zMoxZ0hzHJ3Rx6Y11V2J+lExHepUwNMiI8/ZyEXi1//P9ny5nqqvwVlcnu5k/1jx/frUOrnEGTvOhIw8O6xduxbVq1fHQw89hIkTJ2LKlCno378/HnjgAeTn52Px4sWoVUtb6g8P68kb2roGzr3bH1fmD0LVUH/F/lR+3rbNpfWG7/WmxqOkFn5yq1nediHZo3EljOtWz/q9thXm0c9/xLbOrSRRXqFWECjqDyVeyKvpzcbDGhGsMRQeLP3ZbP8cnhFMvZrYKOFVLcURiEBfb7z8YAM0qBwsUHQL8tUWqRBHuvYVStl/wNR7/SdTgM9jMnOY/0iRIIjcTeXR+4SpGeUZY1Ccrnnu3f54vY+tqqJWYR659iFqGdBSm+Pj8ryBODK9N0Z2KLo5Bft529RbAvqnjUiJCrDpwQ1FWQpKNYF8v8Rvnlan/MuixrDuULcCTs/pJzjP5HC0Jm/CA/XxXJe6+OaZoppVe1FpR3pi8chlQlQP88crPRsKnAA8j4iuibrhQbJGMp/+eeGWJfV767kk2Xq95hJKkUaDAc+Lai3lel2mZBZF98oH+eL9h1vgg4dbYt3L0tefVOTu5Oy+ePr+WoLmzTbvEy26107oJKum+vXTbdGtYSXJ17Si1K+yi0ykno2KA8CWc7eszsBziemq1gWswWUv2jn34RaS6XNju9YVGMc+Xka82KO+bERPqkwBsMyxQyKrw9fbiO9GtZPchoev9V44XJhazjpgQooZJf/48aJ7yJ6Lyu2xnMW4rnUls1mmD7I4R6YNaIJnO9eR/K3trTcWj2yDtS90cqi5enGQc2g0rx4qW3fuTtgaWjXrGT77TqpFiRTFUZzVChl5dnjwwQfx0EMPISYmBitWrMDnn3+OM2fOYMSIEdi7dy/GjRvn8L7FPzS7yBQXcTaoXLQ4cqTHkVbmP9oKR2f0sUnR0wOpCcYgSvSqXykYV+YPwhMaGxCXNPjvvXJsB0l1TpYKQb64Mn+Q9XE5f2+82KO+QI10U6FXFyiKZvRoLFyUzPzrtOCxOI+8qsxEFewnvyBnz12pFCAl5NIZn+hQy3r+Xb2j7N375WACwssV3eDimL5ULOJF7qhOdax/VwgU3iDlavTYRbhULZEYcfrJ9sndFT21MwtVAd8baqmR1CpaYDAYUDHYD10aVMQL3evjkxGR8DIaJIvr9Vb/nPmQbY0PG8l7o18TjO5cB3+8ZFmoKxl5fIpP5RB/LBqurWZQ3EdQjkBfb9Syk64HOKZ2CVgEf2Y+1Axtaxc5caTUY1nmDlPfQ0qMXFNg9hwUGzyLhrfGG/0aY0hkdTzetiY2vfaA3Ugob4D9c+KGpPJt1JQe+OvlLtgySZjizxt+7evYF7cSq9891bE2RnasJekklCPE3wdzh7VES4UyAPY+3KRqOXSoWwGvStz3HK3tcgQ5Y0V8rB3ptTn/0VZ4uE0NrJ3Qye6293KlU/sdFVJh8fU22syxY7rUkd1+/AP1cGR6bzwkatjOGnlqSgVOze4r+5pFZMuyv0wX1U19WphC+9sLnTC6cx28JuFYBIBx3erh6Iw+iroF9sr92LIKdl1QT6LWU0+Uyml8XJyVpgY2eyTAx0tRcX7m4GbWbCS1af0LN5+HSUHQSk/IyLND9+7dsWbNGsTGxiI9PR15eXm4evUqfvnlF3ToULy0DaUTwiT68dX2sdOTCkG+TosY9hblpXO6ak55FmKlURZ+4e3v44UPH2sl2YSZh0+x+O2FThjbtS4OvN0Lb/ZvIvsb8Qs1sVIgX/8SFuiD0Z3r4FORupSPl1EymqC0OK0S4o/pg5pi/iMtNae2idM1ZzOGQkOV6VeP3FdT8LlK6Sj8Yu3+ehUEiz8l1S8WdlH407j7cXh6b8VIARtVerhNDdSrFIw3+xcJJ4nTlJ7rWheH3umNZwoNUEcbQRsMBkwb0MTa6FVsbI7tWhdPaRQgsUdYoC92vtEDDzPNil9joiKhAT6YPaS5tcdlRYV+imxvw0fuq4ma5dXX3WpJkRXPtTzscdfT8xpZM9SmJobFUUEHwHL87SFl8Lz8YAN8/mQbfPR4JHy9jXaPH+t0lBJ3qFk+AN5eRjQURY8fK6xpZZ0rcigJOK18rgOe71ZUl66krmwPNpLHOgfELVN6NtUukOYILWqE2MyhfPRXbOQ5YniGBvjgkxGtZY8ve901rVYOdSoG2aTIFicDgFfrXioRuZs5uBkOvtPLJrPlo8daWZ1XYtjrVO785x0GPl4W8Y1dbzyIxqJzkzcw+XlSTrRED9h0XD7K1a5OBcwe0lzRULV3ntu79Xoxa0426+fzJ9pIbV4s2CwZpXTdMV0sUeHHJerdldZDzqRm+UBMH9QUHz7aEkajAWtfkHeIDGPudVI6Cptes9WyuJWei/pv/4eWszfrM2AFyMhzI0p1deL+Rq70IroCcQqbuDdeaaJX0yqyzbhnPdRc8FippoD3grerUwEzGO8RC3tO8Slmd2Ty9JtVC8HsIc2ttUIsoyTy0O15Scd1q+dQ5JWNwAFA/xZFi9zyKoUiRnepI6hXUaoL/HtiV7z8YH189ZS840TsLWYpYJRi61QMRHiwH1rWDLW2kRCn/7HGFZua9vT9tRDi7433htpGbljVSmcVos8Y3Mwp+65dMQifjGiNy/MG4uTsvoqLdXYGFEeyxV5+LQt5teIRgHw0k52T9HR2GQwGvMdE6xoyBlOfZlWK9ZsEqYywKBmZAODrJb2faYUpc62YtLwrEj30WCNl6+vd8fKD9XFiZl/rcZQTAuLpUKeC4jF/oFElvMMoQ45jDD6tsAb8iaup1r/FRp1U6nZxEEu385y+nm4zf2XlWQwOPl2zemG2RQZjiAzUmNYtx56429a/61QMgr+PF3ZN7SGIgCVn2ArlKMGWfcwe0hwnZ/fFA41s014NBgMql/O3Uel9XCHLRU1mxT8Tu+KlHvWx7fUeACwaActErav4DApevGRdYS16s2ohWFjo/PhhtHJKqVpeZspx1PbOVcP/ejVUXCtmMZFZ9nd2RiTvtxc746Ue9XFsRh/FOsTIiDAcnd4HCwp79LKquEq/u7MZ162etYxFqQ6TvS/1khDVsZe54WxKl+VQwlBaiIpz29nFvxqJek+nX/OqWH+yqM6qTS1tvelKGmIDKTzYD72aVLYpnN4WcwtinmgfgRY1QiUFa8T8/UpXDPx8NwD7C1OleoznH6iHb3YJU4Ec6aWjBr7BOg8bRQiRSecbElkd4cF++GHPZQAWAQG2R5ZSE+i64UF4o590C5Lpg5pi5b54xV5/TaqGoF3t8qgWFiA4hv1bVEPs+wNsvPCs95RNDZw7rCVmPdTcbuRTXA+mlNKkFnEKrzMwGAx22wWwv1IY0/vKaLD93h8/Hom+n+xS9dmbz9peR3I0rRaCjx+PRI2wALSrUx5Ld1/G6kMJ+PaZtth78TaqhzlHuXf+Iy3xxfY4LB55H/p9avleUt5sLUhd8+8/bOtEGN4uAj/uj5fdj1wdKW9EsindH244L7ktT4PKwTbXmz3xiQcVWsGwbJ/cHbtjU/BEB8cXg3LzZJho7pFyhhWHIZHVkZ6dj9YR5fHQ4mjr875eRlQI8kWFIF+rgy41Kx+vrT5uTVuXao2h5LRyFB9vXiFYeP/SqhA7qU8jVAnxR7NCR6W9eeGAjOiJFOUDfdC1QTh8vAw2wjI8lcr5YWp/4TkoTgeWOw/OJqbj0bY1MaR1dV1bqfDo6cCvWT4QR2f2QcN3Nki+Xr+ytDFXnDpgOepXCrY55nKwvfba1CpvrVe9rrPqZ3FYO6ETEu5kYcqvJ2S3mT6oKeqFByEn34SPN1/ApyNao2Ixsgz0gIw8N6JUeN2iRii+G9UO8/47h/EP1BMUP8upPpUkHmpVDf/7RVretzTC2hxRU3rINs6UyhxrWi1EtRpWs+ohgro9JZRy4aUU7BzpVacGcSoc6/yQi/A+0KgS+jWvgnXHr2Nwq2rw9jIKPKKOpv+O61YP47pJN+Fmx/ubjPiK1CKANVrfGSRUFlSzaGAX3LUqBNpEfx2hY111/XycDe9B9jIasO1ckvX5AInedo2qlMNbA5pg3oYY3cfxGGNcvdijvrVmkk3F0ZsnOtSyRr4ndK+HO5l5mnuSSrF0VDt8vPk8Ym5axJvaS6iztqwZip/HdZQ1YOUULPl0xhd61MdXOy4CsDSw15sCO2q6PPUqBaNepWD7GzqA2Ammt1iFwWCwpmSzLH/OEmE6OqMP6kxbDwDotiBKcV9qBR/U0LVBuLVpujht9+un7sNPBxIcimqO7Oic+nqDwYBV45QVyaVQo3LJoreB99aAJjh+NVWXa55Fbpw/jeso20bI2UJ+Wshl1L8Px3vOWrdD3QroULeCwMjj2+LwBPp6W9cPr/S0revt1jBccd3vDChd04Pp06wKtk/pgSc61BJchGqEAjwdT5pUXAGrdCln4MlR3Hqgz5+UzrdP0pBy07x6iN1+UnrB1lhI3Yhf6F4fD7epgXL+Pjg6ow/eLUx37Ne86GapVeHTmYQH+2HWQ80w75GWDkUDWFGi4kovrxrbEc93q2vTNNddhPj7YN9bPXFkem/B4uSeTC9HceSbhfVG13OgMbw7eWtAU3z0eKQu82LvZlVUKcB2bhCOOjLHSW7OiSgUPQnx9xGkmeoB297B1YJbfIqYOIVPTqFYb3iRJUBdz7lnRen0icVses/ydWHaudFgazAMaFkNq8Z1VF2/rAc7pvRw2r77FzapV5MlozcTutfH10+3VdXPsbj0bFJZVrHV02CVOD96TJvglitg0zO13s/bRITpPBr7kJHnRrRKsfNI9ZYqifAqcuM8ZMHpTCb3bYwuDSrKGlw8UqlVjR1sCM0zRKa+7NT1NMnnediUvn9e6epU2V+lAuvdUx/EJyMisWh4JPa/1QvTBjSRHEs5fx+82KM+hrWuLhm9cCdjutSV7T1mjxzGs9lOhSqhEl0bhuOdQc0cFnNxBtVCAxAW6GuVCFeiW8NwfDlSWkGyEdOewRlpVSWJQF8vaw9ALYI1LHyPSDbKydajFkfsBIBNj8Im1coh7v0BiHt/gKAm1RX8OLYj4t4fgAcbC9NED7zdG5890Rp7pvV06uc/1taSbuplNKhK3+vuxHTrcv4+uPjBQFz8YKDTPsMePZl0XTlHhB4seLwVFj4eiY8V1Hs/GeF5hoY9xHOp1P2SV7gt7nWsN2zWk5zStzvpXlhLqqQMLeajx1qhW8Nwm/YxrqB0WAslkMZVy6FtbW0Lts+eaI1FWy5gwaMlb9KR4qmOtdC9USWHFyElifBgP/w0zrYZtZinOtbGO39aWhy0rBGKx9rW1MVgua9WGI4mpAqesyd+8PVTbdHlw+0Y2rq65tQWrcwd1gLPrzwsmeIQUSFQdRTxTZU1ACUJ1rPp6ia2rkTNDd1gMGBQq2qIS2qET7ZeELz2WNuaOFGoJKskmV8WMBgMODGrL/JNnKRAkxpe69UQjxWqmv525BoAYTNucfqit9EAby+Daudlp/oVBeIPzhIYUotURMXLaMDQ1s5L2eUJ8PXC0Rl94O1lUBXNbVUzTPA4Uufz3ZV9vKT4YXR7HIm/iybFdHDaI8TfB4+K6mBHdqyFnw8kALCoYPLqxCWJsV3rom+zqhj/42HE3MzAIxJp59880w4r910RNID3BPq3qIrvoy/L1le6m9kPNUftioEYpmFeeLxdhFVE5suR9+Hln486a3g2GDhXNGogrKSnpyM0NBQjFm/D6ped6x0kSiYnrqZi3fHreK1XI0FBcnHIN5lx8loanvxuv1Xmd2THWqoaQRPuJSffhMFfRCOyZphNI+DSxMXkTPRauNP6WKm21GTmUP/t/wTPbXytG05dS8Pei7cx+6Hmul07BKy1YdFvPmjtUzd2+SFsiymqo3y2U23MkVCKlSMpPQdv/XHKug+1tcRlidhbGegjEhs6Mr03Kgb7WX8TADg9p5+qHnGEffJNZqw/mYjWEWFOjSK6gnu5BbiYnImWNUJLVInM6etpiCgfWKrn8DrT1sOcm4Wrnw5HWloaQkKcozBPs4KbCLOjLkWUXSIjwhCpc+62j5cRbWuXx+rx9+ORr/YCEMo4E56Lv48Xtkx6oETdpB0hnFFZted88DIa8MPodli4+QLO3EgHANQIC0CTqiFuld0ureyd1hOpWfmCRuTi6H6qhrYVgKUv5fej2+PMjTSPSxnzFBpWKQdvo0EgKsX3imtfpzwOXbmLoa2rk4GnIz5eRqcKLrmSID9vm6hvSUBNXWpJ57G2NXH84g1cdfLn0MzgJoLc3DuDKJvcV6s8ecxLIKXdwAMsMtpT+jbCvTyTKiW+nk2qoGeTKriRmo28ArNij0mieFQPC7BR4hQ3/pXrx2mP5tVL/4KuOOx/uxfazd1q8/zyMR0Ql5SJVmU8NZkgSiIfPx6J9PS6CH3LuZ9DloabIM8bQRCEEKmaTHs4q48doUyTauWw80Ky9fET7V2riFlWYNtZsA3Eg/y8dc/4IAiidFG2JcjciCdJvBMEQRCEFv7XsyGGti5S7q0e5nlKeKUNtf0DCYIgADLy3Eawv3uVxAiCIAjCUYL8vK1tcACKqDqT57vVhcEAvNZbexNygiDKLhROchOVgsnrSRAEQZRcyvn74PMn28DbaNDcGJhQz9sDm2Jir4YIobpTgiA0QEaem2he3TlyqQRBEAThKoZEVre/EVEsDAYDGXgEQWiG0jXdRBUVjX8JgiAIgiAIgiC0Qkaem/DxokNPEARBEARBEIT+kKVBEARBEARBEARRiiAjjyAIgiAIgiAIohRBRh5BEARBEARBEEQpgow8giAIgiAIgiCIUgQZeQRBEARBEARBEKUI6pPnYjiOAwCkp6e7eSQEQRAEQRAEQbga3g7g7QJnQEaei7l9+zYAICIiws0jIQiCIAiCIAjCXdy+fRuhoaFO2TcZeS6mQoUKAICEhASn/agEkZ6ejoiICFy9ehUhISHuHg5RSqHzjHAVdK4RroDOM8JVpKWloVatWla7wBmQkedijEZLGWRoaChNIITTCQkJofOMcDp0nhGugs41whXQeUa4Ct4ucMq+nbZngiAIgiAIgiAIwuWQkUcQBEEQBEEQBFGKICPPxfj5+WHWrFnw8/Nz91CIUgydZ4QroPOMcBV0rhGugM4zwlW44lwzcM7U7iQIgiAIgiAIgiBcCkXyCIIgCIIgCIIgShFk5BEEQRAEQRAEQZQiyMgjCIIgCIIgCIIoRZCRRxAEQRAEQRAEUYogI6+YHDp0CAMHDkT58uURFBSEDh064Oeff9a0D7PZjMWLF6NVq1YICAhApUqVMHz4cMTGxjpp1ERJpLjnWnR0NCZPnoy2bduiYsWK8Pf3R5MmTfDmm28iNTXVeQMnShR6zGks+fn5aN26NQwGA5o0aaLjSImSjl7nWkZGBmbNmoUWLVogMDAQYWFhuO+++zBnzhwnjJooaehxnqWmpmLmzJlo1aoVypUrh/DwcLRv3x6LFy9GTk6Ok0ZOlBRWrVqFCRMmoF27dvDz84PBYMDy5cs170d3e4AjHCYqKorz9fXlgoODuXHjxnGTJ0/m6tatywHg3n//fdX7ef755zkAXLNmzbg33niDGzVqFOfn58eFhoZyZ86cceI3IEoKepxrVapU4by8vLju3btzr732Gjdp0iSuTZs2HACufv363K1bt5z8LQhPR685jWXGjBlcUFAQB4Br3LixziMmSip6nWvx8fFc/fr1OYPBwPXp04ebOnUq9+qrr3KDBg3iWrZs6cRvQJQE9DjP7t69y9WrV48DwHXt2pWbPHky98orr3D169fnAHA9e/bkTCaTk78J4cnUrl2bA8CFh4db/162bJnm/ehtD5CR5yD5+flc/fr1OT8/P+7o0aPW59PT07nmzZtz3t7e3IULF+zuZ/v27RwArlu3blxOTo71+a1bt3IGg4F74IEHnDJ+ouSg17k2f/587saNG4LnzGYz9+KLL3IAuJdeekn3sRMlB73OM5YjR45w3t7e3Oeff05GHmFFr3OtoKCAa9++PRcQEMBt375d8nOIsote59mHH37IAeAmTZokeD43N5dr3749B4DbuXOn7uMnSg5btmzhrly5wnEcx82bN88hI88Z9gClazrI9u3bcfHiRYwcORJt2rSxPl+uXDnMmDEDBQUFWLZsmd39fPfddwCAuXPnChoi9urVC/369cOuXbtw4cIF/b8AUWLQ61x78803Ua1aNcFzBoMBM2bMAADs3LlT34ETJQq9zjOevLw8jB49Gvfffz9eeeUVZwyZKKHoda799ttvOHToEKZMmYIHH3zQ5nVvb29dx02ULPQ6zy5dugQAGDhwoOB5X19f9OnTBwCQlJSk48iJkkbv3r1Ru3btYu3DGfYAGXkOsmPHDgBA3759bV7jn1OzaN6xYweCgoLQpUsXm9f69eunej9E6UWvc00OHx8fALQgKuvofZ7Nnj0bsbGx+P7772EwGHQZI1E60OtcW7NmDQDg8ccfx9WrV7FkyRLMnz8fv/76KzIzM/UbMFEi0es8a968OQBg48aNgufz8/OxdetWBAQEoFOnTsUcLVHWcYY9QKs6B+GLIBs2bGjzWvny5REeHm63UPLevXtITExEixYt4OXlZfM6v28SYCnb6HGuKfHDDz8AkL4REmUHPc+zQ4cOYcGCBfjggw/QqFEjXcdJlHz0OtcOHz4MwCIqNWnSJOTm5lpfq1SpEtauXYsePXroM2iixKHXeTZu3Dj8+OOPWLhwIQ4fPoz27dsjNzcXGzduxN27d/Hzzz+jRo0auo+fKDs4yx6gSJ6DpKWlAQBCQ0MlXw8JCbFuU5x9sNsRZRM9zjU5jh8/jjlz5qBy5cqYOnWqw2MkSj56nWe5ubkYPXo02rRpg8mTJ+s6RqJ0oNe5xqfITZw4Ea+99hquXr2K5ORkfP7550hLS8OwYcOQmJio38CJEoVe51lAQAB27NiBp59+Gjt37sTHH3+ML774wpoK2rVrV13HTZQ9nGUPkJFHEGWUy5cvY/DgwTCZTFi9ejXCw8PdPSSiFDBjxgzExsbihx9+kPRIEoRemM1mAMDgwYMxf/581KxZE+Hh4Zg4cSImTZqEtLQ0fP/9924eJVHSSUlJQZ8+fbB//36sX78eqampuHnzJpYsWYJly5ahY8eOuHv3rruHSRA2kJHnILy1LWdVp6eny1rkWvbBbkeUTfQ418TEx8fjwQcfRHJyMn777TdJ0QKibKHHeXb06FEsWrQI77zzDlq2bKn7GInSgV5zGr/NkCFDbF576KGHABSldBJlD73Os9dffx179+7F77//joEDByI0NBRVqlTB888/jwULFuDSpUv49NNP9Rw6UcZwlj1ARp6DKOXH3r17FykpKZJ54CxBQUGoVq0aLl++DJPJZPO6Uj45UXbQ41xjuXLlCnr06IEbN25g7dq1GDx4sG5jJUouepxnJ0+ehMlkwuzZs2EwGAT/AOD8+fMwGAwICwvTffxEyUGvOa1x48YAIHk+8c9lZ2c7PlCiRKPXebZ+/XpUqFABrVq1snmtZ8+eAIAjR44Uc7REWcZZ9gAZeQ7SvXt3AMDmzZttXuOf47ext5979+5hz549Nq9t2rRJ9X6I0ote5xpQZOBdv34da9aswdChQ/UbKFGi0eM8a9SoEcaOHSv5D7B4IceOHYtRo0bpPHqiJKHXnMYvsM+ePWvzGv9cnTp1HB0mUcLR6zzLy8tDeno68vLybF5LTk4GAIHkPUE4glPsAc2d9QiO4yxNNuvVq8f5+flxx44dsz7PNtk8f/689fnk5GTu3LlzXHJysmA/bPPD3Nxc6/PUDJ3g0etcu3z5Mle7dm3O29ub+/333101fKKEoNd5JgeoGTpRiF7n2qVLlzg/Pz+ucuXK3LVr1wT7ad26NQeA27p1q9O/D+GZ6HWe9evXjwPATZ8+XfB8Tk6O9bUvvvjCqd+FKDnYa4buSnuAjLxisH37ds7Hx4cLDg7mnn/+eW7y5Mlc3bp1OQDc3LlzBdvOmjWLA8DNmjXLZj/jxo3jAHDNmjXj3njjDW7UqFGcn58fFxoayp05c8ZF34bwZPQ412rXrs0B4O6//35u1qxZkv+Iso1ec5oUZOQRLHqda59//jkHgKtYsSI3btw47uWXX+bq1KnDAeDGjx/vom9DeCp6nGfHjh3jypUrxwHgOnTowE2aNIl78cUXuXr16nEAuLZt23LZ2dku/FaEp/Hdd99xzz77LPfss89y9913HweA69Kli/W5P//807qtK+0BMvKKyYEDB7j+/ftzoaGhXEBAANeuXTtu1apVNtsp/agmk4n7/PPPuebNm3N+fn5cxYoVuccee0zgYSKI4p5rAOz+Iwg95jQpyMgjxOh1rv39999ct27duODgYM7f359r27Yt9+233zp59ERJQY/z7MKFC9yYMWO4WrVqcT4+PlxAQADXsmVLbs6cOdy9e/dc8C0IT+bZZ59VXFux55Qr7QEDx3GctgRPgiAIgiAIgiAIwlMh4RWCIAiCIAiCIIhSBBl5BEEQBEEQBEEQpQgy8giCIAiCIAiCIEoRZOQRBEEQBEEQBEGUIsjIIwiCIAiCIAiCKEWQkUcQBEEQBEEQBFGKICOPIAiCIAiCIAiiFEFGHkEQBEEQBEEQRCmCjDyCIAiCIAiCIIhCdu3ahYceegjVq1eHwWDAunXrNO+D4zh8/PHHaNSoEfz8/BAREYEPPvhA/8HK4O2yTyIIgiCIEsq6detw/PhxtG7dGsOGDXP3cAiCIAgncu/ePURGRmLMmDF49NFHHdrHq6++is2bN+Pjjz9Gy5YtkZaWhpSUFJ1HKo+B4zjOZZ9GEARBECWQ0aNHY8WKFXj22WexfPlydw+HIAiCcBEGgwF//vmnwMGXl5eH6dOn46effkJqaipatGiBDz/8ED169AAAnDt3Dq1atcLp06fRuHFjt4yb0jUJgiAIgiAIgiBUMmbMGOzZswerV6/GyZMn8fjjj6N///6IjY0FAPzzzz+oV68e/v33X9StWxd16tTBuHHjcOfOHZeNkYw8giAIgiAIgiAIFVy8eBG//PILfv31V3Tr1g3169fHlClT0LVrVyxbtgwAcOnSJcTHx+PXX3/FypUrsXz5chw5cgSPPfaYy8ZJRh5BEARRJlm7di0GDBiAKlWqwMfHB2FhYWjYsCGGDBmCL7/8Ejk5OdixYwcMBgNWrFgBAFixYgUMBoPg344dO2z2ffHiRUycOBFNmzZFcHAwAgMD0bRpU7z22mtISEiQHM/y5cthMBhQp04dAMCWLVswYMAAVKpUCQEBAWjevDnmzp2LnJwc2e904MABPPXUU6hbty78/f0RFBSE2rVro3v37njvvfdw7dq1Yh83giCIsszRo0fBcRwaNWqE4OBg67+dO3fi4sWLAACz2Yzc3FysXLkS3bp1Q48ePfD9998jKioK58+fd8k4SXiFIAiCKHOMHTsWP/zwg/VxcHAw8vPzERcXh7i4OPzzzz8YNGgQfH19UaVKFaSlpSEnJwf+/v4IDQ0V7MvX11fw+LvvvsPLL7+M/Px8AICfnx+MRiNiYmIQExODZcuW4bfffkOfPn1kx/fll19i4sSJ4DgOYWFhKCgowNmzZzFjxgz88ccf2LZtG8qXLy94z4oVKzBmzBjwpfZ+fn7w9vZGQkICEhISsGvXLkRERGD06NHFOXQEQRBlGrPZDC8vLxw5cgReXl6C14KDgwEA1apVg7e3Nxo1amR9rWnTpgCAhIQEl9TpUSSPIAiCKFNER0fjhx9+gNFoxIcffojbt28jIyMD9+7dQ0pKCjZt2oRnn30Wvr6+6Ny5M27evIkRI0YAAEaMGIGbN28K/nXu3Nm673Xr1mH8+PEAgGnTpuHKlSvIzs7GvXv3EBMTg8cffxzp6el47LHHZCN6ycnJmDRpknWbu3fvIiMjA0uWLIGfnx+OHTuGsWPHCt6TlZVlNQqffvppxMXFIScnB2lpacjMzMThw4fxxhtvoHLlyk46qgRBEGWDNm3awGQyISkpCQ0aNBD8q1q1KgCgS5cuKCgosEb2AODChQsAgNq1a7tknBTJIwiCIMoUe/fuBQD07t0bU6dOFbxWsWJF9O3bF3379tW837y8PLzyyisAgCVLluC5554TvN64cWOsXbsWQ4cOxd9//41Fixbh008/tdlPVlYWunfvjtWrV8NotPhi/f39MWHCBHh7e2PcuHH4888/cejQIbRv3x4AcPr0aWRkZCAoKAjLli2Dt3fR7T0oKAht27ZF27ZtNX8ngiCIskhmZibi4uKsjy9fvozjx4+jQoUKaNSoEZ566imMGjUKCxcuRJs2bZCSkoLt27ejZcuWGDhwIHr37o377rsPzz33HD799FOYzWa8/PLL6NOnjyC650wokkcQBEGUKcLCwgBYImYmk0m3/W7YsAHXr19HlSpVMGbMGNntRo0aBQDYtGmT7DbTp0+3GngsY8aMQc2aNQEAq1evtj7Pf6e8vDzcvn3bkeETBEEQhRw+fBht2rRBmzZtAACvv/462rRpg5kzZwIAli1bhlGjRmHy5Mlo3LgxhgwZggMHDiAiIgIAYDQa8c8//yA8PBwPPPAABg0ahKZNmwrmbWdDkTyCIAiiTNG7d2/4+/vj2LFj6NatG8aOHYuePXuibt26xdpvdHQ0AODu3buoVq2a7HZ5eXkAgPj4eMnXvb290a1bN8nXjEYjevTogVWrVuHw4cPW5+vXr48mTZogJiYGHTt2xIsvvoh+/fqhZcuWNjUjBEEQhDI9evSAUitxHx8fzJkzB3PmzJHdpnr16vj999+dMTxVUCSPIAiCKFPUq1cPS5cuRXBwMPbt24dx48ahXr16qFy5MkaMGIG//vpL8eYux40bNwBYjLhbt27J/rt79y4AIDs7W3I/4eHh8PPzk/2cGjVqAACSkpKsz3l5eWH16tWoW7cu4uPjMW3aNLRp0wYhISHo06cPvv76a2RlZWn+TgRBEETJhIw8giAIoszx1FNPIT4+HkuWLMGIESMQERGB5ORkrF27FsOGDUP37t2Rnp6uaZ986mf//v3BcZyqf1IYDAaHvlNkZCRiYmLw+++/Y/z48WjRogWys7OxdetWvPTSS2jSpAlOnTrl0L4JgiCIkgUZeQRBEESZpEKFCpgwYQJWr16NhIQExMXFYdq0aTAYDNi9ezdmz56taX+8qlpxDank5GTk5ubKvn79+nUAkFTK9PX1xSOPPIJvvvkGp06dQnJyMpYsWYIKFSrg6tWrePbZZ4s1NoIgCKJkQEYeQRAEQcBS1zZv3jyMHDkSgKUZOQ8vgqKUxtmlSxcAFiOMr89zhIKCAtn3cxyHXbt2AQDatWtnd18VK1bEhAkT8OGHHwIAjh07RsIsBEEQZQAy8giCIIgyhVKUDAACAgIAQCBYEhISAgBITU2Vfd9DDz1kFVx59dVX7dbA3blzR/a1999/H2az2eb5FStWWPvr8b37APXfCQAJsRAEQZQByMgjCIIgyhSvvPIKhg8fjt9//10gXpKZmYklS5Zg5cqVAICBAwdaX2vRogUAYPfu3YiJiZHcr7+/P7766isYDAYcPXoUXbp0waZNm6xqmoCl19I333yDDh064KuvvpLcT2BgIKKjozFy5Ehcu3YNAJCTk4PvvvsOL774IgBg6NCh6NChg/U9q1evRpcuXfDNN9/g0qVL1udNJhM2bdqEadOmAQA6depkbbdAEARBlF4MnCMSYgRBEARRQhk9ejRWrFhhfRwcHAxvb29BlK5r167YuHEjgoKCAFjaIjRu3BjJyckALAqY/GurV6/G/fffb33vTz/9hPHjx1sjed7e3ggNDUVmZqYg4jZ37ly888471sfLly/HmDFjULt2bbzxxhuYOHEiOI5D+fLlkZmZifz8fAAWgZVt27ahYsWKNu/l8fPzQ3BwMO7evWuNCFavXh3btm1DkyZNincACYIgCI+HjDyCIAiiTHHx4kX8999/iIqKwrlz53Dz5k1kZmaiQoUKiIyMxJNPPolRo0bZpDXGxMRgzpw52L17N5KSkqxGV1RUFHr06CHYNjExEV999RU2btyIuLg4ZGRkIDg4GHXr1kXXrl2tCp7e3kXtalkj78qVK9iyZQsWLVqEQ4cOITMzE3Xr1sXIkSMxZcoUQfolYEn9XL9+PaKionD06FEkJibizp07CAoKQuPGjfHQQw/hlVdeoSgeQRBEGYGMPIIgCILwAMRGHkEQBEE4CtXkEQRBEARBEARBlCLIyCMIgiAIgiAIgihFkJFHEARBEARBEARRiiAjjyAIgiAIgiAIohRBwisEQRAEQRAEQRClCIrkEQRBEARBEARBlCLIyCMIgiAIgiAIgihFkJFHEARBEARBEARRiiAjjyAIgiAIgiAIohRBRh5BEARBEARBEEQpgow8giAIgiAIgiCIUgQZeQRBEARBEARBEKUIMvIIgiAIgiAIgiBKEWTkEQRBEARBEARBlCLIyCMIgiAIgiAIgihFkJFHEARBEARBEARRiiAjjyAIgiAIgiAIohRBRh5BEARBEARBEEQpgow8giAIgiAIgiCIUgQZeQRBEARBEARBEKUIMvIIgiAIgiAIgiBKEWTkEQRBEARBEARBlCK83T2AsobZbMaNGzdQrlw5GAwGdw+HIAiCIAiCIAgXwnEcMjIyUL16dRiNzom5kZHnYm7cuIGIiAh3D4MgCIIgCIIgCDdy9epV1KxZ0yn7JiPPxZQrVw6A5UcNCQlx82gIgiAIgiAIgnAl6enpiIiIsNoFzoCMPBfDp2iGhISQkUcQBEEQBEEQZRRnlm6R8ApBEARBEARBEEQpgow8giAIgiAIwulwHIcj8XeQkZPv7qEQRKmHjDyCIAiCIAjC6aw7fh2Pfr0PQxfvcfdQCKLUQzV5BEEQBEEQhNP5+/gNAMCllHtuHgnhCCaTCfn5FIVVg4+PD7y8vNw6BjLyCIIgCMKJnLyWiuV7rmBq/yaoGurv7uEQhNug/sAlE47jcPPmTaSmprp7KCWKsLAwVK1a1W3nPRl5BEEQBOFEhhSmpl1PzcaaCZ3cPBqCcB9k4pVMeAOvcuXKCAwMJGPdDhzHISsrC0lJSQCAatWquWUcZOQRqkjLykewvze8jHRhEwRBOELMzQx3D4Eg3ArZBiUPk8lkNfAqVqzo7uGUGAICAgAASUlJqFy5sltSN0l4hbDL1TtZiHx3Mx75igqlCYIgHKXAZHb3EAjCrWw9l+TuIRAa4WvwAgMD3TySkgd/zNxVx0hGHmGXf08mAgBOXEtz80gIgiBKLpy7B0AQBOEglKKpHXcfMzLyCKfw57Fr+HrHRXcPgyAIwmOgJRJBFHH3Xp67h0AQpRoy8gi7OOKImLTmBD7cGIOYm+n6D4ggCKIEYiRPOEFYefvPU+4eAkGUasjII5xKWhb1UyEIggBAoTyCYDiacNfdQyCIUg0ZeYRdirMuMZIaJ0EQBEGUefJFwkM5+SRERLiG/fv3o1evXggPD4fBYBD8K829/8jII+yiNcPIbC6SFyAbjyAIwgKlaxJlGXENHqnNEq7gxIkT6NGjByIjI7Fr1y5s3LgRFSpUwIMPPog1a9YgLCzM3UN0GtQnj9CdAsbIS6V0TYIgCABAWjbNhwTBw64ViJIFx3HIzje5/HMDfLw0K1b+73//w9ChQ7Fo0SIAQLNmzfDkk0/iwIEDGD58uDOG6TGQkUfYRes8bOaK3vDx5gvo1bSKziMiCIIgCKIkYyIjr8SSnW9Cs5mbXP65Z9/th0Bf9abLrVu3EB0dje3btwueDwoKcnt7A1dQatM1V61ahQkTJqBdu3bw8/ODwWDA8uXLNe1jx44dNrm77L/9+/c7Z/AehtaUCmEkjySSCYIgCIIQQpG8Iu7cy8P6k4nIK6AUVj05cuQIzGYzIiMjbZ5v164dAGDAgAGYNWsW7r//ftSuXRtnz54FAJw6dQqdOnVCixYt8OijjyIvz7KePX/+PAYOHIi2bduiR48eSElJce2X0kCpjeRNnz4d8fHxCA8PR7Vq1RAfH+/wvrp3744ePXrYPF+zZs1ijLDkkGfSNhGbmO39vEutH4EgCIIgCKLYPLZkLy4l38PLD9bHG/2auHs4dgnw8cLZd/u55XO1YDZbjObs7Gxr7d2pU6ewa9cuvPvuuwCA06dPY8SIEdi/fz/mzp2Lf/75B/Xq1cOTTz6JP/74A40aNcKECROwevVqjBgxAi+//DKWL1+OmjVrYvHixVi6dCmmTZum6/fUi1Jr5C1duhQNGzZE7dq1MX/+fLz11lsO76tHjx6YPXu2foMrYWiN5JmYdE1fMvIIgijDcBxFKwiCUOZS8j0AwIZTN0uEkWcwGDSlTbqLjh07IiAgAFOnTsU777yDixcvYuLEiXjhhRfQuXNnpKWlwcfHB6NHjwYA+Pr6IjQ0FOvWrUP//v3RqFEjAECTJk2QnJyMdevW4ezZsxg8eDAAIDc3F+PGjXPX17OL5/9CDtK7d293D6HUoDWlosBcZBT6a/S6EARBlCbE02dcUgYaVC7nnsEQhBshd4d9ykCZmEupVKkS1q5di8mTJ6NVq1aIiIjACy+8gClTpgCwRPE6dOhg3f706dMYP348tmzZgqZNm1qfP3PmDB599FHs2bMHCxcuxJNPPuny7+IIFGZRQWxsLD7//HPMnz8fv/zyi0fn3zoDtreNWYXBxxZTD4ms7pQxEQRBlARYpxcAfB992U0jIQj3Yqaotl3KghiIqxk8eDDOnz+PvLw8XLx4EVOnToXRaDF/Tp8+jZYtW1q3PXXqFFq0aIFq1aohJiYGAHD06FEcPHgQffv2RdWqVbFp0ybB9p5MqY3k6cnPP/+Mn3/+2fo4ICAAc+bMwRtvvOHGUbmOk9fSrH+bOA5Ghfbo034/idWHrlof+3iRH4EgiLKLWEGQ1rlEWYV0VuxDvYVdy5kzZ6yZfwUFBcjMzERYWBieeeYZDB8+HC1btkT58uWxdu1aeHl5YcyYMdi6dSuaNGkCPz8/DBw4EPPmzXPzt5CHjDwFKlWqhI8++giDBw9GrVq1kJqaiqioKLz55puYOnUqQkJCMGHCBMV95ObmIjc31/o4PT3d2cPWnfBgX+vfJjMHpQxM1sDjtycIgiirkJFHEBbUZAKVdYwUyXMpn3/+ufVvb29vxMbGArC0WFi/fr3N9kFBQVi3bp2rhldsKMyiQPPmzTFlyhQ0adIEgYGBqF69Op566ils3LgRvr6+mDVrllW5R4558+YhNDTU+i8iIsJFo9cPdtL5ZMsFTe91V3rGzwcS8Nfx6275bIIgCJ4d55PdPQSilPPbkWv47cg1dw/DLuTgsM/1u9nuHgJRiiAjzwFatGiBjh074tatW4iLi1Pc9q233kJaWpr139WrVxW390RYx9I3uy5pis65w8i7mZaDt/88hVdXHydlO4Ig3MrEX44JHnMkP0HoSGZuAab8egJTfj2BjJx8dw9HEfF6ICzQx00j8SzikjKtf2fkFrhxJERpg9I1HSQ8PBwAkJWVpbidn58f/Pz8XDEkpyEuBC4wm+FlVKeaqbH7gi5k5hbd6ExmDt5elP5AEIRnQH4nQk/Y5tm5BWZ4sm6r2Mjr2biym0biWdzOzLW/EUE4AEXyHKCgoABHjx6FwWBArVq13D0cpyM2kQo0NEd3RySPNUq1tn8gCIJwJjQjEXrC3p893YEgvh2bPH3ABFHCISMPQEpKCmJiYmxaI+zbt88m3a+goABvvPEG4uPj0a9fP1SoUMGVQ3UL4mlYznCSSo10R6G1kYw8giA8FFrXEnrCJtp4enmCeHx0eyYI51Jq0zWXLl2K6OhoAEV9LJYuXYodO3YAAIYNG4Zhw4YBABYvXow5c+Zg1qxZmD17tnUfTz75JAwGAzp37owaNWogNTUVu3btwvnz51GrVi0sWbLElV/JbdgYujI5mFITtjs8daxn06Qh6kgQBOFsqCaP0BODQksjT0O8RiC1TQsl5Sh4uhPBE3H3MSu1Rl50dDRWrFgheG7Pnj3Ys2cPAKBOnTpWI0+OF198ERs3bsSOHTuQkpICb29vNGjQAO+88w4mT56M8uXLO2v4HoVYQFQuOiaVmumOFgqZTOFyvh31U4IgCDly8k3IzjOhfJCv/Y0Jwg2wTgNPXIInpecgPNgPRqPBZo1ALZZKBj4+FoGcrKwsBAQEuHk0JQtet4M/hq6m1Bp5y5cvx/Lly1VtO3v2bEEEj+fNN9/Em2++qe/ASiDiiTkuKRNVQvxttpNyWHyxPQ6T+zZ21tBsyM4zYfAX0dbHdBMhCMJRuszfjtv38nB4em+EB+skoEVTEqEj7H3XXS2L5NhxPgmjlx3CgBZV8fXTbW3G52njdReefhi8vLwQFhaGpKQkAEBgYKCNIB8hhOM4ZGVlISkpCWFhYfDyUidWqDel1sgj9ENsJ60/lYguDcIltnP/TBV/557gcb475D0Jwg4ZOfko50/y4Z7O7Xt5AIDDV+6if4uquuzT/bMkUZpg77secAsWsGTnRQDAhtM3AdiOzxPWDJ5AQQnIOKpa1TL/8YYeoY6wsDDrsXMHZOQRdhHnFPt6Sev1eOJ8TZE8wtP44L9z+HbXJax4rgO6N6rk7uEQKtDTae3uGg2idMHJ/O0JiOsFbSN5rhyN53I0PtXdQ7CLwWBAtWrVULlyZeTne3Y/Rk/Bx8fHbRE8HjLyCLuIJ+bujSohO8+EAF/hyeuJggKkrkl4Gt/uugQAeO/fs+j+enc3j4ZQg56JSTQjEXoiSNf08Psd29MPICcsz9LoS+4egmq8vLzcbriUBjiOQ3aeyemfQ0YeYRfxPDz+x8PIN3HYM60naoQFyG7nCWjp6UcQriQuKdPdQyDcAAXyCD1hI8Oenv54OUVYTuHp43UVGTkF9jciShWjlx1C1Kl4p3+OR/TJW7VqFdq2bYuQkBBERETg8OHD7h4SwZCWLQzN5xcaTr8evip43hPTkEpCrjvhuWTk5HvkeU1Ik57jnDQiEhkgPBV2dvJERyuL0aCcvkkAvt4esSwnnMzOC8ku+Ry3n00rV67EqFGj4O/vj5EjR+LGjRtIT08HYCnwfPLJJ3HkyBE3j7LscvZGOo5fTZV8zabnjcx8ffjKHX0HpQFKByEcJS4pAy1nb8bzK/VzOol7TJIwkH58sS0WrWZvxl/Hr7t7KIrQjEToidmDI3n7Lt22/p2Tb7Lpm0v3Z1uM5E8idMTtRt7ChQvRv39/7NmzB3PnzhV4zStXroybN2+Wmabjnsj7/52VfU2c/y8X8VgcFafrmLSQT+mahIOs2p8AANh6Tj81sTtZeYLHlE6sHwu3XAAAvPXHKd33ree6y9PrpoiSRUmpybtwK8PGqFOTaJOdZ8LtzFwnjcrzENctFpeUzFzk5Du/9ovwTNxu5MXGxmLo0KEApFNiunbtiujoaJvnCeez8fRN7Im7Lfu62Csn50T0cmOqE3kKCUdxhlfcT1Sw7mme99KAXseUXWwZdbxTUgo5oSe/H7lm/duTb3cFZs4qhMYvCdRcqx0/2Iq2c7eWGUPPzNlmfDjK9dRstJu7FT0/3qHL/oiSh9uNvPLly1vTM6WoVasWbty44cIRlQzu3svD+ZsZTtk3x3E4dS0NCzbFKG6ntrGpmnqWuKRMJGXkqB+kSmhBRSiRmpWHc4nS848z7C+xAm1mbskuuP/vVCLikpwzDzkKf8nvupCMYwl3Hd4PW98XGuBb3GFZIccToSdfbC/KlPFkp5HJzFkjjT6FbZjEjmIp0gtFSQ7HO34tlzT0ykDacd6ShXIjTf+1FVEycLuR16tXL6xatUr29YyMDBj1dKOWEtq9vxX9Pt0lu0AtDlvPJeGhxdG4lHxPcbusXGEKgNzaRaatnpWbaTnovWgnOry/TcswVUHpcIQS3T6MwoDPduPktVSb15yxYBLvsuMH+p/zrmLzmZt46aej6L1ol7uHIsDEcTh/MwOjfjiIh7/ai1RRiqxahKlv+p0L1NaF0JM8JurjyQ6EfJPZeu7zvXa1DHftoav2NyolnLupz7pO3KeQKHu43Xp6++23ERcXh5EjR9pE9DiOw5o1a9CgQQM3jc5z4SfzPXEpuu973TF1wgWpItVNuT55RoMB+y/dxpRfT+CeRORCrwkNAPILqLCbUE9G4fm4Pca27s4ZZ05x9nkuMR27XKTIpYaluy+7ewiSmMwcpq8rqsu7djfb7nvSc/Lx1/HrgsgqO3XoOY3QnKSdQ1fu4EgZiuQ4igcH8kSRPIvxoaWGcJvEHO2pnL2RXiz1xOhYfdZ1JArsmbhSsdvtRl6TJk3w119/YcOGDWjTpg0MBgPWrVuHRYsWoWvXrjh8+DDGjx/v7mF6LM44V9Qq/onzxuXGcjM9B098ux+/HbmGkUsP2Lzux4T6ils4ni0qMCb1QkINUueJMybi4uxzwGe7MeqHg7iY7Bn99bwYGThPE3w4dKXIIFCz0PnfL8fw6urjmPrbCetzbCqZo99P6vem7AJt3MstwONL9uHRr/cit4AEJJRQk/7oLkxMTZ41XdPD5g29GPj5bjxbjLn6v1OJuoyDbDzPxJXnvduNPADo3bs3zpw5gxEjRiAsLAyLFy/GlClTcOjQIbz00ksYN26cu4fosYjV+vRA7Qloo5Qlc4NJSi8qmD4h0Y6Brdkr7k1KXINXOm8hhCtwRjmnHufjjHWnseXsLR325BhJ6TlYsDEGiWlFEbJ8D659VZOytOO8xev+36mb1udYw87R301qOhM7oghl2EbROfmee555Ap5ck2cwGLD3oiVC5V3oIPLk8erBxJ+POVR3fT3VfvaBGiiS55m4MmXfI4w8AKhevTq++eYbJCcn4/Llyzhx4gRSUlLwxRdfUCNaEVfvZFn//nrHRd33r9bQEht5cm+z19yT/XmL6+GwHVPpvokQ+iBu0gvIpx8XBz0WNXsv3ta1d59WXv75KL7acRFXbhfNQ54cnXL09qFH/zGpd1UL9XdsQAQhQdWQovPJ0+93uwvTEHkhkNJu5J1NTMfCzeftblepnJ/gcYc6FXT5fKrJ80xcmWHmMUYej9FoRO3atdGyZUuEhIS4ezgeyV0nRO9YeK+2PfJVRvJ87SivsNNQcT0c4veX0mwQQmekboVOOXdKwfnIpkLyeLJKqFYjb9QPB5Geky/4/R1di7JzYquaoQCAiAqBju1MA2nZ+Ri97CD+PHbN/sYlCE83YtzBg00qWf8uadUJpTVdkyUm0b76sDgdvHezKvp8ONl4Hokr+zd7hJEXFRWFfv36oW7dumjRogVGjhyJtWvXwmSitBYpPOU+l5Mn/H3kxtW1YbjifgTpmsU8+cXv9yRPoV69bwgnIBXJc0oLBQff50HnsRTf7Lzk7iHIojXKuOtCMtYeuioZyeM4TtV1zG/D7qNlDYuR54r6xa+i4rDjfDImrTlhf2MdKTCZVZ+rjsyHpExqC2soedL9TozU2Fy52HUX9jKZgKJjU79SEAD9jF+y8TwTV64F3W7kbdiwAX369MGBAwdQs2ZNVKhQAVu2bMETTzyB1q1b4/Jlz1RwI4CDV+7gElNYLHd/sVdEzK6vi9vXzlMjeW//eQrNZ23CDZ1y7Ql9kboZOkd4xbH3efri1hk9LvVi8BfRmg2r1Kx8wXv4P59feRgdPtimGLn84+g1NJq+AZvP3BT83nwdkivEMZyd7SFFTr4J3RZEYeR3tuJaYub8cwYtZm8SlB7IoYcATmmGnRv2X7rtxpEoIzWfJtzJclq/X09BjcqmSSRI48nGOlF8xFlwzsTtRt7MmTMRGRmJK1euYPfu3di1axeSkpKwbt06pKen44EHHsCdO3fcPUyPwpMu/1X7E6x/y01MiXYacbJeq9ik4ikHisfgKRGQnw8kILfAjM+2xmL/pdu0WBHBcRwOXr7jcE8zR2ANE+maPP1xtM7Pk2veAM9flKSJ2r3Yw2CAKF3T8mDruSTcuZeHbeekhW9OXkvF62tPwMwB4388IjguXoX9Xl1xqNxRi3M0/i4S03KwT4WhsWzPFeTkm/H1Tvs15exc6enODnfAHp9Pt8Z6bAqknP923oZzxdpvXFKGxygOA46tOfiG73qrjrL3NXeuhQpMZuyNS0F2HmXnAUB+QRmK5J0+fRrPPfccwsLCrM8ZDAYMGTIE+/btQ35+Pt599133DdAD8RTDBQCy8oo82o6Oir1JPfHt/mIZQOJFgKfd8NYcvoonvt2PP1X2IiwrrD+ViOHf7MOAz3a77DM7vF/UiFyqbssVzdDVUtwId1knS6OipQHCuUPN7xaXlIEhi/cInmOnH2tvMA+av/XEaNRuWKq5l7FzuqfN556A+J73+trj7hmIHeTO++KIUGTnmdB70S70WrjTY9olaT1HbzJOcH6O0C1dk7kkz6moDXQWn2y9gJFLD+DFn464bQyehCvv52438kJCQmRr76pXr44JEybg77//dvGoCLWwN3Y1i5duEvV5ey4KG3/mFWOyNokuHk9dE/x78oa7h6Cayyn3MPvvM05NNeVTeu1FfZ2FdLqm/p/j6C49PZJ3+MpdbDl7Cx9vOu+RUWqtY1ocFaeoril1bpy6nmb7uYJInr4LODH7Lt7G3H/PIsdNLRrYqIHa4/3Lwauo+9Z6pOfIR1pNZOQBAPIKzPjgv3PYGye8X4qPyV/HPfPeIvfTSWVR8KRlCc8L8XmVml2U+ZHlIVEirafoyWup1r/1juSxh/ZwvPsy4lbujQegXtSvtFOmhFceeOABrFq1CmYZyzYiIgI3bnjmpOUunHV6OBIh9NKYDuDv42Xz3JdRwpSdP446HuUSL4Y9wWsudVy8HPB6u4sR3+zD8r1XMG6F82T7hVGT4v1mjrxfKgrhnEieg+maxbzpy32uXlkBSRm5eH7lYSyOisNmN/Tws/c9tH5NMyduoWD/PX7etnMbx9zWvK31NtrGopYnv9uPpdGX8X20e+rY2UtIS99EjgNeX3Nc9nX2d/DkZt/OZuW+K/h21yWMXCqsedRqEHAc55ZsILnPVDLy5m8UpnL+I3KOsmnJekTy9DguWu8b95hsKF6kRa/znD0+jjoKdTlXXLzc8aRsNynKVDP0t99+GydOnMATTzyB27dtc/mjoqJQtWpVN4zMc3HGCbz5zE20m7sVu2O1eVpYY4Ud1r8Tuzo8luJEjDyxT57UAr0k9X5MyrA0sz+bmO60z9h0psgwaPPeFry//qxD+/lsayzqvvUf+n+6S9P7pH4Op9TkObjT4twUPt50Hp3nb0dy4e/Is2zPZXT4YBviilkHK+ZWumujsYlp2eg0b7viNkoLL7k5gj3kNvOKxNlx/a7tvCWI5BWeZM6OdH62LdYtTZBZR4lWT/XWc0myr7GL07IcyZu7Xrp2TcsxORJ/B42nb0Tdt/7DnH/O6DU0WZpULWf9e+pvJyW3UXJ4XrglnJvEmR6sYZdbzDqn3AIT+n+6G6+uPlas/Wg9R6f8WnRceEdRcVXGpXAkRXDKryfQ55Ndxc4OcOV0NG7FIQz7aq9HzxVlqk9emzZtsGrVKvz999+IiIjA8OHDMWvWLHzwwQcYOHAgVq9ejbFjx7p7mLqTcOcejtgJn9/OzMWO80k2iwJnpG6N//EIbt/LwzPfH5Td5on2ETbPeQnSNS3/VwjyRYtCuXAxSRm52HUhWdH4Kk6QyxPVNaUuaK8SZOQ5i6y8Amw7d8vmBpKalY/vdjsWjfhk6wUAQMzNDOs5duJqKuKSlOsRJIUqnJGu6aiRVwxnxeKoOCSm5eAbkcjFnH/OIjkjF7P+Pu3wvqVwdfT8821xuGnHsFQ6fnIGCbtIUHNT/kAkIGEwCD/Xu7De5rqTFXbzXFjUz8JGZPSUCBdE8swcrt7JwsHLZUeMjeM4Reerlrlh/Moj1nKIZXuuFHdodrlwq2jezWAUad8e2MT6t9L9Xvya+F7BXpdZhfvPN5kRFZOkWWxpT1wKzt/KKHa6q9a5mp1nKof4ObQPOYTK5dr3+duRa4hLysQ2BSeMGLOZw84LyUjJLHIqusqpfT01G1vPJRXe8z1HjEeMKwWk3G7kAcDjjz+OI0eOYNiwYdiwYQPee+89TJ8+HTt37sSMGTPwzjvvaN7nqlWrMGHCBLRr1w5+fn4wGAxYvny55v2YzWYsXrwYrVq1QkBAACpVqoThw4cjNjZW875YBn4WjUe/3idoQSCm/2e7MXrZIfx2RNjQ1l0pK090qGXznLdETZ7SpH3iaipG/XAQm87clN+oGBOCeDHmCemaUotIo0dcee7l9TUnMHbFYad5lLPzTUjJzMXQL/eg9yJhZE+8AHCZ8IqDlqNU9EdrlFpu3tD7a7r+krP/gUrRMzkDjj2+YlU4qe8ofs5oMAgWjEfj7wIAokU1VaUFQbqmjo5IcU1etwVRGP7NPpy94bzMAk9i05lbis5XLRELV6uTyn1cZM0w6998HZoU4u/26Vbhuos9z77YHgcA+CrqIsYsP4RR39tv5cGil/O8OJF6fj2lV7Rfrx7EWu6F645fx7M/HESfRTuZcTj80ZroMr8oo0PhtHI7ZSqSx9O8eXP8/PPPSE1Nxfnz53HhwgWkp6dj9uzZMDqwIp4+fTq+/fZbxMfHo1q1ag6P64UXXsDEiRNhMpkwceJEDBw4EH///Tfat2+Ps2cdSyljYT1dHMfhrT9O4usdFo87n161RSTXLU4LclVKotEAzHukpfA5iXRNNV4bpbqdYkXybGryHN+XXlATdGk2Fhr6vxy86pT938s1Ca6V55YfwpHChbY4dVHqEnKGkedoConU+7TuSu7rqLkB/3bkGl766YiqtB0tw8o3mfG/X46h+cyN+HBjjIZ3FqFmvlFyjN2T6XnHHl9HFscmM4f3/i26RxwuPPdcgTsSBdhzVE/1OHEkj+cEI1jhSg5evoPnlh9C/O17uu0zt8CEl386irWHbOfCXXZKKHbHljynAWuc1a8ULLtd7C3laAy7WP77hMWhwmdznLhmK4SkhJb5/sf98fjfL8ck7+3FSRP0cmIvzeIY+GqOTU6+CS+uOoLX154AANxlRHNSs7RFVfXAk0tiylRNnhgvLy80bNgQDRo0gJeXbSG7WpYuXYorV64gOTkZL7zwgkP7iIqKwnfffYdu3brh6NGjWLBgAVasWIH169cjPT0dL774osPj42FPxKMJqfjl4FWbxQ5v9CRl5CAtOx9viHLbXXXCcBzwZIdaaFC5aFL2kYjkqbm0lPLna5YPdHiM4oJ/T63JK2uK+Dn5Jly7a7/xMUtx1Txz8k2CFLLtMUl49Ou9stuKYX+2HeeTdPG+OWo4St309TJC1fRUm/LrCfx36iZW7Y+3u62Wa+6fEzfw94kbuJdnwtc7Lio2GZdDjVNIyUu/cp/0d2LnVTXqmvbQU2wpO8+keH2w88uVFP2MESXYY6RnSYFgvx6gtDn8m33YHpOEib8Ur3aLZfXBq1h/KhFTf7etWytBGl0ClOYB9jdVar0R7O+t+BliB43We4xwTEV/25vDZqw7jb9P3MD6QlVoluIYaHwZh14RV7NO14uar/TTgQRsOK2QoeVilAR93I0r1bLdbuTdunULTz31FBo2bIhWrVph+PDhmDdvHjZu3IhbtxxXaevduzdq165drLF99913AIC5c+fCz8/P+nyvXr3Qr18/7Nq1CxcuXCjWZ7Cn4V/Hi1QlWY+e0WBARk4+Ory/DZFzNtvsw1Xpm/yndKxbweY5FjUXl9IWARIKnGqxieR5QChPyjjwhDRSR9jioHLiwM92o+uHUThdKDN/WkJuXkzn+ds15dX/eljoBS8wc7IRDbEC4Wf/Z++8w6Mo+jj+vUsnjRB6S+i9hw4CUgWxIDZQijRRERVRkBYEBWyvIipKL9KrgnQIvYaEHmoSOiRAOqm37x+Xvczuzba7vUthPj555Pb2dmd3Z2fm1/dYu1+TE/2gRSdRY8I21W2RwlY5ke6uqe0YUgsXLXNhfIq+xeqTRG6ztrwXasYbueOKrbo85P1Sk5HQT2FBqqeQ1+mHMLSZuRfREgIcqexy1vxAdlF7yuDIHVeurIWzufXYdoFCjPg9ICnIi1U55KZeD9e8pafcHK107W/+dUzwud2sfeoaR4HsT2rdjfki5oLj2NH1XXR211QrTGs5jhS0Piw1PjmDgqwceabcNYcMGYKVK1eiXLlyKFOmDA4fPowJEyagV69eKF++PMqXL49evXrlS9vCwsLg7e2Ntm3bWn3XvXt3AMD+/futvtMCOYiRGmVSo2c0GBD7SHpCcZ4lz3wesgwCmRVNTUyeGuxZlIjdJwqAjEfV2hSAZuHI9XgEj9uK9aKYTzmWHImx6Vw3cgd7XvMpToUtxb4o+YDvm4/SMHbtGVx7mGxl4V5yJAYv/nqI+ruVJ27KHjfqfpJsxj9bsdWNTQ9Lnh7uK+I6lDS0NEu8qy2vvpoYN6kx8t8zd7H6FN1dmLznOSZOWOaDsv+gNsGybXDVcdXBJ5rZK/F+kItUN50CgO8lPsVnayJxKoae9ETgrpl7/s2Rd/D1vxftWrSaKMcVny8/eKKjC5rcArwwCXlz9l7FosNmBZrc+NSQiMmT28+Zgrxe7sZa1i9ixVFeLU2bTy+AfEUibyXYfJx/zyjP1+6u1uOM0vztSNR4qOQXzhy75FWPTuDAgQP44IMPMGfOHMu2hw8fIiIiAhERETh9+jQiIyOd3q7U1FTcu3cP9evXp7qN1qhRAwAUE7BkZGQgIyNPU5yUJAwWVzN+G40G6gvEY2+Heagx5TnZlktEWn2+GWoWk3L7qFlIAkBSehY4DvD3crNsy7LKrmn+zHEc7iamo0JxL1XH1hN741Mys01ISMtEaT9PnVpkpt88c2D6mLVn8Fqziqp+Y++ka/m9TmPckCUncfVhCnZfsrYwLrZRIAWA1/84St2elWOyShSgpW/Z2hWoigInzROk4kTN4kNLHxHvastYdiNOWVv8VCKWUM7lTmhBUlYYech4IHSoWcoh2d6kNMLFiTHRxUWfxc6sbVHYFHkXx64/wpHxna2+J4Uxvl2jV0UCAFpXC0TXumVsOq9UKYuHyRk4fydRMpNzYUKrIJeelQNPNxe7U9tzHKdb7NKdhKf4YafZs2lg62DZ8cloBIa2q4L5h6JlhSJnGmvJc6lOHERTvmkYw8S75gl5+kh55Fh84Irthcj3qShi7kYZZ27Z4T5rL7YmOXMG4nWqI8l3S56Pjw8aNWok2Fa6dGl0794d48aNw5o1a+x2ibSFxESzO5m/P30C8fPzE+wnxYwZM+Dv72/5q1RJWIZAlZBnkHdvtGc8iLqfhBbf7tH0Gw8JgZPXStk7Z6hZSGbnmNAwdCcaTd0pSBkutuTxY9w3Wy+h7cy9WKYipkhv7M009+KvB9Hi2z24+kC+DIAzsFehoLOMh6u5C2c9teqAMN03Cc1lc+Km82g7cy81aYKYHBvfEZrgpN2Sl/fv7efzYkmUEjcMXnxS03nsQY0bry3wCg0tkIs1E8cJ7nd0vLXAJvdu7L8SZymhoCczt9GT1ThinDt2w2zBu5tIVwqKLZ8kCWm2u/mS1g7yHH+EXceLvx7CT7ucvz7QG/kyAtZf8n1Rq1us+FCz91zT9Hs5nhJFvcXvixgXg0GVa2K+WfJk7ivppkvLLaBljhQrafhnrZeLtdhS6MgcBa4UjwFnlOmQoiB4cUnhzGR8+S7k9erVC+Hh4fndDIcxfvx4JCYmWv5u3RIuBNVo0TZH3pXtsPYMCJsi1NeE4S0YYqvi4Vx3Kb6N/EA1/ZX6NrXppkzWsgNX4vDp6kjUmbzdsu1Rap6l1LpOnvnz/NwYrOlb7M+IqpXjNx7Z9Xu+IOyWs/fw37l7GLv2DDKylTW4KRnZ+GxNJPZG2R7bKsbeOWLD6TvKO5Hnc4A2zp7gfJ4Z2y5Z4vr+Pm52/fxi/VnFSZRfAPi45zlRqNH80hYOof9cUJUIhYdcLP6277rMnnncS3yqOXufPU/MGQWa1SKO/yI/F/dyl92fhpZYY47j8M3Wi1T36KVHrbcpHUsPyDGHHmec92+x94KcJ4oS5HEHLrQuJTCbEk9b2JCz5NEEQH480OoGKz4Un4kSAP636wp+20cX+rafv4/P156xWA6T07Pw2epIizveo5QMfLr6TF77OE7ekmcwWFxU5x2MRqKEko52CD1jIUnIPi2X+ITMDP6A4gVFda2XOJ54XHfV2V1TfBxHugn+deCGw45tC5+tiXRq7JuYm4/S8PHKCFy4a6245D1z2tcIdHg78l3Imzp1KrZv346DBw/md1ME8BY8KUsd73YpZenj8fDwgJ+fn+CPRK1uV87lj/ZdelYOzt1OVJzgtSwAKgeas14+V6OUYHv/+ccReSvB8kLx81UDG91oEmSC0AcsPIGNEXcE1jEpdx7xd7TvtfI0Mwdnbydoum+h/+ojWHIAPvj7NNaG38YyiYyAJH/tv44Np+/gvcWnLNtuPU7DvUTprHyPUzNlC4fbq2EkC6SqwRFz0kcr6C56+6IeUgdkMdfjUvDn/huYtuWiVT84rlCkme9/5KJXzT2lCRBrw29j4ib5QubkJEe6LKoVdD8jFm6AOqHbni5yPS5V9t1KSMsUlJ1x5CQuzK5pnb7fqianQmd9PaSS7PckF+8lYd7BaEz5x1ronbxZuE1JK6yX8p60lq84bh3TKo6dI9tFavm1Cib5nWBFjvDYJzZlhBUjp+ul3S6+L+q1aH+UkoFf9lzF9zsuU0uKvL88HOvCb1ssM7P3XMWGiDsWK3/ovxdxjrDCm0ygZp7kMRjyMkkCwPc76RZpWlKk9t/tU3VNWiGtcnLjCjk+0TKB0/q31BgvdsM36uSumZ5lXqeIz6ulr2pZ4zzNzLHECecX4vZG3EzAGol4a/7+6J2Yjzzu8GWn8M+Zu+g12zovAK9EcHVCMb98F/Lq1KkDwJwN88MPP8TevXuRkpL/leq9vb1Rrlw5REdHIyfH2mrCx+LxsXm2otYXX24wp40HAxacQO85h7BawYVM7QS6Z0wH+Hma4zxoMRCv/HYYobkLEv6a5LLJyV21VEpzKQTuPBKWPB57UxMPXnwCL805jPUaLVK6QFzL9K2XFHd/lCp0kUrJyEb77/ah9Yy9VgMiP7E3nbYLXX464PCsWGonEEdoHq9LxEYNXnwSvWYfQlK6vOsn2SZxrNdDiUyN4t8KhDwV12hryuUW3+y2/JtcmKt1IT4qskKrmRS15BehHW3HBek03M2/2Y1u/zuAqPtmJZtUjTs9EBfhJi99y9l7mLxZKGArCevdiJi0tEz5dpPPO1Om3AwADFlySvZ7RwhJNOFTmLiCE7iSkq6qWsfggizkvfbHEfSabb+CemNE3nwiVsItzE1kQsLfQ61KNynPIfKRpMr0Tb5t8w4K2yQu07H0aAw+XytUEInbQSabEdf+zQ/I90xuTCb7b4C3tUWf9kykjkcq6KuW8tYt8cqwpafw0pzDWCay+g9apN71XkvXclYGX9k2UO6xVObkEcvC8dKcw1ii0StCCf64y47FIuq+tLKcf+5uTkgBmu9C3quvvoqAgAAYDAb88ccf6Nq1K4oXL46aNWvirbfewqxZs7Bzp3XZAGfQoUMHpKam4vDhw1bf7dixw7KPPdxWObjJTYy0F+xEbga0lQpCntK72apqCYztXku2YCkP36n5buuIGBQaP+7MczkRv+jhsU/QW5RhMXjcVtScsM0mNyY+LiU/Yvu0Ik4QQrqWiGM57ohqboU7sXCzHI4Q8qTi7XjuJchrJEnFTFa2SKmg0F5+wUo+GzXXKBa21CIVq2ir+9wSFQoYe4PtxVlSSXjhtMfPB7HqxE1ZZUfb6kJXmKFLTgmKkytBviMcx1lZzFaeEI6tSo+RtBQoFQdOy5R3jSTZr5BQwVnrL3IeyjZxFhd5QJhZVKq/82O1OHtnfq8fUzOy8frcI5h/8AbGUerYyWW+VsuFu3kJzFrP2Ispm+Ut9HnumtrOIzUjk4J0Rpac1xD9YYgF8e93XFZsizMWuEr8fTwWr/5+GI9TMwXvu5wSTJBlV6VAJ3XfyO0LBjbHo1xPl/Wn1We8psG72F8RFZPXkmFTreD2y+6reOsveqIye5m95yr6zTumKjyFdo8zsk1466+jmLPXbJRZe+oWXv7tsGXMVOMRFR77GC/+elAyqzAJf9w5Em7PPHz/ctEp87EcDj/DokWLcPr0aWRl0Se1xYsXIyIiAikpKYiMjMSiRYswevRoVKpUCbt378b48ePxwgsvOLSN8fHxiIqKQny8MPZk+PDhAICJEyciMzPPKrJnzx7s2LEDzz33HGrWrGnXub/aeM7yb7L+nJgsGW1ujsyAdOV+MtacuiUp0Ci9xp90qYkPO1VX2EsIvwZ2UWGl1CNehNSCigfYvVEPBW4kPJk5JsHEqhVHF1k/ci0eu0U16bSekbSkii0e4klMzWAH2HbdetR4cyZKygmyW4tdpdeG38JFmX7FZwGluWtyHIc1J29ZrFQkyZR6TEo8TrVOdrE58g4ibyXoms5fjLeH+qTNiRTX7OT0bCw7Fitb7BsAxm04h3Uy5T/+HtpK8Hn3pQdW9RHlOEG43po4ZQuUkoBfMSAv+6pSH1twKC++xd7CueIF+L7LDxUFQ5vOI5O4glSMSIUevPbHEZy7k4i+c4ULRiUliKNlhaVHY3Ey5gmmb72EVSqSK6ll7Noz+Dk3Jq59jZKC75YcjVVlTZJaiIuVdjxSU/KpmDylHi/sHL3+CEMWnxS8B1KWEXFT1VhrPdzyxkBHTAe+KsahCRvPI+JmAn7efQUXiUzhcuExQiHP+nuagJiTw8Fk4rDqxE1ce5iMyFsJ+OfMXct9cncxokpJbysLaX6iVsH6v91XcP6O7WspOX7adQVHrj/CljN5rr/ZOSasOH4TN+KEAixNGbY54g6O3Xhsyfo6dt1ZnCEEXTWOdO/MP4Hzd5KsxiU5pN4THt4d15HzMI/DSygMGTIEBoMBixYtwoABA6Qb4uqKhg0bomHDhoLtt2/fxpkz0mZ/KebPn49Dh8wWnHPnzlm2hYWFAQBeeeUVvPLKKwCAOXPmYOrUqZgyZQpCQ0Mtx+jUqROGDh2K+fPno0mTJujVqxcePHiA1atXw8/PD3/88YfmdslRrbSPZEyPXBatLJkB6WlWDr5YdxZ+nq7oUb+c1fdKQcwlKO4IgNnCx1u1xKhx1+TRy1Bz5Ho82lQrqcnyY0/6aXtfTjkhh+M49JtvzgZ4ckIXVb+hQd7/dxccx/evN7J8FisNSvp4CD7zvxQvwiNsqLVjj4usuF3OQMmFmnwO4v52+Noj9Jx9EDEzrWt7Jj7NomYb4xfH/527b6mPKf69UtxV4tMsQSkRqd/wKe0dWkpEw+OWSpoxadN5/M/bHacnddWpUUJo90vM34R7a46JU7SoyY09Hz9fXVBflOxDGdk5MJkAL/e870k3YHJ8t0XJQv4iOT0Lg3NdtqKm9RC0SQ45xQUPefnihS4paGq1ziu5a77cuIKm49HgOA7JGdmWkAQSe8sU0DgZ8xhrcxUUQ9pVQZPKAVYJjtaH38YbzelxnLxilx87PN2MGNA62JL84uU5h3BqIu3doY9tH644bfk377b49jxzofE9RK0zqWdnS2yTu4PjkZQW8MmEW37i0yxsPUsKEubrycw2IcfECd5Ncj6j3Y8Vx60VplkmE9afvo1xG84Jtv/yVmMAeUofTzcj0mUsqVKQ49nR6/YleuPRw026pA99/UjCcRyS0rNlx2NyPFxx4qYlLpmcJ5+kWisMadlPSci5XqodUuV37IEfH53h7eZ0d80HDx7g9u3byM5Wp5muWLGiTcXQDx06hCVLlmDJkiU4fdo8gB0+fNiyTW3tvT///BOzZ8+GwWDA7NmzsXXrVvTu3RsnTpxA3bp1NbdLDrnYC7nMRWriUk7fTKBuj5NJhPHdaw1Rs4wv9btvXm0g+Tv+vaGl1BXvY28NOZ4rua6iWnzDtaafJpG7Nnsh540nROpxrZkmSSHv9M0EwYQkvvbGlYtb/X7PpQdoNFXoKm3LuE+bCNUeRkrJ4EiUgt5NIrc0tZDvKe0YZ24nSP5W7jy/7rmKRlN3YlOEME5UrmneHsLFfbJCHKIW9HKxpVki9WDtqVtoNHWnZCZBGmZ3TSVXXJkvcwc8vpYU+fzbztyHelO2C4QJKUWCLfeWFAxTM/LOoWX8i5XJeMwjV0KB7L9q3hmylMaKE9ZJXkj0SL4zZs0ZNAzdidM3rd3U1cTNq3EnIyHjdUjXXBJ+PKB5+PDzJt+PXAwGBBJjZXyK+nfnieg9k1vcSwm8l20o7+OiIOTZmxRDrsD87SdpaBCaN7eJ+xDfR9vN2os6k7fjKfGMyPmB9j6SVlGejGwTzt629ii6nNsPeKXxkHZVLN+pVegsOxaLRlN3YnFu7OZVmcRpWtBjHOc4oYKI9iqNXhWJRlN3Cixs1sfJawstlOTy/WQ89/0+q+1K2evJd/urjefRaOpOu7OhA0Dz4ADZ77MtQl4RcNfkmTt3LkqXLo3y5csjKCgIXl5eaNasGSZPnoybN+UHcVtYvHgxOI6T/CMtdqGhoVbbeIxGI0aNGoXz588jPT0d8fHxWLt2rd1umjTktA60NOaVSxRT/B2P1AJFTkCU0iICEEwoYiyWPBVaCql2adf2av+dln1nbLskSLSgVgPzPxtqOJGCL3kWpTH/1z1X8f6ycMuEJXaXJZUIYoWCieMsiXMA4G7CU3yjIrmLEnHJGYJyF1rJj6QLSotQNYtuaoY1YtuNuFSLmxm/L/kuBI/bipbf7qb+VsyPuX1s/IZzCI99jHcXHMfVB8my965JJeEkFCGhBLIFLYqW1lXlU0irqT2oFT7mT03cEI/ZXVN6nL18P5maIIOHfyf5sZF/nCYTh/iUDJg4CJIdkc8uK8eE0zef4J35x3HpHn0BJ7cglOo6HAdE3HyCdxcctyw2xaRn5WDY0lMCq6bkeQSCnPBeXbybhB0X7mPAwhO4L1Fnj2T+wTylZphCIWYfFW55322PEoRGiNmQqyCZs9da8Ffj0nVTY1ye+JDHKNYXD1ezIsbX0/r6xNk1jUaDKs8Z2rUcuCq8v3KvLy/k6VE/nfSGOU1ZuKcRAmX9CnlZyTvUNGf3fv6HMNnjyzVxc6SwdJR4fOUFOT6RFpnRl5wf5LyoSNKzcqjPh1+78Yt9sjSL3Jh/Iy4F7y44jmM3HmFSboZltVm81Wa41kNXxwGYT7ie01xo/zljfhZyhgyyLTSly2JKqZm8FkhDKgJW5iqT3vzrGB4m25cpVMoIcPT6I7y74Diu5bqaOsNd02lC3vHjxxEfH28RsnJychAREYFvvvkG1atXx9ixY5GRoS29elHDjzKYS1G8mJulKLkaTaaUFUgcmKsWucQNvPZETUye1IL6+x2XNbnJ8FppfmB0UyGEqRXy1py8hT/33xBk/cwxcVh2NEZxcv9Fwh3t5uNULDsWS9UAk+0ib6FSa3/cdQXbL9zHwdxJW7zIJ/uJWIv//fbLgoHyx11XdJnIP1sTSd2+TSa9NokgIUB2DpYdi9W8oJKjTjk/q23ZORwaVfSX/I04iyCNLefu4drDFPx9PNbiNrnlrPCa+Ul/+fGbiLqfZPW8HiSZx8P0rBxVsUBGA/DaH0dx8Go8Bi06KSvkrRallranjpmYsMtx2HNJXW3GqqW8Zb//gpLoIj/I4TiciLZeiPIMXmRdv42E7+8WIY8X7CXie2qXzeuXOSYOfX4/gkPX4vHuQnpR96kyCzypbsBxHF79/Uhuf6G3f+HhaOy6+ACHrinXStxNPHOx8u6XPVcxYlk4DlyJs8pKSm2b4h55KI3jHMfh97DrWHH8plUWSDF7CddEHjXrMK3r4Sol8/p9tomzJEoj4WPWMimKUD55lMWSZzRYLX5ptedolyJ2rY1LzpDM/tqiilkpQ8aX2gq5PkhKz0Zmtgkcx2H1yZu4eDdJ0IbqROI3XsF8Q+FZyllgxeOTuAtl5cbQ0ahWMq8ttL7Xlciiy5OelUNdk5zNtdbyi321WWg/WR2Jg1fj8dZfxyT3kYLMekvj1uM0LD0aY7X+ssWyauI4Sx1lJbaeuye5liXv879nrGs7F3Onu50rjQ2X7iVRvRRCKdmDeS7cTcSak9J5LgDp9fbb847h4NV4yzUUicQrPBzH4c0338Ty5cuxbds2LFmyBO+99x4CAwORnZ2Nn376Cd26dSsQ5RPyCzWaOJ6EtCzL/mrSoettEBFnbiThr0LN9Ui9hHP3X8cPGjTtfEYw/nhq3CnV3JOztxOoC83j0Y8xafMFdPlpv2D7vcSnFteOIzKD25UHKZi06Tz+3G+tvRIO7tL3kE9nnWPicJXQNPIuWeJJguwn4kQeZNA5j5b+KAWtWOydhKe4q0KbDwj7x+/7rmPSpvPo9GOY3e3i+aJHLattWTkm+MnEBwjji+iT0scrI9Dlp/2YsPG8RXgWa+T5+zt7z1X0+PmgpKVISlFg3e68dt1JeKoY/E1rix5Ex6diyJJTkgWOSfKzWK0WTBwnawki+7M4qyeQ53Zssd5yQksMIFwYkAoXMvGFVFZOaU22sL+S5yDjv+9JvI/fbZcfgzmOQ0x8Ki7dSxIoMeSsnlKhA8LjKu5iISc386mU8kdgeVHR3/45c1egfFNy+QK0z69kciKppGq8EteTooCZlbtQ56/NxWBtyftUQsEmRmxNmL71Ir79j+7FUSFXuLM3GRBgPeYsPhKNHRfu48v159Bz9kHBu+Hl7oKRHauZz23iVCloTRyH+4npVgLrw6R0qz5o5V6cwwk8EshvyWdHuw+0TOTpWSbqeHwy17WTd9mtUTovPEbOXf1hkvTYrtQXHylY8nrOPojJmy/gx53Cd58mdCoJfjkmzqKsVINUAjh+DIu8lSBoB+9qLOVZpaafdPg+zGpb7KM0y9gmptfsQ/hi/VnsvCityFQrD6sxRtiL04S8n3/+GStXrkS/fv3QvXt3vPvuu5g/fz7u37+POXPmoFixYjh06BAGDx7srCYVCPo0yQsa15qggvfrXyozwTsKOTMz33HVmKLJxcD4F2oLvgvTkAEuPXdS1tuSdyNOXltIWsRi4lPResZei2+4muydP1HcOaWypYoH1NYz9uJOwlN8vvYMuv7vgGU7v5dYk0kucMaoWAAYZB1ebGeBigxitXJjQckJiy8joGdZhcYVi1ttM9dEkz4HKUypeWf5NP/VSwsnf7Glmxq7yHGyygISsXX21d+PqPodQFcl2BsTQ8ucKUZtvb78Rsu9+KiTde3UWrmWubxix+bjCZOq0I8nV1JCDWRfJi/jmkS9SC38uvcaOv4Qhhd+EdaKs7ceKd9mNbFuJhOH95efxnPf78MuysJLyjNCio9XRuDlOXllk9QoQLTGS5NWACmBmLeu0xROvIDOlwR5lJppZXGkWSVp1y/edj0uFXsvWf8WyHsPlN5bcbZQGuIjnIh+jDNE3JpYgCrv75l7bpMqYf1JWhZazdiDtjP3CraL68cC1vcq22RSVdtObbmES/eSsCnS2gIlPk6bankKojaidpOQmUm1sk/B/ZlXAIuFGNqcqOSuqlWJR8bEkr/l3VrFYxafs8BNQqkvZ4yQ4+K9JCw5EoOOIpdgUmEgu77jhMnNpMYxRyR1EuMUIc/V1RXvv/8+vQFGIz744AOcPHkSgYGB2LBhA/bs2eOMZhUINhDJEpQy6EmxhzKYi9E75b/BYJA0kfOTolxMHv+NpTi0ixEjOlQT7EPej+BxWxE8bqvk8fiXhde++VKypImxdyEihk9LHpecgdhHqfhGQhuqxNClecWNyedGi708fDVeUEKC/I3YTYIUAq4rCK+A9IJIS1+iuQPLxS4BQClfD5T2M2fVlBK27BVAeLwofdjsqiP9G4Hbq4p4WB7xgkC8eKRphfvPPy6bQEAvaO+CvQVu1cRT2pP8yJlIx7VxVuMSbVzk3yUyJu/LdWfRMNTxNWDJx2DSKPAoQVNSAfZbevhfP1KRQCSHy3MVnbv/uuC7/VfiEDJ9N+1nspCJUVS5a2q8XLI/ZWbTf8wrSflnJlaCAuZsvjxK40RSepZqq4rU5fBjGCnopFDi+uUUcZNeNCesE2ctzDZxAqum+Bj8gj0rx6Rp7hbXClWTSGfD6TuCc5C/UHLXp3l3TNwk76LcoIK/uW2iZzhPFKc2du0Z9Jp9ULY2o9r3ml9T3Ut8CpOJwxtzj+L9ZeGW75NESrq2M/fiV5FXidR7/lu/ptTvkxRKAZGGgaFL8tZB/NpK7BnE338pSx4p0N/WUL+V4+gxjqvI2qgK7prkOiEuOYMa92xPGS+1OFzI8/Lygo+PD9zd5bPk1a5dGz/++CM4jsOCBQsc3awCxZfrzmJ9+G27hI6sHBPGrj1jlWGP50laFj5eGYEDOtZHWvpeC+p2PohYLiaPL7/ADwI0bSmvLVRjuWmYG0PF76smGN/Emd0++MHuoxWn8SApHYsOR+Prfy+a40dVaGhHr4pASka2YDEg5e4iB8dxmLDxnCB71O0nefWOxAHygPyALq4PKFfklobUZEi2yREYiHOT5yJbU/Wr/8BxHLxUpoCXwoPiCpVj4mTTJpOCnVwxbtpxScR9ntbPj1x/pCq21V5ocVL2Wkx5IW/Z0RhM3nyeqhyQq/8pRov7KX/LvCUUUTSer11a0mojJbDSFi1JMplK+eObOM4qLlJLIhgtyJX8cBS02qSa4IAfd15WlQGVFFzFSpeBC08IhJBdF60Vosp1+JTfP3Eyi31RDzF6VYRkX1BjyeNre5FxdyTjRen4lcaJv4/Rk+fQ+rakci13O7l4X3fKOl5YavE67oXalgyS4vaev5OE+UQdS9ITgONIIY+zWSEOSM+Z5PZ/ztyVseTlbacJdLas46SEFLGieG34bd0Fg8GLTuLyg2SciHmM7RfuW7aLL+NRaqYlyRePlKWuXnmz5wLtXshZ93ghN/JWgqCWJ++yfkiUgJA/Fi2jqZhPV0dKfqd2XPx6S57gx/9iy9m7GLPmjMBadzLmiVXZmO4/53lbOROHC3mlS5dGYmKiVaFxGm+88QZcXV1x+PBhxX2LEqtP3cKYtWfsmoD/ibyLteG38YlER/7nzF38c+YuBiyUThDwTqvKms4ppTl0s9R8cZG09t1PSseEjefw826zZojm2slPhCkqCkF/utp8/3IUNDskJo7DTmJQ23L2Hlp+uwdT/72IhYejseBQtKxFh2dz5F28/dcxS90jALBlDjoe/dgqi504I6MYWsKMM7foC6yFGgpBA/Q4PcB64I5PycBfB66rztpFwmdKIxnctoolq5lUYgrA9qRBJLR4myyTSTbrLLmQPCFR11LMpXtJikLeBgkFTapEinU9od1LtYuV6a/Up27nfz5p8wUsPRpLrd+kZUE05R/lhB08fF+hWWqlqFPOF5e+7oGAYtZeALTsfwDdDYfmIsQ/aXFMHokjCpQDQmup1gWoVBblmmWs445I5IrUq+F2wlP8uveaqqyeWubNWdutk04oWePVWKR/FWXlHLz4JDZH3sXPu+jxtEJLHv38mdkmXI9LAS9PiceqlaLSErT5mE/s8TQzB38euG71PaC+oDeQp5wlF+rX4qzHDilXbXKeFzdXPH+IY5H5Od3srmn7WklKIBDfBzKzL/kV2d/4dmTlmPDn/usYt/6sqpqSYtS4Far1XlFjVRZeg0mTR8rqkzfxJDUTf+6/jjsJ1grfQW2CZZXPUiVDgLz+8cpvQhmgtK/Zs+eoqLwBf61qEkOdlBEEt5+/L/mdFPy5P1oRgfWnb1spUUjPK6lx19G1IgEnCHnNmzcHx3H47bffFPf18PCAj48PHj5Udj8simi1tJCcpGTn0kqzIPnaHmKkNId80hMXowE7PnlO8vd/H7+J9afNi4FUSjYv/r1IzlBXw2vD6duWVMdq6o9k53BIkIkbmr71kupIi3N3EgV1cLSkxk3I9SunZTRTWvjRhBQpd0haBjdbEGtRhy89hW//i8IIwtWDR+k2iK/vr3ebYcRzVdEkt24fuYgWL7ayTSaHFCrNyZEP7LfFxfCFXw5a1cFTm+zkkoSwrTdiS5vaxbPUdXAch1uP81xkaAs/LTEb/53TPhHLJ1IX4uZihLurkTomnKHUuALoC3Sa5adRpeLm1hiEMXnOYOnRGMu/BfF5KtrwYsNy1O2Obr9czSwx9roVSy1ww2MfY/7BG9QYLjEXJCyXfHIsMeRzuCXjRvYgMd3ynJT0lrT5+KXc2MKfdl2WTNpDc7mTqpvJu8WSi9blEhZCGuS8qGQgvUsIEI0qFbcsiM3umravleQSKJGQVrQMYp4hxzH+PVhyJAYztkVh1clbFmVvNYXMwSR3KcKSmHSVtRjVOH6sIayvLkaDpvv55fpzaDJtF2Zsi0L/+dbZfg0Geeu3VOZWvi00+rWkGyDCLj+UPZ5aHqdpr8kq9vISKynI5HZSQ5SbjlmtpXD4GQYOHAiO4/DNN99g8eLFsvveunULCQkJKFasmKObVSAhTeVqIH30yeKntsYrvdwoLwnMhJ51FPeXeiHJgbxSiWJYNbwVPu8mX1eQ1mR+IlSrtbv6MMVyH9JVWD9yTJyqeAtbUFMjkId3J9pNCXZfdoyebYpnST4k3RHDZyqjFSnV2hO71SsLo9GA4rnJBsgFmHgxJ6cRVMMPrzeibs82mWQXjlq0niS81ZrHGW6YWhDHfCot5H96oxE2ftBG8jpMHND+u315x6PcU1vvpVq0vN+8Nl2LzEBrvziL6mdda6Jv04oA8p65o12eSUiBiXyml1VYwrMk+oATZVRF7I3PzcihjyOv/XEU07deomZAFkP27WsyxaifpGYiNSNb0Me+kEmsk/A0y/LMlJRCcgmlj8t4HGRQFC1Kc654bPCXyUZMolQAXeocb4RUsryfNx+nIUsijlEKe3MSkOEXZAkCXtiluSc3D7YuYi8FLQu1mCiJWpZiaCEIYs4SCscyfp42W0ZpigMy4QgNuXlbSjiUUgb+sPMKPvj7tOz5HMXdhHTVyi6p/udeFLJr9urVC71790Z2djaGDBmCvn374ujRo1b7JSUlYciQIQCARo3oiy9GHuX8PdG8St4gQtYoSpZxNZPC3cUIo9GA3/s3xXttq1j85uWQeiHFrpKtqgaid6PymtvELzpHr4pQtT9p+lbjOmg0Ki/odmoUvHlsWcBLZTSTgyZYAY7N2nRWwqpBQ82EQ4MMsucRL+Y2R9LdG9UiZbn+cecV2cQRegkmWhQBzkAcGK6k3e3TtCKaVA5AMQ+6S6T4PtEmRDWWPJOJ05yljUfLa2iL6wwtGZK49uKA1kEWVzp+nU6zepNoiSVUgrzt5DNQ825KxT7lmDjBQtGZeLga8c2r9S1hAfZa8p6kqvMUkYN/VdaF30aXn+ixN8npWWgybReaTNslWPTJLbBPxz6xXJ9SYhU564ncL7WOZxE3recctTFyAkuegpWdtHa6GA2WdcWDpAxMVFFrkcTeODYpSz4fk0cr2aQmZIRHSch6mJyOPiqzJXtS4tT5zKQ85PzWs0E5XS3z77YOkv1err9JeUDJ/Sbschy1yLombBhDNkbcwdh1Z1TtK+WuGVBMPleJHjglu+bq1avx8ssvg+M4bNy4Ee3atUOFChXw6quvYtiwYejTpw+CgoKwZ88eGAwGDB8+3BnNKtSUL+4lKUiIsyJJQb7Y3rkLtZ4NymFy77qqMvpJDWI0V0k1wetiEp9m4bd911QLFWWIgUxNbaPsHE5RIy1XC0Vv9KxVpsbFyFbEsSBy9GxAd/ciWT+yNUKCArBlVDvLNj7WkBzcxc9Kyk1o/oAQ1e2jcfVhiuykR9N820JBs+T9JypQr7aIbfd6ZdG5dmm0qy5Mm957ziHBZ2oKbhUa5N2XHqD2pO2q2iJGy7hjS80iNQtk8r1Wqg/JL/4DJGLhbEFYQiHv32pcnaWUHTkmDitPWCfc0MpzlJhcACjpY339A1oHIWZmL1ye/gL6twzCrNcaWtpCQ63gQQsV0ArvuvWdKOaP7PJ8KEFmtvrskMU8XC19Qmm8KOvnKfmdlJAC5JVhICFLO4lZQIntVns9ZO03paRm4gzQpBJGawI5e2NESfj4MCDvuvmwExI1tXrVcvyG+lALmrKqqUihKcwfwEnGHNuCh6uLbEhDmEwJB37d2bqqsNbo0RuP8A+lCDpPDYUYYSUybbRkbjidp2j+PYwe8wpIj1EfdKpu03m14BQhz9PTExs3bsSSJUtQo0YNcByHe/fuYfPmzVi4cCE2b96MxMREcByHjz76CG+99ZYzmlXgKebugv4SvshGg7RQoGbSepKaiQ7f57lS/da/qeb2SS2gaBkP1dQ7oqEp4xwxo6qRl7JNytkz3wipqP78BPtUlLUQY8uc0Ll2aer2G5RgeL2QcuGiQQ6CNPy93NAsqATWjWyD+rlppIG8iYpfRH+6OlJ1xj61saVBJcxu4W81r2T1HW3R4ulmLXjag9qC8M5CbJX6dLU6LaWbixELBjXHqOflJyyaYVCNhW74snCbNc1axDZb4iOkFjOkwKtlscdfpprrlXKL+rSL0DWeFDRIoVrs0v7e4pNWbkXS7pq2W1dJpDI0e7hazyHi+Yaf/w4SGffIMSKaUsiYhh6FvbNyOMzdf91KkfE4LRPP/xiG4HFbBdZbtQoUjsuLD1ZSWFQqQQ9z6frTflXnIvGUsSS3rW5dA0+tkGePsGVP/JLRYEDi0yx0+5/2eyGGFCjk3lMtStsSCkodtTGqUq7LtPeJJzvHZJU1017k3GNpyY94eEVGOZHlsUJxL3y8Utqjy95yWFIxtXoh1T6l564HTiuGDgDvvvsuoqKicPjwYXz99dd4/fXX0bp1a7Rv3x7Dhw/H/v378csvvzizSQWatMwcpEskYzEYDJKDyFOFWCWO47DocLQgLqRpZW1JVwDpQYxWvkCqFpA9iDO/kfeqc50yir/PzjGhhIK5XE47KocWl1mOM9fDufVYe5xOWX96+zYqCFf20LUOXbAE8qxBn62OlK1ryOMpUdSVt+Txi1JxLUApvnm1Pvy93BTjAoA8rSHNIk1Ljc27kNqqsBDj6Hg0rdgbJ6bknkRLHEAKSWO718KbIdYCtz3MyLX2qIGfh/s2U6/YkXqGXxExzVoWe7yLrJpFy7d9GlC3f9CpmkBx8SphlSEFM3F91b1RDwXjVnaOCf9KaM9zTJyu1hExNHdzscKTX0dWL03X4qutL2lPEo9udfPmmZnbogSx8YA5+y6fFZn87k9R/TPptnGW7JpGo0F2XJNyv71qQ9F7OStoFCURFC/sfNy5huxx7Rnz1CYzWz+ytdU2owH4+3isLhmZyWvIzDZJJsZyNRpUu4vLjRGbIu4ISkvIceFuEtU7iZaFmyfbxNkUTiOHuPsUp2QsBqyFQf4+iL1ldlyQ96giFTVaEt7wnL/rWCHvszWR1O16em9J4VQhj6d169aYOHEiVq9ejUOHDiEsLAxz585F+/bt86M5BRqaGwAgb8mTEgx5MrJNVuZpNSl8xUgNurTJJrik/sl0xAMouTBYI6rdEzWth9Xvs1S4a9qb3EMNOSbO5sLpUtp0R7Sbz3hZzD1PiBcP0nwQtFQ5ALXw/XHruXt4mKzO4vX30Jbo39Ic/xQ2tiOuTH8BUdN64MDYTrK/E1ta3FwM1EW2m4u+ljxbmPtOM82/mdhLOYkSYH9yAhcFi9XWs/estvGT84phLfFhp+qa4ljU0KFmKSutsBS8QKMlM+6iwzGCz7+81RiA0C2SPJ6S0oiXN9RY8mjlRwCzNnzmaw3RJVfRFUi4PioleCAXS/tk3KocnV2TNn7VKOMr+Mxbrq5JCDFqXXXtKV2hd38Vk51jysuuKfN6dalTWnXyE3XnlX6+S45KJwPzkYjP5Zn+Kr3cihrk1ihl/PJcKGuK+glgDiG5poOABwhT8adn5eCFXw5S93MxGlTHismNOVJlsWi8/Nsh3Hxsna1VLv52+tZLiNdQg1QN4vFB6vqs9st9n7TOsaSiZv7A5pp+C+hTjkkOWvkrwDkhG/ki5DHsx2gwSLokKqXazcg2WU0YtmgUpGpQ0QbjYu6uiJjUFbNeo2ufbUF8Ht7dzM3FYDV40IKRc0ycohZXrQZNicjJXSW/s8fVQCqmiczUSk6A9lDG17xAJWN57KlXJAepeZywUV2QPV+AFchLh+/p5gI/L/mJVhyL1aM+PRCdn6iUlChq6KUiVpFG49xU/Fp4XaV17OBVdS5kUihNWEcodfJ4JYWfp3mBaouySYl7Kt1i+bZoWbiTCa+APDdjUl4mLUpK42wWb8mzwxWSPx+f5ZPsy7REMSTkeeUs1vYmO1FCTbygUuIYpae4L+ohPlkVoSp7phRSZQn0Yt7BaEsNMKPBIKmI+a5vI7i6GHEutBuqlNRuyRAjp6Tz9XQVhGRUDDBbFw0GoLiXvGdMp1p5XiCtq1q7fcohZ40ixx5fT2tht6SPu92Kx09WRSDxaRZK+uTNp3KxZ65Gg6Jlk0cvi46Jo7tDyt07wLr+nL1UKiG0OJNWbHKeFq99+I/ahTzzD3/v31SX/u8s1Hob2HUOh5+B4RDkXIrOKSQqycjOwU0bXAPF0GLvAOlFUoC3O4IC5V/Av95VtlTwgc/vtRVmAOUXJWpjYL7575Kq1MW2QBaB79usIorLuIWqKbYrhdJgWMbPQ/Z+tKkWKPmdGF5YSs/Kwd6oBxiz5gwepVprAL+USQkuRqptpOAl1Z/JievIuOcl7zFNcPiub54bn1hQ/ffMXVlLnh51eX7OtfhoRco9Vw61ykLxgoVceMjVu6TtrxZesOLvbY/6ZTUfAzAX4CV5uwU9llmOnvXVCd4tZFKj80mnxIscnrsSddN4+FheWy1lpKs8/zwE/VvhsGS/PymTdl9P4cbWRElSrt48SuPq4MUnsSlSOpmDFKOJhTtNceEoXIwGlJawBPNjoa+nG7Z/or9H1LwBIZb59s2QSgIPEt6Dxt3FSJ37yUQlJJUDi+HA2E54ubE6V8FiMnGCSonWpm+1zVOGZFPkXfxv1xWBoC1Xu9PFaFSVpRwQJqtzxLrf1izXtkITtIe1N9+LECJmXjzP8uOeVus6b3kuk/t+fNZVvmTXswQT8goZc/o1wcYP2uDVJhUks77+pBBEm5KeLYi1oGUyUwPNOgbYp42nxfOJ+fXtJlg/so3VAMprqbW4W337n3QQsD2Q7kZKixF7XJ+2nrN2gSNxNRplJ0ctWfx4d6CnmTkYsuQU1p++jT8oGaVWn1Kfde+dVvR0y+SkdF9CEOcF3C51yqC8xliVVlXyhNvFlFqDNOGZXzTb6wobUMzNpneEj1cTCzRKeMoE3ctB9staZYUuUG+3sLYO2uK6lklY3wFzuZVFg7W720zoVQfrR7ZG1LQeWD+yNb5+uZ7mY7SrYbYs/HtG+p1qWrk4lkgkCwGA67kJj4oXc8eeMR1wZNzzgu+V9Dm8xlutdb+LKPaYVALw93TW9iiLYkLpuJ+sjkTsI7NrkZxbnloWyzxLXrgL8LbNzVAumQQgPa7a65bcqJK/8k4KqE0ORWI0GKQVq8Scp3RfbKF9jZIWQXL+oWhBP+I9G9xcjNTM2h90rIbdnz2H4191tvqucmAxRUVjrVz3Sz8Jd9QaEjGZjuBOwlNZ6x2Jq4sBBoMBmz9sq7ivmpJP9iDldaU3TXNDOmjwgh8ZKiT2WPjrwA1qiQ4l+Hedfw+cYCCzmYEKJSb0hgl5hQwfD1c0qRwAg8Fgc0Facep5uQWyHGqKoav9Da+Io00SVsd3MaJZUACMRgNeIbSAvEZRqv6YnjELWnisUM7AkfEtyelZqBAg/Xy1pJj3zhXAn2blWBarS+1cCA5/rip1uxYhqKLM9QHm/rJ6eCtBuvYSNig2eCFGKbGRErZqGSsHmmOQlPpxn6Z5iTbK+HnA3dUo6R6qpTYcP4E/V7MUJvaqa/W9kiWPtgDgrUzk8yZdutTi5mJEs6AS8HRzQbOgEjYJ0bzlJ5EoQSO+1yHBJWQXTBmEK2+1Uj6ax9Zvtl7E1QfJkrG2vOs177b769tN8H6HapbvyedJPo85e68BoCcUIjkR/Rgdvg9TlTRJDR1lniWvfCLHoPY11LvwKVknpATaHRceYPt5eeWYHD4ebgj7vCN2faps3ZZCqr6pHEaDdCIPrf09tLf1+0sTPCf2qoM9YzrA080FMRLZSlNyk/W4uRjgRhkDBrQORvXSvhYri5ju9eSt9+s/aANAel2x/oM26JeblKdlFWkru16ozSrLv3+lVYRL1LSzBIASxSSUA3qyclgrLB3S0vK5lMiCS6t9Swv3eONP6zraStxJMHtI8HO0VGmWgkD7GqWwZVQ7KwWgo2BCXgEnQJSViHRvs9XNr4RIc6q2rp5a5GSW6qXogxlvbVBTq6oykSp65msNLYt8JUuekkXNUfDX3ENiMttmx4JDiaT0bEntLyDdJhr8cdTEy6jB1SidIVYphkB8HCVaVg3E1y/lWXfUWIyBvBIVw9pXgVvuu0crUaIlC2u/lrZp8ngLhJJg7ke4yvDa06pExrGVw1pZ/t2zgfTzJ2MnAGDpkJZYMawlFg1qbhH4SZRi8gTutdfj8eGK05a+JF6kOiO1tBhasonEp1mYSvSb4wqxK7ZYM78hklGYOKDP70csY+hoUUzPllHtsWJYSywfal5Mebm74DlCMCIVRg+T8qwDsY/TcP5OIiZtvqC5fSSXvrZOYGUrOZT+LOV+PoKiDFKyWPEWSTHvLw/H+8tPq22mFcXcXRBc0hs1yvgKXM/sRW6cBsxCw6sS9eu0uko3pMT2ksoCnkaViqNa7vxFxnnTcHMxWr3H016upxh3JBfKEFDMzTJWS12jn6cbRjxXFSuGtsTCQdq9ALRggPqSG/y8pEYAd4T1VXB8Jwh5rasFCubVFxsKFYt5GbPz3vH7lHhppTh/WskjHn593LBiccE8V5BwdTGgfgV/m40rWmFCXgFH7E5HhjDZ2knikjPwWtO8mL6YR9bZmByFlHvggDbmha+UCygJqSHydHOxaG14LbqL0YDnKfXjxDF8zoIf5KXWwL/tky6iqQXymZKQGm+x9rtTbaHG69e3m0gen382SrXv1CI3lGvRTKux/gJAcElvbBnVDkfHCzVocjEh3/VtiBXDWuKLHrUtC/i0DLNgQtYo9PFUJzQCeYsVqbgtKbbmxn8orefcXAyWOm3v5Gq4yZ+0qpqn7fZwdbEIMbVEWen4z7y11cfDFW2qlZRcbCktfUgjUr95xwXZNsXKnX2fd1Q4mno+6Gi9eKWRFx+Y15baZX0FdcESFRRiSoZxWpbf/iKhnyxj4CvqV55uRrSpVlKwmCL7/+XcgtsAsPNiXlKYK/eT8eKvwuL0tmCL25eUuxqfBZG8Z1JujJ93r2W1zUNCaTdrexRC/7lglyAnB6ms+KSLfrE/n3evhZXDWmGMhKXfxSg9xmuF5rJKc+v3dlc/rrm5GAXPpFfDclZ9WytPiNhPWvw2b7lzdTGiTfWSVOWTnpg49a7UWoQ8LR41PA0q+OPPd5th9XC6MEMmXMsP78VUURkp99xxdXPkXUsNy95ztI9JL8mUeyCnJjVWXW8nubGS1Cnnp7yTjjAhrwDj4+FqtXI6TxRt9PdyU3RVo7HkaKymuDWtiDPOqaF/C/NkoMWCw8NfC69pfJCUgW9fzcvi2TW3ltGw9lWx4YM26COhDXUUvMb6DZ1rgIn5vm9D9Gpo7ZbnLiPkkRPnnH5NBEWcxfAuEbawZVQ7q21ybqpa+oEa6y9P/Qr+KOcvfGc+6ChdxNs7V7BxczFa+hlvySPdYH08XHHiq8745yPl+AueWRpquAF5FnelIuqZ2SbMHxiCjR+0wYDWwQCECxODwYDauTF2rzWrKFlnjI89UVuCgFbbjEQuI6O40LG/l5uky83a94V1sJRiHLQmniEXZQPbBAtcIJUWY7SEAySebi6aJnmxBp62YJSKMSPTtyfo7K0hRcda1s+M5i7+vzcbWdz3SM0+zYLbuFJx6nVLuRr/EXadGmerlSYS8UWC+DcdvUNcjQa0rhYoOfYZDQZdsvG5uRgQHOhtpXCgub+S3i8LB8knyHF3NQosUm2qBeqaPZCmXJotoZSsLYohVoIXHJQ8MrSsbVxy+6eapCe23CYfD1d0r1cWLavSYxrJscjR2XC7UGrnik9JvsOjVtqugKktM36Shg81fa+x6B0n55xh7atQ1y32IuW27CiYkFeAoS2Cxe4s1STcH5VQmYDSJuxJTKFUxJpm/aAN/mX9PXHoy05YP7I1fuvXFID5pW9aOUA3d0O18M+xU+3S2DOmgy7H/JOShdRoNFDNKeTE6y5yCyEXLBUDism6m9lT0qV+BW3JCrTEiqnNpipFUG6sG01YJCcm3mLCx+S5uRgtmvVPu9ZEaT9PqwQlcmjNeMb385Unbsrut+viA3i6uaBJ5QDLRCfWPm/6sC32jumAFlVKWBaV4oQC/Fij2lKqkDlXriwA7XlL9YHmouyWXynUASTHzPUjW+PvoS3xApHF0y/XWlavvLmPku6ZOSYObq55/ULpHaAtdsRszI0xUoP4eLR7IpVZsIwNmVhtgXQ3HUlx+XOjvJ+1yuQt1Mg4xshbCYL9mgcHYM0I6+LWgP7px8Uxo5VLFMP6kdbPilxI6qks5YV1qeW4LdYeMbs/ew77Pu+IQB8PK68Z2v0k93m+dhmr70ncXAyCMc2WUHMl5V74xC6Cz6V86PFuGz9Qr2wDzPUtd336HDZ+qP7dVEKLJe89lVk4ybWOkms4KbAaYJAt42QvpFKd5xVCmd6vZWVB+ZbbT5QVxh6uRnxHUYS6uRgwhRJTCsDKknt6UlfZJFy+HkKlXHtCyf1hp+qoWcbX5sSEBQUm5OUjn3eriahpPXDwi07U7ysEeGH6K8LioeIBQ4sVg+RRinwyELXQXjZbkmvymiZPNxecDe2GqpRaJxN71cGezzpabZeaaCsGFEOzoBJWE8e289axBd3rlbErWFduICFbV62Ujy7pfaUsuGLFQJ1yfoKJgbTKlPHzEEzsRoP0hLTkvRaKMSNKRM/oKci2JxdHIree4VMx89hbkJjvc5GTu1l9J5hURZY8d1cjvu/bECe+6mwpTK2luKnWRRB//jcVLMLlKIqSvs0qwsPVaCm94unmgqq5CiJecBArkCzufiq1wF7uLviqZ23J78/cTpQsP0Hrd2qtJEoKAd6a+Urj8mgWVAJtq5cUjAknJnRB5OSuliQrZF1BcZIFn1ztuFRslNhKTMPTzcVKoJCyPJTz98I8osQAbSEu9RrR0tw7ArJ7uBgNVkkkaDoY8p0llQvieKeudcvY5N1hC593E7qEurkYqUmOSMFHKXW/LUi9blri7r7sQX8PgwO9UTGgGPU7mjAuJ6CI+7CrUeiuecCGIvNKQnOgSKiTEvTVuBV/n1tG58fXG8FgMKAGpYi6PfDPi/bcyDmsvL8nWklY48T0b5lXGobMyUBL4vFVzzzll9Fgjn20JcGLGqso7R2tQZyrX4vKWBuel3VbjSHA080FLzUuj0CRdd/NxYg9lx4q/h4wewZUkujvN77tafVsjEYDoqb1QOTkrihezB3urkbsGdNRoMgqbDAhLx/JzOHg6eYiKK5J8vVL9dCmekmBC9hbovpPShOglBaCjNewh8Ftq1i5fQTIBFKTeLoZ8Xzt0mhauTiCiGQqfp5ugrgUnnL+XtTrddHBLFna1xPjJCZGNchZkwaKUt7bKyzJnU9ssVnyXnPcI2pznSPcffldu9crg0YV/VGvvD91kh3RoSo61Cxld7sNBoMg256cK4RBIoqgR72yKOEtfF9uPbY/ptTP081KC/hJF2HSC37B8yA3oYW7ixFGUe0qJasXGQNAm/znviNTJzJ39zbV5RcENPe9mmV8ETG5q2VhQ8Jf152Ep5Y4ClJZcEpDJsDhz1WTdYeuO3kHNV047V7sVTmRKy20K5UohqhpPfC/NxtbtpHxR55uLrI1Fsv45j3f2rkLwcFtg1W1TYpZrzVEaV8Pi3Io6n6y5L6dapVC/Qp+kklypBb/y4lMd8np9td2rFaKbqklU9vTsj7Tkhy5CpRLef8e0UGYYEUP65VaXF2MgpIUbi4GRSWqHmOPGC8J5YaWWzGyYzWqwkVufCIt1jxyCpTTNxNEvxe6a5psMOWJ5x9aYWtbFdtiXg+phKhpPfAaUXPYHq9G8XxBXsvPbzaGv5cb1r5vLvMygchOrCXTsyDxHqF/osUi1iUSZ/F9Z4IoK/K1b15QjF37vm8ji7eLFDRlAKk0cHUxCOKZM7NNuB6XIuu55Wo0wNPNBUdEMfRuLkZNSiupOE2j0WAVrGg0WM8H/l5ueLGBulqOgHU8uVhIdTZFWsg7efIkevbsiYCAAHh7e6NFixZYsWKF6t+HhYXBYDBI/h07dsyu9vHprKUm6Ta5puMGFfzRvV4ZvNe2ipVmUUmLfXJCF9nv9cDTzcWS0huwHuzErHu/NRpV9MfKYa2wcFBzrB/ZxkojJ04CAQDd6tHdRewpJs7z9/FYWRdWMlkFSdS0HoiZ2Uty4lkwMMRK+9ivZWW0UBhYOyhYFbMlUqHHiRbQJYq549DVeOq+vDDw57sh2PRhW7hIZLssn2udkKu3J4c4CU7MzF6IntFTNjZJakEzp18TvCnKrkUm8NAT8cQlthjGSGTvk4PsqY0rFke3unl92tfDFe7EQkv8bvOKEKX+XkFCc1nM3ZUqEJGKkwELT8Bk4rDqZJ5LqFTGQymU3CdDpu9WdRw93ao93VwE1/5p15poFhSAH15vRN1//Au10apqCbzWtCKMRgNmvdYATSsXxxc9zNYee12Ea5TxxfGvOlusjHK4uhjx70ft8Ht/ugJASkCtVEJ+YaaVPyQUEKTrq9Fg7U1A63Pk/WtbvSQ61SqFjzpVtyr2LU4840hcjAbMG5B3jQaDdPZfHrUKTTXwd+3N5pUFSTN4pLIOft6N7hni4yEfHyqG1qf9i6k/hruLQTCW2CKfi8MJ/qKEJawZYV4/rHuf7sarBbHLqtr4YxriJDxk33mlSQVETu6K5sElrM4p9mKvKWNRJO/pUSLTr9rwhsYVi1v+7eXmYi4vNKI1+rWsjLoS87GXuwvCFBJh0QQpcr50NRqw7n2hK2znH/fLxvnzvxdnHnUxGpClQYEglwFXrEQSr9V4tMTeihUTS4dI11V1BkVWyAsLC0O7du1w8OBB9O3bFyNHjkR8fDz69++Pb7/9VtOxOnTogClTplj9VayoT6Yr8UTSt1lFzH2nqeWzwWDAn++GYDLFNVIu9a6L0eAQdxIavDm7Y61SaBYkL8CEBJfA5o/aoUll88unto1SriN/Hbgh+NxawfWB5udt4uQXs8Uksozxg6vUYoBW88vbw1UyzsR8LqHQTCM1g74AriNyrXAxGpBKuEaQliRynOSfAfksPu9WE32bVbQIVbXK2pYVSpyKX3weGrTFU7VS3nB1MVpZBvRMfkAi1iqLP9tS64qUz4xGA/4iXPFea1ZRcF/2fi6M35yQKzwppfCe9KK8kCWGjKMJj32CDRF3MGHjecu2hsTCQA1Sngl6wL83416w3eoOmC3360e2sbivihnRoRpWDW9tcft6s3llbPigrWURYK+LMCB8B5RS8cu9LzRrhxbUlBPZMqqd5OKTHJdL+nhYrkUu5pS8fy5GAxYNboHPu9cSeAv0aVoBrzZRP8eK63JpRTxfbj17TzGeSqmQty14ubtgy6j2Vtv5mFaxq/5Hz9OVqlqTbYgFhbOh1u7rJI1Ec5SL0QBP4pmLY2fl4ONi24m8FGgulE0qB2DzR+0QouH4ajEYDJjZxzq+zBaiRXUFpd5hsdvrX++GSGaQlFLwKXl08Qofcq4k//3tqw2wiAilIPH1pCsHeSa/SI+PI98do8GAMn6emkoNySnSlOp9khiNBsuY1DzY/H9+zBRflVQ9WfH6rmopb2oGd5onFB/rnV84T03mRLKzszF06FAYDAYcOHAATZqYMzBNmTIFrVu3xpQpU/D666+jRg15ixNPx44dERoaqns7+feV7BfzB4SgS135AGcSuZd7kMhN0JHUK++PmJm9dDtet3plcOga3QIlppSvB+KS8yxYRxVqWbWWmJjJAei/j9uj5+yDls/P1y6NvVHW7mO8BVIq4YYtyQHMVgfr7X6erkhKz0aXOmUEtQLlzmcwGFC/gh/O30kCwLvrmIU+qeyW8waE4HFqBt5sLnQNVrI+SmHL78r6e2JEh6r4c3+eAD8otwSG2GraR6e04oA52cLNXBcs8cAunnTU6CaaBwfgZEyeMCi2QpK4GIVOquVF8V28lYM20a8Y1hLvzD+O3/s3Q2lfbdpo8UJWLLwOUZkUQG8+7VIT/9t9xfJ5xdCWlr70fodq8HZ3QZBCshdHoXd24m9ebYDuPx/Q9ZhqWTmsFf49exc34lKp2QNfb1ZRkDjpj/5NMfJvYXa8v95thoSnWahUohgm9a6LSiWKoTexUF04KATvLT5l+Sx1/0p4u+OnNxrB080FPSUWXFLo4QZPUrlEMYHnTLOgAEFSHsA83s59pylSMnLw+dozms/x17vNMHxZOAChAqiUrwem9K6Lqf9etGzjYyxXDW+FNaduIz0rR2BFFVO3nHIs1Xttq2Dh4Wh4u7tYuQ36KWSK9fN0xdx3mlpKVRy78RiBPh4Y3DYYp2KeYLCGkkX/fNQO/5y5i4FtgrEp8q7q3zmCt1pUxouNyqP+lB0AzP1/bfhtzce5qVCaas+YDvjv7D0MErl+Vw4shtlvN8E/Z6zvA9lHyHIjUkrmv4e2xJUHyRbFN2lFFJfHkMr6KLV98eDmgvALMeQ7XjJXAfNx5xr4auM5q32DA4tZlfKiKdJ4C7fKevQW1uUmUIpPycDfx27i9RDzmoG8bXvGdJC8j+JY+5/eaIzHqRlWa0LH5jC1jSJpydu7dy+uX7+Ofv36WQQ8APD19cWkSZOQnZ2NRYsW5WMLzfAdwmAwWDpbSwm3QCnEnZJ0K1Rba0yv2jt6Iq6vQwss5pnQU2i56C1TRwUwa7XWjGiNUc8LU+eX9vPE2vdbY/sn7VG3vB9OTuiCVxqXx6ddaqJ3Q/lj1ivvjyXv6WOW/7xbLatrmPpSPRz/qgvmvtMUv7zVGGUl3Epep1gmSA2tMBaGfv6udctYCXhq2PpxO0FNrJCgACwa3Bzta9iW0OaTzkL3F97SKtYqvtvKvlpMJKT7nvjdysgWWk+l4gZJfnqjseXfbasHUi1QvJvMq00qCCzzRqMB04jES/xzJCe4/z5uj/UjW6NNtZK4MaMXesgs+qQQK4rEBb/tTXyhZJWWQslC+27rYLuSJdkDTctMs1irJbikvq6VWqhdzhdf9awjmVzge5FLK++BQdKtXllLiRg/Tzd83LmGwMLYrLL6ea1P04qqBTzSWuips0X/jZCKguMPf64qNUtwj/rlrCzCq4e3opaTENNVRqE7uG0VwTzQNHdRXzGgGD7rWhNf9axDfRaW/WW+45nQqw7+ercZ9n/RSWDRpSU+E5P0NMsSUkIypXc9/DuqnaZxI7ikNz7uXEMgVNtbw0wc30miZL0mv28WFICRlFqbb+QKCn2bVcReStbscsXllW3VSvlgVOcaimVXSEgFnxoLfNvqJTG4bRXBnMn31dGUsBpxTLjc3CpXbgkwK5S3jGqHjR+0sSgMaNZ9gwFYPNh67UQTuPjLp828atx3S/p4YHSXGpYMuWRpGblM9WLluYvBoDpZTn5TJIW8sLAwAEC3btbuBvy2/fv3qz7e1atXMXv2bMycORMrV65EfLw6C5MSpQn3kjNTuiF8YhdNLzyNBsQkxFs8fn27CYoXc8PKYa2oWeFoyRjyG/IFL+/vKVv4XTxwvCJT3JqnRZUS6F4vb0Fcv4J5gdY8uARq57ollvL1wM9vNcHoLjUEQelSmfWU4ujE+FHiTYa1r4J+LSujWikfHBvf2ZJ9dWCbYHi5u6BH/XIW//dr37yAP99thkBvd8uE1qRyAMaKCgd/S7if/PluM/zyVmMEFHPDn+/K1z3SSr3y/qhNaI/L+ntS3VXV4uXugo87501EUpO+ngVwyURF4knmoCi2UUrQ5unbrKIgpujVJhWt4jEAczmDo+OfR/0K/ggJDkDdcn6W1PlHCGs2L6D3alAOFYp7YUDrINQt76foHq2E2DJ6I157rKEcv/dvqrwThZ0XhFlwHeGeZStiLfNPbzTSnLadxMPVBRGThCnO5RapYvgFn3iRNknCleqNkIo4MaEzzkzuZlEGqs3eSMs4qYSfl6tA2NcrjGDR4OYIKOaGOf2ayCo1q5Xyxjut5BVXfIzy2y0qoVIJL7zaVOg+rSU+sGXVQMs8IofSfZj+Sn2U8HbHC/XLarbQGwwGQSZnWlZnF6MB3eqVtXKxVhPP6eHqoqnUjVakYk3VMq5HbRz8ohMaVhQK5iuGtcQ5BVdUElcXo1UoR496ZTGzT0Mc/KITfni9kSVTMbkWkcpiqpbv+jZEQDE3QS1A8p7QakryfEARSi3Hfc3cblrd3h71y+LQl51w/dueOPhFJyvLNWCehyMnd1VVWqd+4XblggAAorNJREFUBX+BIoI2xrgZjQgu6Y3jX3VGZ8IF8kac9TzEl+mhJSizpf4cLQmYFGRCFaOR7jnAjyHinBL8+Cz3zBxFkXTXvHr1KgBQ3TEDAgJQsmRJyz5qWLFihSBhi5eXF6ZOnYqxY8cq/jYjIwMZGXkdKSnJ7DbXvW4Z9CPS4dor3PHsuJDnbnPpnvlcvRuVx4sNy8FgMOCnXZetfqN3vSG9URpMxBklUyiZOWmQk/aw9vILKnIyk1vkbPigDfr8fgSAOSueHLXL+eFE9GPL54hJXRFADAK8ECE14bq6GNG9Xll0q1tGsFgQx2zULuuH6Bk9AZgn/hCYi786Il6TvE96JMT5rGtNlPf3xMGr8Xi1KV249vbQz02LFBjFQdnifia2IIupX95P0HelhFR3V6Ml9b6bixFbP87LOto8uISl5Ac/QfoXc8OhLzvp9vzkNO69GmpzmaMhp6CR45MuNTFg4QkA5jhbZ6XSV4PY3bBZUIDd7QvwdsfMPg0wboPZnUlLZsnzU7uD4zirPiEVn2yAwUpoUOuCakt2Q4PBgI0ftMH3Oy4jM9tkd/wcT5tqJXF6UlcYDAZ8tCLC6vtudcvgxzcawcfDHFe0/NhNylGEzOjTUHAvv+xRGzHxqYqx3mLIDIAfdqqGS/eSqS7/PFUo2Uv9vdwQPrGLze/6x51rWDxW1Bxj+ZCWWHQ4WuBBIEWFAC/V3kJaKOHtjsepmXZbSgwGAyqVKIZy/p44ezsRgFk4a1NN3gIlJjiwGG7EpQi2/fJ2YxiNBqu5mXxn7fWQeiOkEl4n4rS3nr2L4c9VRZPKxfH3sViMl4lL/kImUzit3SS8cCq1T62yvjYL4HJdsIyfJzwl5siVw1ph3sEbFqGzcmAxRM/oiSrj/wNgnhttSTQVElQC5+8kqVJWBBBJiDhO/n3iRI6bq4a3wk+7rlgSdzmTIinkJSaaX2h/f3rAo5+fH27fVvaxLlWqFL7//nu8+OKLqFy5MhISErBv3z58+eWX+OKLL+Dn54cRI0bIHmPGjBmYOnWq1fYf32wsmzRFLWS69PUj2+C1P45YPl9+kJeWm++QZHwQYH8qcGegtPgQu4Opjc0ICvTGu62CcPNxmqI7pquLEfMGhOBpVg5iZSwdTSsHYPKLdbH65C3M6SdvwRAv+t1sXCSKB5smlazddMT7OCohD3nc6Hh90ou/1aKyVemQRhX9cSZ34tbjPeIhM4hKxSzySE0qWz9uhyPXHuGdVkECwVDtgoi8h4PbBuOfM3fRrnpJwXY9n5/cBCdXwFwOo8Gc2Oc3hXcAkHb7qUAoK5TibJ2NWCOtV2zgWy0qE0Kett/S+oSUyystq51aS54aDT4Ng8Egu/i0Fbl3gUxspEQw8QzJY9Jc9dRApk5/vnZpjO1eG4MWnUDYZWH9uHXvt8bFe0noKOEJYu+7ruX37WqURLsa6oQgL3cXah1Re9n8YVtsOXsP/RUsr2ohU/d/JArRkGPlsFaIjk9FSHAJHBB5cUiNmeQt0EMpxT+7lxqVtyRj6VSrtKyHTHENGVFtQWlelENpjNl1wTomGDDnURDnUjAYDNgyqh2OXn9k8zp2bPdaKOvviR71lMMcvChrg40ftMHpmwk4dzsBmyLvWsaKd1sHY9Km82if+y7Vr+CPhYPoiW0cTZEU8vSiXr16qFcvz1xdrFgx9O/fH40aNUKzZs0wZcoUDBs2DEaZLEDjx4/HZ599ZvmclJSESpXkixlrgSwk2ywoAG4uBkuqZZohpUEFf0GtNHHcU0FEydJYqUQxbBvdHi/8Yk6UoiXznRqNJQ8fP/Hbvmuy+73XrgreU5GsonppH+wjJny96v9UDiyGnZ8+51TXgBcpFh/ekuwI5r7bDD1/OYg3ZBKZ2AKZRVWpFo+UBbFeeX9LRi2DIe8ltCUjo8FgwKYPbXcDVHsOKXZITLpKRE7phtj4NDTIdZW6+HV31J28g7qvlBucrSU7nIEzshbrkaU0WEL4pPVFLcW2t41uj82Rd63imgsSamN1j43vjLTMbIEXhT3wCz1SGOYVUXPfaYbf913D7L3XMDrXFT0kuESBckVWy0edhM9eD88NwDyf2ypY0zh2I89bRsuYQgoW7i7qlKTzBoZg+NJwqpujs8hRyL5sL2KPFi0oeSeQ61k1Y0v9Cv7UOFm1eHu44v0O6vqah6sL2lQLxKOUTEsNwiaVA9CkcgAys00Y0CYYjXIzUfdvURn1y/vJlolyFgXH/0VHeAseb9ETk5SUJGnlU0P9+vXRsmVLPHjwANeuyS/4PTw84OfnJ/jTkwyRrzi5SKWNuc1EqbpddBIsHAFfs0YuOJ2HfJkcnXFP7ONvK6M6C92J3XQo6s5Ts4yvQ1LZS2nMuqvQhOlJOX8vhE/sivEvaCsXoAS50BW/WyuGtRR8VmNBJNfNetctK8j4ebpZBDzAPC5JxUSdjHlM3S5VtqQg4EgFyi9vNcarTSoI3PltxcVoQM0y1gkFaAkQirm7KtY45alTzg/jXqitazysnrSoUoKqwBvd2fr6yvp7WmKq9IBP036V8KTh75Onmws+61YLN77tiU8pMXIFncWDm6NXw3I4NbGLlRu2HWt/h+JL9FEfG+suqrVet6lWEmendBMUWHc29ghhcvA5JGilA9RCE/LEro08tiQRczR/D22JbaPbW3nluLsa0bRygGX9YDQa0KRyADUG39kUzBHaTvhYvKtXr6JZM2GA5pMnTxAfH482bdrQfqqakiXNZti0NH1c0mxlSLsq2HD6jsWSUrlEMYulrqSKuAe9U4HryaYP2+Lg1Xj0bqQuLuifj9oiLjlDNkuSHrSvUQpz+jWRLVqqBnGK6oIeGwkAX3SvjUWHY6y20wbv2hJlJfTC0fdLnE1TaywHYNb4rh/ZGvEpmQ7vl/ZgMNCVQnoyoWdduLu4YOHhaMF2KUFBTfa4osjLjSvg5cb0+FNbuPIgxWqblBfuJ11qIuxyHCJvJeh2/oJEHVFZgRHPqU9uo8Tuz57DpXvJFlc6spC42OpfGMZ6Gh1rlZZNm18Q8fZwRXJunL7W5DU8WmIP8+vZ8iVnvu2j3jtJC/+OaqdpPUajFSV7fJaE5VGphEd+YDAYVJVOKkgUSUtehw7mdLY7d+60+o7fxu9jC9nZ2Th9+jQMBgMqV9bHb9xW6pX3R+Tkrpj9ljkD049v5KW7/uXNxlb7NxEV3pQrWJvflPHzRN9mFVXHXDWsWByd66ivMWgPLzYsb7eQRyJV966g4eXuQrXm0eZALYkjCiLijGqAbS61zYJKON3SqZUDYztRtw9orV95Ci93F0zuXdcqZkSq9IAW98H8pJA0U4Dcq5llYxxmfkN6qTxISqfuQ5a+GP5cVWpJE1upXtoXvYmEVqQbmK9HwVuw6gVfu1KuZl9+YoubvBh7yqM4i9FdaiBiUle82sQxVkSt6zEaxYu541xoN1z95gXq92QfKghWsKJAwV3h20Hnzp1RtWpVrFixApGRkZbtycnJmDZtGlxdXTFo0CDL9vj4eERFRVmVRjh69KggsQlgFvDGjh2L2NhYdO/eHSVK5L8vffFi7hbtUc0yvpg/IATLh7REMKXWjTjBiDNiSxjKqCn7UFCY0rseDn4hFArIfsQLBvmRSUoP+CDsfi2tBRx702IXVKSsZo6YaLeMaodpL9ezTOgjnpOOiVg1vBXqV/DDmcnqU547C75UyczXCl4JGiXKyqQbd0RyFGcwj0iyEitRiJpc8Jfz93To/FfGzxOLBjfHkvdaCJI2FDX+fKcZvn65HmYQpXoKEnqUeSAzfUrVkywI6BVX6kh8Pd0kLaNkyaT8KDdQFCmS/jCurq6YP38+unfvjvbt2+Ptt9+Gn58fNmzYgOjoaEyfPh01a+b5w8+ZMwdTp07FlClTEBoaatn+9ttvw2AwoE2bNqhQoQISEhJw4MABXL58GZUrV8bcuXPz4eqU6SITw0a6ErQRZStiOJ/ZbzfBljN3MVxl8G9BoVKJYjgzpRsaTTVbxsml0tSX6uGzrjXtrnOUX/zWvylS0rMF7lY88wY0wzdbLwkmo6KAVCY4TwdY+isGFMO7rYPxTqsgJD2l32eeVlUDsWVUe93boAcfdqqO/i0rF6p+PvedplgXfgdjuknHg3WoWQovNiyHLWfvUd2rCipqFoWkJU9tFmZ7sKdOaGEhwNsdA1oH53czJHm5cQX8b/cVamyqFq5/21NyXmBox8fD1arcVZ1yfjj+VWf4eroWGk+Ogk6RFPIAoFOnTjh06BCmTJmCNWvWIDMzE/Xq1cO0adPQv39/VccYOXIktm/fjrCwMMTHx8PV1RXVq1fHhAkTMGbMGAQEWKeqL0w0zM0ExMg/yNTIhQ1/Lzf0bFAWF+4m4Tki/bfBYChUC18xLkaD5ERevbQvFg1u4eQWOR4pt+1BbZWzxNqKwSB9nwsLha2f96hfDj3qK8fU/PB6I7xQv5zqdPoFDamadqQlryhb1xh5jOxYDTXK+KBlFfsUFnLzAkM7Hq5G0GqR21LUnCGNgRP7IzIcCp/ZMzExUfdMm2qJuPkE2y/cx+jONQp0BjtGwYfjOHBc4U0kwMgjeNxWwefjX3VmE24RgHyuMTN75WNLHM8Hf4fjv3P3sWJoS7Sh1F88FfMYfeceBWBOVDFaZTZRBoOhL82/2Y24ZLOUV9THJSmcIQ+wFf4zCF/bg8Gwl8KYbYqhDibgFS2ehff0f282xtju6ahCiUcHhIWcn4X7wWAUVPq3rIyfd19F2+osbMiRMCGPwWAwGIwiTkEul6MXHq4ukgIeAOQQjkvvqCyWzmAw9OfDTtXRqGJxhAQzg4MjKZLZNRkMBoOhjc0fts3vJjAcQLVSZqGni5PKyxRkTER1iAAWX8Vg5BtuLkZ0ql0avgWwHl5RglnyGAwGg4FGlYojfGIXrD99G32aOqbWEsP5/D20Ff49cxdvhFTK76bkO9mElMfKBzEYjKIOE/IYDAaDAQAI9PHAcJm6dYzCR1l/Twx7rmp+N6NA0KpqIIICi6FGad/8bgqDwWA4HCbkMRgMBoPBKPJ4urlg75iOeAbCExkMBoMJeQwGg8FgMJ4NWJFlBoPxrMASrzAYDAaDwWAwGAxGEYJZ8pwMX3s+KSkpn1vCYDAYDAaDwWAwnA0vB3BEaRe9YUKek3n06BEAoFIllumMwWAwGAwGg8F4Vnn06BH8/f0dcmwm5DmZEiVKAABu3rzpsIfKYCQlJaFSpUq4desW/Pz88rs5jCIK62cMZ8H6GsMZsH7GcBaJiYmoXLmyRS5wBEzIczJGozkM0t/fnw0gDIfj5+fH+hnD4bB+xnAWrK8xnAHrZwxnwcsFDjm2w47MYDAYDAaDwWAwGAynw4Q8BoPBYDAYDAaDwShCMCHPyXh4eGDKlCnw8PDI76YwijCsnzGcAetnDGfB+hrDGbB+xnAWzuhrBs6RuTsZDAaDwWAwGAwGg+FUmCWPwWAwGAwGg8FgMIoQTMhjMBgMBoPBYDAYjCIEE/IYDAaDwWAwGAwGowjBhDwGg8FgMBgMBoPBKEIwIc9OTp48iZ49eyIgIADe3t5o0aIFVqxYoekYJpMJc+bMQcOGDeHl5YVSpUrhjTfewNWrVx3UakZhxN6+dujQIYwZMwbNmjVDYGAgPD09Ubt2bXz55ZdISEhwXMMZhQo9xjSSrKwsNG7cGAaDAbVr19axpYzCjl59LTk5GVOmTEH9+vVRrFgxFC9eHE2bNsXUqVMd0GpGYUOPfpaQkIDJkyejYcOG8PX1RcmSJdG8eXPMmTMH6enpDmo5o7CwfPlyjBgxAiEhIfDw8IDBYMDixYs1H0d3eYBj2My+ffs4d3d3zsfHhxs6dCg3ZswYrkqVKhwA7ptvvlF9nGHDhnEAuLp163Jjx47lBgwYwHl4eHD+/v7chQsXHHgFjMKCHn2tTJkynIuLC9ehQwfuk08+4T799FOuSZMmHACuWrVq3IMHDxx8FYyCjl5jGsmkSZM4b29vDgBXq1YtnVvMKKzo1ddiY2O5atWqcQaDgevatSv3xRdfcKNHj+Z69erFNWjQwIFXwCgM6NHPnjx5wlWtWpUDwLVr144bM2YM99FHH3HVqlXjAHDPP/88l5OT4+ArYRRkgoKCOABcyZIlLf9etGiR5uPoLQ8wIc9GsrKyuGrVqnEeHh7c6dOnLduTkpK4evXqca6urtyVK1cUj7N3714OANe+fXsuPT3dsn337t2cwWDgnnvuOYe0n1F40KuvzZw5k7t7965gm8lk4kaOHMkB4D744APd284oPOjVz0jCw8M5V1dXbvbs2UzIY1jQq69lZ2dzzZs357y8vLi9e/dSz8N4dtGrn82aNYsDwH366aeC7RkZGVzz5s05ANz+/ft1bz+j8LBr1y4uJiaG4ziOmzFjhk1CniPkAeauaSN79+7F9evX0a9fPzRp0sSy3dfXF5MmTUJ2djYWLVqkeJx58+YBAKZPny4oiNi5c2d0794dBw4cwJUrV/S/AEahQa++9uWXX6JcuXKCbQaDAZMmTQIA7N+/X9+GMwoVevUznszMTAwaNAitWrXCRx995IgmMwopevW1devW4eTJk/j888/RqVMnq+9dXV11bTejcKFXP7tx4wYAoGfPnoLt7u7u6Nq1KwDg4cOHOracUdjo0qULgoKC7DqGI+QBJuTZSFhYGACgW7duVt/x29QsmsPCwuDt7Y22bdtafde9e3fVx2EUXfTqa1K4ubkBYAuiZx29+1loaCiuXr2KBQsWwGAw6NJGRtFAr762evVqAMDrr7+OW7duYe7cuZg5cybWrl2LlJQU/RrMKJTo1c/q1asHANi+fbtge1ZWFnbv3g0vLy+0bt3aztYynnUcIQ+wVZ2N8EGQNWrUsPouICAAJUuWVAyUTE1Nxb1791C/fn24uLhYfc8fmyVgebbRo6/JsXDhQgD0iZDx7KBnPzt58iS+++47fPvtt6hZs6au7WQUfvTqa6dOnQJgTir16aefIiMjw/JdqVKlsGbNGnTs2FGfRjMKHXr1s6FDh2LZsmX48ccfcerUKTRv3hwZGRnYvn07njx5ghUrVqBChQq6t5/x7OAoeYBZ8mwkMTERAODv70/93s/Pz7KPPccg92M8m+jR16SIjIzE1KlTUbp0aXzxxRc2t5FR+NGrn2VkZGDQoEFo0qQJxowZo2sbGUUDvfoa7yI3atQofPLJJ7h16xbi4uIwe/ZsJCYm4pVXXsG9e/f0azijUKFXP/Py8kJYWBjeeecd7N+/Hz/88AN+/fVXiytou3btdG0349nDUfIAE/IYjGeU6OhovPjii8jJycGqVatQsmTJ/G4SowgwadIkXL16FQsXLqRqJBkMvTCZTACAF198ETNnzkTFihVRsmRJjBo1Cp9++ikSExOxYMGCfG4lo7ATHx+Prl274tixY9i6dSsSEhJw//59zJ07F4sWLULLli3x5MmT/G4mg2EFE/JshJe2paTqpKQkSYlcyzHI/RjPJnr0NTGxsbHo1KkT4uLisG7dOmrSAsazhR797PTp0/jpp58wYcIENGjQQPc2MooGeo1p/D4vvfSS1Xe9e/cGkOfSyXj20KufffbZZzhy5AjWr1+Pnj17wt/fH2XKlMGwYcPw3Xff4caNG/j555/1bDrjGcNR8gAT8mxEzj/2yZMniI+Pp/qBk3h7e6NcuXKIjo5GTk6O1fdy/uSMZwc9+hpJTEwMOnbsiLt372LNmjV48cUXdWsro/CiRz87e/YscnJyEBoaCoPBIPgDgMuXL8NgMKB48eK6t59ReNBrTKtVqxYAUPsTv+3p06e2N5RRqNGrn23duhUlSpRAw4YNrb57/vnnAQDh4eF2tpbxLOMoeYAJeTbSoUMHAMDOnTutvuO38fsoHSc1NRWHDx+2+m7Hjh2qj8MouujV14A8Ae/OnTtYvXo1Xn75Zf0ayijU6NHPatasiSFDhlD/ALMWcsiQIRgwYIDOrWcUJvQa0/gF9sWLF62+47cFBwfb2kxGIUevfpaZmYmkpCRkZmZafRcXFwcAgpT3DIYtOEQe0FxZj8FxnLnIZtWqVTkPDw8uIiLCsp0ssnn58mXL9ri4OO7SpUtcXFyc4Dhk8cOMjAzLdlYMncGjV1+Ljo7mgoKCOFdXV279+vXOaj6jkKBXP5MCrBg6Ixe9+tqNGzc4Dw8PrnTp0tzt27cFx2ncuDEHgNu9e7fDr4dRMNGrn3Xv3p0DwE2cOFGwPT093fLdr7/+6tBrYRQelIqhO1MeYEKeHezdu5dzc3PjfHx8uGHDhnFjxozhqlSpwgHgpk+fLth3ypQpHABuypQpVscZOnQoB4CrW7cuN3bsWG7AgAGch4cH5+/vz124cMFJV8MoyOjR14KCgjgAXKtWrbgpU6ZQ/xjPNnqNaTSYkMcg0auvzZ49mwPABQYGckOHDuU+/PBDLjg4mAPADR8+3ElXwyio6NHPIiIiOF9fXw4A16JFC+7TTz/lRo4cyVWtWpUDwDVr1ox7+vSpE6+KUdCYN28eN3DgQG7gwIFc06ZNOQBc27ZtLds2btxo2deZ8gAT8uzk+PHjXI8ePTh/f3/Oy8uLCwkJ4ZYvX261n9xDzcnJ4WbPns3Vq1eP8/Dw4AIDA7m+ffsKNEwMhr19DYDiH4Ohx5hGgwl5DDF69bV//vmHa9++Pefj48N5enpyzZo14/766y8Ht55RWNCjn125coUbPHgwV7lyZc7NzY3z8vLiGjRowE2dOpVLTU11wlUwCjIDBw6UXVuRfcqZ8oCB4zhOm4Mng8FgMBgMBoPBYDAKKizxCoPBYDAYDAaDwWAUIZiQx2AwGAwGg8FgMBhFCCbkMRgMBoPBYDAYDEYRggl5DAaDwWAwGAwGg1GEYEIeg8FgMBgMBoPBYBQhmJDHYDAYDAaDwWAwGEUIJuQxGAwGg8FgMBgMRhGCCXkMBoPBYDAYDAaDUYRgQh6DwWAwGAwGg8Fg5HLgwAH07t0b5cuXh8FgwKZNmzQfg+M4/PDDD6hZsyY8PDxQqVIlfPvtt/o3VgJXp52JwWAwGAwGg8FgMAo4qampaNSoEQYPHozXXnvNpmOMHj0aO3fuxA8//IAGDRogMTER8fHxOrdUGgPHcZzTzsZgMBgMRiFk06ZNiIyMROPGjfHKK6/kd3MYDAaD4SQMBgM2btwoGPszMzMxceJE/P3330hISED9+vUxa9YsdOzYEQBw6dIlNGzYEOfPn0etWrXypd3MXZPBYDAYDAU2bdqEqVOn2uSyw2AwGIyixeDBg3H48GGsWrUKZ8+exeuvv44ePXrg6tWrAIB///0XVatWxZYtW1ClShUEBwdj6NChePz4sdPayIQ8BoPBYDAYDAaDwVDB9evXsXLlSqxduxbt27dHtWrV8Pnnn6Ndu3ZYtGgRAODGjRuIjY3F2rVrsXTpUixevBjh4eHo27ev09rJYvIYDAaDwWAwGAwGQwWnT58Gx3GoWbOmYHtGRgYCAwMBACaTCRkZGVi6dKllvwULFqBZs2a4fPmyU1w4mSWPwWAwGM8ka9aswQsvvIAyZcrAzc0NxYsXR40aNfDSSy/ht99+Q3p6OsLCwmAwGLBkyRIAwJIlS2AwGAR/YWFhVse+fv06Ro0ahTp16sDHxwfFihVDnTp18Mknn+DmzZvU9ixevBgGgwHBwcEAgF27duGFF15AqVKl4OXlhXr16mH69OlIT0+XvKbjx4+jf//+qFKlCjw9PeHt7Y2goCB06NAB06ZNw+3bt+2+bwwGg/EsYzKZ4OLigvDwcERGRlr+Ll26hF9++QUAUK5cObi6ugoEwTp16gCA5BygN8ySx2AwGIxnjiFDhmDhwoWWzz4+PsjKysK1a9dw7do1/Pvvv+jVqxfc3d1RpkwZJCYmIj09HZ6envD39xccy93dXfB53rx5+PDDD5GVlQUA8PDwgNFoRFRUFKKiorBo0SKsW7cOXbt2lWzfb7/9hlGjRoHjOBQvXhzZ2dm4ePEiJk2ahA0bNmDPnj0ICAgQ/GbJkiUYPHgw+HxqHh4ecHV1xc2bN3Hz5k0cOHAAlSpVwqBBg+y5dQwGg/FM06RJE+Tk5ODhw4do3749dZ+2bdsiOzsb169fR7Vq1QAAV65cAQAEBQU5pZ3MksdgMBiMZ4pDhw5h4cKFMBqNmDVrFh49eoTk5GSkpqYiPj4eO3bswMCBA+Hu7o42bdrg/v37ePPNNwEAb775Ju7fvy/4a9OmjeXYmzZtwvDhwwEA48aNQ0xMDJ4+fYrU1FRERUXh9ddfR1JSEvr27SupzY2Li8Onn35q2efJkydITk7G3Llz4eHhgYiICAwZMkTwm7S0NItQ+M477+DatWtIT09HYmIiUlJScOrUKYwdOxalS5d20F1lMBiMokNKSorFQgcA0dHRiIyMxM2bN1GzZk30798fAwYMwIYNGxAdHY2TJ09i1qxZ+O+//wAAXbp0QdOmTfHee+8hIiIC4eHhGDFiBLp27Wrl5ukwOAaDwWAwniFmzZrFAeC6deum+jcDBw7kAHADBw6U3CcjI4OrUKECB4BbsGCB5H4vvfQSB4AbPXq0YPuiRYs4ABwArkOHDlxOTo7Vb+fPn2/Z58SJE5btx48f5wBw3t7eXFZWlurrYjAYDIY1+/bts4y15B8/B2RmZnKTJ0/mgoODOTc3N65s2bLcq6++yp09e9ZyjDt37nB9+vThfHx8uDJlynCDBg3iHj165LRrYO6aDAaDwXimKF68OACzxSwnJwcuLi66HHfbtm24c+cOypQpg8GDB0vuN2DAAPzzzz/YsWOH5D4TJ06E0WjtbDN48GCEhobi9u3bWLVqFZo3bw4g75oyMzPx6NEjlClTxr6LYTAYjGeYjh07Wlzfabi5uWHq1KmYOnWq5D7ly5fH+vXrHdE8VTB3TQaDwWA8U3Tp0gWenp6IiIhA+/btsWDBAkRHR9t93EOHDgEAnjx5gnLlyqFs2bLUv2HDhgEAYmNjqcdxdXWVjPMwGo2WYrunTp2ybK9WrRpq166NrKwstGzZErNmzUJkZCRycnLsvi4Gg8FgFD6YkMdgMBiMZ4qqVati/vz58PHxwdGjRzF06FBUrVoVpUuXxptvvonNmzfLanCluHv3LgCzNe3BgweSf0+ePAEAPH36lHqckiVLwsPDQ/I8FSpUAAA8fPjQss3FxQWrVq1ClSpVEBsbi3HjxqFJkybw8/ND165d8ccffyAtLU3zNTEYDAajcMKEPAaDwWA8c/Tv3x+xsbGYO3cu3nzzTVSqVAlxcXFYs2YNXnnlFXTo0AFJSUmajslbzXr06AGO41T90TAYDDZdU6NGjRAVFYX169dj+PDhqF+/Pp4+fYrdu3fjgw8+QO3atXHu3Dmbjs1gMBiMwgUT8hgMBoPxTFKiRAmMGDECq1atws2bN3Ht2jWMGzcOBoMBBw8eRGhoqKbjlS1bFgDsFqTi4uKQkZEh+f2dO3cAgJop093dHX369MGff/6Jc+fOIS4uDnPnzkWJEiVw69YtDBw40K62MRgMBqNwwIQ8BoPBYDBgjmubMWMG+vXrB8BcjJyHT4Ii58bZtm1bAGYhjI/Ps4Xs7GzJ33MchwMHDgAAQkJCFI8VGBiIESNGYNasWQCAiIgIPHr0yOa2MRgMBqNwwIQ8BoPBYDxTyFnJAMDLywsABFk3/fz8AAAJCQmSv+vduzfKlSsHABg9erRiDNzjx48lv/vmm29gMpmsti9ZssRSX4+v3QeovyYAumUTZTAYDEbBhQl5DAaDwXim+Oijj/DGG29g/fr1guQlKSkpmDt3LpYuXQoA6Nmzp+W7+vXrAwAOHjyIqKgo6nE9PT3x+++/w2Aw4PTp02jbti127NiBzMxMyz7R0dH4888/0aJFC/z+++/U4xQrVgyHDh1Cv379cPv2bQBAeno65s2bh5EjRwIAXn75ZbRo0cLym1WrVqFt27b4888/cePGDcv2nJwc7NixA+PGjQMAtG7d2lJugcFgMBhFFwNnSwoxBoPBYDAKKYMGDcKSJUssn318fODq6iqw0rVr1w7bt2+Ht7c3AHNZhFq1aiEuLg6AOQMm/92qVavQqlUry2///vtvDB8+3GLJc3V1hb+/P1JSUgQWt+nTp2PChAmWz4sXL8bgwYMRFBSEsWPHYtSoUeA4DgEBAUhJSUFWVhYAc4KVPXv2IDAw0Oq3PB4eHvDx8cGTJ08sFsHy5ctjz549qF27tn03kMFgMBgFHibkMRgMBuOZ4vr16/jvv/+wb98+XLp0Cffv30dKSgpKlCiBRo0a4e2338aAAQOs3BqjoqIwdepUHDx4EA8fPrQIXfv27bPUruO5d+8efv/9d2zfvh3Xrl1DcnIyfHx8UKVKFbRr186SwdPV1dXyG1LIi4mJwa5du/DTTz/h5MmTSElJQZUqVdCvXz98/vnnAvdLwOz6uXXrVuzbtw+nT5/GvXv38PjxY3h7e6NWrVro3bs3PvroI2bFYzAYjGcEJuQxGAwGg1EAEAt5DAaDwWDYCovJYzAYDAaDwWAwGIwiBBPyGAwGg8FgMBgMBqMIwYQ8BoPBYDAYDAaDwShCMCGPwWAwGAwGg8FgMIoQLPEKg8FgMBgMBoPBYBQhmCWPwWAwGAwGg8FgMIoQTMhjMBgMBoPBYDAYjCIEE/IYDAaDwWAwGAwGowjBhDwGg8FgMBgMBoPBKEIwIY/BYDAYDAaDwWAwihBMyGMwGAwGg8FgMBiMIgQT8hgMBoPBYDAYDAajCMGEPAaDwWAwGAwGg8EoQjAhj8FgMBgMBoPBYDCKEEzIYzAYDAaDwWAwGIwiBBPyGAwGg8FgMBgMBqMIwYQ8BoPBYDAYDAaDwShCMCGPwWAwGAwGg8FgMIoQTMhjMBgMBoPBYDAYjCJEoRHyli9fjhEjRiAkJAQeHh4wGAxYvHixpmN07NgRBoNB9m/ZsmWC3wQHB0vu+/777+t4hQwGg8FgMBgMBoNhP6753QC1TJw4EbGxsShZsiTKlSuH2NhYzccYNGgQOnbsaLU9KysLM2bMgNFoROfOna2+9/f3xyeffGK1PSQkRHMbGAwGg8FgMBgMBsORFBohb/78+ahRowaCgoIwc+ZMjB8/XvMxBg0aRN2+fv16cByHnj17onz58lbfFy9eHKGhoZrPx2AwGAwGg8FgMBjOptAIeV26dHHYsefPnw8AGDJkiMPOwWMymXD37l34+vrCYDA4/HwMBoPBYDAYDAaj4MBxHJKTk1G+fHkYjY6Jnis0Qp6juH37Nnbu3ImyZcuiV69e1H0yMjKwZMkS3LlzBwEBAWjTpg0aNWpk0/nu3r2LSpUq2dNkBoPBYDAYDAaDUci5desWKlas6JBjP/NC3qJFi2AymTBo0CC4utJvx/37961cPXv06IFly5ahZMmSms7n6+sLwPxQ/fz8bGozg8FgMBgMBoPBKJwkJSWhUqVKFrnAETzTQh7HcVi0aBEAaVfN9957Dx06dEC9evXg4eGBixcvYurUqdi2bRteeuklHD58WNbtMiMjAxkZGZbPycnJAAA/Pz8m5DEYDAaDwWAwGM8ojgzdKjQlFBzB3r17ER0djQ4dOqB69erUfSZPnowOHTqgZMmS8PX1RcuWLbFlyxa0a9cOR48exX///Sd7jhkzZsDf39/yx1w1nUeOicvvJjAYRR72njEYDIb9sLGUoTfPtJDHJ1wZOnSopt8ZjUYMHjwYAHD48GHZfcePH4/ExETL361bt2xrLEMTs7ZHofHXO3HrcVp+N4XBKLJcj0tBo6k78fPuK/ndFAaDwSi07L8ShwahO7A58k5+N4VRhHhmhbwnT55g48aNKF68OF577TXNv+dj8dLS5IUIDw8Pi2smc9F0Hn+EXUdyejZ+3Xs1v5vCYBRZZm2LQkpGNn7ezd4zBoPBsJWBC08gLTMHo1dF5ndTGEWIZ1bIW758OTIyMtC/f394eXlp/v3x48cBAMHBwTq3jMFgMBgMBoPxrMAqajEcQZEU8uLj4xEVFYX4+HjJfRYsWABAvjbexYsXkZCQYLX90KFD+Omnn+Dh4YE+ffrY3V6G4zCAjZwMhqNgESQMBoNhPy5MymM4gEIj5M2fPx+DBg3CoEGDsHbtWqttmzZtsuw7Z84c1KlTB3PmzKEeKzw8HGfOnEHTpk3RpEkTyXOuWbMG5cuXR+/evTFq1Ch8/vnn6NGjB5577jlkZWVhzpw5qFy5sq7XWRhYe+oWOny/D9ceJud3UxRh42bh4trDZHT4fh/Wnir4sathlx+i/Xd7cezGI4efy2Ti0H/+MXy04rTDz+VMHqVkoPOPYfg97JriviuO30TH7/ch9lGqQ9v01cZzeOW3w8jKMTn0PAzGs8imiDsIHrcVweO24pXf5HMaAMBfB67j+R/C8DA53Qmtyz+MRrZYYehPoRHyDh06hCVLlmDJkiU4fdq80Dl8+LBlW2RkpOpj8VY8pYQrnTp1Qu/evREVFYUlS5Zg9uzZuHDhAt58800cOXJEc8KWosLYdWcR+ygNX64/l99NYRQxvlx/DrGP0jB23dn8booigxadxK3HT/HWX8ccfq4b8Sk4fO0Rtpy9B1MRysD2R9h1XI9LxXfbLyvu+9XGc4h5lIbJmy84tE0rjt9E5K0EHLwa59DzMBjPIp+sjrT8O/JWguL+3/4XhRvxqUU+7peJeAxHUGjq5C1evBiLFy9WtW9oaChCQ0Mlv//999/x+++/Kx6nQ4cO6NChg8oWPntkFwJNN7PkFS6eZubkdxMKKHkdOctkgofRJR/boh+ZNowhmdnOGXdMBX94YzCeGQrDesMeio7qjlGQKDSWPEbBw5EFHBkMRh6uhCvPs15LiXPScogNbwwGw2k828M6w0EwIa8AsOH0bXQsYDFufx24ji4/7UdccgZGrYzAgIUnwHHCUagwupBzHIf3Fp/EyOXh+d0UBgW5eS47x4TX/jiCCRv1cRPmOA4DFp4oFHFuLsTLlpVTdFYDnA2XYstvbEFvIY/jOLy74Dg+WRWh74FlWHgoGp1/DMODJPvjmY5ci0eH7/fhyDXphGYMhjPg+/X9RGG/Ts/KQe9fD+Hb/y7lU8tsx1HKq9/2XUO3/+1HQlqmQ45PMnNbFHrNPsg8cgoQTMgrAHy25gxiHqXh87UFJw7p2/+icO1hCn7ZcwX/nrmLA1fiEB0vTHhgLBSqbmEb7yWmY2/UQ2w7fx+pGdn51CaGLRy+/gjhsU/w9/GbuhwvOj4VB67EYcvZewXeFYgMyi9KMXm2LGycdfV6Z+a9+jAFB6/GY1PkXV2PK8fXWy7ielwqvt+hHPOoRL/5xxH7KA395h/XoWUMhu3w/fqHncJ+/e+Zuzh3JxF/HbiRTy2zHUcpr77fcRlXHqQ45Z7M3X8dF+4mYd3p2w4/F0MdTMgrQKRnFTztR0ZW3uJXvLYsDEKeuImcxL8ZBQOxtZhEb+GGPFxB7wvkfSlIbbV3YeIsq5xN6Dy8mchn6OQLd1YcI4PhTMT9ujC7sju65c7MFpxRANeyzypMyMtnBIs3hbfcWQsD8jxyY6axEPYect3m7IUWw050XnSTCgA9Fgf58X4+q8jdA73ujx7dTaot9nQ3NdfHcZxAKVIQe0xRskgXJArj+KClzXIKr0Kgd5akMD43KUxF6Fr0xtnPuRAu04sOS4/GoNn03ZbPci/GkevxaDJtF7acdayrz487L6PFt3ssn+U6ZEG15J2MeWz5t7iFZJPZMFS40Lu3JT3Nsvzb3nF318UHaPz1Luy7/NDOVtEh2/es99sT0Y/RbPpuLD0aY/VdRnYOuv7vQIGIs3yamYNOP4Th87VnrL6zdRE0fsM5tP9uH1IUXM3bzdqHql/9Z/lc0BaQCw5Fo/HXOxEe+yS/m1KkeJSSgVYz9hTYmDSaNWn1yZtoOm2XqnIKmyLuoMm0XZbPZL/+Yt2ZQlvWieM4uxQ/BY2iFDeuJwsORaPZ9N24+sB5+TeYkJePTN58AY9T84Jh5Sb+AQtOICEtCx+tcGzQ/q97ryEuOcPyWdgiceKVginkDVl8UvI7Ms6mgK17GJB/Jnpnc11DFFzPsbMzDFt6ColPszB4kXTf04ui1G9tvZTHqZnUennHbzzGtYcp2HL2nn0N04GdF+8j5lEa1oVbx6fYKuStPHETt588xUaZmBeO43An4alwm01ncxzTtlxEUno2vt8Rld9NKVIsOBSNB0kZBTYm7VSMtVD/5fpzeJKWhVErlRUzn6yOREIaoZwjvltzqvDGgcWnOD4pijMpaEqlgsK0LRfxODUTEzedd9o5mZBXgJB7L/LL/C133gIq4xUpjRgjD727Gyk0FvRYDqElr2C3NT9xsTPlL7k4sVepIDdkO3I4px67gHYZcsHOsJ8CPozJjl3PslxQ1Nwbi9jl6I4z7w8T8goQci96fr0zcpNGcrrZZYjjOIFFsiAhXqcJPqu8qQXl+h6nZiItM1tzemKTiXNK+mQlUjKykZEt33a5RYCta26p6yflAX5xn5iWVSAybSamZQkET8F9Ed0isn/q3U+T07MUknYQ8bs29DO1k53a67JXyCPHO1uPFB2fihwTJ9tfHbmoo8t46s73JDXTLi28eHx6nJop+95n5piQlG4W9GLiU1W9e09SM/EoJUNxPzEFYQzXA9oz4reRz/mxnc/SlnaRcZZpmdlWyeT0zlhrC46ezzmOw8OkdCSnq1NgJKRlIpuy0HL088vMNqluo1ZSMq3dycVzmj2oeX7k/csxcUjUSaEkd+6nmTkFrnwEE/IKEAVRCycXHB95KwGPUjIwafN5NJ22C7suPnBiy6QRaONFkwr5Se1Ca8a2KDSdtgv/nHFe6nMxP+26gqbTdqHu5B2oN2W7psFyyJKTaPz1Lpy/k+jAFsqTnJ6F+lN2oN2sfbL7PSUWBeJBmXyWETfVx/IMXHQCjb/ehYt3kwTbjSJL3p2Ep2j09U70nnNY9bEdwfW4FDT6eife+POoZRv5uL9YLyy18tVG8/vX+9dDaDptF1af1KfEROLTLDQI3YnnvpN/Zjz8fb50L0l5ZwvK/fi3fdfQlIjDkcPFzqLxJoElT/PPMXf/dXT6IQzViHg4+nm0H5tE7ue0cU3NUBce+xhNpu3CB3/bFs+YlWNC/Sk70CB0B3JMHHZcuI+m03ah/pQdaPHNHupvbsSlou3MvZi7/zo6/hCG6hO2yZ7j6oNkNJm2C82m78bxG49Ut+277eYxfD3FdbYwwcfmf7I60rLtRLT5uX20UhjK0XTaLkxwklvY2dsJaDJtF4YuPQXAHBtbd/IONAzdqVuCHWrpERsOPTN3Pt8cecf+RtGOvz0KLb7dgwahOxWVXlceJKPx17vQb94xwfadue+OI9362n+3Fw1CdyLxqf6C3p/7bwiUgzcfpaHR1zvx2h9H7D723P3X0XTaLiw+HC25zz9n7qLptF2W2NS3/jqKRl/vxPW4FLvOvehwNJpO24W5+69bfZedY0LdKdtRd8p2RWWVM71xmJBXgCiIbljCtN/W3x++/gjLj5kXlT/oUIvJ4RALN7VCHh/fMH3LRUe0SBWz91y1/NvEAakUTZkU+y7HAQCWHY3VvV1qOXvbLGCS8Z40bj3OiyU6LRLkSCPNosMxqs998Kq5ePOKE8LrJ4U8EwdsP38fADQKKfqzITfeikxKQSouwnKfJ8/KE+b371yuED9pk3Wsmi2czj3/fZWFtPn7zLdHL7TUeBMWjddukTXJKIjUMHObuhgzh1ryKIdWc7p5B8yLpm2574FWHqdmwsQB2SYOyelZ+G573r2QW0gmp2ervm+rTubF0f6pIe7s9zDzoiz0H33ejfzij9zr2EwIPH/mLji3nr1nJfSs0KmmqBKLj8QAAPZGmRNP3UswjxmZOSZkmfLeQ3s8oGkeBbasmfh+M22LY5LT/Lk/r1/SYhBJVp0w9+fYR2mC7Xz9P71qwgLWY8CDJPNcfPZ2gm7nIIkjrO3/nDEL1GqS6yjBjxWh/0qvx6blrtXmHTSPaSdzn8PG0/YJ9lNzz0kbrxKeZoHjzPc5wQGCs60wIa+QkF8+zlqy+hXUGD0pCqLl1JHkpxKB5o6ihFV7bRDQSeSaYOI42Onppxs04SI/npyt/SU/40tcDPYJec5qOudAj2Dac3PGuy+2jLu56L+8IJ9PUYtjUoNSnGh+3RHxmCXVDr2H2ILeBZTWRFLfFwS3VntRW4rLEUjdPUeuUYXlueT3ZTF5DADA7SdpmLblompz+rnbibh8X9/UrEoT6YEreVYF8QR06Go87ieaNXpnbiUg6n4S9kU9pPpGx8SnYvv5e9h/JU6TH3p2jgm7Lz5APKE1SiV8ovkm5Zg47Lv8UOCyp9XfXY/38tK9JFm3yeT0LOy59ACZ2SZwHIcDV+LwUKUlRYn8mhCvPUzGbpErr8nEIezyQ8SnZCDyVgLWh9/GtYfCvitu7yMiAxnHAakZ2dhz6YFsnF8SEXNwRebdMAt56mcANW4fCWmZ2Bf1ULPbINkM3vIpvhd8f35Ciw+gXMajlAzsu/zQZteppUdjqPfZVqsRbd8dF+7b7TpEWvKyJdJ4p2flYM+lB0illCEQu2uS76MStOORkNeaZTJhX1Te88vKMWFv1AMcu/EIl+4lWdqYJmGx15rURc0zsXcBdPtJnjXi4NV4uLoIDyjO+KnE+TuJiLovtKqT98PEARfvJuHCXXk3dLWF4CNuPsG1h9bvdXaOCevDb2Nz5B3dEzSduZWAqw+SVfWz8NgniH2UKthmMnHYfyVO4hf2k56Vg3/P3MWmiDvYfv6e6rgmWv3frBwT9iqUmDkZ8xhR95Ow59IDq3g+vUl8mono+FScyi25lJ6Vg9Unb2L7+fu6xcJlZJvMc3gyfQ7XKow8zczR/d44SqAkb+Gtx2nSOwKIfZSKE9GPZfcBIBnv9jQzB+vDb2PbuXvIMXF4KOExpHeGbhJy/VCQsou65ncDnlUibynHFPHxSwsOSfse8yQ+zULvOYcAANEzeurWmcVzmjhQl0wPTtb+2H8lDgMXngAAnJrYBS//lhfnVKO0D3Z91kFwnI4/hFn+/ctbjfFy4wqq2rcu/DbGbTiHdtVLYvnQlpL7LT8WiykiVx2t87W9721mtgkv/HIQAHDx6+4o5m79+g1Zcgonoh9jxHNV0aRycby//DTcXPR5lvk17HT56YDVtnXht61iy8R4ubkIPo8iYk44cBj592kcuBKHAa2D8PXL9anHeHfBCcu/T4lqcgV6u1v+nWPSZsnr/ON+ye9iH6UiKNAbfX4/ghvxqZjYqw6Gtq+q+thkMzr/GIazod0hfnrLjsYg9N+LqFTCS9Uxe80+hPtJ6fjm1fro3zJI1W/I/j558wXciEtF6Ev1FH+n5b0izzFiWThea1oRP77RSP0BRJATLekmRjJ960UsP3YTnWqVwqLBLQTfiROvDFt6CsduPMaw9lUwoVdd2XN/LIqJkmPJkRj8uvcaggOLIWxsJ/y064rFFQ8AXmtaEetP30bXumUwb0CI6uMCEkKeit/ZO2W8+ntevA0ZM8bTduZexMzspepYKRnZePFX83x27ZsX4JprFSTdNTOzc9Bztvx4Cphrv1qQuMb7iemW9ovbOO9gNGblup4mPs3CgNbBqq5BifiUDMu8GBIUgFOxTzCyYzV82aO21b63HqdR45lWn7ol8JJQcofXytdbLgpcPmuX9cX2T56z2k/cd8j+xvfHX/deE7gyirn95Clen5sXh6xmLJCbky/cTUS98v6S32flcOiUu+7Y93lHzN5zFRsjzO58WtYgcvDxrR6uRlye/oLV90aN7iNj153BlrP38Erj8vj5rSZ2t8+RkM9mrUIsbIfvwwAAOz99DjXL+EruN2ZtJHX7uA1nLS7ME3vVkfy9I+2jBbUGM7Pk5RNndPBNJiGzjelZiFKskZNLeU1ONkev5wXF8/75PFcp2lISccyRHPygfOhaPPV7/r3bes66bpaz3RdJS4jUfeS1WWvDb1s0tHo9zwKkXMJOFUl6Svp6SH7HcXlWZLkYMLn3rGlQgOB4eilGeGv6jXiz1v1frTXbiHYkWTLYCnf575w5boqMYZSDj6vbdk59vJX4nLT4Htot06LFFL+D62Xqv2k9nlQz+BjifZRxRuy5cOyG+X1cTQgXUuyJkrdSkIfmFyQxubE4a0U1vvj7YEsyK1sTrxQkF7HHhNVeytX7aVaeEC9nASbrYUoRI7KQkZAJOrbqWH/xzpO8d5dXQIn7AQ/NwgiYrd8kNxUsJloRv/NREt4Qcj2Hfyc3Rmh7t9WMBXJzOB8Hroaoe0mWtQQA7NewBlFDhoSFVtqSR/+Gr/9JTUKjgKQLrYNee1vWV+LkaGL+k5i/yBhV2lqPx1m1nRXdNZ3SCjOFRshbvnw5RowYgZCQEHh4eMBgMGDx4sWajhEWFgaDwSD5d+zYMervTp48iZ49eyIgIADe3t5o0aIFVqxYocNV6YerMe9RZktosG1BvGAQu+BIQb5LRo29TNsiUakd5obQWq3d88a+V1NL5j+lwciWoaqgJPZR+3zV1o3UIrxKuSuaLXl6Wb+F59B6VDV91damahkbxHeKLtBZb9MSK6W34kEQQyxxbDnlueA3Oq8HyPtibzyZ3DtE/6ZgvPuOQm481XNhp2ccoJZmqR27C0qcojB20vx/FyctsPPOq/5eZIn6j72lWFQjcRpHn94Z7oT51RXlbp0ju2BBjRcuNELexIkT8ddffyE2NhblypWz61gdOnTAlClTrP4qVqxotW9YWBjatWuHgwcPom/fvhg5ciTi4+PRv39/fPvttza3YY2Exu7W4zS88edRvP0XXeAEgHcXHMdXG88J/LxdCOErJT0vbiEpPQuTNp23+J1LsS78Nn7ZfdVqOzn2HY9+hD6/y6fA/S9Xi7KW0J5O2aw9o9nc/dcRPG4rbj1Ow7WHyWj89U6MXhVhGZzuJDxF8Litqvy4zW233o9f8O+7/BBT/72gmKghPiUTweO2YnPkHTxMSsdXG88pZmJccCgaC3Pdbcn3fh8Rm5CQlomJm84JMk8ZDULtlBwnYx5j6JJTGL0qwiquTQBnzsS27FgsHialY8LGcxbNWVxyBiZsPEeNF5yz96qqtPy7Lj7A9C0XkWPiMO/ADSw9GkPdz8SpG2w5cEjPykHoPxdwWGSpNdk4oObk7rvsWKwgDfLGiDv4auM5wb6Z2SaE/nMBey49QOg/Fyx9W/Ecom4kda2rT97EnL3W7xwfx0oiXuQpLVwXHIrGIkqK6WM3HuO9xScxbctF7LkkbyUSLwQ4ADO2XcK23PswZs0ZqvWKLzXyNDMHUzafxxEJK7sc/527hxnbLikuRiZuOofEtCykZ+UgeNxWi4sfIN0vSC355M3nsf38PUzcdA5nbiUIzpcsGEezMWnTeUvG03/P3MV326Nk2xcdn2cd2nPpgXARQHTg4HFbBTHFYmjv5YGr8Qj95wJWHL+J4HFbBeM7rU38pluP0xA8bitCpu/G+A3n8NXGc3lWIpkuFRNPt3T9tu8agsdtFWT/lWODCutMelYOQv/NmzOkbjF5DzOzTfj6X3qfziReSP4SV564id/2XaMel4wdXHIkRmC9uptgHvcv30/Gv2fuInjcVhy4EofL95Px1cZz1HeX5Nc9eWMp3XJKv9jvtltnmCVLrPDQZN1DV4Xv39zcOUBPyOHIHEeZ15BTMY+RkZ1jsVrribwi0Bw2EvrPBcW4zByR8otXZt96nIavNp6zxGCfu52ICRvPUes0Pkk1z+NakLKeaxVGPl4ZgeBxW/E0Mwdnbyfgrb+O4oO/wzGPyEBLzgdkP7mfmI5pWy5i98UHiLqfhK82nsMDFXkAMrNNmPrvBey7/BAzt0Vhy1nheuVeovldufJAfZ4IR+sBNpy+LWg3yamYxxi/4Rze+PMogsdtxZIjMTh+4xGCx221ZN6WgxP9e1vuHGYycVgffhv/23XF8n147BP8fdw52c4LTUze/PnzUaNGDQQFBWHmzJkYP368zcfq2LEjQkNDFffLzs7G0KFDYTAYcODAATRpYvaBnjJlClq3bo0pU6bg9ddfR40aNTS3IfZRGowexQTbbj1+iqFLTuGywkvBpyq/m/AUi3NjSkgt2fStlzD7bXNbv9seheXHbmLZsVjZeIjP156hbicXSpNVCGsf/H0aMTN7IZ5wtxHHQinBIS9Fbfvv9sHXwxXJGdnYHHkXLzcuj+drl0HbmXs1HZN6ntxLG7zoJAAgONAbA9sEK/5u9KpItK4aiKM3HmHF8ZuS9zUxLcuSyveN5pUE303efMES2/H1lovYcPqOxY0MgGTgMA0yjmH3xQe48HUP6n53E59iQ65Lys4L93Hwajz+zm3/uPVnsSfqoeUzz7WHyfhhp3lwerN5Zdl2DMutkVTCx92yKHlTdN2AeqGM48zlKxYfibGk6M77jrDkqTpa3rlzTBwmieoP/UJZpC47Fis49+IjMapiirJNJkH77koknPhyvXlB0L1eWdQg4hBWU9zLxLdMbjLMzDZZ+t3rIZXg4yEc5vk05wsORctej/g5ZWabLDE150K7SbpTpee60f2x/zqWHI3FkqPSY4/Us+NjWUKCSki2DzC7XmbncKgYYB2bKOmeRPx76dFYLM0tLbL82E2cntTV8h1fY4ln2bFYyzjKx4e2qhqI52qWop7nZ0JpNmTJKWz+sK3lc44GxcTfx29avZd7RcJ137lHLd/TFvr8pva5NQ/jUzIsbs5bztzF2dDushrw/vOPU7fz5S1+IhYwcny25gz6NLVWppJM33pRcH1S4wVZlHj1yVtYeDgaCw9b92lSWOcZv8H87vVqUA7BJb0F3w1fegpbP26PtMxsqzjuOwlPseL4Taw5mRcLN2DhCbgaDcg2cbj6IBlr329Dbe/VB8n4cVfeWKplQUtzkzwR/dgqJpcm4L+z4LjlntxNeGqZW99pWdkhiSjGrDmDn99sbPk8aNFJ2Tgpe5B7i0wmzpIXoGKAl2xctFSSpmFLTyHqfjJ2nL+P8EldLXkPHqVkYu67zQT7Ttty0TK/qkWv7Jq8Ym3CxnOCNpDujSbOrPT383QTWL7H5K79yNwP0XGpWDm8lew5lx+LxaLDMZLljEatPI34lEyskzBo8JACc0aWNi+0h0npKO3nKdgm16djHqVh9cmblnaTY0XfuUKlCfnuv788XHHuF4Y2mXMGAECTSgGWe0wyYeN59K7TXvaYelBoLHldunRBUFCQU8+5d+9eXL9+Hf369bMIeADg6+uLSZMmITs7G4sWLdL1nEoCnmBfCf94MgOXlC+/WgqC1TmZyFoXnyxfXJSGlIueePGgJfvbRRW11MjC3jkmTlLrf/WBfc+IJFUi+xQAJD7Nu4+X7gn7jlSsBW2BpMQ14npo3oFyrlXvd6hm+TfHWdcPIr+j/VsJk0l9kWwp4UwNZJvSZJ4JIB9PRDseoN4FTakoqxxyt0lNnOhNmTgntchZuHiuPUyhxiZKvfdyt44cE6T6HsljWnZTCUjBzo7HogxNyJN5Sfi4T7nFkdbMmPZw5b5wPJQS8shaobefqG8feS9SMqxjXi/kejfIWX/EcYL853MymZOTREnL9JCvUkTjs9JYSGaA1XNuJ4WSC3eTrLqgluejF2S/UYpVFPf9Uj7meHB+Xnwkes9p1qlrdhbaFrZH/b5kf1Zal2Tl9mklRatSxloAVplexfCK/kyFwY78XmlfMSmUjMZKt+6egrXdVkwSa5I4FXOYIyk0ljw9uXr1KmbPno20tDQEBQWha9euKFmypNV+YWFhAIBu3bpZfcdv279fOsueM8gxcXAxGoQLiFxrhYvRQB3I+e/Iz1I40rdY3A417eHAaU5jLaU1zzYJj6XFT11NKnpB/BMn3Q5bYuXkfkHe1xyBS5P2tMvi81j6W242StrCkAwyp12zbPp3MnFG7n9q2pWVYxLU5ZLsWxynWrNla1yGieNERbXNfSvbxMHFYICJ4wT3jYPwvorJyjFZ3Qc9FfAcx4HjrDO92fPq55g4yMmB/PNSOoeadz3bxGm6H3KHVJtun8fWxZiecdNiqIlXFH6TY+IEiyO5/uhoxH1dqgVZxLMiXe3J/iwe0w0Gg0BAkxf41beZh2YRyhuLhCdLp1gtaPdb7hmIx1+luYT8NtvEwZ145zmOg4nTPu5xnPU4LW6zo2LA5A5LtkGpTqvVfG6Q7/vkmM2fS8tdy84xwWigr88AdWNvVu4xyPMqPTt+bah0P+TOz4/dttS+FZ7D3N/E9TVNJk511lFbxifaPVLTP8V9hBwjDRAKqGq7uzNiI59JIW/FihWCxCleXl6YOnUqxo4dK9jv6lWzuw3NHTMgIAAlS5a07JMfPErNRNNpu9C9XhlB1q/zd5LQasYe7B/bUZSggsPiIzGYtT0KK4a1QtPKAVh2NAbfiNySSBwl5M3dfx2z91zF2vdbW6U53iKTwezawxQ0CN0h+b0406LBID0QdPlJKKBrGS9I6+Lha/FoW91aSUCu4xp9vVPyWLas9x4mZcDP0436XbWv/sPEXnUQl5whuB/X4/I0b6SFJD4lQ6CpH7PmDH58oxFO33wiiMGcd+AGfth5GT++0Qjfbr2ExpWL4/f+QpcVQJjdqt8869hSEyc9IZIpttUmXgGAGhO2IdDbHeGTuuJhUjo6/7QfrzaxToFt4jicu61shV1+LFZyAUjTHpJwnHAxZTAYMHTJKcnsi1ceJGPgwhMo5+9J1XjXmLDNapteySQ4jkPfuUeRkp6N/0a3F0yA3+2IkvydVLwlT7Wv/pP8buiSU9h96QHeblFJcVE6UeRWSyPyVoIgnpWH1n8eJKXLLgza6OAGLsV7i09Z/i2XpdheaFentBiqO3k7ShHZbJt8vdNi4ZPihx3WcWJ6cDLmieDzjbhUNK5U3Go/0ppMZuvt88cRPM3MwdaP2+NNUdxa4tMstJ5h/Yx/2WPtbmrLAjLbxGHr2Xvo1dCcN2Dy5vPYFHEHuz/rIBhPgsdtpf7+SVoWLt5NQt3yfgCAvw5cl3WFFa9Xz9+RH9vId6Lu5O349e0meKGBua0frYxAeMwT7BnTAd4erlaWR56M7Bx4uLrkHs88foSLQjL4UkE8S47aFn+kbCmXfkbTt+ata5SUsuJyPnsuPRDEbIuJjk9F3cnb8Xv/pkjLzMGYtWdUK4gS0jLR+OtdAIARHegupHIWYR5+Xvj3o3aWbUrzQotv9qhqo9S6j++38waE2K0A+uDv04i4mYBVhFvolH8uYP3p29j8YVtVrsS2CJq/7hXG4nIch1cUck0AQFXRnFbtq/9gMADuLkar7KlkRt6nErVOAecUiS807pp6UKpUKXz//fe4dOkSUlNTcefOHSxfvhwlSpTAF198gT///FOwf2Ki+UXz9/enHQ5+fn6WfaTIyMhAUlKS4E8vMrNNSHyahTWnblu56cUlZyDscpxg0fg0KwdT/72I9CyTJQZv0uYLVI0ij6M64cxtUUjLzFEV50cy72C0rPsbH2vBY4BBUwyYLQxfeoq6XfV5bTgnLakGyfStl/DngRuKCzUAWCaagPlYq89Eta6++e8SMrJN+GhFBO4mpkumMyahpbHWQ3FA65e8S82CQ9FITs+2xFoJfmfirPoIjYmbzktmg1MKws4xiSx5Bvn0+t9uvYS0zBxcj0uVTLUtRq2yXelWZ5s4hMc+weUHyVbuN3Luij9TkjSpZXducoyVJ245NOkjrZ/NPyhdp8vR2FvoXS007bDSgiwj2ySYK9SMG3MkEpfojZQwKeXaFXEzAVH3k3HzcRo1HpxUcPF2EL5UBomt49SHK05b/r30aCyS0rOxSBRTLMeUf/IUG9/+FyU7P2uNqSOVKtmmvLghwFwe4n5SuqVsxxKJWKtwQgjPzDFZCXh6skIhOYXaR6RVGLhwN0lRaMvINmHIklMYtTJCkwcAmfAnLcP+ouZ8nCCgve6eFEq3a9jSU3YLedvO38f9pHTLfMBz9naiQIkuB+0d1ar/TErPtrmkGcfRy2P8SChmdl+SnvudYcl7poS8evXq4fPPP0ft2rVRrFgxlC9fHv3798f27dvh7u6OKVOmwKSzG82MGTPg7+9v+atUyToRhaPgOOHgJjDsFxBzsr0mfzWoHYxsndSlrkHtYGPLPdbTwip1JEc9GtXZNeXcOjWnkDeTY1LvHOsqMWEqPS+OE7Zd6VLzwSPOQkGIuXUUtEsrytfLQ+tPzhhnHYWtrq1qhl+18Zn2wnHqK3JoqYvqyFT7UveGbF1heZ/yw+1YCkfWapOas7Sipu/rdUdpY5Paq6AlqNFc79PBXcNNpuyYM3rlM+muKaZ+/fpo2bIlDh48iGvXrqFmzZoA8ix4Uta6pKQkSSsfz/jx4/HZZ58JfuMsQU8cv0bGR6ntXHccHDB95lYCBuRmwLKXsMvWGpPt5+9hdBd12U8fp2YiOT0L/5y5ix71yiLQR7oYNwk/SB2/8QgpGdnoXKcMAOUJcPqWi/Bws03PEnEzAatP3kTrqtZuonqhJVZQS2KGE9GPZbVbPKmZ2ZIdVerevvzbYVmtXJef9uOJSle5OwnWAdo7L9xXvCsJT4UuRkrns2UxSSvkTWPnxfuoVspH8nvyGR+78RhVZfa1B9LFi+RuonW/0UuxdPl+EnZffICcXPfg10Mq6SJQf7GOnom4IHD7SRq1PM+J6Md2J+EiUROTLMWqE8rlWEjikjPw9/FY1Cnnp+l3K1Sc54VfDmJs91pW23/dc1VXyysHTrXVLdtkwo24FFWWUq0xpLRXKz0rB5uIjIx7oh7ilSYVJNtbkGqA7Yl6iH2XHyreh40Rd8BxHCpQsvCq5eBV+wqkrzl1C82CAgRJW3ZeVPaG4VEKEwCEZVvsgXzCJ6If47vtUZg3IES4j43d4O/jsahCZLT9h1IqqkHoTrzVvBJiHqUiK4fDpBfrIoqSVOZE9CNE3LLdkvzTzssOF7RcZApFa31/bYEJebnwiVfS0vJclPhYvKtXr6JZM2Hs0ZMnTxAfH482bejpknk8PDzg4aFOWNAbjhNqsGxJMnLXQZmISA5csW/w5BmUWwqB5G5iuqUWnBL/nLmLbJMJ/527j5UnbmLLKHXpbfn7+mZubcNj4zujrL+n4mQ4PzdlsZymR4qo+8mWFPz2QsvAePtJmqZYwW6i+EY5hkm4t4r5+t+LMlZG+jdKbhdqBTwA1BIBw5eFY9Tz1WV/9+POK3inVZDq86h10bQFpT5C3savNp5Dv5byZTJs5bd91/FZ15pW22lucn8e0Mel8v3lpwWft1+4j0YVi9t9XKkapwWBsWvP4uiNR9TvxDHI9iBVPkMN41S4S5Ncj0vFhI3KsZli/lLZj76nuIP+qLIkhGo0WPKyczg8/6O6Z6VlPAPo42bnH/cLlHT/nrmL8S/UljlG3r8LgoVsMGXep7FJZd1ZKd5dYJ8y+ot1Z622PUhSn3kx9B/l0BYt2X7lINeHfD3GJtN26XJs8bsslRF01cm8UkKv/HaYuk/ovxetN2pYTs3e63iXcznrqtoxyh6eKXdNKbKzs3H69GkYDAZUrpy3yOnQoQMAYOdO66QZ/DZ+n4KIiROm7Se1rwVgbHYaWrRbfJyZUgC7HHG5Ne7U3mMt7jmOgFYE/kFSuiaLilzpBlu5eC9JMk1zfiqTlVIwZ2SbCo0bk3jR5yj3bC2KnG0qi85rJeJmgu7HdESdMXuQEvD05rQD7mVRhoPjCz3bCs0LIy45Q7K95JhRkKx6RZ2dF9Rb/exFzWO1JSv4s4ice+6R6/GOP7/Dz5APxMfHIyoqCvHxwht49OhRq0VMdnY2xo4di9jYWHTv3h0lSuQV3+3cuTOqVq2KFStWIDIy0rI9OTkZ06ZNg6urKwYNGuTIS7Eb8mqF7prPzgtq60SkZcHLie4tx0nXxSto0ITMHJO6gs35dY35ubhQc+rCsvgRKyIc1Wy+QLyqVNUOvHWO6K8F5T13bjsKxjUXVMTPguM47bFCOsK3R0sXkVqc8u8xx3E2ZYbWQgF5tfIV/l67ujhvua5q/mLPRhVyYZLOsIQbuIIyQykwf/58HDpkziJ07tw5nD59Gm3btkX16mbXqVdeeQWvvPIKACA0NBRTp07FlClTEBoaajlGcHAwDAYD2rRpgwoVKiAhIQEHDhzA5cuXUblyZRw4cMCq4Pq+ffvQvXt3eHh44O2334afnx82bNiA6OhoTJ8+HRMmTNB0HXwcX6VP1sDoUcz2G6IDMTN7SaZytocto9rhxV8PKe/oJOqV97MUuNVCaV8PPExW505Rxs9Dk+tFUaJRRX+coWTR1INi7i7UbKotgkvgRIy1q19BYevH7dBrdsF5B6Q4G9oNDUPzPBVKeLtj3oBmaBZUQtexoVopbzzNzHGK+7ccfZtVxLpw/dwtG1Twx8PkdKwc1kq1i52jCPR2tyrazMgfqpXyxlc962DIEnWu6c5g+HNVsTHijsXTRIlOtUpJxv4aDc+WN9CzSMzMXrj2MEVXN+/8oE21QBy57hwPB62YMtJw6+c3kJiYCD8/bTHHaik0MXmHDh3CkiVLBNsOHz6Mw4fNvrrBwcEWIU+KkSNHYvv27QgLC0N8fDxcXV1RvXp1TJgwAWPGjEFAQIDVbzp16oRDhw5hypQpWLNmDTIzM1GvXj1MmzYN/fv31+36ihJj1hSsxAS2CHgAVAt4gDbf+qKGowQ8QFqTW9AtZX1U1N0pCHAiTfzj1EyMWBaOUxO76noeskZjfrLlrH1xOWL4elavzz2qsKfjYQJeweF6XGqBEvAA7fE/csmdmID3bDBJRZ3Sgk5BFfCcRaER8hYvXozFixer2jc0NFRgweP58ssv8eWXX2o+d4sWLbBtm3VBYgYdNW5+DIYapNyKC7qQ58hkKnpCu48FIZmCo3DUpUnVbGMwGIzCSlGeC54VimRMHkMdPX4+4JDj3pQposxg6AFL/KAPtKQ7T9KyEDJdn0xqBQ1Hpay2p6QAg8FgFEROxhbckAiGOpiQ9wwTdT9ZeScbYFpthl6kZ7G+5Ej+Pk6vJRafwlz/tODhZl0DkMFgMAozBdxhhqECJuQxGIwCixdbPDuUSxI1ihjakKuFxGAwGAxGfsCEPAaDUWB5mqV//T1GHjcfM9dqPdCSpInBYDAKOmmZ2fndBIYOMCGPwWAwnlEc5bLNYDAYjMJL3ck78rsJDB1gQh6DwWAwGAwGg8FgFCGYkMdgMBgMBoPBYDAYRQgm5DEYDAaDwWAwGAxGEYIJeQwGg8FgMBgMBoNRhGBCHoPBYDAYDAbDafh4uOZ3ExiMIg8T8hgMBoPBYDAYTsOF1ZZkMByOZiFv9OjRSExMdERbGAwGg8FgMBhFHI7j8rsJDEaRR7OQ9+uvv6JWrVpYtGiRI9rDYDAYDMYzQdvqgfndBAbD6RQv5pbfTWAwngk0C3khISF4+PAhhg4ditatWyM8PNwR7WIwGAWEeuX98rsJDEaRpHKJYvndBAaDwWAUUTQLeSdOnMCff/6JwMBAHD9+HC1btsSIESPw6NEjR7SPwWDkM40qFc/vJjAYRZKQoBL53QQGw+kkpGXldxMYjGcCmxKvDBs2DFeuXMHIkSNhMBgwf/581KxZE3/88YfD/KyXL1+OESNGICQkBB4eHjAYDFi8eLGmYxw6dAhjxoxBs2bNEBgYCE9PT9SuXRtffvklEhISqL8JDg6GwWCg/r3//vv2X1ghpUWw/OKEaagLP1VLeuOrnrXxcqPy+d0Uhk583LlGfjeBQdCnaYX8bgKD4XQqlfCCiYXkMRgOx+bsmsWLF8dvv/2GU6dOoU2bNnjy5Ak++ugjhISE4MiRI3q2EQAwceJE/PXXX4iNjUW5cuVsOkbfvn3xyy+/wNfXFwMGDMAHH3yAYsWK4bvvvrO4odLw9/fHlClTrP5efPFFey6pUOPrKZ/+2JVlzrIJf6+CE6uw9v3WGP5cNRiLwLMMcEAMyNcv19P9mI7m9WYVHX6O715r6PBzFBUMBse+Wzs/fc6hx2cwbKG8vxdymJTHKKT89EYjxMzsld/NUIXdhUoaNWqEgwcPYtmyZRg3bhwiIiLQvn17vPPOO/juu+9QpkwZPdqJ+fPno0aNGggKCsLMmTMxfvx4zcf49NNPMWDAAIGQyHEcPvzwQ/zxxx+YOnUqfvvtN6vfFS9eHKGhofY0v8hRs6wv9kTRhWIAYMO3bbSqWgI7LjzI72YAAIy5C9DCL+IBTxzgHuTnWXAEcrU4I215JWbFLzAUAf0MowhiNBiQw7JrMgopZf0987sJqtGtTt67776Ly5cv49NPP4WrqyuWL1+OWrVq4X//+x9ycnLsPn6XLl0QFBRk1zG+/PJLKyugwWDApEmTAAD79++36/hFge711Anl77YKwqddalK/8/Vw1c1t94fXG9n8WwcryR3CzD6Ot4KozejH3z9n3McPOlZz/ElUsmhwc1X7lS/uhfEv1HZwa/TFVgu7t7uL6n1bVwuEp1vBLsHqW0ALMdctJ0xyVK2Ut13Hc7SlEAD+6N9U1lI+pF0VTccb272WvU2iMuu1Bg45rr0U1L6oFlv6qIvRABOz5D2zvN2isuz3JX08nNQS22hZpfBkRdZ1Jvbx8cGPP/6I8PBw1K5dG0lJSfj8889Rv359jBkzBn///TcuXrxY4OqjuLmZJyhXV/pgm5GRgSVLluDbb7/FH3/8gTNnzuh6/rJ+BUcr8Hk3dROsm4sRo7sI43uWD2kJwLz4jXmUpkt7lGL/5JASQgsyAd7uDj9HUKC6STlvgej4hWJBiuEMVnl/TByHER0KjnCqBlsteVqtc5s+bGvTeXi+7FEbIzpUVbVv9IyeiJnZC62qqh8rBrYJtrFljmWcSGnwQn3bQhN4jISQ5yhFygsNymG0TKxnxQAvq21Srk7P1y6NDztVt7ktXepIKynfbC6/sMwvXmtWEdEzeuZ3M2zmt/5NVe1X0idvbjMaDci2U8gr41ewBQGGNEPaBct+/1oBj1V2hkeMXtilQnr69CkuX76MS5cuISoqyvL/q1evIjMzEwaDARzH4fLly7hy5Yrld15eXmjUqBEOHz5s9wXowcKFCwEA3bp1o35///59DBo0SLCtR48eWLZsGUqWLGn3+RtU9Mf9i+l2H0cP1MZf8bsFervjUWomQoICLBafp1n2W2557FFEF57XUB5fT1ckp2frdjy1Ohb+GTsinq0go3b8Loy1nmydnEwaFXM+TrRO8MqIYzceq/6N1utxBlVKeqOESMlDE5C04O2RZ4FVEtSbBQUgPPaJTecpX1y6nVreE3sVwNVKe2P3Jenva5XxxeUHyQgKLIZYnRSR9sJxnFMsro7CRWXbq5XyQXzK49zf2NffAKBBheJ4kOS40Ia65fxw8V6Sw47/LONdyK3XhQnNlryEhASMGDECVapUga+vL5o1a4Z33nkH06dPx7p163D+/HlkZGSA4ziULVsWnTp1wvDhw9G7d29UrFgRHMchLS0Nx44dc8T1aCYyMhJTp05F6dKl8cUXX1h9/9577yEsLAxxcXFISkrCsWPH8MILL2D79u146aWXFCeljIwMJCUlCf7EzOzTAI1VpqlXWqS1qRaI99pWwd4xHVQdT4xR5YDN77f2/dZ4r20V/Na/qUWoSs3IE0horjeDcrXoE3vVUT6PHRoTR86bS95roduxXm0i1Fr1JZJjTHu5npVVZNHg5mhcqThaBJfA0FxXKG1FldUtpPiFR9VSPoLtmz9siwrFvfBhp2pWi9KigJuL/LAY6O2O8S/URu2yhat+4Pd9G6oS8vo0qWDlQmbQqDKpGOBYy6yvpyum9K5rszu3WiPC930d7z496nmz5WrTh21Rv4I/2tcwKw5HdKgqGAtsobSvJ7rWLYNSvh54I6QS1o9sLbnv7xSLDGktGdhaOlyia90y+LhzDSwYGILpr9QXuGNVLelD/c0/H9lu7X2tKf2+DGwdLPj8apMKGNGhKtaMMF/3wsHN8V7bKhavE+FvbQ8HKabBndle3gyppGruBIDnapZStZ+cy+UvbzVGt7rSFlK5OYDvywDwVc+8NhsNBvzWrynea1sFnWoJ29hbJpuzOzE2z3qtgWpPnw86VsNPb+SNFbXK+Cr+Zv7AELzXVpurMQB83q0m3ghxfIIrPXB3db5b/UedqqOcvxfWvd8aDSr403cyAJNerOvchol4r20VfNKlBpoHB0jus/uzgp/YSvMTfu+99zB//nzExsbCZDLB3d0ddevWRZ8+ffDVV19h6dKlOHHiBBITE3Hnzh3s2bMHc+fOxaZNmxAbG4u4uDjs2LEDM2bMcMT1aCI6OhovvvgicnJysGrVKqpVbvLkyejQoQNKliwJX19ftGzZElu2bEG7du1w9OhR/Pfff7LnmDFjBvz9/S1/lSpVston0MdDtXuT0hqtQnEvTO5dF1VL+aBfS23uKa2rBqrWyvG7VS3lg8m966IM4XJKBlTTBtPQl+ohZmYvDG2v7I5lj1Xckcr6llVK4OAXnXQ5lngCJeNy3m0djGoiIatTrdLY9GFbrHm/NSa+WBcxM3vh9/7NZM9hi2WFvPd1iDY1qlQch8c9j7Hda+uWRbUg2VWUJr7ejcrr4qY5o09ejJCPh6tgEeIIggK9VVkMfnqzMc6GCr0anG1o4BR6hNFgwOC2VWwWguSOT2YOfj2kksOtkmO61ULMzF6WzLrLhrREzMxeGP9CHbgqKBzUMG9ACE5O6AIXowHNZOrylRGFDbzYsBy+6J7nPtqvpbQQZDAY8FnXmuhcpwzeaRWE/sTcYzQYqEJEw4rFNVyFkOmv1KfGfYoVNB6uRox/oQ5aVDFfNz8/0qyaU1+uj2HttS/qAeBHO2LHtXDp6x6Y1bchhravquqd/Ejk+tqmWiA1PGTPmI6Sgs/LjStg+HPSc7VYcdS0cnHLv8ljkhZdo9GAsv6emNy7LoJLCvuGXPzvwDZ5fTDQxwMTX1Qn7H7Rozb6NK2ImJm9EDOzF355u7Hib8rn9hUtuBgN+Oj5GnihgX1u1s7C2cnDYmb2wue5iv+Q4BL4ogc9PMgAg+ZYXltYP7KN5HeTe9fFJ11qYu370vtUL62sLMhvNM8ge/fuBQB88cUXuHz5MtLS0nDu3DmsXbsW06dPxzvvvIOQkBD4+tIvPjAwEF27dqVazZxJbGwsOnXqhLi4OKxbtw6dOqlfsBuNRgwePBgAFF1Ox48fj8TERMvfrVu3BN9rDVpWSjtcvXSeQKBVyKlfwU/1Yo66WMzdRBY6Ndq5RlFrWaRhr8+/HEaDQTchspSv/bEFWmQtKc26GNJ6I2WxtmehJjxXwUHJkqeXwBNIaMANsF5kOwK1Qrke7mNVS9qeNGTvJenMvYD9zyCohHTbmgWZNbe8cCepbS7iVC/tg8PX4y2facoPKYUIufA3GMyKIRpiV061Q6rU8xdvryozv+r5XP3sKH1TRcN7Ql6fmrnR6v5y1q7K/D2Sc2GWs9aJxwpSMUF64pDzSZ2y0otjuXup15wrJdzwClZbxy6+3xek+UyOJoRAnh9I9avgQOfE6BdFTyQxmpfg/v7+CAgIwMyZM1GjRo1C6UseExODjh074u7du1izZo1N9e54q19amrxfv4eHB/z8/AR/JEspbiNSrBzWStbNqG31QAxqG0xsUT8ijuxYDZ92ranaPZIu41lv1OLm9c2r9fG+yEJC/vq/j9urPhYgLxD3aWJfYK/RQLcGzB8Qgi971MZSCXfOER2qWtXCCwkugfEv1Ma8ASEA6E9NKespOeHTXNjI+yiXdIIszuzmovzsvuqpT3ZJPYaRFxvqoz1VegXk+rS7BsuLwN3TYNayk/RrWRl9mlTAttH0fj/tlfqqzwWYBXVPNxf88HojVYuYX95qrOn4ALDxgzyt59IhLawsAHXK+eGnNxopamnDbz6Rvc+0Be7xrzoDMAvP4nFEzBshFbFYIovqD683wogOVfHvqHYAIKltplGQis1/+yo9m+SmD9viw07VBNY2GgNaByPiZoLls3g8cHc1So7JYiFvSu+8mpKDiPFn92fCsALaIp7mLmUwqFvwD2oj3c/mDQiBl5vQaiS3npFyEQXM2QCbalww+3q44uPnq6N/K3k30fJEuvb/t3fn4VFUadvA7+rupLPvEBII2SAJJAHCDiEkQCAsIsioKCiLBBCFVxBQHEVghEEdh/FTR0GQxXEBXEfHV0FZBZWXVWEU2UJYZElYErbs9f0Ruqnuruot1eks9++6cl1Q3V19qvt01XlOnfMcafHsGXXTMsQHL0jW8xQhWrQhDNcq6ebkSNN2SlwTPzzUvSVaBHvjW7O1F6Xny/HpMSa/WmkRBeFO3XtMcofR/DrdItgbLwxLxniTtgzwz1EdVRvxERnkbXH+XPpQJ7wzrjMmZ8bh3QnOTccwdKLV9XZxn8QmGNsjukZrmk7JirdIdmUYem4womNzY8C2fbbljZTkyED0jA9FQrgfOrYMgp9eh2l9W+G+zpYj3lxBroOlT2ITi2ufresJAEQ7EJh+kGt/u7+mHA7y8vPzcfLkSRcUpXYYAryzZ89i3bp1GDZsmFP72bVrFwAgJiamRuVpbmXCurke8crzroJ9PPB+bnfodXcuWo70ej09MAk+njrFC4f5IspyjSy5l9oadiWVk9wMcwYlKf5YIgK9HFqA0to6PEtGdrB7P3I0giAbcGe3DceUrHj0TmhiHBpiENfEF88MaiM7XGZyZjz63x62KXfXzFaPk/QVslkGJd+NteGI0oafPUPF/J0c7mE+B1WNi+I4BzImWhsSVJOy/E8/+zMDas0azdL3DfPzxF/vScWSkR1MhspKPWyjcajk3k4tbKawBqqHacmVzZq0lnca5C2CfUzm4XSNCcHXT2RgRMcWiLKRUMTWHUe5h8MDqs8Pe+f2x0PdLY9PWu91Wg2yEpvK7jvMT49nBrUxNgAcqeNP9red0dfR5Dfmc5bsZbgjaa5DVBBm5yTBy8P6PDJPncakwW7egfHiiFSTkSNS0kPUCIJJx1ai5C5OmJ/e5jl9hExwJUCQvbKYf7LWznXNAr0ssplaY94JY+4BSfZO83O/nE4xwXhyQKLNkQPSu6DSjg97RsloBAEPS+YpVpndybu3UwvZ+bMPdLFsZC8cnoodT/dFa7NhndK2gPn8cvN2glzdK6+ssnivh3vEmJx/AGCAncs72Ut6/kxrGYSBKc0QEeiNZwa1cXpOcX25k7fs4c5YMCylRtm8nx6YZNJJ8ubojphplp19yf0dsHV2H5x8cQhaKrTrPpjYHRtnZOLTx9JxaEEOZg5IdGv2yjEydW/OoCSbcwRTJCMDbI3Q6xLrfNZ4Rzk1mM7Pz77hXu5SWFiIw4cPo7Cw0GS7NMBbu3Yt7rnnHqv7+fXXX3H16lWL7Tt27MCSJUug1+sxYsQINYvuNLkJ1s4MbVC6cJifrO39CYoi0K6FfcNi5Bbflh6CUjtTabiLK9fhEQQgwMvBuTq3i5Nq5+dh9o5WH5U2iv29PEw+c0c6EkJ95YeOdrt9UjJvNDl7Ljb/LtU4pTf1t3+4o7WhTrbK0jZSOeGKI2P0pR0q5u9Zk2HKSqTDgu3dvaFh302Ni5LkPWObWL+G6Gy0YDNaWw98/PWWgZmz5wO12xvtHfz9b/m9wKn3qWkV0gimHWXmnT6HzipnHpTW35qW498HzlpsEwTIDnmQdkbYMxLBfDhnkpVhhNaOQxAcz9iaFqWc0EGqlyR5ibQu2nMnz7yx3Dk6GL1a3dmftMjOZjbVmg3JlO4lSBLcK02fKKsw3W64npuXR4Blm0at4Zs1WapJytBxZOv8XZs3+uTqtFrnNGlHklrz8+sqR4bw2qqW9ua+UEO9yWO6YsUK7NixAwBw8OBB47atW7cCAIYPH47hw4cDAN544w0sWLAA8+bNw/z58437yMrKQn5+Prp3745ffvkFv/zyi8X7SJ+/fv16vPzyy+jXrx9iYmKg1+tx6NAhbNy4ERqNBkuXLkXLluqtvTOtbyu8vvmYU6+VG7rlTD1SGm5m3uaSvZMn8zqdVoMVYzuj66JNNt/bcI5w5E7Ko5nxGNczBt0XW+7f1py8L6am4+43qudU9moVhrzCG/hgYjdk/m2rzfcVBAGhfnr8c1RHPP7BPrvKaijNmB7R+HjvGQDya1fJXbhsfSReHlq8/XAnVIkiAr09sGJsZ6z54SQqqkSM6xmDAf/YblcZY8J88Y+R7S0WI316UBJaBPtY9KZK68GQdhH46pdzFvsc1iESO49dQuH1UuM2895r6X7+3wMd8MTaA3aVV0qppxCoHvL0R9GdZUqsDUtW+qxfezANl6+XWh3qm5McjheGJWPbkQJ8Z2NembQI5nXemSAvt1csjly8ju1HTIOCrrEheLBrlEmWVHt/Y98+2Rsb/3sBo7u3xOofTjpcJinpuaV36zD8ZVgy/i/vMqZkxePoheuYvu6A8XGdRlD8Hv48OMnmnchAHw+8NbojFn99GKcuVw+pt3Zn3xq1A+4xPWJwV7syqyMzlKwe3wXjVu222L5qfBeMN9vuSKnlAiKNIKCiUhrkmT7H8LnKkX5m5p+fta9Brgf/4Jki2f3bGiXyP31tD53t1SoMi+5JMTaEh3dojh+PX8JHt8/P5u+pRID9GVsNHs0yHcr8QW43vP39CWw1C+pHdW2JYB9PeGo1JoG2PXc7DE/ZPDMTmw9fxEPdo1FWWYUvfv7D4rnO/DyiQrxNfqc6rWDSwpWecyqrLO/YAUCF2XZDEGo+jFPuOzd/raO2zMrCpt8u4CE7R0UsuicFm3+7iLLKKvxypghFt8pNHv/L3dVDY82ryuTMOCzbdsL4f40gGM9HnloNZg5IwD1pzfHlL+fwwn9+NXlt/7bh+PZXy6Ui3hiVhvxLN/G3Db9bLfOaR7ri8/1nEeqnx6yPfr5dPnXOaRN7x+GVjdXLo7kiU+e/JnTFw+/8H4DqDor+bcMxODUCH+09g9c2HZV9zVMDE3GjtALZbcJxz5s/OP6mCh9NVmITvDA8xWIos5HZ7yfIx8MkP4WURiNg5bjOKLx8FSNfdbyIjqg3Qd6OHTuwZs0ak207d+40Jj6JiYkxBnlK8vPzAQA//fST4hIO0iCvT58++O2337Bv3z5s27YNJSUlCA8Px8iRIzFjxgx07apeGn2gZgtCy00kduZ3rDREz/ykIDsnT2ajh0ZAU38vu9YlMrze5E6ejQuP+XCbMD9PFF4vA2B6kXj9wTRM+3C/yXOlSUN6xIfiPSfGSQ9pF4F3fwzBrjzba3QZeialjQW5YZhyPcL2dJINSG5m/HdTfy/MlmTGc6Qq3JNmOTzKx1OHiTIZ1qTHMrl3nGyQ175FEP7fA2mImfOV5HXVx375RvV3Ja06rliawLxuyg0RulM2+U8rOTLAItMpUH1xK6uoMr7Pwz1iUFxSYRLkGdbnUiqT+Vs60yk6sXccmvrrEfuMacbfzIQmFt+pUq+9+VDi6FBf2e/dGdIgQRAEjOkRgzG3h5IlhvubBHlarXJio0m97ctsOig1ArtPXsHKnXkA1M+2q9SpYYtWI+ARJzPHKQ0x7aOw3RppFZPrEBME00a0h1lPn7XrizQAMa/L1oIzucBFqUNRtjNM8m9vO5Y1EAQBoyVZQzUaAX+7rz2aBXpZdLjaup46cicvromvydQKAOjZKgw9W4WZnCcNZRwsk63RnuH00mVwDAGX0jBdZ34eLUN8TL4fncY0ELPnPGZ+LjaU2bw8cvMwze8COio2zNeuLN8Go7tFG+tL/yXbLII8Q9IY88N+ZlAbkyBP+niIr6cxW/P9nVuYBHkLh6fg8Hn5O+Z3tYvE4fPFNoO88AAvTM6Mx6bf7gSKSt9Ll5hg7D5p/9qF0jrsyHx0e0mTIwVLPqcJ6bGKQd5jWfZPmZCjVGUFQbB/ioQIlFdY74DomxSO4uKarYNqj9pfJMNJq1evhiiKin/S4Gz+/PkW2wBYfb3hTyozMxPr1q3D0aNHUVxcjLKyMpw+fRoffvih6gGeO0lThnsp9MZoBCC7zZ2GhHyQZ7nNPD2yNcYTj2Q/Ad6SslmZQ2KY4yWdHH/26i0H3tv5ni1DcNVUIUtmQnj1xdWw/o80i6JcYCyd12SQHm+5vIcj/nR7TqXSPB2nSe9G2QglzdPdS4d3JEfeOZmrkW3UnHkHys2ySof3EeJj//yFzmafs1zDVvrVG4IdQy/hcCcSAwmQr09y3/m/D1j25CuV017SpD1ShsQZcg1VA/PGfXSID7rJzS11kPR4Rt6ezG/v2mG2ZJrtJ9jORb+/PuRYYOjsMChbv6PucXfuJI6USXSgEQSkS4b2md/JUzrfAeZ3yu0vv9yxDkxpZrFNaXikdIu9a8/K6SwzfK+twtxYA0eHa9aUGneYpb8Pk/aPA/uWDj1r6u+FnNvXw4hAL5MyKvWrZSXId1CYD6+WO7dFhdxpJPdLkt+PtSG49lCalnFXO8v1/OwdjWSSQEdS583vhqU2D7TaOSVdk9gRSuWzdQ23NvXGkbaevaTlMTmjqBC5qHUdkDIsGXJXuwiUu3C6kCPqzZ28xkDux5wQ7ofn70pGZJAz6dUtf7AfP9oDJwpv4EZpBVqG+ODs1VsmF1Gl3kGNIGB2TpLx7oR8Jk1Lkbfng9kztMTwHOmFwcdTh38/ng6NIFgN8taM74ofT1xCn6QmWLa9usfseonpCTCjdRi+P1oo93LY0wm1YkxnXL5Zhh5xpsOsxvWMQVSwNzoqBFDrJ/fArrzLxt52W42vrrEhePeRrogJvXPSHJjSDCvHdVZMwmHL0wOT0C021KkhYtaYDjmUf45h+1/vSTUOU/XQakyGbCY288cHud3QLNCrRmmNv5megTU/5GNX3iWcKLgBAFg3qTvW7Tmt+BpDEGLowVQ6DqVJ6nJP7xYXijWPdMXYldVDTeQaZBpBwHsTuuH7YwWYfjsr4/u53fDTicvoq9BgaRbghey2TXFvJ8tGufkQ2Ffua49gHw/Z+XRnrli/q+6o+Ca+WDRcPpvj6w92xIHTV5DdRjlxgnmjo2mAF7ISmmDV+C5o3dQPvV7aUuMyLhiWjD5JTdDLxnw+e93bsQXatQhE0c1yFJdUoH2UfXPtzkmGDdujfVQQ9ubb37vu46nF4hGpCLLRKdGvTVO8/mAaCq6VGtdUlQ6P0ggChraPxKf7qufEmQdgoX7K5zFpr7551bfWaJW7/oztGWMxfFIQ5BOvVIkits/ug5OXbsgGavbq3TrMYghs63B//GNkexReK8Oobi2x9fcCk6H6Ds35VKH9pxT8G4af+ng61rxztkgajYD/TOuFssoqBPp4YFzPGLQM8UHH6GAcOntnqK1Stut7O7XAU59YTp2Re7p5R3yLYB+seaQrfjl9FeN7xSJl3gbjY9/O6I3jBTdqPJ/4iewEiyGUAPBYn3gkRfhj8r/2GrcZRyPZaO4Ikkml0s4T6Z2xoe0j0T4qyOTa9cHEbjh87poxSdutMvnIuW1EAH49Z3oH0J64XW4q9NdPZOB6aQW+/fUCnuyfgF/OFJkszbFhem8U3So3tvXsGbXlDJN5vgrPsWdx8v5tw9EpOtg4RHfjjN64erMc9y/7sXrfNeg8WTe5u7Gt9/qWOyMBlj7UEY++V32usJXASW0M8uoQuZ7AKtF04rWUViNYXSZArq52jglx6uJXXlll0svk6O/Ant5oucQrgPIaS1KBPh4WPb4mvZQAIgOVb43b0yua3Va+karVCCZDJc0F+XgaezfNKb2reS+TIAjom+R8djEvD61sj3hNOZJgwSS7oUawmAfUU3LXoF2LQPwiMxfHlqRmAVg8IhUjl/1oDPK6xYVi3W7lIM/LQ4uM1mF3gjyZb8XaUBSl45be6ZEfhlb925b+voN8PK1+T1WiiIUKwZSHWS9wXBNfdJS5K1y9H/n9O3szIrtNuOLwuGaBXhgY6NjyFqJYXeedGYaopPo3oN4ixRqN4NTQYkc/Y3sSiEhN69vaIjucHOF2ECclHfavEUwb1eaNH2vJA6S/dfPgx9rhe8j8TpTqldznWCWKaBnqY3V+rj2U6p502PMgye9UEIDK2o3xFDtO2zUPciq5lzO/fcNrpJkFdVqN8XoorTNKdzqV5kfbulNrkJnQxOKuOlAdlJtnAnWGp8Lvz0OrUbyu2yI9ZKW2UbpMMNAzPgw9JaN6lKYdyM2Ps2c5K/N2UKumfsaO5S63241dzYLmRLM7pY52LtjLdAi4/LHYk/isX1JTPCCZ051gVkecDfFEiCZtPWn1lV53rI2AcIV6M1yzITJfU0l6LRzeofriO7WP8vhiW5XRfNmDmvh47xlESNbrkbvAW2vkT7s9Cf5us0aFdIiT4fVq5TmQfp4aASi3MknbXSl7azPLlpQjC/BaIy2/AMHqWlLAncBnfHospmdXp5s3T7sN3FmXZqDZRXRA23DMGmA7Tf3kzOp5FoYhotaGUmk1gumwEJnvxNowxjkDq+c+julhOV5/yO21+x6X+R07soakIdGIeYp+6VIQ5mt+KaW3B5zPpCcl/a7Ng4WakvssAetLX8hRYwSduwfdmGcazbq9pIJh+ODsHPvX8XOEIAgWQ+z89XcacEPaKTdw9ZJGZpmV+a8GhuyGD8qs3afUwfLckOrlOUyGgdfilyU9TzQP8jEOF5RmM356oPwSDWr8/mbYsVyHEsNwcumyD44M1TaMNHgkPdbq89pJgj9Hh/PJzRO19bE9c3uOvvn6nDVhmAcbHlCzxrn0nPb0wCTjdU9pbU3DoVqrK0rDJw1re0qHGCu1NaTrMDqbRV3KkExuiArr1krrpHQKQ03aTUoBoqEzTToPsCHgnTw3+eaJDLSJNr0zI22ILrm/A2YOSESUlWQstiq63NwuZ5VXVi+kvH9uf2i1gkLvm3KBhraPRIeoIIt0/v8c3RGjllevOWj48dm6qzauZ4xdmf6kJ0dfT53V8evuXJfFHb6ZnoElG48Yh7aundTd2FPnCJMseprqoRCf7LPMTGfwztjOuHCt1FgPOkUHyy7xMDg1Ajue7oOIQG/E//lOIpG3HuoEjQBjRi8lfZPCsX12H+MwZ2ttA3subNYaF+PSY9GvTThayKz99toDaXjmdmZSCw5UuUXDU/BYVrzF+UDvocWN2/MLDXX40IIclJZXyiZjssXeZt73T/VBVIgP/qdfK2g1gtPrSsmZnZNocSf7xF8HY1feZfk1IBs489PhO2O74HxxCSIDvXDmyi2Leqdmx5H5SJFdz/bDlZvl0AoCmgUqTyGQBmbl5re4ZH5M70/shoJrpcYhX1JKxzOhVyxykpshwMvDOAy8NqfBCIKAg/MHoKJShLenFjFhvtj1534mawI+mhmH7nEhzmX5A/DV//RSfOzeTi3QLTYEGS+bDmW25/v/cFJ3i8/bZEqejdcvH9MZ54tLbC7PE+zriW2zs6DVCPDTO9bclEtcYSsQndQ7DoNTI2TPxc6KCvHB//25nzGpihLpQuBybZgFdydj4u0kL1EhPqiqEvFk/wTFNp7h+7CWXMZ8yPTB+QNQXikixNcTPz7T12RJJKXOks2zspA09xsAlu0gZ+Z9Dm0fibSWQVZHTtlLWielAa29HaRz72prOdRW4aUHnh+AW+WVNVo70B6uWB7JGgZ5btIixMdq2nSNRrAa4LmLtR+ArbordzxyqbZtjYn2t3N9Oul+fDy1VhvqaqUUdpS7gku9ToumkgQw3eOcGycu/dg0gnzae+kmnVZj0jCwVsfNA4cm/nqHPi/pkC1r666Z71KuLthqOyodh7UAyJEqp3Q+kNuFn15ns0FlbQkJexjKEh2q/mR7uYajRiM4NZ/U0aGOcuT2UJPfbU3LpNUIxs9I7WuERYeHWVF9PHV2DceS1i/zQFE2C7NWIxvgyZVJup+oEB9cl3Te1SRxkDP8zTpSws2y0xrK6CzzDJzm5PZtz01Cuc/bkZuL0jpoi7PnCKXpK9bU9PNW0jTAdk4EabtELp4yL5utNp7hJ+RI0kppfYwwC7L0HvI7kuY6MB866myzSK1OP9ORQvLbrZEbtqo0PNZXr4Ovgx0RUnb/fmq5ycfhmnXI8LRIJIb7I9fO9Nr29GZIe5fqImkDwJiZysZrHkmPRVwTXzyhMMzBoLdkrpOXhxbPDG6DqBBvvDAs2eK5tbk4JQBMzIhFQrifzeGNdZ35ZGhX9FK9Nbojmgd54+2HO8k+3jzIG6vGdbG6j5kDEhCtME/HsrPFuXLasvT2XUjj+6qwT2c/bvPsn3XBuJ4xaBMRoOrc0Ucz4xEb5mvXEF8l0aE+SG8VihzJGpE1OV9Ms2P9Nqna7IBqGxmArjEhxmH1WYlNkNI8AKNlhlHaMiKtOTq2DDJmuZyYEYvEcH/FLKxSH+R2Q/Mgb6we38VmHff11KJ/23BktA6zWAKkLpBr/NnbHrRnAeYRac1NhpipEei6axqBVGai5Ty7Wk5g6hCltSGXKVy3lEzoFYukZv7GebXTs6uvXc8ObiP7/Pdv/1bWPGI943uHqGB0jg7GsA7KQ+tr2vmntkBvD/RNaorMhCYmCevsrZ8j0pojMdwfk3rHGa8v1rI81wbeyWvEfDx12DDDdnYgIzvqyswBifjt3DV8J1kjxVWcqbrS+RqGxoyVmy4Aqu8mbp6ZZXPf0l4crUZAbJgvvn+qr+xz5XrLRndrifd3nbL5Ps54dkhbPDvEJbu2mxrzQkx71xyZZWa/QakRGKRwYn6waxQWj2hncx+RQd7YNruPxRpUgGHpAcn/5e7kqfBZDUxphh1P90XPFzfXeF93OPeJKy1c685G1Py7LTtfairUT48ts7JqtA9BEPB+bncAMNafmtzJM7/bY/P9nX4nx2k1AtY/2sP4f71Oi/9My3BqX0tGdjD5vyPnvJ6twrBzTvW5+lyR9aVwBEHA8jGdnSmi29jzO3t2cBu7Gt1LRnZARWUVWj37NQDnh6xKz3F1IZiSv4tZBwqmQFAI8uSSwlgz9662Jv83XLuUpEt+K9ZoNQI+ntLT6nPMRxnUdkBiThAErJTpwLW3peGrd7BNXQtq+xPlnbx6zN7KUlu/0wvFjqUGB2Ayf8FArROL9EQg9z5ScsMx3H2CczXz4RzOkH5GfnodQv0sh/M62qh1hNrHoKRdi6Aavw9gmhzF2hBSe6U0V3/h+MbE3iFn5qxlCzb0OCutq+ZofNjAT0N1miHZRk3WWpP7/tpE2N6fI3fktFaGx9qrbeSd+urKc7YzDAl/WoaoPzxcLdIEJvZkgqyL4sJMk3WpcIlyCek5tPXtBGN6hY7L2mLeMWIYVWB+7uCdPFKdQ+v3AFg8IhXPfHoQG2f0xoB/bLf7dScKbzhaNKRFBWF6dmuTbI9qDk9aPCIV10sqFMe+vzW6I349V4wsmd62OjZyQXWDUpphSla8Ypp9e2g0AhaPSMWN0go0C/RCs0AvPNm/enjJW1uP4/KNMuOaPmpaP7kHvjl0HrkZ9g1tNlgxpjP25F9BfBNfzP64em0ma9XN11OLvm3C8efB8lnyHBXs64l5Q9tCp9UopoZ3xN/ubY83Nh+VzUpojXJPaN3tKXeF93O7YeXOPPx+/hp25V22+3Xmy1VIrZ/cA6t25mFyZjwuFJfg8/1n8e6P+cbHHT2/OXoaauCnLSy5v32tvde6ST2wcmdejbI1Sht/7+d2w8b/nlfMqOgsaZ1ydtTBi39qh9c3HcUDXVsiqZk/Hu8Tj9TmQSqV0DlT+7TCG1uOYdOsTADA+PQYFF4vVVz43B3efrgTDpy+arKcgulcdTcUykEfTOyGTb9dxIResXhDsr6ba8bm1JxOq8Gie1JQUl6Foe0i8MaWY8Z17+qKDyd1N14HpGo7cGaQV4/Z21YodzDIe7BrSzzYtSUqJEMp7TlRVTiyUNBtgiAYU+kbtzm8F3kiRGPqeSXWhgK6KxlLbdFoBMUU344w/4wNDRh71upyVtfYEIv1euyR3TYc2W3DsfG/5+16/nu53VTNUgtULx+hlib+eiwYllKjfUiHJdeFYVq1KSbMF38ZloIn1x1w6HXWkqfE3t4nUH2nsGPLYLMgz7EyNvTzkCMe6BKFEbU4jzlG8l2qoW1EANJbya97a87Z36KzwzXD/EzPJbNz1OnYqolZOYmYJVkixMtDazGc0d0GJDezWCdXaX5eXWVYf6+kvNJke10OUEd3uxPUqfkbVUuswrmjts/ndfRmLCm5v3P1Be6R9FhM6l3dQzDIRqKCEbfXF0mOdGxol3TIgT0ZsjrHqNMYrumJxfAbki4a6ojQ2xlEBySrfweK6gZpO0gUletKjAuyR9Y1zi7o25BYW0dRTk2G2jp6ejOsp9XayrqHDVmwz50h4J/tP+vGkjgnwPtOX7o92fsM1117g0Fzaq2BSs5rLlnCoa4lM7HGPP4Y2cXxhEuNjSE50t1WEtoAdxZBN1/719V4J6+eWXRPKkZ2aYn2LQIhCAKyEpvYDN6GdYhETJivw40EaY9DmMxcK3Otmzo/b0Gqpj1f+57rj3NFJSZzDByxeVYWTl++iZQGtigmyRMhom1kAL5+IsM4F+XHZ/riVpnr18xxG8lPTLomXSO7kWfk6HHrVFiawV53tYtAyxAfq4vbN2TSFO+lMmun1XV6nRbfP1WdOEMp4ZHUnmeznbp+7fpzP1wrqTDJQlhfCELDGkUQ4OWBrbOyrA7rroukba+/39ferky4jd0X03rhRMF1m4uofzczE/mFN5GqsIC9qzDIq2c8tBp0kqQ/t2c+lSAIxjTWzrJnbLZaHVY1DfKCfT1r1DgP9PZA4O0frIdWsFzMlxoUQ+OijSRRhhoJXeoja2tQenloUFJe/xrZ9vBxcH5kbS65IggC2jtw/nZ3AgJXqq/H5sjabc5ev8IDvBBeT/Mw+XhocaOs0vYT65GYenhHVdr26tAyiEPF7eCn19mVmC3Ay6PWAzyAQR7ZyZ5MX6qNPa9D55Xq4JZBXkPWGL9d85/YO2M745WNR6wmtfhwYnc88+lBPF/H5sSoYUb/BBw6W2xzDq9BTZZQcJVZAxKw5feCBjnEKsxPj8LrpfjuyUx3F4VcwNl5hKQurUbAyM5RKLpVbtcajc4SRREVFRWorGxYgb05rVYLnU7n1mCZQR6pRq2x53Wq/VSXykKqkQ4NUmMNvPrG/Ij7tQlHvzbW56CmtQzGN9Pr1ppDamnq74Uvp/Wy+/l1Mcib2rc1pjq40Hp9see5bHcXgVyoshGeg+uql+61ve5sTZSVleHcuXO4efOmS9+nrvDx8UFERAQ8Pd0z9YNBHlkV4uuJyzfK0MeOlMVqtXv6JjXFTycuWx06VluGd4jE+j1nkNYyyN1FIRXFN7nTS9k3iQl2yD6RgV74o6gEA2qwLAiHQBGZMlxnO0fbnn5C9VdVVRXy8vKg1WoRGRkJT0/PBns+FEURZWVlKCgoQF5eHlq3bg2NGxYedH8r2k7vvfcevv/+e+zduxcHDx5EWVkZVq1ahXHjxjm0n6qqKrz55pt4++23cfToUfj5+aFPnz5YtGgRWreW7wXdvXs35s2bhx9//BFlZWVITk7G9OnTMWrUKBWOrG77+okM/HTiEgYrLDMgpdZwzfHpsQgP8EK32FBV9lcT8+9ORo/4UPRJrDvr8lDNtQ73x8LhKTh9+Sbu61x7KdnrioZ5WXW9z6em48fjlzAoxfb5UMqw3hcRWeJ1tnEoKytDVVUVoqKi4ONj/zzV+srb2xseHh7Iz89HWVkZvLy8ar0M9SbIe+6555Cfn4+wsDBEREQgPz/f9otkPProo1i+fDnatm2LadOm4cKFC1i3bh02btyIH374AW3bms432bp1K3JycuDp6YkHHngAgYGB+PTTTzF69GicPHkSf/7zn9U4vDorPMDL7vXO1AryPLQal66x5ggfTx3uSWt8QUBjUNcWT61N0oyFZL+m/vafD6VCJdmJGWATmeJ1tnFxxx0td3H3sdabT3rFihU4efIkCgoK8Oijjzq1jy1btmD58uXIyMjAvn378PLLL2PNmjX46quvUFxcjClTppg8v6KiArm5uRAEAdu3b8fy5cvxyiuv4Oeff0ZycjLmzZuHo0ePqnF4DUIj+t0S1WuzcxLRuqkf5g9teElU6iJdHZzDR0REDVu9aZZnZ2cjOrpmPe/Lly8HACxcuBB6/Z21ZPr164ecnBxs374dR44cMW7fvHkzjh8/jlGjRiEtLc243d/fH3PnzkVFRQVWrVpVozI1JKpl1yQilwoP8MK3T2ZiXHqsu4vSKEjXR+NpkoiIakO9CfLUsHXrVvj6+iI9Pd3isZycHADAtm3bTJ4PAAMGDLB4vmGb9PmNHYM8IiJLaZL1TGuyhicREZG96s2cvJq6ceMGzp07h5SUFGi1lvNRDElXpMMvDf+WS8gSHByMsLAwm8M1S0tLUVpaavx/cXGxU+WvD8xHJE3PbpjpvImIHJFwO9FPsI8nArw83F0cIiJqBBrNnbyioiIAQGCg/IrzAQEBJs+z9zXS58tZvHgxAgMDjX9RUVEOl72+ME+Fy8YMEVG1h7pHY0g7x7JyEhGR+yUkJKBHjx64deuWcZsoiujevTueeuopN5bMukZzJ89dnnnmGTz55JPG/xcXFzfoQE+Ky5sSERERkTlRFHGrvNIt7+3toXVojb5169ahR48e2LlzJ7KzswEA77//PvLy8rBx40ZXFbPGGk2QZ7gbp3TnzTCMUnrXzp7XKN3lM9Dr9SZJXoiIiIiIGrNb5ZVo+/wGt7z3r3/JgY+n/SFQWloa2rdvj8OHDyM7Oxs3b97EM888gxdeeME4ErAuajTDNX19fREREYG8vDxUVlr2HMjNv5Obp2dw5coVFBYWKi6gTkRERERE9V9CQgJ+//13AMDLL7+MkJAQTJgwwc2lsq7R3MkDgMzMTKxduxY7d+5E7969TR7bsGGD8TnS5y9evBgbN27EAw88YPJ8w+1Z6fPJFNeGIiIiIiJz3h5a/PqXHLe9t6MSExOxfft2nDlzBn/729/w5ZdfyiZyrEsa5J28wsJCHD58GIWFhSbbJ02aBAB47rnnUFZWZty+adMmbNiwAb1790ZCQoJxe79+/RAXF4cPPvgABw4cMG6/du0aXnjhBeh0OowbN86lx1KfaRjkEREREZEZQRDg46lzy58j8/EMDHfy5syZg/79+6Nv374u+FTUVW/u5K1YsQI7duwAABw8eNC4zbCW3fDhwzF8+HAAwBtvvIEFCxZg3rx5mD9/vnEfffr0QW5uLlasWIG0tDQMGTIEFy5cwLp16xAQEIC33nrL5D11Oh1WrFiBnJwcZGRk4MEHH0RAQAA+/fRT5OXlYeHChSZBIZnSct08IiIiIqrnEhIScPr0aXz88cc4dOiQu4tjl3oT5O3YsQNr1qwx2bZz507s3LkTABATE2MM8qxZtmwZ2rVrh2XLluG1116Dn58fhg4dikWLFskGbH369MGOHTswb948rF+/HmVlZUhOTsYLL7yA0aNHq3JsDVVTfyacISIiIqL6zRAjTJ06Fa1atXJzaewjiKLITPe1yJCRs6ioqE5n5HFWzJyvjP/OWzzYqVviRERERNRwlJSUIC8vD7GxsfDy8nJ3cRx2+fJlhIaG4ueff0a7du3seo21Y66NeKBBzskj9xvVrSUDPCIiIiKq937++Wd4enqiTZs27i6K3RjkkUvw/jARERERNQQ///wz2rZtCw8PD3cXxW4M8oiIiIiIiBRMnz4d+/fvd3cxHMIgj1yCUz2JiIiIiNyDQR65RGUVgzwiIiIiIndgkEcuUck7eUREREREbsEgj1yCMR4RERERkXswyCOX4HBNIiIiIpJqTDkb3H2sDPLIJRjkEREREREA49IDN2/edHNJao/hWN217ILOLe9KDV5VI+qpISIiIiJlWq0WQUFBuHjxIgDAx8cHgiC4uVSuIYoibt68iYsXLyIoKAhardYt5WCQRy7BO3lEREREZNCsWTMAMAZ6DV1QUJDxmN2BQR6pKibUBycv3cSQdhHuLgoRERER1RGCICAiIgJNmzZFeXm5u4vjUh4eHm67g2fAII9U9cW0Xjhy/ho6RQe7uyhEREREVMdotVq3B0CNAYM8UlWAlwc6x4S4uxhERERERI0Ws2sSERERERE1IAzyiIiIiIiIGhAO16xlhoURi4uL3VwSIiIiIiKqbYY4wJULpjPIq2WXLl0CAERFRbm5JERERERE5C6XLl1CYGCgS/bNIK+WhYRUJyU5deqUy75UouLiYkRFReH06dMICAhwd3GogWI9o9rCuka1gfWMaktRURFatmxpjAtcgUFeLdNoqqdBBgYG8gRCLhcQEMB6Ri7Heka1hXWNagPrGdUWQ1zgkn27bM9ERERERERU6xjkERERERERNSAM8mqZXq/HvHnzoNfr3V0UasBYz6g2sJ5RbWFdo9rAeka1pTbqmiC6MncnERERERER1SreySMiIiIiImpAGOQRERERERE1IAzyiIiIiIiIGhAGeTW0e/duDB48GMHBwfD19UXXrl3xwQcfOLSPqqoqvPHGG2jXrh28vb3RpEkT3H///Th69KiLSk31UU3r2o4dOzBz5kx06tQJoaGh8PLyQlJSEp5++mlcvXrVdQWnekWNc5pUeXk5OnToAEEQkJSUpGJJqb5Tq65du3YN8+bNQ0pKCnx8fBAUFISOHTtiwYIFLig11Tdq1LOrV6/i+eefR7t27eDv74+wsDB06dIFb7zxBkpKSlxUcqov3nvvPUyePBmdO3eGXq+HIAhYvXq1w/tRPR4QyWlbtmwRPT09RT8/PzE3N1ecOXOmGBsbKwIQFy1aZPd+Jk6cKAIQ27ZtK86ePVscM2aMqNfrxcDAQPG///2vC4+A6gs16lp4eLio1WrFzMxMcfr06eKMGTPEtLQ0EYAYHx8vXrhwwcVHQXWdWuc0qblz54q+vr4iADExMVHlElN9pVZdy8/PF+Pj40VBEMT+/fuLTz31lPjEE0+IQ4YMEVNTU114BFQfqFHPrly5IsbFxYkAxF69eokzZ84Up06dKsbHx4sAxL59+4qVlZUuPhKqy6Kjo0UAYlhYmPHfq1atcng/ascDDPKcVF5eLsbHx4t6vV7ct2+fcXtxcbGYnJws6nQ68ciRIzb3s3nzZhGAmJGRIZaUlBi3f/fdd6IgCGLv3r1dUn6qP9Sqay+++KL4xx9/mGyrqqoSp0yZIgIQH3vsMdXLTvWHWvVMau/evaJOpxNfe+01BnlkpFZdq6ioELt06SJ6e3uLmzdvln0farzUqmcvvfSSCECcMWOGyfbS0lKxS5cuIgBx27Ztqpef6o9vv/1WPHnypCiKorh48WKngjxXxAMcrumkzZs34/jx4xg1ahTS0tKM2/39/TF37lxUVFRg1apVNvezfPlyAMDChQtN1sro168fcnJysH37dhw5ckT9A6B6Q6269vTTTyMiIsJkmyAImDt3LgBg27Zt6hac6hW16plBWVkZxo0bh+7du2Pq1KmuKDLVU2rVtY8//hi7d+/GrFmz0KdPH4vHdTqdquWm+kWtenbixAkAwODBg022e3p6on///gCAixcvqlhyqm+ys7MRHR1do324Ih5gkOekrVu3AgAGDBhg8Zhhmz2N5q1bt8LX1xfp6ekWj+Xk5Ni9H2q41KprSjw8PACwQdTYqV3P5s+fj6NHj+Kdd96BIAiqlJEaBrXq2rp16wAA9913H06fPo2lS5fixRdfxEcffYTr16+rV2Cql9SqZ8nJyQCAb775xmR7eXk5vvvuO3h7e6NHjx41LC01dq6IB9iqc5JhEmTr1q0tHgsODkZYWJjNiZI3btzAuXPnkJKSAq1Wa/G4Yd9MwNK4qVHXrFm5ciUA+QshNR5q1rPdu3fj5Zdfxl//+lckJCSoWk6q/9Sqa3v27AFQnVRqxowZKC0tNT7WpEkTrF+/HllZWeoUmuodtepZbm4u/vWvf+Hvf/879uzZgy5duqC0tBTffPMNrly5gg8++ADNmzdXvfzUeLgqHuCdPCcVFRUBAAIDA2UfDwgIMD6nJvuQPo8aJzXqmpIDBw5gwYIFaNq0KZ566imny0j1n1r1rLS0FOPGjUNaWhpmzpypahmpYVCrrhmGyE2bNg3Tp0/H6dOnUVBQgNdeew1FRUUYPnw4zp07p17BqV5Rq555e3tj69ateOihh7Bt2za88soreP31141DQXv16qVquanxcVU8wCCPqJHKy8vDXXfdhcrKSqxduxZhYWHuLhI1AHPnzsXRo0excuVK2R5JIrVUVVUBAO666y68+OKLaNGiBcLCwjBt2jTMmDEDRUVFeOedd9xcSqrvCgsL0b9/f/z000/46quvcPXqVZw/fx5Lly7FqlWr0K1bN1y5csXdxSSywCDPSYZoWymqLi4uVozIHdmH9HnUOKlR18zl5+ejT58+KCgowMcffyybtIAaFzXq2b59+7BkyRI8++yzSE1NVb2M1DCodU4zPOfuu++2eGzo0KEA7gzppMZHrXr25JNP4ocffsAnn3yCwYMHIzAwEOHh4Zg4cSJefvllnDhxAq+++qqaRadGxlXxAIM8J1kbH3vlyhUUFhbKjgOX8vX1RUREBPLy8lBZWWnxuLXx5NR4qFHXpE6ePImsrCz88ccfWL9+Pe666y7Vykr1lxr17JdffkFlZSXmz58PQRBM/gDg999/hyAICAoKUr38VH+odU5LTEwEANn6ZNh269Yt5wtK9Zpa9eyrr75CSEgI2rVrZ/FY3759AQB79+6tYWmpMXNVPMAgz0mZmZkAgI0bN1o8ZthmeI6t/dy4cQM7d+60eGzDhg1274caLrXqGnAnwDt79izWrVuHYcOGqVdQqtfUqGcJCQmYMGGC7B9Q3Qs5YcIEjBkzRuXSU32i1jnN0MD+9ddfLR4zbIuJiXG2mFTPqVXPysrKUFxcjLKyMovHCgoKAMAk5T2RM1wSDzi8sh6Joli9yGZcXJyo1+vF/fv3G7dLF9n8/fffjdsLCgrE3377TSwoKDDZj3Txw9LSUuN2LoZOBmrVtby8PDE6OlrU6XTiJ598UlvFp3pCrXqmBFwMnW5Tq66dOHFC1Ov1YtOmTcUzZ86Y7KdDhw4iAPG7775z+fFQ3aRWPcvJyREBiM8995zJ9pKSEuNjr7/+ukuPheoPW4uh12Y8wCCvBjZv3ix6eHiIfn5+4sSJE8WZM2eKsbGxIgBx4cKFJs+dN2+eCECcN2+exX5yc3NFAGLbtm3F2bNni2PGjBH1er0YGBgo/ve//62lo6G6TI26Fh0dLQIQu3fvLs6bN0/2jxo3tc5pchjkkZRade21114TAYihoaFibm6u+Pjjj4sxMTEiAHHSpEm1dDRUV6lRz/bv3y/6+/uLAMSuXbuKM2bMEKdMmSLGxcWJAMROnTqJt27dqsWjorpm+fLl4tixY8WxY8eKHTt2FAGI6enpxm2fffaZ8bm1GQ8wyKuhXbt2iQMHDhQDAwNFb29vsXPnzuJ7771n8TxrX2plZaX42muvicnJyaJerxdDQ0PFe++916SHiaimdQ2AzT8iNc5pchjkkTm16toXX3whZmRkiH5+fqKXl5fYqVMn8e2333Zx6am+UKOeHTlyRBw/frzYsmVL0cPDQ/T29hZTU1PFBQsWiDdu3KiFo6C6bOzYsVbbVtI6VZvxgCCKoujYAE8iIiIiIiKqq5h4hYiIiIiIqAFhkEdERERERNSAMMgjIiIiIiJqQBjkERERERERNSAM8oiIiIiIiBoQBnlEREREREQNCIM8IiIiIiKiBoRBHhERERERUQPCII+IiIiIiKgBYZBHRERERER02/bt2zF06FBERkZCEAR8/vnnDu9DFEW88sorSEhIgF6vR1RUFP7617+qX1gFulp7JyIionrq888/x4EDB9ChQwcMHz7c3cUhIiIXunHjBtq3b4/x48fjT3/6k1P7eOKJJ7Bx40a88sorSE1NRVFREQoLC1UuqTJBFEWx1t6NiIioHho3bhzWrFmDsWPHYvXq1e4uDhER1RJBEPDZZ5+ZdPCVlZXhueeew/vvv4+rV68iJSUFL730ErKysgAAv/32G9q1a4dDhw4hMTHRLeXmcE0iIiIiIiI7jR8/Hjt37sTatWvxyy+/4L777sPAgQNx9OhRAMCXX36JuLg4/Oc//0FsbCxiYmKQm5uLy5cv11oZGeQRERERERHZ4fjx4/jwww/x0UcfISMjA/Hx8Zg1axZ69eqFVatWAQBOnDiB/Px8fPTRR3j33XexevVq7N27F/fee2+tlZNBHhERNUrr16/HoEGDEB4eDg8PDwQFBaF169a4++678c9//hMlJSXYunUrBEHAmjVrAABr1qyBIAgmf1u3brXY9/HjxzFt2jS0adMGfn5+8PHxQZs2bTB9+nScOnVKtjyrV6+GIAiIiYkBAHz77bcYNGgQmjRpAm9vbyQnJ2PhwoUoKSlRPKZdu3Zh9OjRiI2NhZeXF3x9fREdHY3MzEy88MILOHPmTI0/NyKixmzfvn0QRREJCQnw8/Mz/m3btg3Hjx8HAFRVVaG0tBTvvvsuMjIykJWVhXfeeQdbtmzB77//XivlZOIVIiJqdCZMmICVK1ca/+/n54fy8nIcO3YMx44dw5dffokhQ4bA09MT4eHhKCoqQklJCby8vBAYGGiyL09PT5P/L1++HI8//jjKy8sBAHq9HhqNBocPH8bhw4exatUqfPzxx+jfv79i+f75z39i2rRpEEURQUFBqKiowK+//oq5c+fi008/xaZNmxAcHGzymjVr1mD8+PEwTLXX6/XQ6XQ4deoUTp06he3btyMqKgrjxo2ryUdHRNSoVVVVQavVYu/evdBqtSaP+fn5AQAiIiKg0+mQkJBgfKxNmzYAgFOnTtXKPD3eySMiokZlx44dWLlyJTQaDV566SVcunQJ165dw40bN1BYWIgNGzZg7Nix8PT0RM+ePXH+/HmMHDkSADBy5EicP3/e5K9nz57GfX/++eeYNGkSAGDOnDk4efIkbt26hRs3buDw4cO47777UFxcjHvvvVfxjl5BQQFmzJhhfM6VK1dw7do1LF26FHq9Hvv378eECRNMXnPz5k1jUPjQQw/h2LFjKCkpQVFREa5fv449e/Zg9uzZaNq0qYs+VSKixiEtLQ2VlZW4ePEiWrVqZfLXrFkzAEB6ejoqKiqMd/YA4MiRIwCA6OjoWikn7+QREVGj8sMPPwAAsrOz8dRTT5k8FhoaigEDBmDAgAEO77esrAxTp04FACxduhSPPPKIyeOJiYlYv349hg0bhi+++AJLlizBq6++arGfmzdvIjMzE2vXroVGU90X6+XlhcmTJ0On0yE3NxefffYZdu/ejS5dugAADh06hGvXrsHX1xerVq2CTnfn8u7r64tOnTqhU6dODh8TEVFjdP36dRw7dsz4/7y8PBw4cAAhISFISEjA6NGjMWbMGPz9739HWloaCgsLsXnzZqSmpmLw4MHIzs5Gx44d8cgjj+DVV19FVVUVHn/8cfTv39/k7p4r8U4eERE1KkFBQQCq75hVVlaqtt+vv/4aZ8+eRXh4OMaPH6/4vDFjxgAANmzYoPic5557zhjgSY0fPx4tWrQAAKxdu9a43XBMZWVluHTpkjPFJyKi2/bs2YO0tDSkpaUBAJ588kmkpaXh+eefBwCsWrUKY8aMwcyZM5GYmIi7774bu3btQlRUFABAo9Hgyy+/RFhYGHr37o0hQ4agTZs2JudtV+OdPCIialSys7Ph5eWF/fv3IyMjAxMmTEDfvn0RGxtbo/3u2LEDAHDlyhVEREQoPq+srAwAkJ+fL/u4TqdDRkaG7GMajQZZWVl47733sGfPHuP2+Ph4JCUl4fDhw+jWrRumTJmCnJwcpKamWswZISIi67KysmBtKXEPDw8sWLAACxYsUHxOZGQkPvnkE1cUzy68k0dERI1KXFwcVqxYAT8/P/z444/Izc1FXFwcmjZtipEjR+Lf//631Yu7kj/++ANAdRB34cIFxb8rV64AAG7duiW7n7CwMOj1esX3ad68OQDg4sWLxm1arRZr165FbGws8vPzMWfOHKSlpSEgIAD9+/fHW2+9hZs3bzp8TEREVD8xyCMiokZn9OjRyM/Px9KlSzFy5EhERUWhoKAA69evx/Dhw5GZmYni4mKH9mkY+jlw4ECIomjXnxxBEJw6pvbt2+Pw4cP45JNPMGnSJKSkpODWrVv47rvv8NhjjyEpKQkHDx50at9ERFS/MMgjIqJGKSQkBJMnT8batWtx6tQpHDt2DHPmzIEgCPj+++8xf/58h/ZnyKpW00CqoKAApaWlio+fPXsWAGQzZXp6emLEiBFYtmwZDh48iIKCAixduhQhISE4ffo0xo4dW6OyERFR/cAgj4iICNXz2hYvXoxRo0YBqF6M3MCQBMXaMM709HQA1UGYYX6eMyoqKhRfL4oitm/fDgDo3LmzzX2FhoZi8uTJeOmllwAA+/fvZ2IWIqJGgEEeERE1KtbukgGAt7c3AJgkLAkICAAAXL16VfF1Q4cONSZceeKJJ2zOgbt8+bLiY4sWLUJVVZXF9jVr1hjX1zOs3QfYf0wAmIiFiKgRYJBHRESNytSpU3H//ffjk08+MUlecv36dSxduhTvvvsuAGDw4MHGx1JSUgAA33//PQ4fPiy7Xy8vL7z55psQBAH79u1Deno6NmzYYMymCVSvtbRs2TJ07doVb775pux+fHx8sGPHDowaNQpnzpwBAJSUlGD58uWYMmUKAGDYsGHo2rWr8TVr165Feno6li1bhhMnThi3V1ZWYsOGDZgzZw4AoEePHsblFoiIqOESRGdSiBEREdVT48aNw5o1a4z/9/Pzg06nM7lL16tXL3zzzTfw9fUFUL0sQmJiIgoKCgBUZ8A0PLZ27Vp0797d+Nr3338fkyZNMt7J0+l0CAwMxPXr103uuC1cuBDPPvus8f+rV6/G+PHjER0djdmzZ2PatGkQRRHBwcG4fv06ysvLAVQnWNm0aRNCQ0MtXmug1+vh5+eHK1euGO8IRkZGYtOmTUhKSqrZB0hERHUegzwiImpUjh8/jv/93//Fli1b8Ntvv+H8+fO4fv06QkJC0L59ezz44IMYM2aMxbDGw4cPY8GCBfj+++9x8eJFY9C1ZcsWZGVlmTz33LlzePPNN/HNN9/g2LFjuHbtGvz8/BAbG4tevXoZM3jqdHeWq5UGeSdPnsS3336LJUuWYPfu3bh+/TpiY2MxatQozJo1y2T4JVA99POrr77Cli1bsG/fPpw7dw6XL1+Gr68vEhMTMXToUEydOpV38YiIGgkGeURERHWAeZBHRETkLM7JIyIiIiIiakAY5BERERERETUgDPKIiIiIiIgaEAZ5REREREREDQgTrxARERERETUgvJNHRERERETUgDDIIyIiIiIiakAY5BERERERETUgDPKIiIiIiIgaEAZ5REREREREDQiDPCIiIiIiogaEQR4REREREVEDwiCPiIiIiIioAWGQR0RERERE1ID8f6Hq+Fnfj8rQAAAAAElFTkSuQmCC\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""C.plot_traces(figname=\""traces.pdf\"", xlim=(0, 1e6))"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""

Computing the autocorrelation

\n"", ""\n"", ""Next, we need to determine the trajectory length at which sampling becomes decorrelated. Autocorrelations curves and autocorrelation times are computed for each time-series of sampled nuisance parameters. The computed autocorrelation times for each nuisance parameter are stored in `C` to be used for further convergence analysis. By default, our `get_autocorrelation_curves` method uses an autocorrelation function (`method=\""auto\""`) with a window of length `maxtau=10000` to compute the autocorrelation time. To obtain the autocorrelation time, we take the integral of the autocorrelation function over all lag-times $\\tau$. \n"", ""\n"", ""\n"", ""Three options for the argument `method` are provided: block average (`\""block-avg\""`), exponential fitting (`\""exp\""`) or autocorrelation function (`\""auto\""`). Each method varying in the level of statistical sophistication to compute the autocorrelation times of each nuisance parameter. \n"", ""\n"", ""\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""\n"", ""

Single exponential fitting

\n"", ""\n"", ""$$f(x) = a_{0} + a_{1}*exp(-(x/\\tau_{1})) $$\n"", ""\n"", ""\n"", ""Computing the autocorrelation time via an exponential curve fitting is achieved by finding the best fitting of varied parameters: $a_{0}$, $a_{1}$ and $\\tau_{1}$. The autocorrelation time $\\tau_{auto}$=$\\tau_{1}$ from the optimal fitting. \n"", ""\n"", ""\n"", ""\\begin{equation}\n"", ""N_{ind} = \\frac{N}{1+2\\tau_{auto}}\n"", ""\\end{equation}\n"", ""where $N$ is the total number of raw samples. In practice, curve fitting method may require prior knowledge (e.g single or double exponential decay).\n"", ""\n"", ""\n"", ""\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 4, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""C.get_autocorrelation_curves(method=\""exp\"", maxtau=5000)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""The functional form can also be changed from single to doubly exponential. The curve fitting method may require prior knowledge about the exponential decay. In this case, the doubly exponential decay does not apply. Below is the code that would be used:\n"", ""\n"", ""```python\n"", ""C.exp_function = \""double\""\n"", ""C.get_autocorrelation_curves(method=\""exp\"", maxtau=5000)\n"", ""```\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""For example, a larger value of `maxtau` may be necessary in cases of more slowly decorrelated time series. Occasionally, negative values of $\\tau_{auto}$ may be obtained indicating the amount of data is not enough for computing autocorrelation time. Since convergence check of BICePs could be complicated, we offered multiple methods aiming for cross-validation for users to determine if the sampling achieves convergence. \n"", ""\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""

Autocorrelation function $C_{\\tau}$

\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\\begin{equation}\n"", ""C\\left(\\theta_{t}, \\theta_{t+\\tau}\\right) \\equiv \\frac{\\overline{\\left(\\theta_{t}-\\overline{\\theta}\\right)\\left(\\theta_{t+\\tau}-\\overline{\\theta}\\right)}}{s(\\theta)^{2}} \\Rightarrow c_{\\tau}\n"", ""\\label{eq:g} \\tag{1}\n"", ""\\end{equation}\n"", ""\n"", ""where $s(\\theta)^{2}$ is the variance and $c_{\\tau}$ is independent of the lagtime $\\tau$. To find the proper number of lagtime ($\\tau_{auto}$), we take integral of $C_{\\tau}$ over all lagtimes\n"", ""\n"", ""\n"", ""\\begin{equation}\n"", ""\\tau_{auto} = \\int C_{\\tau} d \\tau\n"", ""\\label{eq:tau} \\tag{2}\n"", ""\\end{equation}\n"", ""\n"", ""\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 5, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""C.get_autocorrelation_curves(method=\""auto\"", maxtau=500)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""

Block-averaging

\n"", ""\n"", ""This approach works by partitioning a window of length `maxtau` into 4 blocks of equal size, then averaging the autocorrelation time for each block. Form these blocks, we can pull out the uncertainty of $\\tau_{auto}$."" ] }, { ""cell_type"": ""code"", ""execution_count"": 6, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""C.get_autocorrelation_curves(method=\""block-avg-auto\"", maxtau=200, nblocks=5)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Please note that significant changes in the autocorrelation curve at large $\\tau$ may indicate more sampling is required and the system has not reached equilibrium. Occasionally, a negative value of $\\tau_{auto}$ may arise, which is an indication that `maxtau` is too small i.e., the amount of data is not enough for computing autocorrelation time. On the other hand, a slowly decorrelated time series with lots of data may also require a larger `maxtau`.\n"", ""\n"", ""\n"", ""\n"", ""The JSD analysis uses the stored autocorrelation times inside the convergence object `C`."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""

Using $\\tau_{auto}$ from block averaged autocorrelations for processing (JSD distributions)

\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""After the autocorrelation times have been stored, `C.process` is called to perform a series of operations including the output of plots from the resulting JSD analysis. By default, the latter method includes numerous preset arguments: `nround=100` is the number of rounds of bootstrapping when computing JSDs, `nfold=10` is the number of partitions in the shuffled (subsampled) trajectory, and `block_avg=False` specifies whether block averaging is to be used. When `block_avg=True`, the decorrelated time-series data gets partitioned into $n$ blocks (`nblock=5`) and an average is taken over the values of greatest frequency for each block.\n"", ""\n"", ""```python\n"", ""C.process(nblock=5, nfold=10, nround=100, savefile=False, block_avg=True, normalize=True)\n"", ""```\n"", ""\n"", ""Jensen-Shannon divergence (JSD) is an improved method from Kullback-Leibler divergence and is a statistical way to measure the similarity between two probability distributions. In our convergence test, we are aiming to check if we use more data, will the distribution be different or similar to the less data which is a perfect situation that JSD calculation could be helpful. Given two sets data from BICePs sampling $P_1$ and $P_2$, to check if these two distribution is similar or not, we can compute the JSD as:\n"", ""\n"", ""\\begin{equation}\n"", ""JSD = H(P_{comb}) - {\\pi_1}{H(P_1)} - {\\pi_2}{H(P_2)}\n"", ""\\label{eq:JSD_def}\\tag{3}\n"", ""\\end{equation}\n"", ""\n"", ""where $P_{comb}$ is the combined data ($P_{1} \\cup P_{2}$). $H$ is the Shannon entropy of distribution $P_i$ and $\\pi_i$ is the weight for the probability distribution $P_i$.\n"", ""Specifically, in BICePs the $P_i$ is the distribution of sampled parameters and ${H(P_i)}$ can be computed as:\n"", ""\n"", ""\\begin{equation}\n"", ""{H(P_i)} = \\sum -\\frac{r_i}{N_i}*\\ln{\\frac{r_i}{N_i}}\n"", ""\\tag{4}\n"", ""\\end{equation}\n"", ""\n"", ""where $r_i$ and $N_i$ represents sampled times of a specific parameter index and the total number of samples of the parameter, respectively. $\\pi_i$ can be computed as $\\frac{N_i}{N_{total}}$ where $N_{total} = \\sum{N_i}$. Combined together we have:\n"", ""\n"", ""\\begin{equation}\n"", ""JSD = \\sum{(-\\frac{r_{total}}{N_{total}}*\\ln{\\frac{r_{total}}{N_{total}}})} - \\frac{N_i}{N_{total}}*\\sum(-\\frac{r_i}{N_i}*\\ln{\\frac{r_i}{N_i}})\n"", ""\\label{eq:JSD}\\tag{5}\n"", ""\\end{equation}\n"", ""\n"", ""where $i = 1, 2$ in this example.\n"", ""In `biceps`, we can import different amount of data into our JSD calculation. To do that, we may use $p\\%$ ($p = 10,20,...100$) data and divide the dataset ($P_{total}$) into two parts (the first half and second half) to get $P_1$ and $P_2$ in eq \\ref{eq:JSD_def} and compute the JSD value ($JSD_{single}$) using eq \\ref{eq:JSD}. Then we can randomly pick up $N_{total}/2$ points from $P_{total}$ as $P_1$ ($N_{total}$ is the total number of data after chopped) and the remaining data as $P_2$. In this way, we are mixing the data and the computed JSD ($JSD_{random}$) from this mixing data should be smaller than the computed JSD from just first versus second half data. But if the dataset is completely converged, $JSD_{single}$ and $JSD_{random}$ should be close. Repeat mixing data $N$ times, we shall get $\\Big\\{JSD_{random}\\Big\\}_N$ values and a corresponded distribution. Our null hypothesis is the computed $JSD_{single}$ is not in the distribution of $\\Big\\{JSD_{random}\\Big\\}_N$. To test if we can accept or reject the hypothesis, we rank the $JSD_{single}$ values in $\\Big\\{JSD_{random}\\Big\\}_N$ in ascending order. If it is in the top 99\\% ranked, then we reject the hypothesis which indicates $P_1$ and $P_2$ no matter mixing the data or not are drawn from a mutual distribution and the data is converged. If the ranked $JSD_{single}$ is in the last 1\\%, the data is not converged yet.\n"", ""\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 7, ""metadata"": { ""scrolled"": false }, ""outputs"": [ { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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\n"", ""text/plain"": [ ""
"" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""C.process(nblock=5, nfold=10, nround=100, savefile=False, block_avg=True, normalize=True)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""\n"", ""\n"", ""In summary of the `biceps.convergence` class is extremely convenient and useful for objectively quantifying sampling quality. Despite there not being a one-size-fits-all approach to checking the validity of MCMC trajectories, we included an assortment of methods to check convergence. Users only need to specify the relative path and trajectory name. If desired, a `method` for computing the autocorrleation time can be specified. The convergence module is extremely convenient and useful for determining sufficient sampling so we can put more trust our simulations. \n"", ""\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""References\n"", ""\n"", ""
  • (1) Grossfield, Alan, et al. \""Best practices for quantification of uncertainty and sampling quality in molecular simulations [Article v1. 0].\"" Living journal of computational molecular science 1.1 (2018). ↩
    • \n"", ""\n"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
    # NOTE: The following cell is for pretty notebook rendering
    "" ] }, { ""cell_type"": ""code"", ""execution_count"": 8, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"" ], ""text/plain"": [ """" ] }, ""execution_count"": 8, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from IPython.core.display import HTML\n"", ""def css_styling():\n"", "" styles = open(\""../../../theme.css\"", \""r\"").read()\n"", "" return HTML(styles)\n"", ""css_styling()"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""Python 3 (ipykernel)"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.8.13"" } }, ""nbformat"": 4, ""nbformat_minor"": 2 } ","Unknown" "Conformation","vvoelz/biceps","docs/examples/Tutorials/Tools/toolbox.ipynb",".ipynb","12668","391","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Toolbox\n"", ""=======\n"", ""\n"", ""\n"", ""
    \n"", ""\n"", ""This tutorial shows the user what `biceps.toolbox` has to offer. \n"", ""\n"", ""
    "" ] }, { ""cell_type"": ""code"", ""execution_count"": 1, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""BICePs - Bayesian Inference of Conformational Populations, Version 2.0\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""Warning on use of the timeseries module: If the inherent timescales of the system are long compared to those being analyzed, this statistical inefficiency may be an underestimate. The estimate presumes the use of many statistically independent samples. Tests should be performed to assess whether this condition is satisfied. Be cautious in the interpretation of the data.\n"" ] } ], ""source"": [ ""import numpy as np\n"", ""import biceps"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Convert populations to energy**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 2, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""[5.583336321580334, 9.721165995742174, 9.115030192171858, 9.433483923290392, 6.495645628155304, 11.107460356862065, 6.094605306027495, 10.126631103850338, 8.8387768155437, 9.721165995742174]\n"" ] } ], ""source"": [ ""pop_filename = 'population.txt'\n"", ""# convert from population to energy(kT): E = -kT*log(P) \n"", ""out = biceps.toolbox.convert_pop_to_energy(pop_filename)\n"", ""print(out[::100]) # printing every 100"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Compute J coupling constants for natural amino acids**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 3, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""saving output file...\n"", ""Done!\n"", ""saving output file...\n"", ""Done!\n"", ""saving output file...\n"", ""Done!\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""/Users/RR/miniconda3/lib/python3.8/site-packages/numpy/lib/npyio.py:521: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n"", "" arr = np.asanyarray(arr)\n"" ] } ], ""source"": [ ""# Compute J3_HN_HA for frames in trajectories\n"", ""# for only 1 *gro/*pdb file\n"", ""J = biceps.toolbox.get_J3_HN_HA('J3/example.gro',\n"", "" model = \""Habeck\"", outname='J3_out.npy')\n"", ""# for 1 trajectory\n"", ""J = biceps.toolbox.get_J3_HN_HA(traj='J3/example.xtc',top='J3/example.gro',\n"", "" model = \""Habeck\"", outname='J3_out.npy')\n"", ""# for 1 trajectory with selected frames\n"", ""frames = [0,1,3,5,7,9]\n"", ""J = biceps.toolbox.get_J3_HN_HA(traj='J3/example.xtc',top='J3/example.gro',\n"", "" frame = frames, model = \""Habeck\"", outname='J3_out.npy')"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Compute J coupling constants for non-natural amino acids**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 5, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""[[11.59929633 11.5908202 3.77981085 3.06534659 11.46025735 0.61495801\n"", "" 10.80616333 2.94538664 1.24030298 2.77752424 1.3801523 10.88224604]]\n"", ""[[11.59359379 11.58796156 11.5994007 10.86025507 4.40292064 12.30620068\n"", "" 3.43600049 10.7195684 1.07170021 2.98419957 10.8572357 1.18375748]]\n"", ""[[11.58811557 11.58931135 10.49392263 4.02871242 11.33110466 12.59204923\n"", "" 10.9224119 2.64105364 1.43223646 2.05262705 10.99946341 1.99195757]]\n"", ""[[11.59995984 11.59170756 11.34322617 10.98300376 2.75242845 0.56631515\n"", "" 1.14966803 10.75983707 3.06268945 2.78762916 1.35818234 10.85199877]]\n"", ""[[11.58991007 11.58508194 10.75085679 3.20760985 11.53892434 0.03746871\n"", "" 10.9185836 2.76861831 1.46725946 2.17715562 10.99202389 1.80701938]]\n"" ] } ], ""source"": [ ""biceps.toolbox.mkdir(\""J_coupling\"")\n"", ""# compute J coupling constants of non-natural amino acids\n"", ""# Karplus relations need to be determined \n"", ""index = np.load('ind.npy') # atom indices\n"", ""karplus_key = np.load('Karplus.npy').astype(str) # Karplus relation for each J coupling constant\n"", ""for i in range(100):\n"", "" J = biceps.toolbox.compute_nonaa_Jcoupling('top/%d.pdb'%i, indices=index, karplus_key=karplus_key)\n"", "" if i<5:\n"", "" print(J) # print the first 5\n"", "" np.savetxt('J_coupling/%d.txt'%i,J)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
    \n"", ""\n"", ""**Tools to be used after BICePs sampling**"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ """" ] }, { ""cell_type"": ""markdown"", ""metadata"": { ""collapsed"": true }, ""source"": [ """" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Convert `biceps` trajectory file to Pandas DataFrame**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 6, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ "" step E accept state para_index\n"", ""0 0 135.228336 1 25 [[151], [116, 81]]\n"", ""1 100 43.798846 1 58 [[170], [108, 92]]\n"", ""2 200 35.797135 0 84 [[172], [110, 94]]\n"", ""3 300 24.634310 0 79 [[176], [114, 95]]\n"", ""4 400 19.433472 0 79 [[183], [113, 97]]\n"", ""5 500 12.780269 0 87 [[187], [112, 98]]\n"", ""6 600 8.845128 1 87 [[196], [117, 98]]\n"", ""7 700 9.259623 0 87 [[194], [118, 100]]\n"", ""8 800 10.022916 0 87 [[190], [124, 95]]\n"", ""9 900 10.252859 1 87 [[193], [117, 96]]\n"" ] } ], ""source"": [ ""file = \""results/traj_lambda0.00.npz\""\n"", ""df = biceps.toolbox.npz_to_DataFrame(file)\n"", ""print(df)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
    # NOTE: The following cell is for pretty notebook rendering
    "" ] }, { ""cell_type"": ""code"", ""execution_count"": 7, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"" ], ""text/plain"": [ """" ] }, ""execution_count"": 7, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from IPython.core.display import HTML\n"", ""def css_styling():\n"", "" styles = open(\""../../../theme.css\"", \""r\"").read()\n"", "" return HTML(styles)\n"", ""css_styling()"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""Python 3 (ipykernel)"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.8.13"" } }, ""nbformat"": 4, ""nbformat_minor"": 1 } ","Unknown" "Conformation","vvoelz/biceps","docs/examples/Tutorials/Tools/top/new_cluster.py",".py","346","22","import numpy as np import mdtraj as md import os, sys #t=md.load('traj0.xtc',top='conf.gro') #a=np.load('Assignments.npy') Ind = np.load('Ind_noe.npy') for i in range(100): print i p=[] t=md.load('%d.pdb'%i) d=md.compute_distances(t,Ind) p=np.reshape(d,(30,1)) np.savetxt(""../NOE/average_state%d.txt""%i,p) sys.exit() ","Python" "Conformation","vvoelz/biceps","docs/examples/Tutorials/MP_Lambdas/mp_lambdas.ipynb",".ipynb","12372","388","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Multiprocessing Lambdas\n"", ""=====================\n"", ""\n"", ""
    \n"", ""\n"", ""This tutorial explains how to run lambda values in parallel. We show the user how to construct a simple wrapper function for the code to be multiprocessed, then we decorate the wrapper function with `@biceps.multiprocess`.\n"", ""\n"", ""In the [preparation tutorial](https://biceps.readthedocs.io/en/latest/examples/Tutorials/Prep_Rest_Post_Ana/preparation.html), we generated the input data that will be used here. \n"", ""\n"", ""Please be aware of the following:\n"", ""
      \n"", ""
    • never use multiprocessing when debugging
      • \n"", ""
    • always make sure verbose=False for all methods inside wrapper function
      • \n"", ""
    \n"", ""\n"", ""\n"", ""
    "" ] }, { ""cell_type"": ""code"", ""execution_count"": 1, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""BICePs - Bayesian Inference of Conformational Populations, Version 2.0\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""Warning on use of the timeseries module: If the inherent timescales of the system are long compared to those being analyzed, this statistical inefficiency may be an underestimate. The estimate presumes the use of many statistically independent samples. Tests should be performed to assess whether this condition is satisfied. Be cautious in the interpretation of the data.\n"" ] } ], ""source"": [ ""import numpy as np\n"", ""import pandas as pd\n"", ""import biceps"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Data, output directories and parameters**\n"" ] }, { ""cell_type"": ""code"", ""execution_count"": 4, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""
    \n"", ""\n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
    refsigmagamma
    0uniform(0.05, 20.0, 1.02)NaN
    1exponential(0.05, 5.0, 1.02)(0.2, 5.0, 1.02)
    \n"", ""
    "" ], ""text/plain"": [ "" ref sigma gamma\n"", ""0 uniform (0.05, 20.0, 1.02) NaN\n"", ""1 exponential (0.05, 5.0, 1.02) (0.2, 5.0, 1.02)"" ] }, ""execution_count"": 4, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""energies = np.loadtxt('cineromycin_B/cineromycinB_QMenergies.dat')*627.509 # convert from hartrees to kcal/mol\n"", ""energies = energies/0.5959 # convert to reduced free energies F = f/kT\n"", ""energies -= energies.min() # set ground state to zero, just in case\n"", ""input_data = biceps.toolbox.sort_data('cineromycin_B/J_NOE')\n"", ""nsteps=100000\n"", ""n_lambdas = 2\n"", ""outdir = '%s_steps_%s_lam'%(nsteps, n_lambdas)\n"", ""biceps.toolbox.mkdir(outdir)\n"", ""lambda_values = np.linspace(0.0, 1.0, n_lambdas)\n"", ""parameters = [dict(ref=\""uniform\"", sigma=(0.05, 20.0, 1.02)),\n"", "" dict(ref=\""exponential\"", sigma=(0.05, 5.0, 1.02), gamma=(0.2, 5.0, 1.02)),]\n"", ""pd.DataFrame(parameters)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 5, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Number of CPUs: 10\n"", ""Number of processes: 2\n"", ""lambda: 0.0\n"", ""lambda: 1.0\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""100%|███████████████████████████████████████████████████████████| 100000/100000 [00:01<00:00, 66316.92it/s]\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted 70.836 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [32.905 29.871 29.871 8.06 ] % \n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""\r"", ""100%|███████████████████████████████████████████████████████████| 100000/100000 [00:01<00:00, 66102.80it/s]"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""\n"", ""Accepted 64.41900000000001 % \n"", ""\n"", ""\n"", ""Accepted [ ...Nuisance paramters..., state] %\n"", ""Accepted [32.817 29.933 29.933 1.669] % \n"", ""\n"" ] } ], ""source"": [ ""@biceps.multiprocess(iterable=lambda_values)\n"", ""def mp_lambdas(lam):\n"", "" print(f\""lambda: {lam}\"")\n"", "" ensemble = biceps.Ensemble(lam, energies)\n"", "" ensemble.initialize_restraints(input_data, parameters)\n"", "" sampler = biceps.PosteriorSampler(ensemble)\n"", "" sampler.sample(nsteps, verbose=False)\n"", "" sampler.traj.process_results(outdir+'/traj_lambda%2.2f.npz'%(lam))\n"", "" filename = outdir+'/sampler_lambda%2.2f.pkl'%(lam)\n"", "" biceps.toolbox.save_object(sampler, filename)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""### Note that the output from each lambda will be returned to stdout as soon as the job has completed..."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""
    # NOTE: The following cell is for pretty notebook rendering
    "" ] }, { ""cell_type"": ""code"", ""execution_count"": 6, ""metadata"": {}, ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"" ], ""text/plain"": [ """" ] }, ""execution_count"": 6, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""from IPython.core.display import HTML\n"", ""def css_styling():\n"", "" styles = open(\""../../../theme.css\"", \""r\"").read()\n"", "" return HTML(styles)\n"", ""css_styling()"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""Python 3 (ipykernel)"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.8.13"" } }, ""nbformat"": 4, ""nbformat_minor"": 2 } ","Unknown" "Conformation","StructuralBiology-ICLMedicine/SIDESPLITTER","main.c",".c","11266","395"," /* * Copyright 14/08/2019 - Dr. Christopher H. S. Aylett * * This program is free software; you can redistribute it and/or modify * it under the terms of version 3 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details - YOU HAVE BEEN WARNED! * * Program: SIDESPLITTER V1.2 * * Authors: Chris Aylett * Colin Palmer * */ // Library header inclusion for linking #include ""sidesplitter.h"" // Main algorithm function int main(int argc, char **argv){ int32_t i, j; // Get arguments arguments *args = parse_args(argc, argv); int32_t nthread = get_num_jobs(); // Read MRC inputs r_mrc *vol1 = read_mrc(args->vol1); r_mrc *vol2 = read_mrc(args->vol2); r_mrc *mask; if (args->mask){ mask = read_mrc(args->mask); } else { mask = make_msk(vol1, (double) vol1->n_crs[0] / 4, nthread); } double apix = vol1->length_xyz[0] / (float) vol1->n_xyz[0]; // Check map sizes and CPUs int32_t xyz = mask->n_crs[0]; if (xyz != vol1->n_crs[0] || xyz != vol2->n_crs[0]){ printf(""\n\t MAPS MUST BE THE SAME SIZE! \n""); return 1; } size_t r_st = xyz * xyz * xyz * sizeof(double); size_t k_st = xyz * xyz * ((xyz / 2) + 1) * sizeof(fftw_complex); // FFTW set-up printf(""\n\t Setting up threads and maps\n""); printf(""\n\t Using %i threads. If you want to override this, set the OMP_NUM_THREADS environment variable.\n"", nthread); fftw_init_threads(); fftw_plan_with_nthreads(nthread); // Allocate memory for maps double *ri1 = fftw_malloc(r_st); double *ri2 = fftw_malloc(r_st); double *ro1 = fftw_malloc(r_st); double *ro2 = fftw_malloc(r_st); fftw_complex *ki1 = fftw_malloc(k_st); fftw_complex *ki2 = fftw_malloc(k_st); fftw_complex *ko1 = fftw_malloc(k_st); fftw_complex *ko2 = fftw_malloc(k_st); // Make FFTW plans printf(""\n\t FFTW doing its thing - ""); fflush(stdout); fftw_plan fft_ro1_ki1 = fftw_plan_dft_r2c_3d(xyz, xyz, xyz, ro1, ki1, FFTW_MEASURE); printf(""#""); fflush(stdout); fftw_plan fft_ro2_ki2 = fftw_plan_dft_r2c_3d(xyz, xyz, xyz, ro2, ki2, FFTW_ESTIMATE); printf(""#""); fflush(stdout); fftw_plan fft_ko1_ri1 = fftw_plan_dft_c2r_3d(xyz, xyz, xyz, ko1, ri1, FFTW_MEASURE); printf(""#""); fflush(stdout); fftw_plan fft_ko2_ri2 = fftw_plan_dft_c2r_3d(xyz, xyz, xyz, ko2, ri2, FFTW_ESTIMATE); printf(""#\n""); fflush(stdout); // Zero fill maps memset(ro1, 0, r_st); memset(ro2, 0, r_st); memset(ri1, 0, r_st); memset(ri2, 0, r_st); memset(ko1, 0, k_st); memset(ko2, 0, k_st); memset(ki1, 0, k_st); memset(ki2, 0, k_st); // Copy data into place add_map(vol1, ro1, nthread); add_map(vol2, ro2, nthread); // Apply masks in situ apply_mask(mask, ro1, nthread); apply_mask(mask, ro2, nthread); // Execute forward transform fftw_execute(fft_ro1_ki1); fftw_execute(fft_ro2_ki2); // Obtain spectra long double *spec1 = calloc(xyz, sizeof(long double)); long double *spec2 = calloc(xyz, sizeof(long double)); double maxres = get_spectrum(ki1, ki2, spec1, spec2, xyz, nthread); // Report FSC cut-off printf(""\n\t FSC cut-off within mask = %12.6f \n"", apix / maxres); // Zero fill maps memset(ro1, 0, r_st); memset(ro2, 0, r_st); // Copy data into place add_map(vol1, ro1, nthread); add_map(vol2, ro2, nthread); // Execute forward transform fftw_execute(fft_ro1_ki1); fftw_execute(fft_ro2_ki2); // Copy across ffts if tapering fftw_complex *inpk1 = NULL; fftw_complex *inpk2 = NULL; if (args->rotf){ inpk1 = fftw_malloc(k_st); inpk2 = fftw_malloc(k_st); memcpy(inpk1, ki1, k_st); memcpy(inpk2, ki2, k_st); } // Zero fill maps memset(ro1, 0, r_st); memset(ro2, 0, r_st); // Initialise list list head; head.res = 0.000; head.stp = 0.025; head.prv = NULL; head.nxt = NULL; head.crf = 0.00; head.fsc = 1.00; list *tail = &head; double mean_p; // Noise suppression loop printf(""\n\t Normalising -- Pass 1 \n""); printf(""\n\t # Resolution is reported in Ångströms [Å] everywhere it is quoted ""); printf(""\n\t # MeanProb records the estimated probability voxels are not noise ""); printf(""\n\t # FSC indicates the Fourier Shell Correlation between half sets -\n\n""); fflush(stdout); i = 0; do { if (tail->res == 0.0){ lowpass_filter(ki1, ko1, tail, xyz, nthread); lowpass_filter(ki2, ko2, tail, xyz, nthread); } else { bandpass_filter(ki1, ko1, tail, xyz, nthread); bandpass_filter(ki2, ko2, tail, xyz, nthread); } tail->fsc = calc_fsc(ko1, ko2, xyz, nthread); tail->crf = sqrt(fabs((2.0 * tail->fsc) / (1.0 + tail->fsc))); fftw_execute(fft_ko1_ri1); fftw_execute(fft_ko2_ri2); mean_p = normalise(ri1, ri2, ro1, ro2, mask, tail, xyz, nthread); if (tail->res + tail->stp >= maxres || mean_p <= 0.05){ maxres = tail->res + tail->stp; break; } printf(""\t Resolution = %12.6Lf | MeanProb = %12.6f | FSC = %12.6f \n"", apix / (tail->res + tail->stp), mean_p, tail->fsc); fflush(stdout); tail = extend_list(tail, mean_p); } while (1); // Back-transform noise-suppressed maps fftw_execute(fft_ro1_ki1); fftw_execute(fft_ro2_ki2); // Zero fill maps memset(ro1, 0, r_st); memset(ro2, 0, r_st); // Truncate by SNR printf(""\n\t De-noising volume -- Pass 2 \n""); printf(""\n\t # Recovery indicates the fraction of the mask recovered by the current resolution""); printf(""\n\t # This should reach at least 1.0 but will preferably end up considerably higher -\n\n""); fflush(stdout); strip_ext(args->vol1); size_t name_buffer = snprintf(NULL, 0, ""%s%s"", args->vol1, ""_sidesplitter.mrc"") + 1; char *name1 = malloc(name_buffer); sprintf(name1, ""%s%s"", args->vol1, ""_sidesplitter.mrc""); strip_ext(args->vol2); name_buffer = snprintf(NULL, 0, ""%s%s"", args->vol2, ""_sidesplitter.mrc"") + 1; char *name2 = malloc(name_buffer); sprintf(name2, ""%s%s"", args->vol2, ""_sidesplitter.mrc""); // Choose tapering loop if required if (args->rotf){ double *ori1 = fftw_malloc(r_st); double *ori2 = fftw_malloc(r_st); memset(ori1, 0, r_st); memset(ori2, 0, r_st); fftw_complex *oki1 = fftw_malloc(k_st); fftw_complex *oki2 = fftw_malloc(k_st); memset(oki1, 0, k_st); memset(oki2, 0, k_st); fftw_plan fft_oki1_ori1 = fftw_plan_dft_c2r_3d(xyz, xyz, xyz, oki1, ori1, FFTW_ESTIMATE); fftw_plan fft_oki2_ori2 = fftw_plan_dft_c2r_3d(xyz, xyz, xyz, oki2, ori2, FFTW_ESTIMATE); do { lowpass_filter(ki1, ko1, tail, xyz, nthread); lowpass_filter(ki2, ko2, tail, xyz, nthread); lowpass_filter(inpk1, oki1, tail, xyz, nthread); lowpass_filter(inpk2, oki2, tail, xyz, nthread); fftw_execute(fft_ko1_ri1); fftw_execute(fft_ko2_ri2); fftw_execute(fft_oki1_ori1); fftw_execute(fft_oki2_ori2); mean_p = taper_map(ri1, ri2, ro1, ro2, ori1, ori2, mask, tail, args, xyz, nthread); printf(""\t Resolution = %12.6Lf | Recovery = %12.6f\n"", apix / (tail->res + tail->stp), mean_p); fflush(stdout); if (tail->prv == NULL){ break; } else{ tail = tail->prv; } } while (1); // Renormalise maps int32_t total = xyz * xyz * xyz; for (i = 0; i < total; i++){ ro1[i] /= (double) total; ro2[i] /= (double) total; } // Output maps if SNR tapering write_mrc(vol1, ro1, name1, xyz); write_mrc(vol2, ro2, name2, xyz); // Over and out... printf(""\n\n\n\t ++++ ++++ That's All Folks! ++++ ++++ \n\n\n""); return 0; } else { do { lowpass_filter(ki1, ko1, tail, xyz, nthread); lowpass_filter(ki2, ko2, tail, xyz, nthread); fftw_execute(fft_ko1_ri1); fftw_execute(fft_ko2_ri2); mean_p = truncate_map(ri1, ri2, ro1, ro2, mask, tail, args, xyz, nthread); printf(""\t Resolution = %12.6Lf | Recovery = %12.6f\n"", apix / (tail->res + tail->stp), mean_p); fflush(stdout); if (tail->prv == NULL){ break; } else{ tail = tail->prv; } } while (1); } // Back-transform noise-suppressed maps fftw_execute(fft_ro1_ki1); fftw_execute(fft_ro2_ki2); // Zero fill maps memset(ro1, 0, r_st); memset(ro2, 0, r_st); // Noise suppression loop 2 printf(""\n\t Reapplying spectum \n""); printf(""\n\t # Spectrum indicates the spectral power reapplied at the current resolution\n\n""); fflush(stdout); i = 0; do { if (tail->res == 0.0){ lowpass_filter(ki1, ko1, tail, xyz, nthread); lowpass_filter(ki2, ko2, tail, xyz, nthread); } else { bandpass_filter(ki1, ko1, tail, xyz, nthread); bandpass_filter(ki2, ko2, tail, xyz, nthread); } fftw_execute(fft_ko1_ri1); fftw_execute(fft_ko2_ri2); reverse_norm(ri1, ri2, ro1, ro2, mask, tail, xyz, nthread); printf(""\t Resolution = %12.6Lf | Spectrum = %12.6Lf \n"", apix / (tail->res + tail->stp), tail->pwr); fflush(stdout); if (tail->nxt == NULL){ break; } else{ tail = tail->nxt; } } while (1); // Apply masks in situ apply_mask(mask, ro1, nthread); apply_mask(mask, ro2, nthread); // Output final volume printf(""\n\t Writing noise truncated MRC files\n""); fflush(stdout); if (!args->spec){ fftw_execute(fft_ro1_ki1); fftw_execute(fft_ro2_ki2); apply_spectrum(ki1, ki2, spec1, spec2, maxres, xyz, nthread); fftw_plan fft_ki1_ri1 = fftw_plan_dft_c2r_3d(xyz, xyz, xyz, ki1, ri1, FFTW_ESTIMATE); fftw_plan fft_ki2_ri2 = fftw_plan_dft_c2r_3d(xyz, xyz, xyz, ki2, ri2, FFTW_ESTIMATE); fftw_execute(fft_ki1_ri1); fftw_execute(fft_ki2_ri2); // Renormalise maps int32_t total = xyz * xyz * xyz; for (i = 0; i < total; i++){ ri1[i] /= (double) total; ri2[i] /= (double) total; } write_mrc(vol1, ri1, name1, xyz); write_mrc(vol2, ri2, name2, xyz); } else { // Renormalise maps int32_t total = xyz * xyz * xyz; for (i = 0; i < total; i++){ ro1[i] /= (double) total; ro2[i] /= (double) total; } write_mrc(vol1, ro1, name1, xyz); write_mrc(vol2, ro2, name2, xyz); } // Over and out... printf(""\n\n\n\t ++++ ++++ That's All Folks! ++++ ++++ \n\n\n""); return 0; } ","C" "Conformation","StructuralBiology-ICLMedicine/SIDESPLITTER","truncate.c",".c","7565","247"," /* * Copyright 14/08/2019 - Dr. Christopher H. S. Aylett * * This program is free software; you can redistribute it and/or modify * it under the terms of version 3 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details - YOU HAVE BEEN WARNED! * * Program: SIDESPLITTER V1.2 * * Authors: Chris Aylett * Colin Palmer * */ // Library header inclusion for linking #include ""sidesplitter.h"" #include ""truncate.h"" // Updates out if in1/2 over noise - returns fractional recovery double truncate_map(double *in1, double *in2, double *out1, double *out2, r_mrc *mask, list *node, arguments *args, int32_t size, int32_t nthreads){ int32_t i, m, n, full = size * size * size; double cor, cur; // Calculate max noise pthread_t threads[nthreads]; max_arg arg1[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg1[i].mask = mask; arg1[i].in1 = in1; arg1[i].in2 = in2; arg1[i].noise = 0.0; arg1[i].sigma = 0.0; arg1[i].count = 0.0; arg1[i].size = full; arg1[i].step = nthreads; arg1[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) calc_max_noise_thread, &arg1[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } double count = 0.0; double noise = 0.0; long double sigma = 0.0; // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } count += arg1[i].count; sigma += arg1[i].sigma; if (noise < arg1[i].noise){ noise = arg1[i].noise; } } // Take normal estimate of maximum if higher sigma = sqrtl(sigma / (long double) count); sigma = sigma * sqrtl(2.0) * sqrtl(logl((long double) count)); sigma = sigma * sigma; if (noise < (double) sigma){ noise = (double) sigma; } // Pass through signal greater than noise ass_vox_arg arg2[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg2[i].in1 = in1; arg2[i].in2 = in2; arg2[i].out1 = out1; arg2[i].out2 = out2; arg2[i].noise = noise; arg2[i].rcv = 0.0; arg2[i].size = full; arg2[i].step = nthreads; arg2[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) assign_voxels_thread, &arg2[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } double rcv = 0.0; // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } rcv += arg2[i].rcv; } return rcv / count; } // Updates out if in1/2 over noise - returns fractional recovery double taper_map(double *in1, double *in2, double *out1, double *out2, double *ori1, double *ori2, r_mrc *mask, list *node, arguments *args, int32_t size, int32_t nthreads){ int32_t i, m, n, full = size * size * size; double cor, cur; // Calculate max noise pthread_t threads[nthreads]; max_arg arg1[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg1[i].mask = mask; arg1[i].in1 = in1; arg1[i].in2 = in2; arg1[i].noise = 0.0; arg1[i].sigma = 0.0; arg1[i].count = 0.0; arg1[i].size = full; arg1[i].step = nthreads; arg1[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) calc_max_noise_thread, &arg1[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } double count = 0.0; double noise = 0.0; long double sigma = 0.0; // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } count += arg1[i].count; sigma += arg1[i].sigma; if (noise < arg1[i].noise){ noise = arg1[i].noise; } } // Take normal estimate of maximum if higher sigma = sqrtl(sigma / (long double) count); sigma = sigma * sqrtl(2.0) * sqrtl(logl((long double) count)); sigma = sigma * sigma; if (noise < (double) sigma){ noise = (double) sigma; } // Pass through signal greater than noise ass_vox_arg arg2[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg2[i].in1 = in1; arg2[i].in2 = in2; arg2[i].out1 = out1; arg2[i].out2 = out2; arg2[i].ori1 = ori1; arg2[i].ori2 = ori2; arg2[i].noise = noise; arg2[i].rcv = 0.0; arg2[i].size = full; arg2[i].step = nthreads; arg2[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) taper_voxels_thread, &arg2[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } double rcv = 0.0; // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } rcv += arg2[i].rcv; } return rcv / count; } void calc_max_noise_thread(max_arg *arg){ int32_t i; double cor, cur; for (i = arg->thread; i < arg->size; i += arg->step){ // Normalise input transforms first arg->in1[i] = arg->in1[i] / arg->size; arg->in2[i] = arg->in2[i] / arg->size; // Do not calculate statistics from voxels outside the mask if (arg->mask->data[i] < 0.99){ continue; } arg->count += 1.0; cur = 0.5 * (arg->in1[i] - arg->in2[i]); cor = cur * cur; if (cor > arg->noise){ arg->noise = cor; } arg->sigma += (long double) cor; } return; } void assign_voxels_thread(ass_vox_arg *arg){ int32_t i; double cor, cur; for (i = arg->thread; i < arg->size; i += arg->step){ if (fabs(arg->out1[i]) > 0.0){ arg->rcv += 0.5; } else if ((arg->in1[i] * arg->in1[i]) > arg->noise){ arg->out1[i] = arg->in1[i]; arg->rcv += 0.5; } if (fabs(arg->out2[i]) > 0.0){ arg->rcv += 0.5; } else if ((arg->in2[i] * arg->in2[i]) > arg->noise){ arg->out2[i] = arg->in2[i]; arg->rcv += 0.5; } } return; } void taper_voxels_thread(ass_vox_arg *arg){ int32_t i; double cor, cur; for (i = arg->thread; i < arg->size; i += arg->step){ if (fabs(arg->out1[i]) > 0.0){ arg->rcv += 0.5; } else if ((arg->in1[i] * arg->in1[i]) > arg->noise){ arg->out1[i] = arg->ori1[i]; arg->rcv += 0.5; } if (fabs(arg->out2[i]) > 0.0){ arg->rcv += 0.5; } else if ((arg->in2[i] * arg->in2[i]) > arg->noise){ arg->out2[i] = arg->ori2[i]; arg->rcv += 0.5; } } return; } ","C" "Conformation","StructuralBiology-ICLMedicine/SIDESPLITTER","suppress.c",".c","5451","172"," /* * Copyright 14/08/2019 - Dr. Christopher H. S. Aylett * * This program is free software; you can redistribute it and/or modify * it under the terms of version 3 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details - YOU HAVE BEEN WARNED! * * Program: SIDESPLITTER V1.2 * * Authors: Chris Aylett * Colin Palmer * */ // Library header inclusion for linking #include ""sidesplitter.h"" #include ""suppress.h"" // Normalise between in/out double normalise(double *in1, double *in2, double *out1, double *out2, r_mrc *mask, list *node, int32_t size, int32_t nthreads){ int32_t i, max = size * size * size; pthread_t threads[nthreads]; // Calculate mean noise and mean signal cns_arg arg1[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg1[i].mask = mask; arg1[i].in1 = in1; arg1[i].in2 = in2; arg1[i].count = 0.0; arg1[i].noise = 0.0; arg1[i].power = 0.0; arg1[i].size = max; arg1[i].step = nthreads; arg1[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) calc_noise_signal_thread, &arg1[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } long double count = 0.0; long double noise = 0.0; long double power = 0.0; // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } count += arg1[i].count; noise += arg1[i].noise; power += arg1[i].power; } noise /= count; power /= count; double psnr = fabsl(1.0 - noise / power); node->pwr = sqrtl(power); // Correct according to probability and power prob_arg arg2[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg2[i].mask = mask; arg2[i].in1 = in1; arg2[i].in2 = in2; arg2[i].out1 = out1; arg2[i].out2 = out2; arg2[i].rstp = node->stp; arg2[i].rmsd = node->pwr; arg2[i].size = max; arg2[i].step = nthreads; arg2[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) probability_correct_thread, &arg2[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } node->max = psnr; // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } } return psnr; } void calc_noise_signal_thread(cns_arg *arg){ int32_t i; double cur; for (i = arg->thread; i < arg->size; i += arg->step){ // Normalise input transforms first arg->in1[i] = arg->in1[i] / arg->size; arg->in2[i] = arg->in2[i] / arg->size; // Do not calculate statistics from voxels outside the mask if (arg->mask->data[i] < 0.99){ continue; } arg->count += 1.0; cur = arg->in1[i] - arg->in2[i]; arg->noise += cur * cur; cur = arg->in1[i] + arg->in2[i]; arg->power += cur * cur; } return; } void probability_correct_thread(prob_arg *arg){ int32_t i; double res_stp_sd = arg->rstp / arg->rmsd; for (i = arg->thread; i < arg->size; i += arg->step){ arg->out1[i] += arg->in1[i] * res_stp_sd; arg->out2[i] += arg->in2[i] * res_stp_sd; } return; } // Undo normalisation between in/out void reverse_norm(double *in1, double *in2, double *out1, double *out2, r_mrc *mask, list *node, int32_t size, int32_t nthreads){ int32_t i, max = size * size * size; pthread_t threads[nthreads]; prob_arg arg[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg[i].in1 = in1; arg[i].in2 = in2; arg[i].out1 = out1; arg[i].out2 = out2; arg[i].rstp = node->stp; arg[i].rmsd = node->pwr; arg[i].size = max; arg[i].step = nthreads; arg[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) revert_thread, &arg[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } } return; } void revert_thread(prob_arg *arg){ int32_t i; double res_stp_sd = arg->rstp / arg->rmsd; for (i = arg->thread; i < arg->size; i += arg->step){ // Correct output arg->out1[i] += arg->in1[i] / res_stp_sd; arg->out2[i] += arg->in2[i] / res_stp_sd; } return; } ","C" "Conformation","StructuralBiology-ICLMedicine/SIDESPLITTER","realspace.h",".h","2153","65"," /* * Copyright 14/08/2019 - Dr. Christopher H. S. Aylett * * This program is free software; you can redistribute it and/or modify * it under the terms of version 3 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details - YOU HAVE BEEN WARNED! * * Program: SIDESPLITTER V1.2 * * Authors: Chris Aylett * Colin Palmer * */ // Inclusions #include #include #include #include #include #include #include #include #include #include #include // Filter map thread arguments structure typedef struct{ r_mrc *in; double *out; int32_t size; int32_t step; int32_t thread; } map_arg; // Mask making thread argument structure typedef struct{ r_mrc *out; double rad; double cen; int32_t size; int32_t size_2; int32_t step; int32_t thread; } make_mask_arg; void make_mask_thread(make_mask_arg *arg); // Make mask at diameter // pthread function void add_map_thread(map_arg *arg); // Add MRC map in to out // pthread function void apply_mask_thread(map_arg *arg); // Multiply out by in elementwise // pthread function ","Unknown" "Conformation","StructuralBiology-ICLMedicine/SIDESPLITTER","compile.sh",".sh","74","2","gcc -O3 *.c -lm -pthread -lfftw3 -lfftw3_threads -std=c99 -o sidesplitter ","Shell" "Conformation","StructuralBiology-ICLMedicine/SIDESPLITTER","realspace.c",".c","4794","152"," /* * Copyright 14/08/2019 - Dr. Christopher H. S. Aylett * * This program is free software; you can redistribute it and/or modify * it under the terms of version 3 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details - YOU HAVE BEEN WARNED! * * Program: SIDESPLITTER V1.2 * * Authors: Chris Aylett * Colin Palmer * */ // Library header inclusion for linking #include ""sidesplitter.h"" #include ""realspace.h"" // Make mask from radius in voxels r_mrc *make_msk(r_mrc *in, double rad, int32_t nthreads){ r_mrc *out = malloc(sizeof(r_mrc)); int32_t size = in->n_crs[0], i; double cen = (double) size / 2; memcpy(out, in, sizeof(r_mrc)); out->data = calloc(size * size * size, sizeof(float)); pthread_t threads[nthreads]; make_mask_arg arg[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg[i].rad = rad * rad; arg[i].out = out; arg[i].size = size; arg[i].size_2 = size * size; arg[i].cen = cen; arg[i].step = nthreads; arg[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) make_mask_thread, &arg[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } } return out; } void make_mask_thread(make_mask_arg *arg){ double i, j, k, norm; for(int32_t _k = 0; _k < arg->size; _k++){ k = (double) _k - arg->cen; k = k * k; for(int32_t _j = 0; _j < arg->size; _j++){ j = (double) _j - arg->cen; j = j * j; for(int32_t _i = arg->thread; _i < arg->size; _i += arg->step){ i = (double) _i - arg->cen; i = i * i; norm = (double) k + j + i; arg->out->data[ _k * arg->size_2 + _j * arg->size + _i ] = 1.0 / sqrt(1.0 + pow((norm / arg->rad), 8.0)); } } } return; } // Add MRC map in to out void add_map(r_mrc *in, double *out, int32_t nthreads){ int32_t size = in->n_crs[0] * in->n_crs[1] * in->n_crs[2], i; pthread_t threads[nthreads]; map_arg arg[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg[i].in = in; arg[i].out = out; arg[i].size = size; arg[i].step = nthreads; arg[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) add_map_thread, &arg[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } } return; } void add_map_thread(map_arg *arg){ int32_t i; for (i = arg->thread; i < arg->size; i += arg->step){ arg->out[i] += (double) arg->in->data[i]; } return; } // Multiply out by in elementwise void apply_mask(r_mrc *in, double *out, int32_t nthreads){ int32_t size = in->n_crs[0] * in->n_crs[1] * in->n_crs[2], i; pthread_t threads[nthreads]; map_arg arg[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg[i].in = in; arg[i].out = out; arg[i].size = size; arg[i].step = nthreads; arg[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) apply_mask_thread, &arg[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } } return; } void apply_mask_thread(map_arg *arg){ int32_t i; for (i = arg->thread; i < arg->size; i += arg->step){ arg->out[i] *= (double) arg->in->data[i]; } return; } ","C" "Conformation","StructuralBiology-ICLMedicine/SIDESPLITTER","sidesplitter_wrapper.sh",".sh","8451","189","#!/bin/bash # Wrapper to run relion_external_reconstruct and sidesplitter # Version 1.3 # Author: Colin M. Palmer & Takanori Nakane # Usage: # sidesplitter_wrapper.sh path/to/relion_external_reconstruct_star_file.star # # To use from RELION 3.1, set the RELION_EXTERNAL_RECONSTRUCT_EXECUTABLE environment variable to point to this script, # set SIDESPLITTER to point to the sidesplitter binary (or make sure sidesplitter can be found via PATH), and run # relion_refine with the --external_reconstruct argument. For example: # # export RELION_EXTERNAL_RECONSTRUCT_EXECUTABLE=/path/to/sidesplitter_wrapper.sh # export SIDESPLITTER=/path/to/sidesplitter # # then run RELION auto-refine from the GUI and put ""--external_reconstruct"" in the additional arguments box. To run on # a cluster, depending on your configuration you might need to put the environment variable definitions into your # submission script. # Troubleshooting # # If you have problems running SIDESPLITTER using this script, the first thing to check is that external reconstruction # from RELION is working correctly. Try running a normal refinement job, using the ""--external_reconstruct"" argument # but without setting the RELION_EXTERNAL_RECONSTRUCT_EXECUTABLE environment variable. If this fails, the problem is # likely to be with your RELION installation - perhaps it is the wrong version, or different installations are # conflicting with each other. If normal external reconstruction is successful, the problem is likely to be with the # SIDESPLITTER installation, or a bug in this script. # How this script works: # # If the target file name contains ""_half"", this script assumes two copies of itself will be running (for the two half # data sets). The two copies will coordinate with each other by creating, checking for and deleting a directory called # ""sidesplitter_running"". Both scripts will run relion_external_reconstruct for their given half data set. The first # script will wait for both reconstructions to finish, then call SIDESPLITTER to process both half maps. The second # script will wait for the first to finish running SIDESPLITTER and then exit (because if either of the scripts exits # before the processing is finished, RELION moves on and tries to continue its own processing before the filtered # volumes are ready). # # If the target file name does not contain ""_half"", this script assumes there is only a single copy of itself running. # In this case it calls relion_external_reconstruct, waits for the reconstruction to finish and then exits. # This handles the final iteration when the two half sets are combined, at which point RELION calls the external # reconstruction program just once to reconstruct the final combined volume. # # Note that this script is not particularly robust. If one of the commands fails, it's possible you might need to # manually tidy up the job directory and remove the ""sidesplitter_running"" directory to avoid problems in the next run. #### Configuration # SIDESPLITTER command (""sidesplitter"" unless defined in the SIDESPLITTER environment variable) sidesplitter_default=sidesplitter sidesplitter=${SIDESPLITTER:-${sidesplitter_default}} # Change to true to activate debug output (to check for problems with process coordination) debug=false #### Main script # Convenience function to print and run a command echo_and_run() { echo ""$$ $(date) Running $@"" eval ""$@"" } # Expect this to be called with one argument, pointing at a STAR file for relion_external_reconstruct base_name=$(basename -- ""$1"" "".star"") job_dir=$(dirname -- ""$1"") base_path=""${job_dir}/${base_name}"" base_dir=`dirname $base_path` body_id=$(echo ${base_name} | sed -n 's,^.*_body\([0-9]*\)_external_reconstruct.*$,\1,p') # Find the mask # TODO: Do this only once! mask="""" if [ -z ""$body_id"" ]; then # multibody mask=$(awk '/fn_mask/ { gsub(/^""|""$/, """", $2); print $2 }' ${base_dir}/job.star) else fnbody=$(awk '/fn_bodies/ { gsub(/^""|""$/, """", $2); print $2 }' ${base_dir}/job.star) origmask=$(relion_star_printtable $fnbody data_ rlnBodyMaskName | sed ""${body_id}q;d"") mask=${base_dir}/centered_mask_body${body_id}.mrc relion_image_handler --i $origmask --o $mask `relion_image_handler --i $origmask --com | awk '{print ""--shift_x ""(-$10)"" --shift_y ""(-$12)"" --shift_z ""(-$14)}'` fi # Because only one of the two performs the actual work, use twice the number of threads. nthreads=$(awk '/nr_threads/ { gsub(/^""|""$/, """", $2); print 2*$2 }' ${base_path%/*}/job.star) $debug && echo NTHREADS=$nthreads $debug && echo BODY_ID=$body_id $debug && echo MASK=$mask # Create a name to use for Sidesplitter output by removing ""_half1"" or ""_half2"" and ""_external_reconstruct"" from base_name name_without_half=""${base_name/_half[12]/}"" sidesplitter_base=""${job_dir}/${name_without_half/_external_reconstruct/}_sidesplitter"" running_indicator_dir=""${sidesplitter_base}_running"" $debug && echo ""$$ Checking for existence of $running_indicator_dir ..."" if mkdir ""$running_indicator_dir"" 2> /dev/null; then first=true $debug && echo ""$$ Created $running_indicator_dir"" else first=false $debug && echo ""$$ $running_indicator_dir already exists"" fi echo_and_run ""relion_external_reconstruct \""$1\"" > \""${base_path}.out\"" 2> \""${base_path}.err\"""" if [[ $base_name != *""_half""* ]]; then if $first; then $debug && echo ""$$ $(date) Only a single reconstruction, removing $running_indicator_dir and exiting."" rmdir ""$running_indicator_dir"" exit 0 else $debug && echo ""$$ $(date) Error! Found pre-existing $running_indicator_dir for single reconstruction job."" exit 1 fi fi $debug && echo ""$$ Moving output file ${base_path}.mrc to ${base_path}_orig.mrc"" mv ""${base_path}.mrc"" ""${base_path}_orig.mrc"" #### START OF FSC MODIFICATION SEGMENT #### # Inflate FSC by FSC_SS = (sqrt(2 (FSC + FSC^2)) + FSC) / (2 + FSC) # Comment this out if FSC modification is not desirable - e.g. for particularly poorly stable refinements outstar=`awk '/_rlnExtReconsResultStarfile/ {print $2}' $1` echo ""Writing adjusted FSC curve to $outstar"" echo ""data_ loop_ _rlnSpectralIndex #1 _rlnGoldStandardFsc #2 _rlnFourierShellCorrelation #3 "" > $outstar relion_star_printtable $1 data_external_reconstruct_tau2 rlnSpectralIndex rlnGoldStandardFsc | awk '{$3 = (sqrt(2 * ($2 + $2 * $2)) + $2) / (2 + $2); print $0}' >> $outstar #### END OF FSC MODIFICATION SEGMENT #### if $first; then $debug && echo ""$$ $(date) First reconstruct job finished; waiting for $running_indicator_dir to disappear"" while [[ -d $running_indicator_dir ]]; do $debug && echo ""$$ $(date) $running_indicator_dir still exists; waiting..."" sleep 5 done $debug && echo ""$$ $(date) $running_indicator_dir has disappeared. Moving on to SIDESPLITTER step."" # Prepare the SIDESPLITTER command half1_basename=${base_path/half2/half1} half2_basename=${base_path/half1/half2} sidesplitter_command=""OMP_NUM_THREADS=$nthreads $sidesplitter --v1 \""${half1_basename}_orig.mrc\"" --v2 \""${half2_basename}_orig.mrc\"" --rotfl"" if [[ -z ""$mask"" ]]; then echo ""Warning: no mask found! SIDESPLITTER will give better results if you use a mask."" else sidesplitter_command=""${sidesplitter_command} --mask \""${mask}\"""" fi sidesplitter_command=""${sidesplitter_command} > \""${sidesplitter_base}.out\"""" # Run SIDESPLITTER echo_and_run ""$sidesplitter_command"" # Move output files to where RELION expects them $debug && echo ""$$ Moving sidesplitter output ${half1_basename}_orig_sidesplitter.mrc to ${half1_basename}.mrc"" mv ${half1_basename}_orig_sidesplitter.mrc ${half1_basename}.mrc $debug && echo ""$$ Moving sidesplitter output ${half2_basename}_orig_sidesplitter.mrc to ${half2_basename}.mrc"" mv ${half2_basename}_orig_sidesplitter.mrc ${half2_basename}.mrc $debug && echo ""$$ $(date) Finished sidesplitter. Recreating $running_indicator_dir to indicate job finished."" mkdir ""$running_indicator_dir"" else $debug && echo ""$$ $(date) Second reconstruct job finished; removing $running_indicator_dir"" rmdir ""$running_indicator_dir"" $debug && echo ""$$ $(date) Waiting for $running_indicator_dir to reappear"" while [[ ! -d $running_indicator_dir ]]; do $debug && echo ""$$ $(date) $running_indicator_dir does not exist; waiting..."" sleep 60 done $debug && echo ""$$ $(date) $running_indicator_dir has reappeared. Removing it and exiting"" rmdir ""$running_indicator_dir"" fi ","Shell" "Conformation","StructuralBiology-ICLMedicine/SIDESPLITTER","suppress.h",".h","2385","72"," /* * Copyright 14/08/2019 - Dr. Christopher H. S. Aylett * * This program is free software; you can redistribute it and/or modify * it under the terms of version 3 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details - YOU HAVE BEEN WARNED! * * Program: SIDESPLITTER V1.2 * * Authors: Chris Aylett * Colin Palmer * */ // Inclusions #include #include #include #include #include #include #include #include #include #include #include // Noise and signal power thread arguments structure typedef struct{ r_mrc *mask; double *in1; double *in2; long double count; long double noise; long double power; int32_t size; int32_t step; int32_t thread; } cns_arg; // Probabilistic correction thread arguments structure typedef struct{ r_mrc *mask; double *in1; double *in2; double *out1; double *out2; long double rstp; long double rmsd; int32_t size; int32_t step; int32_t thread; } prob_arg; void calc_noise_signal_thread(cns_arg *arg); // Calculate noise and signal power // pthread function void probability_correct_thread(prob_arg *arg); // Correct according to probability // pthread function void revert_thread(prob_arg *arg); // Revert to original power // pthread function ","Unknown" "Conformation","StructuralBiology-ICLMedicine/SIDESPLITTER","sidesplitter.h",".h","5035","156"," /* * Copyright 14/08/2019 - Dr. Christopher H. S. Aylett * * This program is free software; you can redistribute it and/or modify * it under the terms of version 3 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details - YOU HAVE BEEN WARNED! * * Program: SIDESPLITTER V1.2 * * Authors: Chris Aylett * Colin Palmer * */ // Library header inclusion for linking #include #include #include #include #include #include #include #include #include #include #include /* Type definitions */ #ifndef NDEBUG #define DEBUG #endif // Arguments typedef struct { char *vol1; char *vol2; char *mask; int8_t spec; int8_t rotf; } arguments; // List node typedef struct list list; struct list { long double res; long double stp; long double pwr; double crf; double fsc; double max; list *prv; list *nxt; }; // MRC files typedef struct { int32_t n_crs[3]; int32_t mode; int32_t start_crs[3]; int32_t n_xyz[3]; float length_xyz[3]; float angle_xyz[3]; int32_t map_crs[3]; float d_min; float d_max; float d_mean; int32_t ispg; int32_t nsymbt; int32_t extra[25]; int32_t ori_xyz[3]; char map[4]; char machst[4]; float rms; int32_t nlabl; char label[800]; float *data; } r_mrc; /* Function definitions */ arguments *parse_args(int argc, char **argv); // Read and return arguments structure // Exit if required args not specified int get_num_jobs(); // Returns number of processors list *extend_list(list *node, double p); // Extend list by one using p-val // Calculates step size list *end_list(list *node); // Finish list to 0.5 for overfit calculation r_mrc *read_mrc(char* filename); // Read mrc file and build struct void write_mrc(r_mrc *mrc, double *map, char* filename, int32_t size); // Read mrc file and build struct void strip_ext(char *fname); // Strip extention from filename r_mrc *make_msk(r_mrc *mrc, double rad, int32_t nthread); // Make mask from radius in voxels void add_map(r_mrc *in, double *out, int32_t nthread); // Add MRC map in to out void add_fft(fftw_complex *in, fftw_complex *out, int32_t size, int32_t nthread); // Add FFT in to out double get_spectrum(fftw_complex *half1, fftw_complex *half2, long double *spec1, long double *spec2, int32_t full, int32_t nthreads); // Get spectra for halves void apply_spectrum(fftw_complex *half1, fftw_complex *half2, long double *spec1, long double *spec2, double cutoff, int32_t full, int32_t nthreads); // Reapply spectra to halves void apply_mask(r_mrc *in, double *out, int32_t nthread); // Multiply out by in elementwise void bandpass_filter(fftw_complex *in, fftw_complex *out, list *node, int32_t size, int32_t nthread); // Apply bandpass to in and writes to out // List node specifies resolutions void lowpass_filter(fftw_complex *in, fftw_complex *out, list *node, int32_t size, int32_t nthread); // Butterworth lowpass from in to out // List node specifies resolution double calc_fsc(fftw_complex *half1, fftw_complex *half2, int32_t size, int32_t nthread); // Calculate FSC over map // Returns FSC double normalise(double *in1, double *in2, double *out1, double *out2, r_mrc *mask, list *node, int32_t size, int32_t nthread); // Suppress noise between in/out // Returns mean p-val in mask void reverse_norm(double *in1, double *in2, double *out1, double *out2, r_mrc *mask, list *node, int32_t size, int32_t nthread); // Revert normalised data double truncate_map(double *in1, double *in2, double *out1, double *out2, r_mrc *mask, list *node, arguments *args, int32_t size, int32_t nthread); // Updates out if in1/2 over noise // Returns fractional recovery double taper_map(double *in1, double *in2, double *out1, double *out2, double *ori1, double *ori2, r_mrc *mask, list *node, arguments *args, int32_t size, int32_t nthread); // Updates out if in1/2 over noise // Returns fractional recovery ","Unknown" "Conformation","StructuralBiology-ICLMedicine/SIDESPLITTER","fouriers.c",".c","14033","434"," /* * Copyright 14/08/2019 - Dr. Christopher H. S. Aylett * * This program is free software; you can redistribute it and/or modify * it under the terms of version 3 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details - YOU HAVE BEEN WARNED! * * Program: SIDESPLITTER V1.2 * * Authors: Chris Aylett * Colin Palmer * */ // Library header inclusion for linking #include ""sidesplitter.h"" #include ""fouriers.h"" // Add FFT in to FFT out void add_fft(fftw_complex *in, fftw_complex *out, int32_t full, int32_t nthreads){ int32_t size = full * full * (full / 2 + 1), i; pthread_t threads[nthreads]; add_fft_arg arg[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg[i].in = in; arg[i].out = out; arg[i].size = size; arg[i].step = nthreads; arg[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) add_fft_thread, &arg[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } } return; } void add_fft_thread(add_fft_arg *arg){ for(int32_t index = arg->thread; index < arg->size; index += arg->step){ arg->out[index] += arg->in[index]; } return; } // Calculate FSC over map double calc_fsc(fftw_complex *half1, fftw_complex *half2, int32_t full, int32_t nthreads){ int32_t size = full * full * (full / 2 + 1), i; pthread_t threads[nthreads]; calc_fsc_arg arg[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg[i].half1 = half1; arg[i].half2 = half2; arg[i].numerator = 0.0; arg[i].denomin_2 = 0.0; arg[i].denomin_1 = 0.0; arg[i].size = size; arg[i].step = nthreads; arg[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) calc_fsc_thread, &arg[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } long double numerator = 0.0; long double denomin_1 = 0.0; long double denomin_2 = 0.0; // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } numerator += arg[i].numerator; denomin_1 += arg[i].denomin_1; denomin_2 += arg[i].denomin_2; } return (double) (numerator / sqrtl(fabsl(denomin_1 * denomin_2))); } void calc_fsc_thread(calc_fsc_arg *arg){ for(int32_t index = arg->thread; index < arg->size; index += arg->step){ arg->numerator += creal(arg->half1[index] * conj(arg->half2[index])); arg->denomin_1 += creal(arg->half1[index] * conj(arg->half1[index])); arg->denomin_2 += creal(arg->half2[index] * conj(arg->half2[index])); } return; } // Apply bandpass to in and writes to out void bandpass_filter(fftw_complex *in, fftw_complex *out, list *node, int32_t full, int32_t nthreads){ double hires = node->res + node->stp; double lores = node->res; hires = hires * hires; lores = lores * lores; double dim = (double) full; int32_t size = (full / 2) + 1, i; int32_t full_size = full * size; pthread_t threads[nthreads]; filter_arg arg[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg[i].in = in; arg[i].out = out; arg[i].hires = hires; arg[i].lores = lores; arg[i].dim = dim; arg[i].full_size = full_size; arg[i].full = full; arg[i].size = size; arg[i].step = nthreads; arg[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) bandpass_filter_thread, &arg[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } } return; } void bandpass_filter_thread(filter_arg* arg){ double norms, kd, jd, id; int32_t index; for(int _k = 0, k = 0; _k < arg->full; _k++, k = (_k < arg->size) ? _k : _k - arg->full){ kd = ((double) k) / arg->dim; for(int _j = 0, j = 0; _j < arg->full; _j++, j = (_j < arg->size) ? _j : _j - arg->full){ jd = ((double) j) / arg->dim; for(int _i = arg->thread, i = arg->thread; _i < arg->size; _i += arg->step, i = _i){ id = ((double) i) / arg->dim; norms = kd * kd + jd * jd + id * id; index = _k * arg->full_size + _j * arg->size + _i; arg->out[index] = arg->in[index] * (sqrt(1.0 / (1.0 + pow((norms / arg->hires), 8.0))) - sqrt(1.0 / (1.0 + pow((norms / arg->lores), 8.0)))); } } } return; } // Butterworth lowpass from in to out void lowpass_filter(fftw_complex *in, fftw_complex *out, list *node, int32_t full, int32_t nthreads){ double hires = node->res + node->stp; hires = hires * hires; double dim = (double) full; int32_t size = (full / 2) + 1, i; int32_t full_size = full * size; pthread_t threads[nthreads]; filter_arg arg[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg[i].in = in; arg[i].out = out; arg[i].hires = hires; arg[i].dim = dim; arg[i].full_size = full_size; arg[i].full = full; arg[i].size = size; arg[i].step = nthreads; arg[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) lowpass_filter_thread, &arg[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } } return; } void lowpass_filter_thread(filter_arg *arg){ double norms, kd, jd, id; int32_t index; for(int _k = 0, k = 0; _k < arg->full; _k++, k = (_k < arg->size) ? _k : _k - arg->full){ kd = ((double) k) / arg->dim; for(int _j = 0, j = 0; _j < arg->full; _j++, j = (_j < arg->size) ? _j : _j - arg->full){ jd = ((double) j) / arg->dim; for(int _i = arg->thread, i = arg->thread; _i < arg->size; _i += arg->step, i = _i){ id = ((double) i) / arg->dim; norms = kd * kd + jd * jd + id * id; index = _k * arg->full_size + _j * arg->size + _i; arg->out[index] = arg->in[index] * sqrt(1.0 / (1.0 + pow((norms / arg->hires), 8.0))); } } } return; } // Calculate spectrum over map double get_spectrum(fftw_complex *half1, fftw_complex *half2, long double *spec1, long double *spec2, int32_t full, int32_t nthreads){ double fsc, crf, cut = 0.0; double dim = (double) full; int32_t size = (full / 2) + 1, i, j; int32_t full_size = full * size; int32_t *n = calloc(full, sizeof(int32_t)); long double *nom = calloc(full, sizeof(long double)); long double *dn1 = calloc(full, sizeof(long double)); long double *dn2 = calloc(full, sizeof(long double)); pthread_t threads[nthreads]; spec_arg arg[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg[i].in1 = half1; arg[i].in2 = half2; arg[i].out1 = calloc(full, sizeof(long double)); arg[i].out2 = calloc(full, sizeof(long double)); arg[i].n = calloc(full, sizeof(int32_t)); arg[i].nom = calloc(full, sizeof(long double)); arg[i].dn1 = calloc(full, sizeof(long double)); arg[i].dn2 = calloc(full, sizeof(long double)); arg[i].dim = dim; arg[i].full_size = full_size; arg[i].full = full; arg[i].size = size; arg[i].step = nthreads; arg[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) get_spec_thread, &arg[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } for (j = 0; j < full; j++){ n[j] += arg[i].n[j]; spec1[j] += arg[i].out1[j]; spec2[j] += arg[i].out2[j]; nom[j] += arg[i].nom[j]; dn1[j] += arg[i].dn1[j]; dn2[j] += arg[i].dn2[j]; } free(arg[i].n); free(arg[i].out1); free(arg[i].out2); free(arg[i].nom); free(arg[i].dn1); free(arg[i].dn2); } for (i = 0; i < full; i++){ if (n[i] == 0){ continue; } fsc = fabsl((fabsl(nom[i]) / sqrtl(fabsl(dn1[i]) * fabsl(dn2[i])))); crf = sqrt((2.0 * fsc) / (1.0 + fsc)); spec1[i] = crf * (spec1[i] / (double) n[i]); spec2[i] = crf * (spec2[i] / (double) n[i]); if ((cut == 0.0) && (fsc < 0.1)){ cut = ((double) i) / (full * 2.0); } } free(n); spec1[0] = creal(half1[0]); spec2[0] = creal(half2[0]); if (cut == 0.0){ cut = 0.475; } return cut; } void get_spec_thread(spec_arg *arg){ double kd, jd, id; int32_t index, norms; for(int _k = 0, k = 0; _k < arg->full; _k++, k = (_k < arg->size) ? _k : _k - arg->full){ kd = (double) k; for(int _j = 0, j = 0; _j < arg->full; _j++, j = (_j < arg->size) ? _j : _j - arg->full){ jd = (double) j; for(int _i = arg->thread, i = arg->thread; _i < arg->size; _i += arg->step, i = _i){ id = (double) i; norms = (int32_t) round(sqrt(fabs(kd * kd + jd * jd + id * id)) * 2.0); if (norms >= arg->full){ continue; } index = _k * arg->full_size + _j * arg->size + _i; arg->out1[norms] += sqrtl(fabsl(creal(arg->in1[index] * conj(arg->in1[index])))); arg->out2[norms] += sqrtl(fabsl(creal(arg->in2[index] * conj(arg->in2[index])))); if (arg->nom && arg->dn1 && arg->dn2){ arg->nom[norms] += creal((arg->in1[index]) * conj(arg->in2[index])); arg->dn1[norms] += creal((arg->in1[index]) * conj(arg->in1[index])); arg->dn2[norms] += creal((arg->in2[index]) * conj(arg->in2[index])); } arg->n[norms]++; } } } return; } // Apply spectrum over map void apply_spectrum(fftw_complex *half1, fftw_complex *half2, long double *spec1, long double *spec2, double maxres, int32_t full, int32_t nthreads){ double dim = (double) full; int32_t size = (full / 2) + 1, i, j; int32_t full_size = full * size; int32_t *n = calloc(full, sizeof(int32_t)); long double *cor1 = calloc(full, sizeof(long double)); long double *cor2 = calloc(full, sizeof(long double)); pthread_t threads[nthreads]; spec_arg arg[nthreads]; // Start threads for (i = 0; i < nthreads; i++){ arg[i].in1 = half1; arg[i].in2 = half2; arg[i].out1 = calloc(full, sizeof(long double)); arg[i].out2 = calloc(full, sizeof(long double)); arg[i].n = calloc(full, sizeof(int32_t)); arg[i].nom = NULL; arg[i].dn1 = NULL; arg[i].dn2 = NULL; arg[i].dim = dim; arg[i].full_size = full_size; arg[i].full = full; arg[i].size = size; arg[i].step = nthreads; arg[i].thread = i; if (pthread_create(&threads[i], NULL, (void*) get_spec_thread, &arg[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } for (j = 0; j < full; j++){ n[j] += arg[i].n[j]; cor1[j] += arg[i].out1[j]; cor2[j] += arg[i].out2[j]; } free(arg[i].n); free(arg[i].out1); free(arg[i].out2); } // Normalise int32_t cut = (int32_t) (maxres * full * 2.0); for (i = 0; i < full; i++){ if (i < cut){ cor1[i] = spec1[i] / (cor1[i] / (long double) n[i]); cor2[i] = spec2[i] / (cor2[i] / (long double) n[i]); } else { cor1[i] = 0.0; cor2[i] = 0.0; } } // Start threads for (i = 0; i < nthreads; i++){ arg[i].out1 = cor1; arg[i].out2 = cor2; if (pthread_create(&threads[i], NULL, (void*) apply_spec_thread, &arg[i])){ printf(""\nThread initialisation failed!\n""); fflush(stdout); exit(1); } } // Join threads for (i = 0; i < nthreads; i++){ if (pthread_join(threads[i], NULL)){ printf(""\nThread failed during run!\n""); fflush(stdout); exit(1); } } half1[0] = spec1[0] + 0.0J; half2[0] = spec2[0] + 0.0J; free(cor1); free(cor2); free(n); return; } void apply_spec_thread(spec_arg *arg){ double kd, jd, id; int32_t index, norms; for(int _k = 0, k = 0; _k < arg->full; _k++, k = (_k < arg->size) ? _k : _k - arg->full){ kd = (double) k; for(int _j = 0, j = 0; _j < arg->full; _j++, j = (_j < arg->size) ? _j : _j - arg->full){ jd = (double) j; for(int _i = arg->thread, i = arg->thread; _i < arg->size; _i += arg->step, i = _i){ id = (double) i; norms = (int32_t) round(sqrt(fabs(kd * kd + jd * jd + id * id)) * 2.0); index = _k * arg->full_size + _j * arg->size + _i; if (norms >= arg->full){ arg->in1[index] *= 0.0; arg->in2[index] *= 0.0; continue; } arg->in1[index] *= arg->out1[norms]; arg->in2[index] *= arg->out2[norms]; } } } return; } ","C" "Conformation","StructuralBiology-ICLMedicine/SIDESPLITTER","fouriers.h",".h","3253","112"," /* * Copyright 14/08/2019 - Dr. Christopher H. S. Aylett * * This program is free software; you can redistribute it and/or modify * it under the terms of version 3 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details - YOU HAVE BEEN WARNED! * * Program: SIDESPLITTER V1.2 * * Authors: Chris Aylett * Colin Palmer * */ // Inclusions #include #include #include #include #include #include #include #include #include #include #include // Add FFT thread arguments structure typedef struct { fftw_complex *in; fftw_complex *out; int32_t size; int32_t step; int32_t thread; } add_fft_arg; // Calc FSC thread arguments structure typedef struct{ fftw_complex *half1; fftw_complex *half2; long double numerator; long double denomin_1; long double denomin_2; int32_t size; int32_t step; int32_t thread; } calc_fsc_arg; // Filter map thread arguments structure typedef struct{ fftw_complex *in; fftw_complex *out; double hires; double lores; double dim; int32_t full_size; int32_t full; int32_t size; int32_t step; int32_t thread; } filter_arg; // Spectrum thread arguments structure typedef struct{ fftw_complex *in1; fftw_complex *in2; long double *out1; long double *out2; long double *nom; long double *dn1; long double *dn2; int32_t *n; double dim; int32_t full_size; int32_t full; int32_t size; int32_t step; int32_t thread; } spec_arg; void add_fft_thread(add_fft_arg *arg); // Add FFT in to out // pthread function void bandpass_filter_thread(filter_arg *arg); // Apply bandpass to in and writes to out // List node specifies resolutions // pthread function void lowpass_filter_thread(filter_arg *arg); // Butterworth lowpass from in to out // List node specifies resolution // pthread function void calc_fsc_thread(calc_fsc_arg *arg); // Calculate FSC over map // pthread function void get_spec_thread(spec_arg *arg); // Calculate spectrum over map // pthread function void apply_spec_thread(spec_arg *arg); // Calculate spectrum over map // pthread function ","Unknown" "Conformation","StructuralBiology-ICLMedicine/SIDESPLITTER","truncate.h",".h","2363","73"," /* * Copyright 14/08/2019 - Dr. Christopher H. S. Aylett * * This program is free software; you can redistribute it and/or modify * it under the terms of version 3 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details - YOU HAVE BEEN WARNED! * * Program: SIDESPLITTER V1.2 * * Authors: Chris Aylett * Colin Palmer * */ // Inclusions #include #include #include #include #include #include #include #include #include #include #include // Noise and signal power thread arguments structure typedef struct{ r_mrc *mask; double *in1; double *in2; double noise; double count; int32_t size; int32_t step; int32_t thread; long double sigma; } max_arg; // Probabilistic correction thread arguments structure typedef struct{ double *in1; double *in2; double *out1; double *out2; double *ori1; double *ori2; double noise; double rcv; int32_t size; int32_t step; int32_t thread; } ass_vox_arg; void calc_max_noise_thread(max_arg *arg); // Calculate noise and signal power // pthread function void assign_voxels_thread(ass_vox_arg *arg); // Correct according to probability // pthread function void taper_voxels_thread(ass_vox_arg *arg); // Correct according to probability // pthread function ","Unknown" "Conformation","StructuralBiology-ICLMedicine/SIDESPLITTER","interact.c",".c","24456","355"," /* * Copyright 14/08/2019 - Dr. Christopher H. S. Aylett * * This program is free software; you can redistribute it and/or modify * it under the terms of version 3 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details - YOU HAVE BEEN WARNED! * * Program: SIDESPLITTER V1.2 * * Authors: Chris Aylett * Colin Palmer * */ // Library header inclusion for linking #include ""sidesplitter.h"" int get_num_jobs(void){ // Obtain thread number from environmental variables char* thread_number = getenv(""OMP_NUM_THREADS""); int nthreads = 0; if (thread_number){ // If thread number specified by user - use this one nthreads = atoi(thread_number); } if (nthreads < 1){ // If thread number still not set - try sysconf nthreads = sysconf(_SC_NPROCESSORS_ONLN); } if (nthreads < 1){ // If variables are both empty - use a single thread nthreads = 1; } return nthreads; } arguments *parse_args(int argc, char **argv){ // Print usage and disclaimer printf(""\n\n\n""); char *splash = "" \n"" "" \n"" "" #@#..*%@@@( \n"" "" .@# .#@( ,@@@(./#@@@( \n"" "" %& &@* .@@ ,@% \n"" "" *@, @# ,@# @ @# \n"" "" @% .@. .@/ @ @ \n"" "" @ #( @( ,* # \n"" "" .& *&* *@& @ .@ /# %* \n"" "" #, (@, &( / (,. /@*@ @ (/ @ \n"" "" & ( %@.( *., ,% #*@ @. *, \n"" "" ( , @ %& (/ /% *#&@@@@@&&&@@@@@%( ( @ @ @ ,# \n"" "" , % %/ .*,/ *& @ %* /, \n"" "" % %@ /# . ,/,, % @ . @ \n"" "" @ @ .%#*@* @( ,% @ \n"" "" # & @. @ & % % \n"" "" / ** @, (, .( ,@ # # ./ \n"" "" @ @ @ /% * @*& %* .,%@@@@( # ,. \n"" "" / ,/& @ ,,#%. #%,..*@%% @ @ @( .//&,#@ @ / \n"" "" @ % % @ .& %/&%*..@* . @ /# /. @(% & % ** & \n"" "" @@ #*/ (,( @* @ .% @/ .*.@& @ &. / .(&@@%/@# \n"" "" & %( ** ./ & , .( @ ( ## @, & @ * @ ./@@, \n"" "" ., @ @@&(#%@( *,@ @/@@&((@@@ @ @ #( @ %, % # @ /@ \n"" "" %. @ @& @ ,* @ %* ,& @ @ @ , @ (//& ,@@#. (@&@ @ @ @& \n"" "" ,* ,(* .(, ## @# @* @ @. #%/%@ * (@* & , @ & @ @( \n"" "" & &@ ,(# #%@#, .* ( / &%%,% @. / # &( ,@ , ,%. .# % ,@ \n"" "" **@ @ @ , , , (.@ %& * #( ,@,/&/ %% . @ .@ \n"" "" ,& .& *@ .*(&%/ % . *& ( @ @ , ,&/ # @*@ @ @# @/@@* @ % &. # (& \n"" "" ,@@@@ #@ . @ % & #*( #(. @/# .@/@&@% & *&@ /@ @% (* & %.@* @ @#, (, \n"" "" @ .@ % @ & & * * . ,@. & @/&&(/ % #@%@# @&( (, @.*#@ @ % .% (, /@ \n"" "" &* @.(@/ /@@ @ ./ / /% (%(,.. *@ .@/ @# @* & , , .%@#( % #& @,&.( & / & @ @ @ \n"" "" @ %( @,&( .,, .( &. * ...., # @,#(% (. #%.%% *@, % *,(@ (//(@ # @/ @ , % .@, \n"" "" @ @ @@@ % @ .@ &, #& &@#@ #@@ #* % ( . & @ ,& /.* @ @. ,& // \n"" "" /& . (@* # / */ . @&& %& . /@. @ *. /& %@* & (& \n"" "" @,, # & (& (%%* (%#,& % ,@( , * @( @ @ (& / .# # @, ,@ \n"" "" /(&(@ ( .% ,. @ (& .,.@ @. @/ # @ . @, @ ,& & ,( , ,@ * ** ,. \n"" "" @ % * & /. % * @& &@, / ,@ @ % (, @ @ .. (,@@@% .% * , @ @ (@@% \n"" "" @ * (. / @,. @ % *, @ @ @# @#&( / @# & @ , . , @* (& (@ \n"" "" & # ( . ., % ** .. #.# % *@ *@ % * ,@ ,& @ / . & @ /@* (% \n"" "" # %/% ( @ % @ ( * .. %@ // @ ( ( %/#( #@ % # @ #( */ & . \n"" "" @, , @ .% , & .,,/ @@ # @ .* *.@ & @. # . @, .@ @/ %/ ,# &. %. #% \n"" "" @ @ &,@ ( % @.( ( @@ @ /. / @ @ *,( @* @ &% *@ & @ #@&* @ \n"" "" .( % &(%**@ . (, & @@ @ /% /@ & & /@ ,@& @,& (@ . *, . \n"" "" @ (@@ @@ .@ % (# %/ (*@ .& / .& %( , @ @( %@ @%, & \n"" "" % @@ & & (@ &,& %@ @ @ @/ %* & & @ (. , @, & \n"" "" , % .@* @ @ @ @%@ &@ &@ ,@@@, (@ .( * @ / % %/ & @ @. \n"" "" @ . # *#& @/*&@ @& ,@, @ . ( @ ,@ @ #& /@ \n"" "" @ @ &. &*( ( @ @( @@ & . . , @ @/ \n"" "" @( (* ,@ /*( . ,@, @ @ & @ *, @ .@#@@&&,, &@ & \n"" "" .@@ @ %* # &%/@ & */ /@(. &@( % & @# @. \n"" "" .% @ %, / @%@ %. @ * % (@ %@* , %@* & ( \n"" "" /. @, /@ @# @. @ % @ @ @ % @@ & @ . \n"" "" @ .@% /&@ ,( @ @ % .% .% & # @* @ #@ . \n"" "" * ,@/ % % %@ & @ @ # @ @ @ % &@ @ @.& \n"" "" @ @ .% * & @ , @ /% & # & ( @ @. % * &* \n"" "" , ., # # # & @ &@@. # ( (, % & @ .(. &/ & @ \n"" "" / @ @ . * /( @ @ @ @, # / @ @ %/ @# %,( & @* \n"" "" %@( * *& . @ %, . ,# *@, / * @ @ @( % @ \n"" "" ** % / % @ /@%/. %/ @@% ., & /, @ % \n"" "" @( @ @ %. #// (/ / @ .* /* & .@ @( \n"" "" %# ,, @. @ ,% &% & & @ ## .@ \n"" "" @ && .&/ (/ * ,. & @, .@ @ @ @, (& \n"" "" % .@ @% ,@ % @ @. ,@ @@ @* @ &* #.@ *((/(//@, @,( \n"" "" *# @. ,@ %& . & @/ %@@ @* @ @ %@. ##, . .@ \n"" "" (@ @, @ ,/ # (. / *@ @ *@ &% ( . ,# \n"" "" %& @* ,% & . # * & @@ #@ @ @ % \n"" "" #@ *&@@@* @ . / @ @. % @ %@& (%& \n"" "" /@ ,&// # *@@ ( .@@@&. @ .( *% . , \n"" "" @, @, /@@&%/,*/#&@%* *# @( &, @ /# \n"" "" @@ .@ & . @ #@ @ .(%&* & . \n"" "" @@ / .@@, # .&(&@ @ (@ ((. & # @ . \n"" "" @@( & &/&/. .*%%&*. @@, % . &@ \n"" "" &@@@ & @( . @@ .@@, \n"" "" %@@@ #& ## .,@&@@* \n"" "" \n"" "" \n"" "" \n"" "" \n"" "" \n"" "" __ __ __ ____ __ ____ __ __ ______ ______ ____ _____ \n"" "" / /\\| |\\| \\ | _|\\ / /\\| \\ | |\\ | || || || _|| \\ \n"" "" / / /| ||| \\ | |\\_\\/ / /| > || || | ||__ __||_ _|| |\\ | > /\\ \n"" "" \\ \\/ | ||| , \\| -| \\ \\/ | _/\\| || | ||\\| |\\_\\\\| |\\\\| -,| / / \n"" "" \\ \\ | ||| ` /| -'\\ \\ \\ | |\\\\/| |_ | || | || | || | -\\| \\/ \n"" "" / /\\| ||| / | |_\\/ / /\\| || | || || | || | || | |_\\| \\ \n"" "" /__/ /|__|||__/ /|____|\\/__/ /|__|| |____||__|| |__|| |__|| |____||__/\\__\\ \n"" "" \\__\\/ \\__\\/\\__\\/ \\____\\/\\__\\/ \\__\\/ \\____\\\\__\\/ \\__\\/ \\__\\/ \\____\\/\\__\\\\__\\ \n"" "" \n"" "" \n"" "" \n""; printf(""\n%s\n\n"", splash); if (argc < 7){ printf(""\n Usage: %s --v1 half_map1.mrc --v2 half_map2.mrc --mask mask.mrc [ --spectrum || --rotfl ]\n\n"", argv[0]); } printf("" PLEASE NOTE: SIDESPLITTER requires the unfiltered halfmaps and mask from each iteration or your results will be invalid\n""); printf("" Setting flag --spectrum outputs the natural SNR weighted spectrum rather than matching your input spectrum\n""); printf("" Setting flag --rotfl performs SNR tapering, matching input density in real-space rather than Fourier-space\n""); printf("" Remember - Junk in = Junk out! Please report any bug or observation to c.aylett@imperial.ac.uk, good luck!\n\n""); printf("" SIDESPLITTER V1.2: LAFTER algorithm for halfmaps - 06-06-2020 GNU Public Licensed - K Ramlaul, CM Palmer and CHS Aylett\n\n""); // Capture user requested settings int i; arguments *args = malloc(sizeof(arguments)); memset(args, 0, sizeof(arguments)); for (i = 1; i < argc; i++){ if (!strcmp(argv[i], ""--v1"") && ((i + 1) < argc)){ args->vol1 = argv[i + 1]; } else if (!strcmp(argv[i], ""--v2"") && ((i + 1) < argc)){ args->vol2 = argv[i + 1]; } else if (!strcmp(argv[i], ""--mask"") && ((i + 1) < argc)){ args->mask = argv[i + 1]; } else if (!strcmp(argv[i], ""--spectrum"")){ args->spec = 1; } else if (!strcmp(argv[i], ""--rotfl"")){ args->rotf = 1; } } if (args->vol1 == NULL || args->vol2 == NULL){ printf("" Necessary maps not found or unspecified - SIDESPLITTER absolutely requires the two halfset volumes and any mask applied\n\n""); exit(1); } return args; } // Extend list by one using p-val list *extend_list(list *current, double p){ list *node = calloc(1, sizeof(list)); node->res = current->res + current->stp; node->stp = p * (node->res / 64.0); node->prv = current; node->nxt = NULL; current->nxt = node; return node; } // End list for overfitting calculation list *end_list(list *current){ list *node = calloc(1, sizeof(list)); node->res = current->res + current->stp; node->stp = 0.475 - (current->res + current->stp); if (node->stp < 0.0625){ node->stp = 0.0625; } node->prv = current; node->nxt = NULL; current->nxt = node; return node; } // Read map header and data and return corresponding data structure r_mrc *read_mrc(char *filename){ FILE *f; int i; f = fopen(filename, ""rb""); if (!f){ printf(""\n\tError reading %s - bad file handle\n\n"", filename); exit(1); } r_mrc *header = calloc(1, sizeof(r_mrc)); fread(&header->n_crs, 4, 3, f); fread(&header->mode, 4, 1, f); /* We only accept mode 2 - c float32 / FORTRAN real - because implementing checks for other data types would require pointer casting everywhere */ if (header->mode != 2){ printf(""Error reading %s - not 32 bit data \n"", filename); exit(1); } fread(&header->start_crs, 4, 3, f); fread(&header->n_xyz, 4, 3, f); fread(&header->length_xyz, 4, 3, f); fread(&header->angle_xyz, 4, 3, f); fread(&header->map_crs, 4, 3, f); fread(&header->d_min, 4, 1, f); fread(&header->d_max, 4, 1, f); fread(&header->d_mean, 4, 1, f); fread(&header->ispg, 4, 1, f); fread(&header->nsymbt, 4, 1, f); fread(&header->extra, 4, 25, f); fread(&header->ori_xyz, 4, 3, f); fread(&header->map, 1, 4, f); fread(&header->machst, 1, 4, f); fread(&header->rms, 4, 1, f); fread(&header->nlabl, 4, 1, f); fread(&header->label, 1, 800, f); // Check cube if (header->n_crs[0] != header->n_crs[1] || header->n_crs[0] != header->n_crs[2]){ printf(""Error reading %s - map is not a cube\n"", filename); exit(1); } /* Assign float array for data, initialize it to zero and read it in - note that the endianness is not corrected - architectures may therefore be cross-incompatible*/ header->data = calloc((header->n_crs[0] * header->n_crs[1] * header->n_crs[2]), sizeof(float)); if (!header->data){ printf(""Error reading %s - map not allocated\n"", filename); exit(1); } fread(header->data, sizeof(float), (header->n_crs[0] * header->n_crs[1] * header->n_crs[2]), f); fclose(f); if (header->length_xyz[0] < 1e-9 || header->length_xyz[1] < 1e-9 || header->length_xyz[2] < 1e-9){ header->length_xyz[0] = (float) header->n_xyz[0]; header->length_xyz[1] = (float) header->n_xyz[1]; header->length_xyz[2] = (float) header->n_xyz[2]; } return header; } // Write MRC file given an mrc structure and corresponding data void write_mrc(r_mrc* header, double *vol, char* filename, int32_t size){ int i; double total = size * size * size; double current = 0; double tmp, sum = 0; float *hold = header->data; header->data = calloc(total, sizeof(float)); if (!header->data){ printf(""Error reading %s - map not allocated\n"", filename); exit(1); } for (i = 0; i < total; i++){ // Convert double map to float for writing out header->data[i] = (float) vol[i]; } // Calculate new min, max and mean figures for header header->d_min = header->data[0]; header->d_max = header->data[0]; for (i = 0; i < total; i++){ current = (double) header->data[i]; if (current < header->d_min){ header->d_min = (float) current; } if (current > header->d_max){ header->d_max = (float) current; } sum += current; } header->d_mean = (float) (sum / total); // Calculate RMSD to fill in the rms field for scaling sum = 0; for (i = 0; i < total; i++){ tmp = (double) (header->d_mean - header->data[i]); sum += tmp * tmp; } header->rms = (float) sqrt((sum / total)); // Write out 1024 byte header FILE * f; f = fopen(filename, ""wb""); if (!f){ printf(""Error writing %s - bad file handle\n"", filename); exit(1); } fwrite(&size, 4, 1, f); fwrite(&size, 4, 1, f); fwrite(&size, 4, 1, f); fwrite(&header->mode, 4, 1, f); fwrite(&header->start_crs, 4, 3, f); fwrite(&size, 4, 1, f); fwrite(&size, 4, 1, f); fwrite(&size, 4, 1, f); fwrite(&header->length_xyz, 4, 3, f); fwrite(&header->angle_xyz, 4, 3, f); fwrite(&header->map_crs, 4, 3, f); fwrite(&header->d_min, 4, 1, f); fwrite(&header->d_max, 4, 1, f); fwrite(&header->d_mean, 4, 1, f); fwrite(&header->ispg, 4, 1, f); fwrite(&header->nsymbt, 4, 1, f); fwrite(&header->extra, 4, 25, f); fwrite(&header->ori_xyz, 4, 3, f); fwrite(&header->map, 1, 4, f); fwrite(&header->machst, 1, 4, f); fwrite(&header->rms, 4, 1, f); fwrite(&header->nlabl, 4, 1, f); fwrite(&header->label, 1, 800, f); // Write data to file fwrite(header->data, 4, total, f); fclose(f); free(header->data); header->data = hold; return; } void strip_ext(char *fname){ // Strip file extention char *end = fname + strlen(fname); while (end > fname && *end != '.') { --end; } if (end > fname) { *end = '\0'; } } ","C" "Conformation","wen-biao/OM-HiC-scaffolding","integrated-OM-HiC-scaffolding/hirise_commands.pa.sh",".sh","166033","875"," ############################# # #specify the input files: # BAMS=($1) INPUT_FASTA=$2 SHOTGUN_BAM=$3 # ############################# #### # #Some of the scripts expect comma-separated lists of bam files, others expect repeated command-line flags. # BAM1=${BAMS[0]} echo $BAM1 BAMLIST_OPT="""" for f in ${BAMS[@]} do BAMLIST_OPT+=""-b $f "" done echo $BAMLIST_OPT BAMLIST_COMMA=$BAM1 unset BAMS[0] for f in ${BAMS[@]} do BAMLIST_COMMA+="",$f"" done echo $BAMLIST_COMMA BAMS+=($BAM1) echo ${BAMS[*]} HISTOGRAMS="""" #unset BAMS[0] for f in ${BAMS[@]} do HISTOGRAMS+=`basename $f` HISTOGRAMS+="".histogram "" done echo ""histograms: "" $HISTOGRAMS # ##### qual1=$4 qual2=$5 ## ## HiRise Commands start here: ## mkdir links mkdir merge_links mkdir merge_links_tmp bam2len.py -b $BAM1 > raw_lengths.txt if [ ! -e raw_chunks ] ; then mkdir raw_chunks ; fi ; nseqs=`wc -l raw_lengths.txt | cut -d' ' -f 1 ` ; cat raw_lengths.txt | awk '{print $1,0,$2, rand()}' | sort -k4n | awk '{print $1,$2,$3}' | split -d -l `expr $nseqs / 16 + 1` - raw_chunks/bed_chunk. samtools mpileup -q $qual1 -l raw_chunks/bed_chunk.00 $SHOTGUN_BAM | cut -f 1,2,4 | depth_histogram.py -o raw_chunks/00.dhist -t raw_chunks/00.depth_thresholds if [ ! -e raw_chunks ] ; then mkdir raw_chunks ; fi ; nseqs=`wc -l raw_lengths.txt | cut -d' ' -f 1 ` ; cat raw_lengths.txt | awk '{print $1, rand()}' | sort -k2n | awk '{print $1}' | split -d -l `expr $nseqs / 16 + 1` - raw_chunks/chunk. hirise_assembly.py -o assembly0.hra $BAMLIST_OPT -S $SHOTGUN_BAM for f in ${BAMS[@]} do pair_sep_histogram.py -q $qual2 -b $f > `basename $f`.histogram 2> `basename $f`.histogram.err done add_hist.py $HISTOGRAMS > all.merged_histogram window_stats.py -i assembly0.hra -N 1000 > contig_window_sample.txt for k in {0..15};do { if [ $k -lt 10 ] then samtools mpileup -q $qual1 -l raw_chunks/bed_chunk.0$k $SHOTGUN_BAM | cut -f 1,2,4 | dt2.py -t raw_chunks/00.depth_thresholds > raw_chunks/0$k.deep_regions.bed else samtools mpileup -q $qual1 -l raw_chunks/bed_chunk.$k $SHOTGUN_BAM | cut -f 1,2,4 | dt2.py -t raw_chunks/00.depth_thresholds > raw_chunks/$k.deep_regions.bed fi } & done wait contiguity_correction.py -l raw_lengths.txt > contiguity_correction.txt cat raw_chunks/*.deep_regions.bed > deep_regions.bed cat contig_window_sample.txt | cut -f 6 | percentile.py -p 98 > chicago_link_density_threshold.txt estimate_Pn_bam.py -q $qual2 -b $BAMLIST_COMMA -o nn_estimate.txt -N 200 > nn_estimate.txt.out cat all.merged_histogram | histo_smooth2.py | apply_contiguity_correction.py -c contiguity_correction.txt > all_smoothed_corrected.merged_histogram cat all_smoothed_corrected.merged_histogram | model_fit.py -m 1000 -P nn_estimate.txt -o datamodel.out > datamodel.out.out for k in {0..15};do { link_density_scan.py --mask deep_regions.bed -q $qual2 -i assembly0.hra -m 2 -w 1000 -C 16 -c $k -o promisc_segs_$k.txt -M $( cat chicago_link_density_threshold.txt ) } & done wait for k in {0..15};do { if [ $k -lt 10 ] then (cat raw_chunks/chunk.0$k | xargs samtools faidx $INPUT_FASTA ) | gap_lengths.py > raw_chunks/gaps.0$k else (cat raw_chunks/chunk.$k | xargs samtools faidx $INPUT_FASTA ) | gap_lengths.py > raw_chunks/gaps.$k fi } & done wait ####combine the masked regions cat promisc_segs_*.txt > promisc_segs.txt cat promisc_segs.txt > blacklisted_segments.bed cat raw_chunks/gaps.00 raw_chunks/gaps.01 raw_chunks/gaps.02 raw_chunks/gaps.03 raw_chunks/gaps.04 raw_chunks/gaps.05 raw_chunks/gaps.06 raw_chunks/gaps.07 raw_chunks/gaps.08 raw_chunks/gaps.09 raw_chunks/gaps.10 raw_chunks/gaps.11 raw_chunks/gaps.12 raw_chunks/gaps.13 raw_chunks/gaps.14 raw_chunks/gaps.15 | cut -f 2-4,6 > gaps.bed hra_readdeserts.py -q $qual2 -i assembly0.hra -o deserts.bed cat deep_regions.bed blacklisted_segments.bed gaps.bed deserts.bed > combined_mask.bed ###find the potential miss-assembly, break the input assembly contigs/scaffolds for k in {0..15};do { if [ $k -lt 10 ] then weakspots.py -c raw_chunks/chunk.0$k -b $BAMLIST_COMMA -q $qual2 -t 150 -M datamodel.out -B 2.0 > raw_chunks/breaks.0$k else weakspots.py -c raw_chunks/chunk.$k -b $BAMLIST_COMMA -q $qual2 -t 150 -M datamodel.out -B 2.0 > raw_chunks/breaks.$k fi } & done wait hirise_assembly.py -i assembly0.hra -o assembly1.hra -m combined_mask.bed -M datamodel.out cat raw_chunks/breaks.00 raw_chunks/breaks.01 raw_chunks/breaks.02 raw_chunks/breaks.03 raw_chunks/breaks.04 raw_chunks/breaks.05 raw_chunks/breaks.06 raw_chunks/breaks.07 raw_chunks/breaks.08 raw_chunks/breaks.09 raw_chunks/breaks.10 raw_chunks/breaks.11 raw_chunks/breaks.12 raw_chunks/breaks.13 raw_chunks/breaks.14 raw_chunks/breaks.15 > raw_breaks.txt; cat raw_breaks.txt | merge_ranges.py -w 300 -t 0.0 > breaks.txt break_hra.py -i assembly1.hra -b breaks.txt -o broken.hra for k in {0..15};do { if [ $k -lt 10 ] then export_links.py -C 16 -c 0$k -i broken.hra -o links/0$k.merged.links -q $qual2 else export_links.py -C 16 -c $k -i broken.hra -o links/$k.merged.links -q $qual2 fi } & done wait bamMeanDepth2.py -b $SHOTGUN_BAM -q 10 > mean_depth.txt for k in {0..15};do { if [ $k -lt 10 ] then cat links/0$k.merged.links | score_links4.py -M datamodel.out -p 0.0000001 > links/0$k.merged.score else cat links/$k.merged.links | score_links4.py -M datamodel.out -p 0.0000001 > links/$k.merged.score fi } & done wait cat mean_depth.txt | doubleDepthFilter.py > double_depth.txt dump_lengths.py -i broken.hra -o broken_lengths.txt cat links/00.merged.score links/01.merged.score links/02.merged.score links/03.merged.score links/04.merged.score links/05.merged.score links/06.merged.score links/07.merged.score links/08.merged.score links/09.merged.score links/10.merged.score links/11.merged.score links/12.merged.score links/13.merged.score links/14.merged.score links/15.merged.score | grep -v '^#' > merged.scores cat broken_lengths.txt | awk '{print $1,$1}' | sed -e 's/_/ /' | awk '{print $1,$3}' | screen_out.py -k double_depth.txt 1 | awk '{print $2}' > double_depth_broken.txt cat merged.scores | awk '{print $1}' | uniq -c | awk '$1>=7 {print $2}' > cluster_blacklist0.txt cat cluster_blacklist0.txt double_depth_broken.txt > cluster_blacklist.txt cat merged.scores | awk '{print $1,$2,$3-$4}' |clusterpledge.py -L links/00.merged.links -L links/01.merged.links -L links/02.merged.links -L links/03.merged.links -L links/04.merged.links -L links/05.merged.links -L links/06.merged.links -L links/07.merged.links -L links/08.merged.links -L links/09.merged.links -L links/10.merged.links -L links/11.merged.links -L links/12.merged.links -L links/13.merged.links -L links/14.merged.links -L links/15.merged.links --fake -b cluster_blacklist.txt -t 4 > chunking_edges.txt if [ ! -e link_chunks ] ; then mkdir link_chunks ; fi ; cat links/00.merged.links links/01.merged.links links/02.merged.links links/03.merged.links links/04.merged.links links/05.merged.links links/06.merged.links links/07.merged.links links/08.merged.links links/09.merged.links links/10.merged.links links/11.merged.links links/12.merged.links links/13.merged.links links/14.merged.links links/15.merged.links | component_chunk_filter.py -c 16 -l broken_lengths.txt -E chunking_edges.txt -t 0 -m 1000 > component_x.txt for k in {0..15};do { assembler3.py -l broken_lengths.txt -Z component_x.txt -m 1000 -k link_chunks/intra.$k.links -c 1 --set_insert_size_dist_fit_params datamodel.out > assembler.$k.out greedy_chicagoan2.py -t 20.0 -l broken_lengths.txt -Z component_x.txt -m 1000 -c $k -j assembler.$k.out -k link_chunks/intra.$k.links --set_insert_size_dist_fit_params datamodel.out > greedy.$k.out local_oo_opt.py -E -l link_chunks/intra.$k.links -i greedy.$k.out --set_insert_size_dist_fit_params datamodel.out > refined.$k.out.inter cat refined.$k.out.inter | p2edges.py > refined.$k.out } & done wait cat link_chunks/inter.3-10.links link_chunks/intra.3.links link_chunks/intra.10.links | linker4.py -d -a 3 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-10.out 2> merge_links/links.3-10.out.err cat link_chunks/inter.6-9.links link_chunks/intra.6.links link_chunks/intra.9.links | linker4.py -d -a 6 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-9.out 2> merge_links/links.6-9.out.err cat link_chunks/inter.12-13.links link_chunks/intra.12.links link_chunks/intra.13.links | linker4.py -d -a 12 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.12.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.12-13.out 2> merge_links/links.12-13.out.err cat link_chunks/inter.3-12.links link_chunks/intra.3.links link_chunks/intra.12.links | linker4.py -d -a 3 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-12.out 2> merge_links/links.3-12.out.err cat link_chunks/inter.7-9.links link_chunks/intra.7.links link_chunks/intra.9.links | linker4.py -d -a 7 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-9.out 2> merge_links/links.7-9.out.err cat link_chunks/inter.9-10.links link_chunks/intra.9.links link_chunks/intra.10.links | linker4.py -d -a 9 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.9.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.9-10.out 2> merge_links/links.9-10.out.err cat link_chunks/inter.14-14.links link_chunks/intra.14.links link_chunks/intra.14.links | linker4.py -d -a 14 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.14.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.14-14.out 2> merge_links/links.14-14.out.err cat link_chunks/inter.4-11.links link_chunks/intra.4.links link_chunks/intra.11.links | linker4.py -d -a 4 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-11.out 2> merge_links/links.4-11.out.err cat link_chunks/inter.12-12.links link_chunks/intra.12.links link_chunks/intra.12.links | linker4.py -d -a 12 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.12.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.12-12.out 2> merge_links/links.12-12.out.err cat link_chunks/inter.8-15.links link_chunks/intra.8.links link_chunks/intra.15.links | linker4.py -d -a 8 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-15.out 2> merge_links/links.8-15.out.err cat link_chunks/inter.4-15.links link_chunks/intra.4.links link_chunks/intra.15.links | linker4.py -d -a 4 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-15.out 2> merge_links/links.4-15.out.err cat link_chunks/inter.1-8.links link_chunks/intra.1.links link_chunks/intra.8.links | linker4.py -d -a 1 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-8.out 2> merge_links/links.1-8.out.err cat link_chunks/inter.0-3.links link_chunks/intra.0.links link_chunks/intra.3.links | linker4.py -d -a 0 -b 3 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.3.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-3.out 2> merge_links/links.0-3.out.err cat link_chunks/inter.3-4.links link_chunks/intra.3.links link_chunks/intra.4.links | linker4.py -d -a 3 -b 4 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.4.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-4.out 2> merge_links/links.3-4.out.err cat link_chunks/inter.2-8.links link_chunks/intra.2.links link_chunks/intra.8.links | linker4.py -d -a 2 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-8.out 2> merge_links/links.2-8.out.err cat link_chunks/inter.4-4.links link_chunks/intra.4.links link_chunks/intra.4.links | linker4.py -d -a 4 -b 4 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.4.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-4.out 2> merge_links/links.4-4.out.err cat link_chunks/inter.1-7.links link_chunks/intra.1.links link_chunks/intra.7.links | linker4.py -d -a 1 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-7.out 2> merge_links/links.1-7.out.err cat link_chunks/inter.4-9.links link_chunks/intra.4.links link_chunks/intra.9.links | linker4.py -d -a 4 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-9.out 2> merge_links/links.4-9.out.err cat link_chunks/inter.5-12.links link_chunks/intra.5.links link_chunks/intra.12.links | linker4.py -d -a 5 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-12.out 2> merge_links/links.5-12.out.err cat link_chunks/inter.2-14.links link_chunks/intra.2.links link_chunks/intra.14.links | linker4.py -d -a 2 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-14.out 2> merge_links/links.2-14.out.err cat link_chunks/inter.14-15.links link_chunks/intra.14.links link_chunks/intra.15.links | linker4.py -d -a 14 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.14.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.14-15.out 2> merge_links/links.14-15.out.err cat link_chunks/inter.3-13.links link_chunks/intra.3.links link_chunks/intra.13.links | linker4.py -d -a 3 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-13.out 2> merge_links/links.3-13.out.err cat link_chunks/inter.10-14.links link_chunks/intra.10.links link_chunks/intra.14.links | linker4.py -d -a 10 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.10.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.10-14.out 2> merge_links/links.10-14.out.err cat link_chunks/inter.4-12.links link_chunks/intra.4.links link_chunks/intra.12.links | linker4.py -d -a 4 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-12.out 2> merge_links/links.4-12.out.err cat link_chunks/inter.4-13.links link_chunks/intra.4.links link_chunks/intra.13.links | linker4.py -d -a 4 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-13.out 2> merge_links/links.4-13.out.err cat link_chunks/inter.1-1.links link_chunks/intra.1.links link_chunks/intra.1.links | linker4.py -d -a 1 -b 1 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.1.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-1.out 2> merge_links/links.1-1.out.err cat link_chunks/inter.3-5.links link_chunks/intra.3.links link_chunks/intra.5.links | linker4.py -d -a 3 -b 5 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.5.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-5.out 2> merge_links/links.3-5.out.err cat link_chunks/inter.2-2.links link_chunks/intra.2.links link_chunks/intra.2.links | linker4.py -d -a 2 -b 2 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.2.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-2.out 2> merge_links/links.2-2.out.err cat link_chunks/inter.1-2.links link_chunks/intra.1.links link_chunks/intra.2.links | linker4.py -d -a 1 -b 2 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.2.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-2.out 2> merge_links/links.1-2.out.err cat link_chunks/inter.3-15.links link_chunks/intra.3.links link_chunks/intra.15.links | linker4.py -d -a 3 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-15.out 2> merge_links/links.3-15.out.err cat link_chunks/inter.12-15.links link_chunks/intra.12.links link_chunks/intra.15.links | linker4.py -d -a 12 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.12.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.12-15.out 2> merge_links/links.12-15.out.err cat link_chunks/inter.11-15.links link_chunks/intra.11.links link_chunks/intra.15.links | linker4.py -d -a 11 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.11.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.11-15.out 2> merge_links/links.11-15.out.err cat link_chunks/inter.11-11.links link_chunks/intra.11.links link_chunks/intra.11.links | linker4.py -d -a 11 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.11.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.11-11.out 2> merge_links/links.11-11.out.err cat link_chunks/inter.5-8.links link_chunks/intra.5.links link_chunks/intra.8.links | linker4.py -d -a 5 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-8.out 2> merge_links/links.5-8.out.err cat link_chunks/inter.1-10.links link_chunks/intra.1.links link_chunks/intra.10.links | linker4.py -d -a 1 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-10.out 2> merge_links/links.1-10.out.err cat link_chunks/inter.8-10.links link_chunks/intra.8.links link_chunks/intra.10.links | linker4.py -d -a 8 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-10.out 2> merge_links/links.8-10.out.err cat link_chunks/inter.1-14.links link_chunks/intra.1.links link_chunks/intra.14.links | linker4.py -d -a 1 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-14.out 2> merge_links/links.1-14.out.err cat link_chunks/inter.7-8.links link_chunks/intra.7.links link_chunks/intra.8.links | linker4.py -d -a 7 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-8.out 2> merge_links/links.7-8.out.err cat link_chunks/inter.0-12.links link_chunks/intra.0.links link_chunks/intra.12.links | linker4.py -d -a 0 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-12.out 2> merge_links/links.0-12.out.err cat link_chunks/inter.0-7.links link_chunks/intra.0.links link_chunks/intra.7.links | linker4.py -d -a 0 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-7.out 2> merge_links/links.0-7.out.err cat link_chunks/inter.1-11.links link_chunks/intra.1.links link_chunks/intra.11.links | linker4.py -d -a 1 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-11.out 2> merge_links/links.1-11.out.err cat link_chunks/inter.0-2.links link_chunks/intra.0.links link_chunks/intra.2.links | linker4.py -d -a 0 -b 2 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.2.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-2.out 2> merge_links/links.0-2.out.err cat link_chunks/inter.7-11.links link_chunks/intra.7.links link_chunks/intra.11.links | linker4.py -d -a 7 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-11.out 2> merge_links/links.7-11.out.err cat link_chunks/inter.13-15.links link_chunks/intra.13.links link_chunks/intra.15.links | linker4.py -d -a 13 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.13.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.13-15.out 2> merge_links/links.13-15.out.err cat link_chunks/inter.0-4.links link_chunks/intra.0.links link_chunks/intra.4.links | linker4.py -d -a 0 -b 4 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.4.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-4.out 2> merge_links/links.0-4.out.err cat link_chunks/inter.11-14.links link_chunks/intra.11.links link_chunks/intra.14.links | linker4.py -d -a 11 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.11.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.11-14.out 2> merge_links/links.11-14.out.err cat link_chunks/inter.5-10.links link_chunks/intra.5.links link_chunks/intra.10.links | linker4.py -d -a 5 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-10.out 2> merge_links/links.5-10.out.err cat link_chunks/inter.2-9.links link_chunks/intra.2.links link_chunks/intra.9.links | linker4.py -d -a 2 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-9.out 2> merge_links/links.2-9.out.err cat link_chunks/inter.7-15.links link_chunks/intra.7.links link_chunks/intra.15.links | linker4.py -d -a 7 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-15.out 2> merge_links/links.7-15.out.err cat link_chunks/inter.1-3.links link_chunks/intra.1.links link_chunks/intra.3.links | linker4.py -d -a 1 -b 3 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.3.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-3.out 2> merge_links/links.1-3.out.err cat link_chunks/inter.3-9.links link_chunks/intra.3.links link_chunks/intra.9.links | linker4.py -d -a 3 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-9.out 2> merge_links/links.3-9.out.err cat link_chunks/inter.7-13.links link_chunks/intra.7.links link_chunks/intra.13.links | linker4.py -d -a 7 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-13.out 2> merge_links/links.7-13.out.err cat link_chunks/inter.4-10.links link_chunks/intra.4.links link_chunks/intra.10.links | linker4.py -d -a 4 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-10.out 2> merge_links/links.4-10.out.err cat link_chunks/inter.3-14.links link_chunks/intra.3.links link_chunks/intra.14.links | linker4.py -d -a 3 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-14.out 2> merge_links/links.3-14.out.err cat link_chunks/inter.1-13.links link_chunks/intra.1.links link_chunks/intra.13.links | linker4.py -d -a 1 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-13.out 2> merge_links/links.1-13.out.err cat link_chunks/inter.1-15.links link_chunks/intra.1.links link_chunks/intra.15.links | linker4.py -d -a 1 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-15.out 2> merge_links/links.1-15.out.err cat link_chunks/inter.6-15.links link_chunks/intra.6.links link_chunks/intra.15.links | linker4.py -d -a 6 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-15.out 2> merge_links/links.6-15.out.err cat link_chunks/inter.2-3.links link_chunks/intra.2.links link_chunks/intra.3.links | linker4.py -d -a 2 -b 3 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.3.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-3.out 2> merge_links/links.2-3.out.err cat link_chunks/inter.5-11.links link_chunks/intra.5.links link_chunks/intra.11.links | linker4.py -d -a 5 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-11.out 2> merge_links/links.5-11.out.err cat link_chunks/inter.0-0.links link_chunks/intra.0.links link_chunks/intra.0.links | linker4.py -d -a 0 -b 0 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.0.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-0.out 2> merge_links/links.0-0.out.err cat link_chunks/inter.9-14.links link_chunks/intra.9.links link_chunks/intra.14.links | linker4.py -d -a 9 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.9.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.9-14.out 2> merge_links/links.9-14.out.err cat link_chunks/inter.7-10.links link_chunks/intra.7.links link_chunks/intra.10.links | linker4.py -d -a 7 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-10.out 2> merge_links/links.7-10.out.err cat link_chunks/inter.1-5.links link_chunks/intra.1.links link_chunks/intra.5.links | linker4.py -d -a 1 -b 5 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.5.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-5.out 2> merge_links/links.1-5.out.err cat link_chunks/inter.8-13.links link_chunks/intra.8.links link_chunks/intra.13.links | linker4.py -d -a 8 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-13.out 2> merge_links/links.8-13.out.err cat link_chunks/inter.2-6.links link_chunks/intra.2.links link_chunks/intra.6.links | linker4.py -d -a 2 -b 6 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.6.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-6.out 2> merge_links/links.2-6.out.err cat link_chunks/inter.0-10.links link_chunks/intra.0.links link_chunks/intra.10.links | linker4.py -d -a 0 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-10.out 2> merge_links/links.0-10.out.err cat link_chunks/inter.8-9.links link_chunks/intra.8.links link_chunks/intra.9.links | linker4.py -d -a 8 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-9.out 2> merge_links/links.8-9.out.err cat link_chunks/inter.0-13.links link_chunks/intra.0.links link_chunks/intra.13.links | linker4.py -d -a 0 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-13.out 2> merge_links/links.0-13.out.err cat link_chunks/inter.0-6.links link_chunks/intra.0.links link_chunks/intra.6.links | linker4.py -d -a 0 -b 6 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.6.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-6.out 2> merge_links/links.0-6.out.err cat link_chunks/inter.8-12.links link_chunks/intra.8.links link_chunks/intra.12.links | linker4.py -d -a 8 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-12.out 2> merge_links/links.8-12.out.err cat link_chunks/inter.6-11.links link_chunks/intra.6.links link_chunks/intra.11.links | linker4.py -d -a 6 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-11.out 2> merge_links/links.6-11.out.err cat link_chunks/inter.9-11.links link_chunks/intra.9.links link_chunks/intra.11.links | linker4.py -d -a 9 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.9.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.9-11.out 2> merge_links/links.9-11.out.err cat link_chunks/inter.9-13.links link_chunks/intra.9.links link_chunks/intra.13.links | linker4.py -d -a 9 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.9.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.9-13.out 2> merge_links/links.9-13.out.err cat link_chunks/inter.6-8.links link_chunks/intra.6.links link_chunks/intra.8.links | linker4.py -d -a 6 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-8.out 2> merge_links/links.6-8.out.err cat link_chunks/inter.8-14.links link_chunks/intra.8.links link_chunks/intra.14.links | linker4.py -d -a 8 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-14.out 2> merge_links/links.8-14.out.err cat link_chunks/inter.10-13.links link_chunks/intra.10.links link_chunks/intra.13.links | linker4.py -d -a 10 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.10.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.10-13.out 2> merge_links/links.10-13.out.err cat link_chunks/inter.1-6.links link_chunks/intra.1.links link_chunks/intra.6.links | linker4.py -d -a 1 -b 6 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.6.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-6.out 2> merge_links/links.1-6.out.err cat link_chunks/inter.2-10.links link_chunks/intra.2.links link_chunks/intra.10.links | linker4.py -d -a 2 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-10.out 2> merge_links/links.2-10.out.err cat link_chunks/inter.3-7.links link_chunks/intra.3.links link_chunks/intra.7.links | linker4.py -d -a 3 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-7.out 2> merge_links/links.3-7.out.err cat link_chunks/inter.3-11.links link_chunks/intra.3.links link_chunks/intra.11.links | linker4.py -d -a 3 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-11.out 2> merge_links/links.3-11.out.err cat link_chunks/inter.2-11.links link_chunks/intra.2.links link_chunks/intra.11.links | linker4.py -d -a 2 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-11.out 2> merge_links/links.2-11.out.err cat link_chunks/inter.9-15.links link_chunks/intra.9.links link_chunks/intra.15.links | linker4.py -d -a 9 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.9.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.9-15.out 2> merge_links/links.9-15.out.err cat link_chunks/inter.2-4.links link_chunks/intra.2.links link_chunks/intra.4.links | linker4.py -d -a 2 -b 4 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.4.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-4.out 2> merge_links/links.2-4.out.err cat link_chunks/inter.4-5.links link_chunks/intra.4.links link_chunks/intra.5.links | linker4.py -d -a 4 -b 5 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.5.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-5.out 2> merge_links/links.4-5.out.err cat link_chunks/inter.10-12.links link_chunks/intra.10.links link_chunks/intra.12.links | linker4.py -d -a 10 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.10.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.10-12.out 2> merge_links/links.10-12.out.err cat link_chunks/inter.0-15.links link_chunks/intra.0.links link_chunks/intra.15.links | linker4.py -d -a 0 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-15.out 2> merge_links/links.0-15.out.err cat link_chunks/inter.9-9.links link_chunks/intra.9.links link_chunks/intra.9.links | linker4.py -d -a 9 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.9.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.9-9.out 2> merge_links/links.9-9.out.err cat link_chunks/inter.6-14.links link_chunks/intra.6.links link_chunks/intra.14.links | linker4.py -d -a 6 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-14.out 2> merge_links/links.6-14.out.err cat link_chunks/inter.10-10.links link_chunks/intra.10.links link_chunks/intra.10.links | linker4.py -d -a 10 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.10.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.10-10.out 2> merge_links/links.10-10.out.err cat link_chunks/inter.0-8.links link_chunks/intra.0.links link_chunks/intra.8.links | linker4.py -d -a 0 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-8.out 2> merge_links/links.0-8.out.err cat link_chunks/inter.3-8.links link_chunks/intra.3.links link_chunks/intra.8.links | linker4.py -d -a 3 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-8.out 2> merge_links/links.3-8.out.err cat link_chunks/inter.4-6.links link_chunks/intra.4.links link_chunks/intra.6.links | linker4.py -d -a 4 -b 6 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.6.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-6.out 2> merge_links/links.4-6.out.err cat link_chunks/inter.5-13.links link_chunks/intra.5.links link_chunks/intra.13.links | linker4.py -d -a 5 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-13.out 2> merge_links/links.5-13.out.err cat link_chunks/inter.12-14.links link_chunks/intra.12.links link_chunks/intra.14.links | linker4.py -d -a 12 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.12.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.12-14.out 2> merge_links/links.12-14.out.err cat link_chunks/inter.11-12.links link_chunks/intra.11.links link_chunks/intra.12.links | linker4.py -d -a 11 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.11.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.11-12.out 2> merge_links/links.11-12.out.err cat link_chunks/inter.5-7.links link_chunks/intra.5.links link_chunks/intra.7.links | linker4.py -d -a 5 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-7.out 2> merge_links/links.5-7.out.err cat link_chunks/inter.2-7.links link_chunks/intra.2.links link_chunks/intra.7.links | linker4.py -d -a 2 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-7.out 2> merge_links/links.2-7.out.err cat link_chunks/inter.4-8.links link_chunks/intra.4.links link_chunks/intra.8.links | linker4.py -d -a 4 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-8.out 2> merge_links/links.4-8.out.err cat link_chunks/inter.1-4.links link_chunks/intra.1.links link_chunks/intra.4.links | linker4.py -d -a 1 -b 4 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.4.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-4.out 2> merge_links/links.1-4.out.err cat link_chunks/inter.6-10.links link_chunks/intra.6.links link_chunks/intra.10.links | linker4.py -d -a 6 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-10.out 2> merge_links/links.6-10.out.err cat link_chunks/inter.0-1.links link_chunks/intra.0.links link_chunks/intra.1.links | linker4.py -d -a 0 -b 1 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.1.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-1.out 2> merge_links/links.0-1.out.err cat link_chunks/inter.0-9.links link_chunks/intra.0.links link_chunks/intra.9.links | linker4.py -d -a 0 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-9.out 2> merge_links/links.0-9.out.err cat link_chunks/inter.0-11.links link_chunks/intra.0.links link_chunks/intra.11.links | linker4.py -d -a 0 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-11.out 2> merge_links/links.0-11.out.err cat link_chunks/inter.2-12.links link_chunks/intra.2.links link_chunks/intra.12.links | linker4.py -d -a 2 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-12.out 2> merge_links/links.2-12.out.err cat link_chunks/inter.1-12.links link_chunks/intra.1.links link_chunks/intra.12.links | linker4.py -d -a 1 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-12.out 2> merge_links/links.1-12.out.err cat link_chunks/inter.11-13.links link_chunks/intra.11.links link_chunks/intra.13.links | linker4.py -d -a 11 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.11.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.11-13.out 2> merge_links/links.11-13.out.err cat link_chunks/inter.8-11.links link_chunks/intra.8.links link_chunks/intra.11.links | linker4.py -d -a 8 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-11.out 2> merge_links/links.8-11.out.err cat link_chunks/inter.3-3.links link_chunks/intra.3.links link_chunks/intra.3.links | linker4.py -d -a 3 -b 3 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.3.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-3.out 2> merge_links/links.3-3.out.err cat link_chunks/inter.7-7.links link_chunks/intra.7.links link_chunks/intra.7.links | linker4.py -d -a 7 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-7.out 2> merge_links/links.7-7.out.err cat link_chunks/inter.7-14.links link_chunks/intra.7.links link_chunks/intra.14.links | linker4.py -d -a 7 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-14.out 2> merge_links/links.7-14.out.err cat link_chunks/inter.8-8.links link_chunks/intra.8.links link_chunks/intra.8.links | linker4.py -d -a 8 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-8.out 2> merge_links/links.8-8.out.err cat link_chunks/inter.15-15.links link_chunks/intra.15.links link_chunks/intra.15.links | linker4.py -d -a 15 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.15.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.15-15.out 2> merge_links/links.15-15.out.err cat link_chunks/inter.13-13.links link_chunks/intra.13.links link_chunks/intra.13.links | linker4.py -d -a 13 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.13.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.13-13.out 2> merge_links/links.13-13.out.err cat link_chunks/inter.3-6.links link_chunks/intra.3.links link_chunks/intra.6.links | linker4.py -d -a 3 -b 6 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.6.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-6.out 2> merge_links/links.3-6.out.err cat link_chunks/inter.13-14.links link_chunks/intra.13.links link_chunks/intra.14.links | linker4.py -d -a 13 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.13.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.13-14.out 2> merge_links/links.13-14.out.err cat link_chunks/inter.10-15.links link_chunks/intra.10.links link_chunks/intra.15.links | linker4.py -d -a 10 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.10.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.10-15.out 2> merge_links/links.10-15.out.err cat link_chunks/inter.5-9.links link_chunks/intra.5.links link_chunks/intra.9.links | linker4.py -d -a 5 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-9.out 2> merge_links/links.5-9.out.err cat link_chunks/inter.7-12.links link_chunks/intra.7.links link_chunks/intra.12.links | linker4.py -d -a 7 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-12.out 2> merge_links/links.7-12.out.err cat link_chunks/inter.6-13.links link_chunks/intra.6.links link_chunks/intra.13.links | linker4.py -d -a 6 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-13.out 2> merge_links/links.6-13.out.err cat link_chunks/inter.4-7.links link_chunks/intra.4.links link_chunks/intra.7.links | linker4.py -d -a 4 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-7.out 2> merge_links/links.4-7.out.err cat link_chunks/inter.5-15.links link_chunks/intra.5.links link_chunks/intra.15.links | linker4.py -d -a 5 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-15.out 2> merge_links/links.5-15.out.err cat link_chunks/inter.1-9.links link_chunks/intra.1.links link_chunks/intra.9.links | linker4.py -d -a 1 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-9.out 2> merge_links/links.1-9.out.err cat link_chunks/inter.4-14.links link_chunks/intra.4.links link_chunks/intra.14.links | linker4.py -d -a 4 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-14.out 2> merge_links/links.4-14.out.err cat link_chunks/inter.10-11.links link_chunks/intra.10.links link_chunks/intra.11.links | linker4.py -d -a 10 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.10.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.10-11.out 2> merge_links/links.10-11.out.err cat link_chunks/inter.0-14.links link_chunks/intra.0.links link_chunks/intra.14.links | linker4.py -d -a 0 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-14.out 2> merge_links/links.0-14.out.err cat link_chunks/inter.6-7.links link_chunks/intra.6.links link_chunks/intra.7.links | linker4.py -d -a 6 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-7.out 2> merge_links/links.6-7.out.err cat link_chunks/inter.9-12.links link_chunks/intra.9.links link_chunks/intra.12.links | linker4.py -d -a 9 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.9.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.9-12.out 2> merge_links/links.9-12.out.err cat link_chunks/inter.2-13.links link_chunks/intra.2.links link_chunks/intra.13.links | linker4.py -d -a 2 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-13.out 2> merge_links/links.2-13.out.err cat link_chunks/inter.2-15.links link_chunks/intra.2.links link_chunks/intra.15.links | linker4.py -d -a 2 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-15.out 2> merge_links/links.2-15.out.err cat link_chunks/inter.0-5.links link_chunks/intra.0.links link_chunks/intra.5.links | linker4.py -d -a 0 -b 5 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.5.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-5.out 2> merge_links/links.0-5.out.err cat link_chunks/inter.5-6.links link_chunks/intra.5.links link_chunks/intra.6.links | linker4.py -d -a 5 -b 6 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.6.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-6.out 2> merge_links/links.5-6.out.err cat link_chunks/inter.5-14.links link_chunks/intra.5.links link_chunks/intra.14.links | linker4.py -d -a 5 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-14.out 2> merge_links/links.5-14.out.err cat link_chunks/inter.6-6.links link_chunks/intra.6.links link_chunks/intra.6.links | linker4.py -d -a 6 -b 6 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.6.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-6.out 2> merge_links/links.6-6.out.err cat link_chunks/inter.6-12.links link_chunks/intra.6.links link_chunks/intra.12.links | linker4.py -d -a 6 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-12.out 2> merge_links/links.6-12.out.err cat link_chunks/inter.2-5.links link_chunks/intra.2.links link_chunks/intra.5.links | linker4.py -d -a 2 -b 5 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.5.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-5.out 2> merge_links/links.2-5.out.err cat link_chunks/inter.5-5.links link_chunks/intra.5.links link_chunks/intra.5.links | linker4.py -d -a 5 -b 5 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.5.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-5.out 2> merge_links/links.5-5.out.err cat merge_links/links.0-0.out merge_links/links.0-1.out merge_links/links.1-1.out merge_links/links.0-2.out merge_links/links.1-2.out merge_links/links.2-2.out merge_links/links.0-3.out merge_links/links.1-3.out merge_links/links.2-3.out merge_links/links.3-3.out merge_links/links.0-4.out merge_links/links.1-4.out merge_links/links.2-4.out merge_links/links.3-4.out merge_links/links.4-4.out merge_links/links.0-5.out merge_links/links.1-5.out merge_links/links.2-5.out merge_links/links.3-5.out merge_links/links.4-5.out merge_links/links.5-5.out merge_links/links.0-6.out merge_links/links.1-6.out merge_links/links.2-6.out merge_links/links.3-6.out merge_links/links.4-6.out merge_links/links.5-6.out merge_links/links.6-6.out merge_links/links.0-7.out merge_links/links.1-7.out merge_links/links.2-7.out merge_links/links.3-7.out merge_links/links.4-7.out merge_links/links.5-7.out merge_links/links.6-7.out merge_links/links.7-7.out merge_links/links.0-8.out merge_links/links.1-8.out merge_links/links.2-8.out merge_links/links.3-8.out merge_links/links.4-8.out merge_links/links.5-8.out merge_links/links.6-8.out merge_links/links.7-8.out merge_links/links.8-8.out merge_links/links.0-9.out merge_links/links.1-9.out merge_links/links.2-9.out merge_links/links.3-9.out merge_links/links.4-9.out merge_links/links.5-9.out merge_links/links.6-9.out merge_links/links.7-9.out merge_links/links.8-9.out merge_links/links.9-9.out merge_links/links.0-10.out merge_links/links.1-10.out merge_links/links.2-10.out merge_links/links.3-10.out merge_links/links.4-10.out merge_links/links.5-10.out merge_links/links.6-10.out merge_links/links.7-10.out merge_links/links.8-10.out merge_links/links.9-10.out merge_links/links.10-10.out merge_links/links.0-11.out merge_links/links.1-11.out merge_links/links.2-11.out merge_links/links.3-11.out merge_links/links.4-11.out merge_links/links.5-11.out merge_links/links.6-11.out merge_links/links.7-11.out merge_links/links.8-11.out merge_links/links.9-11.out merge_links/links.10-11.out merge_links/links.11-11.out merge_links/links.0-12.out merge_links/links.1-12.out merge_links/links.2-12.out merge_links/links.3-12.out merge_links/links.4-12.out merge_links/links.5-12.out merge_links/links.6-12.out merge_links/links.7-12.out merge_links/links.8-12.out merge_links/links.9-12.out merge_links/links.10-12.out merge_links/links.11-12.out merge_links/links.12-12.out merge_links/links.0-13.out merge_links/links.1-13.out merge_links/links.2-13.out merge_links/links.3-13.out merge_links/links.4-13.out merge_links/links.5-13.out merge_links/links.6-13.out merge_links/links.7-13.out merge_links/links.8-13.out merge_links/links.9-13.out merge_links/links.10-13.out merge_links/links.11-13.out merge_links/links.12-13.out merge_links/links.13-13.out merge_links/links.0-14.out merge_links/links.1-14.out merge_links/links.2-14.out merge_links/links.3-14.out merge_links/links.4-14.out merge_links/links.5-14.out merge_links/links.6-14.out merge_links/links.7-14.out merge_links/links.8-14.out merge_links/links.9-14.out merge_links/links.10-14.out merge_links/links.11-14.out merge_links/links.12-14.out merge_links/links.13-14.out merge_links/links.14-14.out merge_links/links.0-15.out merge_links/links.1-15.out merge_links/links.2-15.out merge_links/links.3-15.out merge_links/links.4-15.out merge_links/links.5-15.out merge_links/links.6-15.out merge_links/links.7-15.out merge_links/links.8-15.out merge_links/links.9-15.out merge_links/links.10-15.out merge_links/links.11-15.out merge_links/links.12-15.out merge_links/links.13-15.out merge_links/links.14-15.out merge_links/links.15-15.out | hiriseJoin.py -m 20.0 -s <( cat refined.0.out refined.1.out refined.2.out refined.3.out refined.4.out refined.5.out refined.6.out refined.7.out refined.8.out refined.9.out refined.10.out refined.11.out refined.12.out refined.13.out refined.14.out refined.15.out) -l broken_lengths.txt > hirise.out cp hirise.out hirise_iter_0.out set_layout.py -i assembly1.hra -o hirise_iter_0.hra -L hirise_iter_0.out for k in {0..7};do { parallel_breaker.py -i hirise_iter_0.hra -o chicago_weak_segs_iter0_part$k.out -t 20 -T 30 -q $qual2 -j 2 -S $k,8 -H chicago_weak_segs_iter0_part$k.out.histogram > pb0-$k.out 2> pb0-$k.err } & done wait cat chicago_weak_segs_iter0_part0.out chicago_weak_segs_iter0_part1.out chicago_weak_segs_iter0_part2.out chicago_weak_segs_iter0_part3.out chicago_weak_segs_iter0_part4.out chicago_weak_segs_iter0_part5.out chicago_weak_segs_iter0_part6.out chicago_weak_segs_iter0_part7.out > chicago_weak_segs_iter0.out break_playout.py -T 0.0 -t 0.0 -i hirise_iter_0.out -o hirise_iter_broken_0.out -b chicago_weak_segs_iter0.out > hirise_iter_broken_0.log set_layout.py -i assembly1.hra -o r0.hra -L hirise_iter_broken_0.out for k in {0..15};do { if [ ! -e hirise_iter_broken_links_0 ] ; then mkdir hirise_iter_broken_links_0 ; fi ; export_links.py -q $qual2 -i r0.hra -c $k -C 16 > hirise_iter_broken_links_0/$k.links } & done wait for k in {0..15};do { cat hirise_iter_broken_0.out | local_oo_opt.py -N 16 -a $k -l ""hirise_iter_broken_links_0/*.links"" -M datamodel.out > merge_links_tmp/refined_0.$k.out } & done wait cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-11.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 3 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-3.out cat merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.9-13.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-8.out cat merge_links_tmp/refined_0.14.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 14 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.14-14.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.1.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 1 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-1.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-7.out cat merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.9-9.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-8.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 5 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-5.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-10.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-12.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-15.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-13.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 4 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-4.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-12.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 6 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-6.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-8.out cat merge_links_tmp/refined_0.15.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 15 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.15-15.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-12.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-11.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 4 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-4.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-15.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-7.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-15.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-10.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-11.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 6 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-6.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 6 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-6.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 4 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-4.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-13.out cat merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.9-11.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-7.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 5 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-5.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-14.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-13.out cat merge_links_tmp/refined_0.11.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.11-13.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 4 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-4.out cat merge_links_tmp/refined_0.10.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.10-10.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 2 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-2.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 4 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-4.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-14.out cat merge_links_tmp/refined_0.13.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.13-14.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-11.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-15.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-12.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 3 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-3.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-8.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 2 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-2.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 6 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-6.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-7.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-10.out cat merge_links_tmp/refined_0.11.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.11-12.out cat merge_links_tmp/refined_0.10.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.10-12.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-11.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-10.out cat merge_links_tmp/refined_0.12.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.12-12.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-14.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-14.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-13.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-10.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-14.out cat merge_links_tmp/refined_0.12.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.12-13.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-9.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-11.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-14.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-9.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-12.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-9.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-10.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-8.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-15.out cat merge_links_tmp/refined_0.11.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.11-11.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 6 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-6.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-8.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-14.out cat merge_links_tmp/refined_0.12.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.12-14.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 6 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-6.out cat merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.9-15.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-9.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-15.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-10.out cat merge_links_tmp/refined_0.13.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.13-15.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.0.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 0 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-0.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-15.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.1.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 1 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-1.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-9.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-7.out cat merge_links_tmp/refined_0.14.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 14 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.14-15.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-8.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 2 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-2.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-9.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-13.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-7.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-15.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-12.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 5 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-5.out cat merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.9-14.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-12.out cat merge_links_tmp/refined_0.10.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.10-14.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 3 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-3.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-14.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-12.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-14.out cat merge_links_tmp/refined_0.12.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.12-15.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-13.out cat merge_links_tmp/refined_0.11.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.11-14.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-7.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-13.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-15.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-13.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-10.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 6 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-6.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 3 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-3.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-13.out cat merge_links_tmp/refined_0.10.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.10-15.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-10.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-12.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 5 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-5.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-11.out cat merge_links_tmp/refined_0.11.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.11-15.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 5 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-5.out cat merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.9-10.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-11.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-9.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-9.out cat merge_links_tmp/refined_0.13.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.13-13.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-11.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-7.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-8.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-8.out cat merge_links_tmp/refined_0.10.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.10-11.out cat merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.9-12.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 5 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-5.out cat merge_links_tmp/refined_0.10.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.10-13.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-9.out cat merge_links_tmp/links_0.0-0.out merge_links_tmp/links_0.0-1.out merge_links_tmp/links_0.1-1.out merge_links_tmp/links_0.0-2.out merge_links_tmp/links_0.1-2.out merge_links_tmp/links_0.2-2.out merge_links_tmp/links_0.0-3.out merge_links_tmp/links_0.1-3.out merge_links_tmp/links_0.2-3.out merge_links_tmp/links_0.3-3.out merge_links_tmp/links_0.0-4.out merge_links_tmp/links_0.1-4.out merge_links_tmp/links_0.2-4.out merge_links_tmp/links_0.3-4.out merge_links_tmp/links_0.4-4.out merge_links_tmp/links_0.0-5.out merge_links_tmp/links_0.1-5.out merge_links_tmp/links_0.2-5.out merge_links_tmp/links_0.3-5.out merge_links_tmp/links_0.4-5.out merge_links_tmp/links_0.5-5.out merge_links_tmp/links_0.0-6.out merge_links_tmp/links_0.1-6.out merge_links_tmp/links_0.2-6.out merge_links_tmp/links_0.3-6.out merge_links_tmp/links_0.4-6.out merge_links_tmp/links_0.5-6.out merge_links_tmp/links_0.6-6.out merge_links_tmp/links_0.0-7.out merge_links_tmp/links_0.1-7.out merge_links_tmp/links_0.2-7.out merge_links_tmp/links_0.3-7.out merge_links_tmp/links_0.4-7.out merge_links_tmp/links_0.5-7.out merge_links_tmp/links_0.6-7.out merge_links_tmp/links_0.7-7.out merge_links_tmp/links_0.0-8.out merge_links_tmp/links_0.1-8.out merge_links_tmp/links_0.2-8.out merge_links_tmp/links_0.3-8.out merge_links_tmp/links_0.4-8.out merge_links_tmp/links_0.5-8.out merge_links_tmp/links_0.6-8.out merge_links_tmp/links_0.7-8.out merge_links_tmp/links_0.8-8.out merge_links_tmp/links_0.0-9.out merge_links_tmp/links_0.1-9.out merge_links_tmp/links_0.2-9.out merge_links_tmp/links_0.3-9.out merge_links_tmp/links_0.4-9.out merge_links_tmp/links_0.5-9.out merge_links_tmp/links_0.6-9.out merge_links_tmp/links_0.7-9.out merge_links_tmp/links_0.8-9.out merge_links_tmp/links_0.9-9.out merge_links_tmp/links_0.0-10.out merge_links_tmp/links_0.1-10.out merge_links_tmp/links_0.2-10.out merge_links_tmp/links_0.3-10.out merge_links_tmp/links_0.4-10.out merge_links_tmp/links_0.5-10.out merge_links_tmp/links_0.6-10.out merge_links_tmp/links_0.7-10.out merge_links_tmp/links_0.8-10.out merge_links_tmp/links_0.9-10.out merge_links_tmp/links_0.10-10.out merge_links_tmp/links_0.0-11.out merge_links_tmp/links_0.1-11.out merge_links_tmp/links_0.2-11.out merge_links_tmp/links_0.3-11.out merge_links_tmp/links_0.4-11.out merge_links_tmp/links_0.5-11.out merge_links_tmp/links_0.6-11.out merge_links_tmp/links_0.7-11.out merge_links_tmp/links_0.8-11.out merge_links_tmp/links_0.9-11.out merge_links_tmp/links_0.10-11.out merge_links_tmp/links_0.11-11.out merge_links_tmp/links_0.0-12.out merge_links_tmp/links_0.1-12.out merge_links_tmp/links_0.2-12.out merge_links_tmp/links_0.3-12.out merge_links_tmp/links_0.4-12.out merge_links_tmp/links_0.5-12.out merge_links_tmp/links_0.6-12.out merge_links_tmp/links_0.7-12.out merge_links_tmp/links_0.8-12.out merge_links_tmp/links_0.9-12.out merge_links_tmp/links_0.10-12.out merge_links_tmp/links_0.11-12.out merge_links_tmp/links_0.12-12.out merge_links_tmp/links_0.0-13.out merge_links_tmp/links_0.1-13.out merge_links_tmp/links_0.2-13.out merge_links_tmp/links_0.3-13.out merge_links_tmp/links_0.4-13.out merge_links_tmp/links_0.5-13.out merge_links_tmp/links_0.6-13.out merge_links_tmp/links_0.7-13.out merge_links_tmp/links_0.8-13.out merge_links_tmp/links_0.9-13.out merge_links_tmp/links_0.10-13.out merge_links_tmp/links_0.11-13.out merge_links_tmp/links_0.12-13.out merge_links_tmp/links_0.13-13.out merge_links_tmp/links_0.0-14.out merge_links_tmp/links_0.1-14.out merge_links_tmp/links_0.2-14.out merge_links_tmp/links_0.3-14.out merge_links_tmp/links_0.4-14.out merge_links_tmp/links_0.5-14.out merge_links_tmp/links_0.6-14.out merge_links_tmp/links_0.7-14.out merge_links_tmp/links_0.8-14.out merge_links_tmp/links_0.9-14.out merge_links_tmp/links_0.10-14.out merge_links_tmp/links_0.11-14.out merge_links_tmp/links_0.12-14.out merge_links_tmp/links_0.13-14.out merge_links_tmp/links_0.14-14.out merge_links_tmp/links_0.0-15.out merge_links_tmp/links_0.1-15.out merge_links_tmp/links_0.2-15.out merge_links_tmp/links_0.3-15.out merge_links_tmp/links_0.4-15.out merge_links_tmp/links_0.5-15.out merge_links_tmp/links_0.6-15.out merge_links_tmp/links_0.7-15.out merge_links_tmp/links_0.8-15.out merge_links_tmp/links_0.9-15.out merge_links_tmp/links_0.10-15.out merge_links_tmp/links_0.11-15.out merge_links_tmp/links_0.12-15.out merge_links_tmp/links_0.13-15.out merge_links_tmp/links_0.14-15.out merge_links_tmp/links_0.15-15.out | grep '^link score\|^interc:' > iter_links_0.out dump_lengths.py -i r0.hra -o broken_lengths_0.out cat iter_links_0.out | hiriseJoin.py -m 30.0 -s <( cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.10.out merge_links_tmp/refined_0.11.out merge_links_tmp/refined_0.12.out merge_links_tmp/refined_0.13.out merge_links_tmp/refined_0.14.out merge_links_tmp/refined_0.15.out |p2edges.py ) -l broken_lengths_0.out > hirise_iter_1.out set_layout.py -i assembly1.hra -o hirise_iter_1.hra -L hirise_iter_1.out for k in {0..7}; do { parallel_breaker.py -i hirise_iter_1.hra -o chicago_weak_segs_iter1_part$k.out -t 20 -T 30 -q $qual2 -j 2 -S $k,8 -H chicago_weak_segs_iter1_part$k.out.histogram > pb1-$k.out 2> pb1-$k.err } & done wait cat chicago_weak_segs_iter1_part0.out chicago_weak_segs_iter1_part1.out chicago_weak_segs_iter1_part2.out chicago_weak_segs_iter1_part3.out chicago_weak_segs_iter1_part4.out chicago_weak_segs_iter1_part5.out chicago_weak_segs_iter1_part6.out chicago_weak_segs_iter1_part7.out > chicago_weak_segs_iter1.out break_playout.py -T 0.0 -t 0.0 -i hirise_iter_1.out -o hirise_iter_broken_1.out -b chicago_weak_segs_iter1.out > hirise_iter_broken_1.log set_layout.py -i assembly1.hra -o r1.hra -L hirise_iter_broken_1.out for k in {0..15}; do { if [ ! -e hirise_iter_broken_links_1 ] ; then mkdir hirise_iter_broken_links_1 ; fi ; export_links.py -q $qual2 -i r1.hra -c $k -C 16 > hirise_iter_broken_links_1/$k.links } & done wait for k in {0..15}; do { cat hirise_iter_broken_1.out | local_oo_opt.py -N 16 -a $k -l ""hirise_iter_broken_links_1/*.links"" -M datamodel.out > merge_links_tmp/refined_1.$k.out } & done wait cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-9.out cat merge_links_tmp/refined_1.11.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.11-14.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-13.out cat merge_links_tmp/refined_1.12.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.12-12.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 6 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-6.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-12.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-8.out cat merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.9-9.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-14.out cat merge_links_tmp/refined_1.10.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.10-12.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-10.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-13.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 5 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-5.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 2 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-2.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-14.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-8.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-12.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-9.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 6 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-6.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-14.out cat merge_links_tmp/refined_1.13.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.13-14.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-10.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 4 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-4.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-15.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 5 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-5.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-7.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-11.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-11.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 2 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-2.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.1.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 1 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-1.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-15.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 6 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-6.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-12.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-8.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-13.out cat merge_links_tmp/refined_1.12.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.12-15.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-9.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 2 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-2.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-13.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-10.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-11.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-13.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-8.out cat merge_links_tmp/refined_1.14.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 14 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.14-14.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-12.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 5 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-5.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-15.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-14.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 4 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-4.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-10.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-13.out cat merge_links_tmp/refined_1.15.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 15 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.15-15.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-8.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-15.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 3 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-3.out cat merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.9-13.out cat merge_links_tmp/refined_1.10.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.10-10.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.1.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 1 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-1.out cat merge_links_tmp/refined_1.10.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.10-13.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-12.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-9.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-11.out cat merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.9-12.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 6 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-6.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-13.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-10.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-7.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-15.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-15.out cat merge_links_tmp/refined_1.11.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.11-13.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-10.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-11.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-7.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-7.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-9.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-14.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-13.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-10.out cat merge_links_tmp/refined_1.14.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 14 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.14-15.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 5 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-5.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-9.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-7.out cat merge_links_tmp/refined_1.11.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.11-15.out cat merge_links_tmp/refined_1.11.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.11-12.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.0.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 0 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-0.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-7.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-13.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 3 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-3.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 5 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-5.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-14.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-12.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-12.out cat merge_links_tmp/refined_1.10.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.10-11.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 4 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-4.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 6 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-6.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-9.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 3 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-3.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-11.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-7.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 4 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-4.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-8.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-12.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 6 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-6.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-8.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 6 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-6.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-8.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-15.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 5 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-5.out cat merge_links_tmp/refined_1.10.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.10-15.out cat merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.9-15.out cat merge_links_tmp/refined_1.12.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.12-14.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-14.out cat merge_links_tmp/refined_1.12.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.12-13.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-11.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-14.out cat merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.9-14.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-11.out cat merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.9-10.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 4 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-4.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-9.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 3 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-3.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-10.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-8.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-12.out cat merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.9-11.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-14.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-9.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-7.out cat merge_links_tmp/refined_1.11.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.11-11.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-15.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-11.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-15.out cat merge_links_tmp/refined_1.13.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.13-13.out cat merge_links_tmp/refined_1.10.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.10-14.out cat merge_links_tmp/refined_1.13.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.13-15.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-10.out dump_lengths.py -i r1.hra -o broken_lengths_1.out cat merge_links_tmp/links_1.0-0.out merge_links_tmp/links_1.0-1.out merge_links_tmp/links_1.1-1.out merge_links_tmp/links_1.0-2.out merge_links_tmp/links_1.1-2.out merge_links_tmp/links_1.2-2.out merge_links_tmp/links_1.0-3.out merge_links_tmp/links_1.1-3.out merge_links_tmp/links_1.2-3.out merge_links_tmp/links_1.3-3.out merge_links_tmp/links_1.0-4.out merge_links_tmp/links_1.1-4.out merge_links_tmp/links_1.2-4.out merge_links_tmp/links_1.3-4.out merge_links_tmp/links_1.4-4.out merge_links_tmp/links_1.0-5.out merge_links_tmp/links_1.1-5.out merge_links_tmp/links_1.2-5.out merge_links_tmp/links_1.3-5.out merge_links_tmp/links_1.4-5.out merge_links_tmp/links_1.5-5.out merge_links_tmp/links_1.0-6.out merge_links_tmp/links_1.1-6.out merge_links_tmp/links_1.2-6.out merge_links_tmp/links_1.3-6.out merge_links_tmp/links_1.4-6.out merge_links_tmp/links_1.5-6.out merge_links_tmp/links_1.6-6.out merge_links_tmp/links_1.0-7.out merge_links_tmp/links_1.1-7.out merge_links_tmp/links_1.2-7.out merge_links_tmp/links_1.3-7.out merge_links_tmp/links_1.4-7.out merge_links_tmp/links_1.5-7.out merge_links_tmp/links_1.6-7.out merge_links_tmp/links_1.7-7.out merge_links_tmp/links_1.0-8.out merge_links_tmp/links_1.1-8.out merge_links_tmp/links_1.2-8.out merge_links_tmp/links_1.3-8.out merge_links_tmp/links_1.4-8.out merge_links_tmp/links_1.5-8.out merge_links_tmp/links_1.6-8.out merge_links_tmp/links_1.7-8.out merge_links_tmp/links_1.8-8.out merge_links_tmp/links_1.0-9.out merge_links_tmp/links_1.1-9.out merge_links_tmp/links_1.2-9.out merge_links_tmp/links_1.3-9.out merge_links_tmp/links_1.4-9.out merge_links_tmp/links_1.5-9.out merge_links_tmp/links_1.6-9.out merge_links_tmp/links_1.7-9.out merge_links_tmp/links_1.8-9.out merge_links_tmp/links_1.9-9.out merge_links_tmp/links_1.0-10.out merge_links_tmp/links_1.1-10.out merge_links_tmp/links_1.2-10.out merge_links_tmp/links_1.3-10.out merge_links_tmp/links_1.4-10.out merge_links_tmp/links_1.5-10.out merge_links_tmp/links_1.6-10.out merge_links_tmp/links_1.7-10.out merge_links_tmp/links_1.8-10.out merge_links_tmp/links_1.9-10.out merge_links_tmp/links_1.10-10.out merge_links_tmp/links_1.0-11.out merge_links_tmp/links_1.1-11.out merge_links_tmp/links_1.2-11.out merge_links_tmp/links_1.3-11.out merge_links_tmp/links_1.4-11.out merge_links_tmp/links_1.5-11.out merge_links_tmp/links_1.6-11.out merge_links_tmp/links_1.7-11.out merge_links_tmp/links_1.8-11.out merge_links_tmp/links_1.9-11.out merge_links_tmp/links_1.10-11.out merge_links_tmp/links_1.11-11.out merge_links_tmp/links_1.0-12.out merge_links_tmp/links_1.1-12.out merge_links_tmp/links_1.2-12.out merge_links_tmp/links_1.3-12.out merge_links_tmp/links_1.4-12.out merge_links_tmp/links_1.5-12.out merge_links_tmp/links_1.6-12.out merge_links_tmp/links_1.7-12.out merge_links_tmp/links_1.8-12.out merge_links_tmp/links_1.9-12.out merge_links_tmp/links_1.10-12.out merge_links_tmp/links_1.11-12.out merge_links_tmp/links_1.12-12.out merge_links_tmp/links_1.0-13.out merge_links_tmp/links_1.1-13.out merge_links_tmp/links_1.2-13.out merge_links_tmp/links_1.3-13.out merge_links_tmp/links_1.4-13.out merge_links_tmp/links_1.5-13.out merge_links_tmp/links_1.6-13.out merge_links_tmp/links_1.7-13.out merge_links_tmp/links_1.8-13.out merge_links_tmp/links_1.9-13.out merge_links_tmp/links_1.10-13.out merge_links_tmp/links_1.11-13.out merge_links_tmp/links_1.12-13.out merge_links_tmp/links_1.13-13.out merge_links_tmp/links_1.0-14.out merge_links_tmp/links_1.1-14.out merge_links_tmp/links_1.2-14.out merge_links_tmp/links_1.3-14.out merge_links_tmp/links_1.4-14.out merge_links_tmp/links_1.5-14.out merge_links_tmp/links_1.6-14.out merge_links_tmp/links_1.7-14.out merge_links_tmp/links_1.8-14.out merge_links_tmp/links_1.9-14.out merge_links_tmp/links_1.10-14.out merge_links_tmp/links_1.11-14.out merge_links_tmp/links_1.12-14.out merge_links_tmp/links_1.13-14.out merge_links_tmp/links_1.14-14.out merge_links_tmp/links_1.0-15.out merge_links_tmp/links_1.1-15.out merge_links_tmp/links_1.2-15.out merge_links_tmp/links_1.3-15.out merge_links_tmp/links_1.4-15.out merge_links_tmp/links_1.5-15.out merge_links_tmp/links_1.6-15.out merge_links_tmp/links_1.7-15.out merge_links_tmp/links_1.8-15.out merge_links_tmp/links_1.9-15.out merge_links_tmp/links_1.10-15.out merge_links_tmp/links_1.11-15.out merge_links_tmp/links_1.12-15.out merge_links_tmp/links_1.13-15.out merge_links_tmp/links_1.14-15.out merge_links_tmp/links_1.15-15.out | grep '^link score\|^interc:' > iter_links_1.out cat iter_links_1.out | hiriseJoin.py -m 30.0 -s <( cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.10.out merge_links_tmp/refined_1.11.out merge_links_tmp/refined_1.12.out merge_links_tmp/refined_1.13.out merge_links_tmp/refined_1.14.out merge_links_tmp/refined_1.15.out |p2edges.py ) -l broken_lengths_1.out > hirise_iter_2.out set_layout.py -i assembly1.hra -o hirise_iter_2.hra -L hirise_iter_2.out for k in {0..7}; do { parallel_breaker.py -i hirise_iter_2.hra -o chicago_weak_segs_iter2_part$k.out -t 20 -T 30 -q $qual2 -j 2 -S $k,8 -H chicago_weak_segs_iter2_part$k.out.histogram > pb2-$k.out 2> pb2-$k.err } & done wait cat chicago_weak_segs_iter2_part0.out chicago_weak_segs_iter2_part1.out chicago_weak_segs_iter2_part2.out chicago_weak_segs_iter2_part3.out chicago_weak_segs_iter2_part4.out chicago_weak_segs_iter2_part5.out chicago_weak_segs_iter2_part6.out chicago_weak_segs_iter2_part7.out > chicago_weak_segs_iter2.out break_playout.py -T 0.0 -t 0.0 -i hirise_iter_2.out -o hirise_iter_broken_2.out -b chicago_weak_segs_iter2.out > hirise_iter_broken_2.log set_layout.py -i assembly1.hra -o r2.hra -L hirise_iter_broken_2.out for k in {0..15}; do { if [ ! -e hirise_iter_broken_links_2 ] ; then mkdir hirise_iter_broken_links_2 ; fi ; export_links.py -q $qual2 -i r2.hra -c $k -C 16 > hirise_iter_broken_links_2/$k.links } & done wait for k in {0..15}; do { cat hirise_iter_broken_2.out | local_oo_opt.py -N 16 -a $k -l ""hirise_iter_broken_links_2/*.links"" -M datamodel.out > merge_links_tmp/refined_2.$k.out } & done wait cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-7.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-11.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-14.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 6 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-6.out cat merge_links_tmp/refined_2.10.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.10-11.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-13.out cat merge_links_tmp/refined_2.14.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 14 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.14-14.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-14.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.1.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 1 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-1.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-14.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 5 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-5.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 5 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-5.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-8.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-9.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 3 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-3.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-9.out cat merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.9-14.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-7.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-12.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-11.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 5 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-5.out cat merge_links_tmp/refined_2.11.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.11-13.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-11.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-13.out cat merge_links_tmp/refined_2.10.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.10-13.out cat merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.9-9.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-11.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-15.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-13.out cat merge_links_tmp/refined_2.14.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 14 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.14-15.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-8.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-9.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-9.out cat merge_links_tmp/refined_2.12.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.12-12.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-8.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-13.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 3 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-3.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 5 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-5.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-9.out cat merge_links_tmp/refined_2.12.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.12-13.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-11.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-11.out cat merge_links_tmp/refined_2.10.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.10-10.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-13.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-8.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-11.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 3 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-3.out cat merge_links_tmp/refined_2.13.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.13-13.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-10.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-10.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-8.out cat merge_links_tmp/refined_2.10.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.10-14.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 6 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-6.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 5 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-5.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 6 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-6.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-12.out cat merge_links_tmp/refined_2.10.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.10-15.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-12.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-10.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-9.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-14.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 6 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-6.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 6 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-6.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-11.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 6 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-6.out cat merge_links_tmp/refined_2.11.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.11-12.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 4 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-4.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-15.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-8.out cat merge_links_tmp/refined_2.10.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.10-12.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-7.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-7.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-7.out cat merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.9-12.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-8.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-12.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-8.out cat merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.9-13.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-10.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-15.out cat merge_links_tmp/refined_2.12.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.12-15.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.1.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 1 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-1.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-13.out cat merge_links_tmp/refined_2.13.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.13-14.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-12.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 2 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-2.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 4 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-4.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-13.out cat merge_links_tmp/refined_2.15.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 15 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.15-15.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.0.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 0 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-0.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 5 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-5.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 3 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-3.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 4 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-4.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-13.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-9.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-15.out cat merge_links_tmp/refined_2.13.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.13-15.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-15.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-12.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 2 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-2.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-7.out cat merge_links_tmp/refined_2.11.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.11-11.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-14.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 4 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-4.out cat merge_links_tmp/refined_2.11.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.11-14.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-12.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-15.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-8.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-13.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-15.out cat merge_links_tmp/refined_2.11.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.11-15.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-7.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-14.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-9.out cat merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.9-15.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-10.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-12.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-14.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-15.out cat merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.9-10.out cat merge_links_tmp/refined_2.12.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.12-14.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-10.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-7.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-10.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-11.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-12.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 4 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-4.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 2 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-2.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-10.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-15.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-14.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-9.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-10.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-14.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 6 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-6.out cat merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.9-11.out dump_lengths.py -i r2.hra -o broken_lengths_2.out cat merge_links_tmp/links_2.0-0.out merge_links_tmp/links_2.0-1.out merge_links_tmp/links_2.1-1.out merge_links_tmp/links_2.0-2.out merge_links_tmp/links_2.1-2.out merge_links_tmp/links_2.2-2.out merge_links_tmp/links_2.0-3.out merge_links_tmp/links_2.1-3.out merge_links_tmp/links_2.2-3.out merge_links_tmp/links_2.3-3.out merge_links_tmp/links_2.0-4.out merge_links_tmp/links_2.1-4.out merge_links_tmp/links_2.2-4.out merge_links_tmp/links_2.3-4.out merge_links_tmp/links_2.4-4.out merge_links_tmp/links_2.0-5.out merge_links_tmp/links_2.1-5.out merge_links_tmp/links_2.2-5.out merge_links_tmp/links_2.3-5.out merge_links_tmp/links_2.4-5.out merge_links_tmp/links_2.5-5.out merge_links_tmp/links_2.0-6.out merge_links_tmp/links_2.1-6.out merge_links_tmp/links_2.2-6.out merge_links_tmp/links_2.3-6.out merge_links_tmp/links_2.4-6.out merge_links_tmp/links_2.5-6.out merge_links_tmp/links_2.6-6.out merge_links_tmp/links_2.0-7.out merge_links_tmp/links_2.1-7.out merge_links_tmp/links_2.2-7.out merge_links_tmp/links_2.3-7.out merge_links_tmp/links_2.4-7.out merge_links_tmp/links_2.5-7.out merge_links_tmp/links_2.6-7.out merge_links_tmp/links_2.7-7.out merge_links_tmp/links_2.0-8.out merge_links_tmp/links_2.1-8.out merge_links_tmp/links_2.2-8.out merge_links_tmp/links_2.3-8.out merge_links_tmp/links_2.4-8.out merge_links_tmp/links_2.5-8.out merge_links_tmp/links_2.6-8.out merge_links_tmp/links_2.7-8.out merge_links_tmp/links_2.8-8.out merge_links_tmp/links_2.0-9.out merge_links_tmp/links_2.1-9.out merge_links_tmp/links_2.2-9.out merge_links_tmp/links_2.3-9.out merge_links_tmp/links_2.4-9.out merge_links_tmp/links_2.5-9.out merge_links_tmp/links_2.6-9.out merge_links_tmp/links_2.7-9.out merge_links_tmp/links_2.8-9.out merge_links_tmp/links_2.9-9.out merge_links_tmp/links_2.0-10.out merge_links_tmp/links_2.1-10.out merge_links_tmp/links_2.2-10.out merge_links_tmp/links_2.3-10.out merge_links_tmp/links_2.4-10.out merge_links_tmp/links_2.5-10.out merge_links_tmp/links_2.6-10.out merge_links_tmp/links_2.7-10.out merge_links_tmp/links_2.8-10.out merge_links_tmp/links_2.9-10.out merge_links_tmp/links_2.10-10.out merge_links_tmp/links_2.0-11.out merge_links_tmp/links_2.1-11.out merge_links_tmp/links_2.2-11.out merge_links_tmp/links_2.3-11.out merge_links_tmp/links_2.4-11.out merge_links_tmp/links_2.5-11.out merge_links_tmp/links_2.6-11.out merge_links_tmp/links_2.7-11.out merge_links_tmp/links_2.8-11.out merge_links_tmp/links_2.9-11.out merge_links_tmp/links_2.10-11.out merge_links_tmp/links_2.11-11.out merge_links_tmp/links_2.0-12.out merge_links_tmp/links_2.1-12.out merge_links_tmp/links_2.2-12.out merge_links_tmp/links_2.3-12.out merge_links_tmp/links_2.4-12.out merge_links_tmp/links_2.5-12.out merge_links_tmp/links_2.6-12.out merge_links_tmp/links_2.7-12.out merge_links_tmp/links_2.8-12.out merge_links_tmp/links_2.9-12.out merge_links_tmp/links_2.10-12.out merge_links_tmp/links_2.11-12.out merge_links_tmp/links_2.12-12.out merge_links_tmp/links_2.0-13.out merge_links_tmp/links_2.1-13.out merge_links_tmp/links_2.2-13.out merge_links_tmp/links_2.3-13.out merge_links_tmp/links_2.4-13.out merge_links_tmp/links_2.5-13.out merge_links_tmp/links_2.6-13.out merge_links_tmp/links_2.7-13.out merge_links_tmp/links_2.8-13.out merge_links_tmp/links_2.9-13.out merge_links_tmp/links_2.10-13.out merge_links_tmp/links_2.11-13.out merge_links_tmp/links_2.12-13.out merge_links_tmp/links_2.13-13.out merge_links_tmp/links_2.0-14.out merge_links_tmp/links_2.1-14.out merge_links_tmp/links_2.2-14.out merge_links_tmp/links_2.3-14.out merge_links_tmp/links_2.4-14.out merge_links_tmp/links_2.5-14.out merge_links_tmp/links_2.6-14.out merge_links_tmp/links_2.7-14.out merge_links_tmp/links_2.8-14.out merge_links_tmp/links_2.9-14.out merge_links_tmp/links_2.10-14.out merge_links_tmp/links_2.11-14.out merge_links_tmp/links_2.12-14.out merge_links_tmp/links_2.13-14.out merge_links_tmp/links_2.14-14.out merge_links_tmp/links_2.0-15.out merge_links_tmp/links_2.1-15.out merge_links_tmp/links_2.2-15.out merge_links_tmp/links_2.3-15.out merge_links_tmp/links_2.4-15.out merge_links_tmp/links_2.5-15.out merge_links_tmp/links_2.6-15.out merge_links_tmp/links_2.7-15.out merge_links_tmp/links_2.8-15.out merge_links_tmp/links_2.9-15.out merge_links_tmp/links_2.10-15.out merge_links_tmp/links_2.11-15.out merge_links_tmp/links_2.12-15.out merge_links_tmp/links_2.13-15.out merge_links_tmp/links_2.14-15.out merge_links_tmp/links_2.15-15.out | grep '^link score\|^interc:' > iter_links_2.out cat iter_links_2.out | hiriseJoin.py -m 30.0 -s <( cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.10.out merge_links_tmp/refined_2.11.out merge_links_tmp/refined_2.12.out merge_links_tmp/refined_2.13.out merge_links_tmp/refined_2.14.out merge_links_tmp/refined_2.15.out |p2edges.py ) -l broken_lengths_2.out > hirise_iter_3.out set_layout.py -i assembly1.hra -o hirise_iter_3.hra -L hirise_iter_3.out for k in {0..7};do { parallel_breaker.py -i hirise_iter_3.hra -o chicago_weak_segs_iter3_part$k.out -t 20 -T 30 -q $qual2 -j 2 -S $k,8 -H chicago_weak_segs_iter3_part$k.out.histogram > pb3-$k.out 2> pb3-$k.err } & done wait cat chicago_weak_segs_iter3_part0.out chicago_weak_segs_iter3_part1.out chicago_weak_segs_iter3_part2.out chicago_weak_segs_iter3_part3.out chicago_weak_segs_iter3_part4.out chicago_weak_segs_iter3_part5.out chicago_weak_segs_iter3_part6.out chicago_weak_segs_iter3_part7.out > chicago_weak_segs_iter3.out break_playout.py -T 0.0 -t 0.0 -i hirise_iter_3.out -o hirise_iter_broken_3.out -b chicago_weak_segs_iter3.out > hirise_iter_broken_3.log set_layout.py -i assembly1.hra -o hirise_iter_broken_3.hra -L hirise_iter_broken_3.out dump_broken_contigs.py -i hirise_iter_broken_3.hra -f $INPUT_FASTA -o hirise_iter_broken_3.broken.fa cat hirise_iter_broken_3.out | p2srf.py > hirise_iter_broken_3.srf for k in {0..15};do { if [ $k -lt 10 ] then cat hirise_iter_broken_3.out | place_gapper.py -b $SHOTGUN_BAM -f hirise_iter_broken_3.broken.fa -c 0$k -C 16 -K 51 | tee hirise_iter_broken_3.meraudierin.0$k.txt.inter | sort -k4,4 -k5,5 | format4merauder.py > hirise_iter_broken_3.meraudierin.0$k.txt merauder -A -c hirise_iter_broken_3.broken.fa -g hirise_iter_broken_3.meraudierin.0$k.txt -i 2000 -m 51 -P -s hirise_iter_broken_3.srf -D 3 > hirise_iter_broken_3.gapclose.0$k 2> hirise_iter_broken_3.gapclose.0$k.err else cat hirise_iter_broken_3.out | place_gapper.py -b $SHOTGUN_BAM -f hirise_iter_broken_3.broken.fa -c $k -C 16 -K 51 | tee hirise_iter_broken_3.meraudierin.$k.txt.inter | sort -k4,4 -k5,5 | format4merauder.py > hirise_iter_broken_3.meraudierin.$k.txt merauder -A -c hirise_iter_broken_3.broken.fa -g hirise_iter_broken_3.meraudierin.$k.txt -i 2000 -m 51 -P -s hirise_iter_broken_3.srf -D 3 > hirise_iter_broken_3.gapclose.$k 2> hirise_iter_broken_3.gapclose.$k.err fi } & done wait cat hirise_iter_broken_3.gapclose.00 hirise_iter_broken_3.gapclose.01 hirise_iter_broken_3.gapclose.02 hirise_iter_broken_3.gapclose.03 hirise_iter_broken_3.gapclose.04 hirise_iter_broken_3.gapclose.05 hirise_iter_broken_3.gapclose.06 hirise_iter_broken_3.gapclose.07 hirise_iter_broken_3.gapclose.08 hirise_iter_broken_3.gapclose.09 hirise_iter_broken_3.gapclose.10 hirise_iter_broken_3.gapclose.11 hirise_iter_broken_3.gapclose.12 hirise_iter_broken_3.gapclose.13 hirise_iter_broken_3.gapclose.14 hirise_iter_broken_3.gapclose.15 > hirise_iter_broken_3.gapclose cat hirise_iter_broken_3.out | grep '^p:' | p2fa2.py -l hirise_iter_broken_3.gapclosed.table --seed -1 -f $INPUT_FASTA -o /dev/stdout -g hirise_iter_broken_3.gapclose 2> hirise_iter_broken_3.gapclosed.fasta.out | add_short_contigs.py -b $INPUT_FASTA -o hirise_iter_broken_3.gapclosed.fasta ","Shell" "Conformation","wen-biao/OM-HiC-scaffolding","integrated-OM-HiC-scaffolding/run.sh",".sh","15346","205","####Integrated Optical-Mapping and Dovetail-HiC Scaffolding ## step 0: find misassembled regions using Hi-C data mkdir 0-falconHiC 0-pbcrHiC cd 0-falconHiC bwa index falcon.contigs.fasta ##copy your falcon assembly contigs here mkdir HiCMap shortMap cd HiCMap #ln -s xx.fq ./ ctg1=../falcon.contigs.fasta bwa aln $ctg1 ./reads_1.fq -f reads1_1.sai -t 20 bwa aln $ctg1 ./reads_2.fq -f reads1_2.sai -t 20 bwa sampe -a 300000 $ctg1 reads_1.sai reads_2.sai reads_1.fq reads_2.fq |samblaster --addMateTags |samtools view -bS - -o reads.bam samtools sort reads.bam reads.srt samtools rmdup reads.srt.bam reads.srt.rmdup.bam samtools index reads.srt.rmdup.bam cd ../shortMap #ln -s xx.fq ./ bwa aln $ctg1 ./reads_1.fq -f reads1_1.sai -t 20 bwa aln $ctg1 ./reads_2.fq -f reads1_2.sai -t 20 bwa sampe -a 300000 $ctg1 reads_1.sai reads_2.sai reads_1.fq reads_2.fq |samblaster --addMateTags |samtools view -bS - -o reads.bam samtools sort reads.bam reads.srt samtools rmdup reads.srt.bam reads.srt.rmdup.bam samtools index reads.srt.rmdup.bam # run HiRise scaffolding cd ../scaffolding run hirise_commands.pa.sh ../HiCMap/reads.srt.rmdup.bam ../falcon.contigs.fasta ../shortMap/reads.srt.rmdup.bam 10 30 cd ../../0-pbcrHiC bwa index pbcr.contigs.fasta ##copy your pbcr assembly contigs here mkdir HiCMap shortMap cd HiCMap #ln -s xx.fq ./ ctg2=../pbcr.contigs.fasta bwa aln $ctg2 ./reads_1.fq -f reads1_1.sai -t 20 bwa aln $ctg2 ./reads_2.fq -f reads1_2.sai -t 20 bwa sampe -a 300000 $ctg2 reads_1.sai reads_2.sai reads_1.fq reads_2.fq |samblaster --addMateTags |samtools view -bS - -o reads.bam samtools sort reads.bam reads.srt samtools rmdup reads.srt.bam reads.srt.rmdup.bam samtools index reads.srt.rmdup.bam cd ../shortMap #ln -s xx.fq ./ bwa aln $ctg2 ./reads_1.fq -f reads1_1.sai -t 20 bwa aln $ctg2 ./reads_2.fq -f reads1_2.sai -t 20 bwa sampe -a 300000 $ctg2 reads_1.sai reads_2.sai reads_1.fq reads_2.fq |samblaster --addMateTags |samtools view -bS - -o reads.bam samtools sort reads.bam reads.srt samtools rmdup reads.srt.bam reads.srt.rmdup.bam samtools index reads.srt.rmdup.bam # run HiRise scaffolding cd ../scaffolding run hirise_commands.pa.sh ../HiCMap/reads.srt.rmdup.bam ../pbcr.contigs.fasta ../shortMap/reads.srt.rmdup.bam 10 30 cd ../../ mkdir 1-falcon 1-pbcr 2-falconBroken 2-pbcrBroken perl ./hirise.breaks.table.to.bed.pl 0-falconHiC/scaffolding/hirise_iter_broken_3.gapclosed.table 1-falcon/falcon.hirise.breaks.bed perl ./hirise.breaks.table.to.bed.pl 0-pbcrHiC/scaffolding/hirise_iter_broken_3.gapclosed.table 1-pbcr/pbcr.hirise.breaks.bed ## step 1: align CMAPs to sequence assemblies with low and high initial alignment p-value, respectively #low p-value Falcon perl hybridScaffold.pl -n Aalpina.falcon.assembly.fasta -b Aalpina.denovo.cmap -c xml/hybridScaffold_config_out5.xml -o OM-HiC_int/1-falcon/output5 -f > OM-HiC_int/1-falcon/output5.log #high p-value Falcon perl hybridScaffold.pl -n Aalpina.falcon.assembly.fasta -b Aalpina.denovo.cmap -c xml/hybridScaffold_config_out7.xml -o OM-HiC_int/1-falcon/output7 -f > OM-HiC_int/1-falcon/output7.log #low p-value PBcR perl hybridScaffold.pl -n Aalpina.pbcr.assembly.fasta -b Aalpina.denovo.cmap -c xml/hybridScaffold_config_out5.xml -o OM-HiC_int/1-pbcr/output5 -f > OM-HiC_int/1-pbcr/output5.log #high p-value PBcR perl hybridScaffold.pl -n Aalpina.pbcr.assembly.fasta -b Aalpina.denovo.cmap -c xml/hybridScaffold_config_out7.xml -o OM-HiC_int/1-pbcr/output7 -f > OM-HiC_int/1-pbcr/output7.log ## step 2: find breaks cd OM-HiC_int perl OM.find.conflict-regions.pl -k ../Aalpina.falcon.assembly_BspQI_0Kb_0labels_key.txt -d ./1-falcon/output5/ -o ./1-falcon/output5/breaks >1-falcon/output5/breaks.log perl OM.find.conflict-regions.pl -k ../Aalpina.falcon.assembly_BspQI_0Kb_0labels_key.txt -d ./1-falcon/output7/ -o ./1-falcon/output7/breaks >1-falcon/output7/breaks.log perl OM.find.conflict-regions.pl -k ../Aalpina.pbcr.assembly_BspQI_0Kb_0labels_key.txt -d ./1-pbcr/output7/ -o ./1-pbcr/output7/breaks >1-pbcr/output7/breaks.log perl OM.find.conflict-regions.pl -k ../Aalpina.pbcr.assembly_BspQI_0Kb_0labels_key.txt -d ./1-pbcr/output5/ -o ./1-pbcr/output5/breaks >1-pbcr/output5/breaks.log ## step 3: merge breaks from low and high pvalue runnings perl OM.merge.low-high.breaks.pl -a ./1-falcon/output5/breaks/seq.assembly.conflicts.breaks -b ./1-falcon/output7/breaks/seq.assembly.conflicts.breaks -c ./1-falcon/output5/breaks/OM.assembly.conflicts.breaks -d ./1-falcon/output7/breaks/OM.assembly.conflicts.breaks -o ./2-falconBroken/mergeBreaks >2-falconBroken/mergeBreaks.log perl OM.merge.low-high.breaks.pl -a ./1-pbcr/output5/breaks/seq.assembly.conflicts.breaks -b ./1-pbcr/output7/breaks/seq.assembly.conflicts.breaks -c ./1-pbcr/output5/breaks/OM.assembly.conflicts.breaks -d ./1-pbcr/output7/breaks/OM.assembly.conflicts.breaks -o ./2-pbcrBroken/mergeBreaks >2-pbcrBroken/mergeBreaks.log ## step 4: windowBed btx OM-breaks, HR-breaks perl ./OM.conflicts.add.HiRise.pl -s 2-falconBroken/mergeBreaks/seq.breaks4 -m 1-falcon/output5/align1/align1_r.cmap -r ./falcon.hirise.breaks.bed -o 2-falconBroken/mergeBreaks >>2-falconBroken/mergeBreaks.log perl ./OM.conflicts.add.HiRise.pl -s 2-pbcrBroken/mergeBreaks/seq.breaks4 -m 1-pbcr/output5/align1/align1_r.cmap -r ./pbcr.hirise.breaks.bed -o 2-pbcrBroken/mergeBreaks >>2-pbcrBroken/mergeBreaks.log ## step 5: check whether conflict CMAP region is fullly aligned by another seq CMAP perl ./OM.conflicts.falcon-pbcr.cross-check.pl -c 2-falconBroken/mergeBreaks/OM.breaks4 -s 2-falconBroken/mergeBreaks/seq.breaks4.HR.bed -x 1-pbcr/output7/align1/align1.xmap -k ../Aalpina.pbcr.assembly_BspQI_0Kb_0labels_key.txt -o 2-falconBroken/mergeBreaks >> 2-falconBroken/mergeBreaks.log perl ./OM.conflicts.falcon-pbcr.cross-check.pl -c 2-pbcrBroken/mergeBreaks/OM.breaks4 -s 2-pbcrBroken/mergeBreaks/seq.breaks4.HR.bed -x 1-falcon/output7/align1/align1.xmap -k ../Aalpina.falcon.assembly_BspQI_0Kb_0labels_key.txt -o 2-pbcrBroken/mergeBreaks >> 2-pbcrBroken/mergeBreaks.log ## step 6: filter Seq and OM breaks based on 2-CMAP, HR-breaks and falcon-pbcr cross-check perl ./OM.breaks.filter.pl -c 2-falconBroken/mergeBreaks/OM.breaks4.OMGoodAln.bed -s 2-falconBroken/mergeBreaks/seq.breaks4.HR.OMGoodAln.bed -o 2-falconBroken/mergeBreaks >2-falconBroken/mergeBreaks.log perl ./OM.breaks.filter.pl -c 2-pbcrBroken/mergeBreaks/OM.breaks4.OMGoodAln.bed -s 2-pbcrBroken/mergeBreaks/seq.breaks4.HR.OMGoodAln.bed -o 2-pbcrBroken/mergeBreaks >2-pbcrBroken/mergeBreaks.log ## step 7: split the Seq and OM perl ./OM.breaks.ctg.pl -s 2-falconBroken/mergeBreaks/seq.breaks4.flt.manual.check.bed -f ../Aalpina.falcon.assembly.fasta -m 2-falconBroken/mergeBreaks/OM.breaks4.flt.manual.check.bed -c 1-falcon/output5/align1/align1_q.cmap -o 2-falconBroken/split > 2-falconBroken/split.log perl ./OM.breaks.ctg.pl -s 2-pbcrBroken/mergeBreaks/seq.breaks4.flt.manual.check.bed -f ../Aalpina.pbcr.assembly.fasta -m 2-pbcrBroken/mergeBreaks/OM.breaks4.flt.manual.check.bed -c 1-pbcr/output5/align1/align1_q.cmap -o 2-pbcrBroken/split > 2-pbcrBroken/split.log ## step 8: realign and ## step 9: do hybrid scaffolding #lower pvalue for assigning conflict alignment, to avoid wrong conflict due to partial/multiple alignment cd ../ perl hybridScaffold.pl -n OM-HiC_int/2-falconBroken/split/seq.broken.fasta -b OM-HiC_int/2-falconBroken/split/OM.broken.cmap -c xml/hybridScaffold_config_out54.xml -o OM-HiC_int/2-falconBroken/output54 -f > OM-HiC_int/2-falconBroken/output54.log perl hybridScaffold.pl -n OM-HiC_int/2-pbcrBroken/split/seq.broken.fasta -b OM-HiC_int/2-pbcrBroken/split/OM.broken.cmap -c xml/hybridScaffold_config_out54.xml -o OM-HiC_int/2-pbcrBroken/output54 -f > OM-HiC_int/2-pbcrBroken/output54.log cd OM-HiC_int/2-falconBroken/output54 RefAligner -f -ref ./align_final/step2.hybrid.cmap -i ../split/seq.broken_BspQI_0Kb_0labels.cmap -o brkCtg_HybridMap -endoutlier 1e-3 -outlier 1e-4 -extend 0 -FN 0.05 -FP 0.5 -sf 0.2 -sd 0.1 -sr 0.02 -res 0 -resSD 0.75 -mres 0 -A 5 -biaswt 0 -M 1 -Mfast 0 -maxmem 128 -maxthreads 20 -deltaX 9 -deltaY 9 -RepeatMask 2 0.01 -RepeatRec 0.7 0.6 -T 1e-9 -BestRef 1 -nosplit 2 -XmapStatWrite brkCtg_HybridMap -stdout -stderr -hashgen 5 3 2.4 1.5 0.05 5.0 1 1 1 -hash -hashdelta 50 perl ../../OM.scaffolding.pl -x brkCtg_HybridMap.xmap -r brkCtg_HybridMap_r.cmap -q brkCtg_HybridMap_q.cmap -key ../split/seq.broken_BspQI_0Kb_0labels_key.txt -outdir scafSeq -seq ../split/seq.broken.fasta -sID scaf > scaffolding.log& cd ../../../OM-HiC_int/2-pbcrBroken/output54 RefAligner -f -ref ./align_final/step2.hybrid.cmap -i ../split/seq.broken_BspQI_0Kb_0labels.cmap -o brkCtg_HybridMap -endoutlier 1e-3 -outlier 1e-4 -extend 0 -FN 0.05 -FP 0.5 -sf 0.2 -sd 0.1 -sr 0.02 -res 0 -resSD 0.75 -mres 0 -A 5 -biaswt 0 -M 1 -Mfast 0 -maxmem 128 -maxthreads 20 -deltaX 9 -deltaY 9 -RepeatMask 2 0.01 -RepeatRec 0.7 0.6 -T 1e-9 -BestRef 1 -nosplit 2 -XmapStatWrite brkCtg_HybridMap -stdout -stderr -hashgen 5 3 2.4 1.5 0.05 5.0 1 1 1 -hash -hashdelta 50 perl ../../OM.scaffolding.pl -x brkCtg_HybridMap.xmap -r brkCtg_HybridMap_r.cmap -q brkCtg_HybridMap_q.cmap -key ../split/seq.broken_BspQI_0Kb_0labels_key.txt -outdir scafSeq -seq ../split/seq.broken.fasta -sID scaf > scaffolding.log& echo ""start 2nd-round hybrid scaffolding"" ## step 10: align the pbcr-hybrid cmap to falcon-hybrid scaffolds cd ../../ mkdir 3-falconOMint cp 2-pbcrBroken/output54/mergeNGS_BN/step2.hybrid.cmap ./3-falconOMint/pbcr.hybrid.BN.naive.cmap grep -v '#' 2-pbcrBroken/output54/mergeNGS_BN/step1.BN.naive.cmap >>./3-falconOMint/pbcr.hybrid.BN.naive.cmap cp 2-falconBroken/output54/scafSeq/hybrid.map.scaffolds.fasta 3-falconOMint/hybrid.map.scaffolds.fasta cd ../ perl hybridScaffold.pl -n OM-HiC_int/3-falconOMint/hybrid.map.scaffolds.fasta -b OM-HiC_int/3-falconOMint/pbcr.hybrid.BN.naive.cmap -c xml/hybridScaffold_config_out5.xml -o OM-HiC_int/3-falconOMint/output5 -f >OM-HiC_int/3-falconOMint/output5.log ## step 11: find the conflicting alignment and break the scaffold sequences and hybrid cmap cd OM-HiC_int perl ./OM.find.conflict-regions.pl -k 3-falconOMint/hybrid.map.scaffolds_BspQI_0Kb_0labels_key.txt -d 3-falconOMint/output/ -o 3-falconOMint/output/breaks ###check the conflicts perl ./OM.split-misassembly.pl -k ./3-falconOMint/hybrid.map.scaffolds_BspQI_0Kb_0labels_key.txt -f ./3-falconOMint/hybrid.map.scaffolds.fasta -s ./3-falconOMint/output/breaks/seq.assembly.conflicts.mrg.breaks -m ./3-falconOMint/output/breaks/OM.assembly.conflicts.mrg.breaks -o ./3-falconOMint/output -d ./3-falconOMint/output/breaks > 3-falconOMint/output/breaks/split.log ## step 12: further hybrid scaffolding perl hybridScaffold.pl -n OM-HiC_int/3-falconOMint/output/breaks/seq.assembly.conflicts.broken.fasta -bOM-HiC_int/3-falconOMint/output/breaks/BNG.assembly.conflicts.broken.cmap -c xml/hybridScaffold_config_out54.xml -o OM-HiC_int/3-falconOMint/outSplitRealign -f > OM-HiC_int/3-falconOMint/outSplitRealign.log cd OM-HiC_int/3-falconOMint/outSplitRealign RefAligner -f -ref align_final/step2.hybrid.cmap -i ../output/breaks/seq.assembly.conflicts.broken_BspQI_0Kb_0labels.cmap -o bScafSeq_HybridMap -endoutlier 1e-3 -outlier 1e-4 -extend 0 -FN 0.05 -FP 0.5 -sf 0.2 -sd 0.1 -sr 0.02 -res 0 -resSD 0.75 -mres 0 -A 5 -biaswt 0 -M 1 -Mfast 0 -maxmem 128 -maxthreads 20 -deltaX 9 -deltaY 9 -RepeatMask 2 0.01 -RepeatRec 0.7 0.6 -T 1e-9 -BestRef 1 -nosplit 2 -XmapStatWrite bScafSeq_HybridMap -stdout -stderr -hashgen 5 3 2.4 1.5 0.05 5.0 1 1 1 -hash -hashdelta 50 perl ../../OM.scaffolding.pl -x bScafSeq_HybridMap.xmap -r bScafSeq_HybridMap_r.cmap -q bScafSeq_HybridMap_q.cmap -key ../output/breaks/seq.broken.new.key.txt -outdir scafSeq -seq ../output/breaks/seq.assembly.conflicts.broken.fasta -sID xcaf > scaffolding.log ###intergrate Hi-C data # step 13: run HiRise to do assembly scaffolding using Dovetail Hi-C data cd ../../../ mkdir 4-HiC cd 4-HiC; mkdir HiCMap shortMap scaffolding cp ../../3-falconOMint/hybrid.map.scaffolds.fasta ./ # step 14: map Dovetail Hi-C reads and illumina reads from short fragments library to the above assembled scaffolds bwa index hybrid.map.scaffolds.fasta cd HiCMap #ln -s xx.fq ./ ref=../hybrid.map.scaffolds.fasta bwa aln $ref ./reads_1.fq -f reads1_1.sai -t 20 bwa aln $ref ./reads_2.fq -f reads1_2.sai -t 20 bwa sampe -a 300000 $ref reads_1.sai reads_2.sai reads_1.fq reads_2.fq |samblaster --addMateTags |samtools view -bS - -o reads.bam samtools sort reads.bam reads.srt samtools rmdup reads.srt.bam reads.srt.rmdup.bam samtools index reads.srt.rmdup.bam cd ../shortMap #ln -s xx.fq ./ bwa aln $ref ./reads_1.fq -f reads1_1.sai -t 20 bwa aln $ref ./reads_2.fq -f reads1_2.sai -t 20 bwa sampe -a 300000 $ref reads_1.sai reads_2.sai reads_1.fq reads_2.fq |samblaster --addMateTags |samtools view -bS - -o reads.bam samtools sort reads.bam reads.srt samtools rmdup reads.srt.bam reads.srt.rmdup.bam samtools index reads.srt.rmdup.bam # step 15: run HiRise scaffolding cd ../scaffolding run hirise_commands.pa.sh ../HiCMap/reads.srt.rmdup.bam ../hybrid.map.scaffolds.fasta ../shortMap/reads.srt.rmdup.bam 10 30 # step 16: interative OM scaffolding cd ../../ mkdir 5-OMiter cp 4-HiC/scaffolding/hirise_iter_broken_3.gapclosed.fasta ./5-OMiter/scaffolds.fasta cp 3-OMint/outSplitRealign/step2.hybrid.cmap ./5-OMinter/OMint.hybrid.BN.naive.cmap grep -v '#' 3-OMint/outSplitRealign/mergeNGS_BN/step1.BN.naive.cmap >> ./5-OMinter/OMint.hybrid.BN.naive.cmap cd ../ perl hybridScaffold.pl -n OM-HiC_int/5-OMiter/hybrid.map.scaffolds.fasta -b OM-HiC_int/5-OMiter/OMint.hybrid.BN.naive.cmap -c xml/hybridScaffold_config_out54.xml -o OM-HiC_int/5-OMiter/output54 -f >OM-HiC_int/5-OMiter/output54.log cd OM-HiC_int/ perl ./OM.find.conflict-regions.pl -k 5-OMiter/scaffolds_BspQI_0Kb_0labels_key.txt -d 5-OMiter/output54/ -o 5-OMiter/output54/breaks perl ./OM.split-misassembly.pl -k 5-OMiter/scaffolds_BspQI_0Kb_0labels_key.txt -f 5-OMiter/scaffolds.fasta -s 5-OMiter/output54/breaks/seq.assembly.conflicts.mrg.breaks -m 5-OMiter/output54/breaks/OM.assembly.conflicts.mrg.breaks -o 5-OMiter/output54 -d 5-OMiter/output54/breaks > 5-OMiter/output54/breaks/split.log cd ../ perl hybridScaffold.pl -n OM-HiC_int/5-OMiter/output54/breaks/seq.assembly.conflicts.broken.fasta -b OM-HiC_int/5-OMiter/OMint.hybrid.BN.naive.cmap -c xml/hybridScaffold_config_out55.xml -o OM-HiC_int/5-OMiter/output55 -f >OM-HiC_int/5-OMiter/output55.log cd OM-HiC_int/5-OMiter/output55 RefAligner -f -ref align_final/step2.hybrid.cmap -i ../output54/breaks/seq.assembly.conflicts.broken_BspQI_0Kb_0labels.cmap -o bScafSeq_HybridMap -endoutlier 1e-3 -outlier 1e-4 -extend 0 -FN 0.05 -FP 0.5 -sf 0.2 -sd 0.1 -sr 0.02 -res 0 -resSD 0.75 -mres 0 -A 5 -biaswt 0 -M 1 -Mfast 0 -maxmem 128 -maxthreads 20 -deltaX 9 -deltaY 9 -RepeatMask 2 0.01 -RepeatRec 0.7 0.6 -T 1e-9 -BestRef 1 -nosplit 2 -XmapStatWrite bScafSeq_HybridMap -stdout -stderr -hashgen 5 3 2.4 1.5 0.05 5.0 1 1 1 -hash -hashdelta 50 perl ../../OM.scaffolding.pl -x bScafSeq_HybridMap.xmap -r bScafSeq_HybridMap_r.cmap -q bScafSeq_HybridMap_q.cmap -key ../output54/breaks/seq.broken.new.key.txt -outdir scafSeq -seq ../output54/breaks/seq.assembly.conflicts.broken.fasta -sID xcaf > scaffolding.log ","Shell" "Conformation","wen-biao/OM-HiC-scaffolding","HiC-ImpScaffolding/hirise_commands.pa.sh",".sh","166380","872"," ############################# # #specify the input files: # BAMS=(/netscratch/dep_coupland/grp_schneeberger/projects/BraChrEvo/assembly/Aalpina/HiRise/pbcr/bwaMap/chicago/merged.srt.rmdup.bam) INPUT_FASTA=/netscratch/dep_coupland/grp_schneeberger/projects/BraChrEvo/assembly/Aalpina/version1/Aalpina.pacbio.v0.fasta SHOTGUN_BAM=/netscratch/dep_coupland/grp_schneeberger/projects/BraChrEvo/assembly/Aalpina/HiRise/pbcr/bwaMap/pep1/reads.srt.rmdup.bam # ############################# #### # #Some of the scripts expect comma-separated lists of bam files, others expect repeated command-line flags. # BAM1=${BAMS[0]} echo $BAM1 BAMLIST_OPT="""" for f in ${BAMS[@]} do BAMLIST_OPT+=""-b $f "" done echo $BAMLIST_OPT BAMLIST_COMMA=$BAM1 unset BAMS[0] for f in ${BAMS[@]} do BAMLIST_COMMA+="",$f"" done echo $BAMLIST_COMMA BAMS+=($BAM1) echo ${BAMS[*]} HISTOGRAMS="""" #unset BAMS[0] for f in ${BAMS[@]} do HISTOGRAMS+=`basename $f` HISTOGRAMS+="".histogram "" done echo ""histograms: "" $HISTOGRAMS # ##### qual1=$1 qual2=$2 ## ## HiRise Commands start here: ## mkdir links mkdir merge_links mkdir merge_links_tmp bam2len.py -b $BAM1 > raw_lengths.txt if [ ! -e raw_chunks ] ; then mkdir raw_chunks ; fi ; nseqs=`wc -l raw_lengths.txt | cut -d' ' -f 1 ` ; cat raw_lengths.txt | awk '{print $1,0,$2, rand()}' | sort -k4n | awk '{print $1,$2,$3}' | split -d -l `expr $nseqs / 16 + 1` - raw_chunks/bed_chunk. samtools mpileup -q $qual1 -l raw_chunks/bed_chunk.00 $SHOTGUN_BAM | cut -f 1,2,4 | depth_histogram.py -o raw_chunks/00.dhist -t raw_chunks/00.depth_thresholds if [ ! -e raw_chunks ] ; then mkdir raw_chunks ; fi ; nseqs=`wc -l raw_lengths.txt | cut -d' ' -f 1 ` ; cat raw_lengths.txt | awk '{print $1, rand()}' | sort -k2n | awk '{print $1}' | split -d -l `expr $nseqs / 16 + 1` - raw_chunks/chunk. hirise_assembly.py -o assembly0.hra $BAMLIST_OPT -S $SHOTGUN_BAM for f in ${BAMS[@]} do pair_sep_histogram.py -q $qual2 -b $f > `basename $f`.histogram 2> `basename $f`.histogram.err done add_hist.py $HISTOGRAMS > all.merged_histogram window_stats.py -i assembly0.hra -N 1000 > contig_window_sample.txt for k in {0..15};do { if [ $k -lt 10 ] then samtools mpileup -q $qual1 -l raw_chunks/bed_chunk.0$k $SHOTGUN_BAM | cut -f 1,2,4 | dt2.py -t raw_chunks/00.depth_thresholds > raw_chunks/0$k.deep_regions.bed else samtools mpileup -q $qual1 -l raw_chunks/bed_chunk.$k $SHOTGUN_BAM | cut -f 1,2,4 | dt2.py -t raw_chunks/00.depth_thresholds > raw_chunks/$k.deep_regions.bed fi } & done wait contiguity_correction.py -l raw_lengths.txt > contiguity_correction.txt cat raw_chunks/*.deep_regions.bed > deep_regions.bed cat contig_window_sample.txt | cut -f 6 | percentile.py -p 98 > chicago_link_density_threshold.txt estimate_Pn_bam.py -q $qual2 -b $BAMLIST_COMMA -o nn_estimate.txt -N 200 > nn_estimate.txt.out cat all.merged_histogram | histo_smooth2.py | apply_contiguity_correction.py -c contiguity_correction.txt > all_smoothed_corrected.merged_histogram cat all_smoothed_corrected.merged_histogram | model_fit.py -m 1000 -P nn_estimate.txt -o datamodel.out > datamodel.out.out for k in {0..15};do { link_density_scan.py --mask deep_regions.bed -q $qual2 -i assembly0.hra -m 2 -w 1000 -C 16 -c $k -o promisc_segs_$k.txt -M $( cat chicago_link_density_threshold.txt ) } & done wait for k in {0..15};do { if [ $k -lt 10 ] then (cat raw_chunks/chunk.0$k | xargs samtools faidx $INPUT_FASTA ) | gap_lengths.py > raw_chunks/gaps.0$k else (cat raw_chunks/chunk.$k | xargs samtools faidx $INPUT_FASTA ) | gap_lengths.py > raw_chunks/gaps.$k fi } & done wait ####combine the masked regions cat promisc_segs_*.txt > promisc_segs.txt cat promisc_segs.txt > blacklisted_segments.bed cat raw_chunks/gaps.00 raw_chunks/gaps.01 raw_chunks/gaps.02 raw_chunks/gaps.03 raw_chunks/gaps.04 raw_chunks/gaps.05 raw_chunks/gaps.06 raw_chunks/gaps.07 raw_chunks/gaps.08 raw_chunks/gaps.09 raw_chunks/gaps.10 raw_chunks/gaps.11 raw_chunks/gaps.12 raw_chunks/gaps.13 raw_chunks/gaps.14 raw_chunks/gaps.15 | cut -f 2-4,6 > gaps.bed hra_readdeserts.py -q $qual2 -i assembly0.hra -o deserts.bed cat deep_regions.bed blacklisted_segments.bed gaps.bed deserts.bed > combined_mask.bed ###find the potential miss-assembly, break the input assembly contigs/scaffolds for k in {0..15};do { if [ $k -lt 10 ] then weakspots.py -c raw_chunks/chunk.0$k -b $BAMLIST_COMMA -q $qual2 -t 150 -M datamodel.out -B 2.0 > raw_chunks/breaks.0$k else weakspots.py -c raw_chunks/chunk.$k -b $BAMLIST_COMMA -q $qual2 -t 150 -M datamodel.out -B 2.0 > raw_chunks/breaks.$k fi } & done wait hirise_assembly.py -i assembly0.hra -o assembly1.hra -m combined_mask.bed -M datamodel.out cat raw_chunks/breaks.00 raw_chunks/breaks.01 raw_chunks/breaks.02 raw_chunks/breaks.03 raw_chunks/breaks.04 raw_chunks/breaks.05 raw_chunks/breaks.06 raw_chunks/breaks.07 raw_chunks/breaks.08 raw_chunks/breaks.09 raw_chunks/breaks.10 raw_chunks/breaks.11 raw_chunks/breaks.12 raw_chunks/breaks.13 raw_chunks/breaks.14 raw_chunks/breaks.15 > raw_breaks.txt; cat raw_breaks.txt | merge_ranges.py -w 300 -t 0.0 > breaks.txt break_hra.py -i assembly1.hra -b breaks.txt -o broken.hra for k in {0..15};do { if [ $k -lt 10 ] then export_links.py -C 16 -c 0$k -i broken.hra -o links/0$k.merged.links -q $qual2 else export_links.py -C 16 -c $k -i broken.hra -o links/$k.merged.links -q $qual2 fi } & done wait bamMeanDepth2.py -b $SHOTGUN_BAM -q 10 > mean_depth.txt for k in {0..15};do { if [ $k -lt 10 ] then cat links/0$k.merged.links | score_links4.py -M datamodel.out -p 0.0000001 > links/0$k.merged.score else cat links/$k.merged.links | score_links4.py -M datamodel.out -p 0.0000001 > links/$k.merged.score fi } & done wait cat mean_depth.txt | doubleDepthFilter.py > double_depth.txt dump_lengths.py -i broken.hra -o broken_lengths.txt cat links/00.merged.score links/01.merged.score links/02.merged.score links/03.merged.score links/04.merged.score links/05.merged.score links/06.merged.score links/07.merged.score links/08.merged.score links/09.merged.score links/10.merged.score links/11.merged.score links/12.merged.score links/13.merged.score links/14.merged.score links/15.merged.score | grep -v '^#' > merged.scores cat broken_lengths.txt | awk '{print $1,$1}' | sed -e 's/_/ /' | awk '{print $1,$3}' | screen_out.py -k double_depth.txt 1 | awk '{print $2}' > double_depth_broken.txt cat merged.scores | awk '{print $1}' | uniq -c | awk '$1>=7 {print $2}' > cluster_blacklist0.txt cat cluster_blacklist0.txt double_depth_broken.txt > cluster_blacklist.txt cat merged.scores | awk '{print $1,$2,$3-$4}' |clusterpledge.py -L links/00.merged.links -L links/01.merged.links -L links/02.merged.links -L links/03.merged.links -L links/04.merged.links -L links/05.merged.links -L links/06.merged.links -L links/07.merged.links -L links/08.merged.links -L links/09.merged.links -L links/10.merged.links -L links/11.merged.links -L links/12.merged.links -L links/13.merged.links -L links/14.merged.links -L links/15.merged.links --fake -b cluster_blacklist.txt -t 4 > chunking_edges.txt if [ ! -e link_chunks ] ; then mkdir link_chunks ; fi ; cat links/00.merged.links links/01.merged.links links/02.merged.links links/03.merged.links links/04.merged.links links/05.merged.links links/06.merged.links links/07.merged.links links/08.merged.links links/09.merged.links links/10.merged.links links/11.merged.links links/12.merged.links links/13.merged.links links/14.merged.links links/15.merged.links | component_chunk_filter.py -c 16 -l broken_lengths.txt -E chunking_edges.txt -t 0 -m 1000 > component_x.txt for k in {0..15};do { assembler3.py -l broken_lengths.txt -Z component_x.txt -m 1000 -k link_chunks/intra.$k.links -c 1 --set_insert_size_dist_fit_params datamodel.out > assembler.$k.out greedy_chicagoan2.py -t 20.0 -l broken_lengths.txt -Z component_x.txt -m 1000 -c $k -j assembler.$k.out -k link_chunks/intra.$k.links --set_insert_size_dist_fit_params datamodel.out > greedy.$k.out local_oo_opt.py -E -l link_chunks/intra.$k.links -i greedy.$k.out --set_insert_size_dist_fit_params datamodel.out > refined.$k.out.inter cat refined.$k.out.inter | p2edges.py > refined.$k.out } & done wait cat link_chunks/inter.3-10.links link_chunks/intra.3.links link_chunks/intra.10.links | linker4.py -d -a 3 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-10.out 2> merge_links/links.3-10.out.err cat link_chunks/inter.6-9.links link_chunks/intra.6.links link_chunks/intra.9.links | linker4.py -d -a 6 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-9.out 2> merge_links/links.6-9.out.err cat link_chunks/inter.12-13.links link_chunks/intra.12.links link_chunks/intra.13.links | linker4.py -d -a 12 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.12.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.12-13.out 2> merge_links/links.12-13.out.err cat link_chunks/inter.3-12.links link_chunks/intra.3.links link_chunks/intra.12.links | linker4.py -d -a 3 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-12.out 2> merge_links/links.3-12.out.err cat link_chunks/inter.7-9.links link_chunks/intra.7.links link_chunks/intra.9.links | linker4.py -d -a 7 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-9.out 2> merge_links/links.7-9.out.err cat link_chunks/inter.9-10.links link_chunks/intra.9.links link_chunks/intra.10.links | linker4.py -d -a 9 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.9.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.9-10.out 2> merge_links/links.9-10.out.err cat link_chunks/inter.14-14.links link_chunks/intra.14.links link_chunks/intra.14.links | linker4.py -d -a 14 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.14.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.14-14.out 2> merge_links/links.14-14.out.err cat link_chunks/inter.4-11.links link_chunks/intra.4.links link_chunks/intra.11.links | linker4.py -d -a 4 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-11.out 2> merge_links/links.4-11.out.err cat link_chunks/inter.12-12.links link_chunks/intra.12.links link_chunks/intra.12.links | linker4.py -d -a 12 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.12.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.12-12.out 2> merge_links/links.12-12.out.err cat link_chunks/inter.8-15.links link_chunks/intra.8.links link_chunks/intra.15.links | linker4.py -d -a 8 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-15.out 2> merge_links/links.8-15.out.err cat link_chunks/inter.4-15.links link_chunks/intra.4.links link_chunks/intra.15.links | linker4.py -d -a 4 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-15.out 2> merge_links/links.4-15.out.err cat link_chunks/inter.1-8.links link_chunks/intra.1.links link_chunks/intra.8.links | linker4.py -d -a 1 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-8.out 2> merge_links/links.1-8.out.err cat link_chunks/inter.0-3.links link_chunks/intra.0.links link_chunks/intra.3.links | linker4.py -d -a 0 -b 3 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.3.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-3.out 2> merge_links/links.0-3.out.err cat link_chunks/inter.3-4.links link_chunks/intra.3.links link_chunks/intra.4.links | linker4.py -d -a 3 -b 4 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.4.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-4.out 2> merge_links/links.3-4.out.err cat link_chunks/inter.2-8.links link_chunks/intra.2.links link_chunks/intra.8.links | linker4.py -d -a 2 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-8.out 2> merge_links/links.2-8.out.err cat link_chunks/inter.4-4.links link_chunks/intra.4.links link_chunks/intra.4.links | linker4.py -d -a 4 -b 4 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.4.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-4.out 2> merge_links/links.4-4.out.err cat link_chunks/inter.1-7.links link_chunks/intra.1.links link_chunks/intra.7.links | linker4.py -d -a 1 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-7.out 2> merge_links/links.1-7.out.err cat link_chunks/inter.4-9.links link_chunks/intra.4.links link_chunks/intra.9.links | linker4.py -d -a 4 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-9.out 2> merge_links/links.4-9.out.err cat link_chunks/inter.5-12.links link_chunks/intra.5.links link_chunks/intra.12.links | linker4.py -d -a 5 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-12.out 2> merge_links/links.5-12.out.err cat link_chunks/inter.2-14.links link_chunks/intra.2.links link_chunks/intra.14.links | linker4.py -d -a 2 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-14.out 2> merge_links/links.2-14.out.err cat link_chunks/inter.14-15.links link_chunks/intra.14.links link_chunks/intra.15.links | linker4.py -d -a 14 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.14.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.14-15.out 2> merge_links/links.14-15.out.err cat link_chunks/inter.3-13.links link_chunks/intra.3.links link_chunks/intra.13.links | linker4.py -d -a 3 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-13.out 2> merge_links/links.3-13.out.err cat link_chunks/inter.10-14.links link_chunks/intra.10.links link_chunks/intra.14.links | linker4.py -d -a 10 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.10.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.10-14.out 2> merge_links/links.10-14.out.err cat link_chunks/inter.4-12.links link_chunks/intra.4.links link_chunks/intra.12.links | linker4.py -d -a 4 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-12.out 2> merge_links/links.4-12.out.err cat link_chunks/inter.4-13.links link_chunks/intra.4.links link_chunks/intra.13.links | linker4.py -d -a 4 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-13.out 2> merge_links/links.4-13.out.err cat link_chunks/inter.1-1.links link_chunks/intra.1.links link_chunks/intra.1.links | linker4.py -d -a 1 -b 1 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.1.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-1.out 2> merge_links/links.1-1.out.err cat link_chunks/inter.3-5.links link_chunks/intra.3.links link_chunks/intra.5.links | linker4.py -d -a 3 -b 5 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.5.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-5.out 2> merge_links/links.3-5.out.err cat link_chunks/inter.2-2.links link_chunks/intra.2.links link_chunks/intra.2.links | linker4.py -d -a 2 -b 2 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.2.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-2.out 2> merge_links/links.2-2.out.err cat link_chunks/inter.1-2.links link_chunks/intra.1.links link_chunks/intra.2.links | linker4.py -d -a 1 -b 2 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.2.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-2.out 2> merge_links/links.1-2.out.err cat link_chunks/inter.3-15.links link_chunks/intra.3.links link_chunks/intra.15.links | linker4.py -d -a 3 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-15.out 2> merge_links/links.3-15.out.err cat link_chunks/inter.12-15.links link_chunks/intra.12.links link_chunks/intra.15.links | linker4.py -d -a 12 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.12.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.12-15.out 2> merge_links/links.12-15.out.err cat link_chunks/inter.11-15.links link_chunks/intra.11.links link_chunks/intra.15.links | linker4.py -d -a 11 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.11.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.11-15.out 2> merge_links/links.11-15.out.err cat link_chunks/inter.11-11.links link_chunks/intra.11.links link_chunks/intra.11.links | linker4.py -d -a 11 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.11.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.11-11.out 2> merge_links/links.11-11.out.err cat link_chunks/inter.5-8.links link_chunks/intra.5.links link_chunks/intra.8.links | linker4.py -d -a 5 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-8.out 2> merge_links/links.5-8.out.err cat link_chunks/inter.1-10.links link_chunks/intra.1.links link_chunks/intra.10.links | linker4.py -d -a 1 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-10.out 2> merge_links/links.1-10.out.err cat link_chunks/inter.8-10.links link_chunks/intra.8.links link_chunks/intra.10.links | linker4.py -d -a 8 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-10.out 2> merge_links/links.8-10.out.err cat link_chunks/inter.1-14.links link_chunks/intra.1.links link_chunks/intra.14.links | linker4.py -d -a 1 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-14.out 2> merge_links/links.1-14.out.err cat link_chunks/inter.7-8.links link_chunks/intra.7.links link_chunks/intra.8.links | linker4.py -d -a 7 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-8.out 2> merge_links/links.7-8.out.err cat link_chunks/inter.0-12.links link_chunks/intra.0.links link_chunks/intra.12.links | linker4.py -d -a 0 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-12.out 2> merge_links/links.0-12.out.err cat link_chunks/inter.0-7.links link_chunks/intra.0.links link_chunks/intra.7.links | linker4.py -d -a 0 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-7.out 2> merge_links/links.0-7.out.err cat link_chunks/inter.1-11.links link_chunks/intra.1.links link_chunks/intra.11.links | linker4.py -d -a 1 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-11.out 2> merge_links/links.1-11.out.err cat link_chunks/inter.0-2.links link_chunks/intra.0.links link_chunks/intra.2.links | linker4.py -d -a 0 -b 2 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.2.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-2.out 2> merge_links/links.0-2.out.err cat link_chunks/inter.7-11.links link_chunks/intra.7.links link_chunks/intra.11.links | linker4.py -d -a 7 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-11.out 2> merge_links/links.7-11.out.err cat link_chunks/inter.13-15.links link_chunks/intra.13.links link_chunks/intra.15.links | linker4.py -d -a 13 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.13.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.13-15.out 2> merge_links/links.13-15.out.err cat link_chunks/inter.0-4.links link_chunks/intra.0.links link_chunks/intra.4.links | linker4.py -d -a 0 -b 4 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.4.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-4.out 2> merge_links/links.0-4.out.err cat link_chunks/inter.11-14.links link_chunks/intra.11.links link_chunks/intra.14.links | linker4.py -d -a 11 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.11.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.11-14.out 2> merge_links/links.11-14.out.err cat link_chunks/inter.5-10.links link_chunks/intra.5.links link_chunks/intra.10.links | linker4.py -d -a 5 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-10.out 2> merge_links/links.5-10.out.err cat link_chunks/inter.2-9.links link_chunks/intra.2.links link_chunks/intra.9.links | linker4.py -d -a 2 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-9.out 2> merge_links/links.2-9.out.err cat link_chunks/inter.7-15.links link_chunks/intra.7.links link_chunks/intra.15.links | linker4.py -d -a 7 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-15.out 2> merge_links/links.7-15.out.err cat link_chunks/inter.1-3.links link_chunks/intra.1.links link_chunks/intra.3.links | linker4.py -d -a 1 -b 3 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.3.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-3.out 2> merge_links/links.1-3.out.err cat link_chunks/inter.3-9.links link_chunks/intra.3.links link_chunks/intra.9.links | linker4.py -d -a 3 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-9.out 2> merge_links/links.3-9.out.err cat link_chunks/inter.7-13.links link_chunks/intra.7.links link_chunks/intra.13.links | linker4.py -d -a 7 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-13.out 2> merge_links/links.7-13.out.err cat link_chunks/inter.4-10.links link_chunks/intra.4.links link_chunks/intra.10.links | linker4.py -d -a 4 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-10.out 2> merge_links/links.4-10.out.err cat link_chunks/inter.3-14.links link_chunks/intra.3.links link_chunks/intra.14.links | linker4.py -d -a 3 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-14.out 2> merge_links/links.3-14.out.err cat link_chunks/inter.1-13.links link_chunks/intra.1.links link_chunks/intra.13.links | linker4.py -d -a 1 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-13.out 2> merge_links/links.1-13.out.err cat link_chunks/inter.1-15.links link_chunks/intra.1.links link_chunks/intra.15.links | linker4.py -d -a 1 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-15.out 2> merge_links/links.1-15.out.err cat link_chunks/inter.6-15.links link_chunks/intra.6.links link_chunks/intra.15.links | linker4.py -d -a 6 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-15.out 2> merge_links/links.6-15.out.err cat link_chunks/inter.2-3.links link_chunks/intra.2.links link_chunks/intra.3.links | linker4.py -d -a 2 -b 3 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.3.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-3.out 2> merge_links/links.2-3.out.err cat link_chunks/inter.5-11.links link_chunks/intra.5.links link_chunks/intra.11.links | linker4.py -d -a 5 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-11.out 2> merge_links/links.5-11.out.err cat link_chunks/inter.0-0.links link_chunks/intra.0.links link_chunks/intra.0.links | linker4.py -d -a 0 -b 0 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.0.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-0.out 2> merge_links/links.0-0.out.err cat link_chunks/inter.9-14.links link_chunks/intra.9.links link_chunks/intra.14.links | linker4.py -d -a 9 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.9.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.9-14.out 2> merge_links/links.9-14.out.err cat link_chunks/inter.7-10.links link_chunks/intra.7.links link_chunks/intra.10.links | linker4.py -d -a 7 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-10.out 2> merge_links/links.7-10.out.err cat link_chunks/inter.1-5.links link_chunks/intra.1.links link_chunks/intra.5.links | linker4.py -d -a 1 -b 5 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.5.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-5.out 2> merge_links/links.1-5.out.err cat link_chunks/inter.8-13.links link_chunks/intra.8.links link_chunks/intra.13.links | linker4.py -d -a 8 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-13.out 2> merge_links/links.8-13.out.err cat link_chunks/inter.2-6.links link_chunks/intra.2.links link_chunks/intra.6.links | linker4.py -d -a 2 -b 6 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.6.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-6.out 2> merge_links/links.2-6.out.err cat link_chunks/inter.0-10.links link_chunks/intra.0.links link_chunks/intra.10.links | linker4.py -d -a 0 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-10.out 2> merge_links/links.0-10.out.err cat link_chunks/inter.8-9.links link_chunks/intra.8.links link_chunks/intra.9.links | linker4.py -d -a 8 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-9.out 2> merge_links/links.8-9.out.err cat link_chunks/inter.0-13.links link_chunks/intra.0.links link_chunks/intra.13.links | linker4.py -d -a 0 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-13.out 2> merge_links/links.0-13.out.err cat link_chunks/inter.0-6.links link_chunks/intra.0.links link_chunks/intra.6.links | linker4.py -d -a 0 -b 6 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.6.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-6.out 2> merge_links/links.0-6.out.err cat link_chunks/inter.8-12.links link_chunks/intra.8.links link_chunks/intra.12.links | linker4.py -d -a 8 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-12.out 2> merge_links/links.8-12.out.err cat link_chunks/inter.6-11.links link_chunks/intra.6.links link_chunks/intra.11.links | linker4.py -d -a 6 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-11.out 2> merge_links/links.6-11.out.err cat link_chunks/inter.9-11.links link_chunks/intra.9.links link_chunks/intra.11.links | linker4.py -d -a 9 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.9.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.9-11.out 2> merge_links/links.9-11.out.err cat link_chunks/inter.9-13.links link_chunks/intra.9.links link_chunks/intra.13.links | linker4.py -d -a 9 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.9.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.9-13.out 2> merge_links/links.9-13.out.err cat link_chunks/inter.6-8.links link_chunks/intra.6.links link_chunks/intra.8.links | linker4.py -d -a 6 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-8.out 2> merge_links/links.6-8.out.err cat link_chunks/inter.8-14.links link_chunks/intra.8.links link_chunks/intra.14.links | linker4.py -d -a 8 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-14.out 2> merge_links/links.8-14.out.err cat link_chunks/inter.10-13.links link_chunks/intra.10.links link_chunks/intra.13.links | linker4.py -d -a 10 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.10.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.10-13.out 2> merge_links/links.10-13.out.err cat link_chunks/inter.1-6.links link_chunks/intra.1.links link_chunks/intra.6.links | linker4.py -d -a 1 -b 6 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.6.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-6.out 2> merge_links/links.1-6.out.err cat link_chunks/inter.2-10.links link_chunks/intra.2.links link_chunks/intra.10.links | linker4.py -d -a 2 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-10.out 2> merge_links/links.2-10.out.err cat link_chunks/inter.3-7.links link_chunks/intra.3.links link_chunks/intra.7.links | linker4.py -d -a 3 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-7.out 2> merge_links/links.3-7.out.err cat link_chunks/inter.3-11.links link_chunks/intra.3.links link_chunks/intra.11.links | linker4.py -d -a 3 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-11.out 2> merge_links/links.3-11.out.err cat link_chunks/inter.2-11.links link_chunks/intra.2.links link_chunks/intra.11.links | linker4.py -d -a 2 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-11.out 2> merge_links/links.2-11.out.err cat link_chunks/inter.9-15.links link_chunks/intra.9.links link_chunks/intra.15.links | linker4.py -d -a 9 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.9.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.9-15.out 2> merge_links/links.9-15.out.err cat link_chunks/inter.2-4.links link_chunks/intra.2.links link_chunks/intra.4.links | linker4.py -d -a 2 -b 4 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.4.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-4.out 2> merge_links/links.2-4.out.err cat link_chunks/inter.4-5.links link_chunks/intra.4.links link_chunks/intra.5.links | linker4.py -d -a 4 -b 5 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.5.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-5.out 2> merge_links/links.4-5.out.err cat link_chunks/inter.10-12.links link_chunks/intra.10.links link_chunks/intra.12.links | linker4.py -d -a 10 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.10.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.10-12.out 2> merge_links/links.10-12.out.err cat link_chunks/inter.0-15.links link_chunks/intra.0.links link_chunks/intra.15.links | linker4.py -d -a 0 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-15.out 2> merge_links/links.0-15.out.err cat link_chunks/inter.9-9.links link_chunks/intra.9.links link_chunks/intra.9.links | linker4.py -d -a 9 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.9.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.9-9.out 2> merge_links/links.9-9.out.err cat link_chunks/inter.6-14.links link_chunks/intra.6.links link_chunks/intra.14.links | linker4.py -d -a 6 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-14.out 2> merge_links/links.6-14.out.err cat link_chunks/inter.10-10.links link_chunks/intra.10.links link_chunks/intra.10.links | linker4.py -d -a 10 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.10.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.10-10.out 2> merge_links/links.10-10.out.err cat link_chunks/inter.0-8.links link_chunks/intra.0.links link_chunks/intra.8.links | linker4.py -d -a 0 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-8.out 2> merge_links/links.0-8.out.err cat link_chunks/inter.3-8.links link_chunks/intra.3.links link_chunks/intra.8.links | linker4.py -d -a 3 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-8.out 2> merge_links/links.3-8.out.err cat link_chunks/inter.4-6.links link_chunks/intra.4.links link_chunks/intra.6.links | linker4.py -d -a 4 -b 6 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.6.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-6.out 2> merge_links/links.4-6.out.err cat link_chunks/inter.5-13.links link_chunks/intra.5.links link_chunks/intra.13.links | linker4.py -d -a 5 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-13.out 2> merge_links/links.5-13.out.err cat link_chunks/inter.12-14.links link_chunks/intra.12.links link_chunks/intra.14.links | linker4.py -d -a 12 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.12.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.12-14.out 2> merge_links/links.12-14.out.err cat link_chunks/inter.11-12.links link_chunks/intra.11.links link_chunks/intra.12.links | linker4.py -d -a 11 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.11.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.11-12.out 2> merge_links/links.11-12.out.err cat link_chunks/inter.5-7.links link_chunks/intra.5.links link_chunks/intra.7.links | linker4.py -d -a 5 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-7.out 2> merge_links/links.5-7.out.err cat link_chunks/inter.2-7.links link_chunks/intra.2.links link_chunks/intra.7.links | linker4.py -d -a 2 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-7.out 2> merge_links/links.2-7.out.err cat link_chunks/inter.4-8.links link_chunks/intra.4.links link_chunks/intra.8.links | linker4.py -d -a 4 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-8.out 2> merge_links/links.4-8.out.err cat link_chunks/inter.1-4.links link_chunks/intra.1.links link_chunks/intra.4.links | linker4.py -d -a 1 -b 4 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.4.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-4.out 2> merge_links/links.1-4.out.err cat link_chunks/inter.6-10.links link_chunks/intra.6.links link_chunks/intra.10.links | linker4.py -d -a 6 -b 10 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.10.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-10.out 2> merge_links/links.6-10.out.err cat link_chunks/inter.0-1.links link_chunks/intra.0.links link_chunks/intra.1.links | linker4.py -d -a 0 -b 1 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.1.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-1.out 2> merge_links/links.0-1.out.err cat link_chunks/inter.0-9.links link_chunks/intra.0.links link_chunks/intra.9.links | linker4.py -d -a 0 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-9.out 2> merge_links/links.0-9.out.err cat link_chunks/inter.0-11.links link_chunks/intra.0.links link_chunks/intra.11.links | linker4.py -d -a 0 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-11.out 2> merge_links/links.0-11.out.err cat link_chunks/inter.2-12.links link_chunks/intra.2.links link_chunks/intra.12.links | linker4.py -d -a 2 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-12.out 2> merge_links/links.2-12.out.err cat link_chunks/inter.1-12.links link_chunks/intra.1.links link_chunks/intra.12.links | linker4.py -d -a 1 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-12.out 2> merge_links/links.1-12.out.err cat link_chunks/inter.11-13.links link_chunks/intra.11.links link_chunks/intra.13.links | linker4.py -d -a 11 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.11.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.11-13.out 2> merge_links/links.11-13.out.err cat link_chunks/inter.8-11.links link_chunks/intra.8.links link_chunks/intra.11.links | linker4.py -d -a 8 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-11.out 2> merge_links/links.8-11.out.err cat link_chunks/inter.3-3.links link_chunks/intra.3.links link_chunks/intra.3.links | linker4.py -d -a 3 -b 3 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.3.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-3.out 2> merge_links/links.3-3.out.err cat link_chunks/inter.7-7.links link_chunks/intra.7.links link_chunks/intra.7.links | linker4.py -d -a 7 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-7.out 2> merge_links/links.7-7.out.err cat link_chunks/inter.7-14.links link_chunks/intra.7.links link_chunks/intra.14.links | linker4.py -d -a 7 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-14.out 2> merge_links/links.7-14.out.err cat link_chunks/inter.8-8.links link_chunks/intra.8.links link_chunks/intra.8.links | linker4.py -d -a 8 -b 8 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.8.out refined.8.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.8-8.out 2> merge_links/links.8-8.out.err cat link_chunks/inter.15-15.links link_chunks/intra.15.links link_chunks/intra.15.links | linker4.py -d -a 15 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.15.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.15-15.out 2> merge_links/links.15-15.out.err cat link_chunks/inter.13-13.links link_chunks/intra.13.links link_chunks/intra.13.links | linker4.py -d -a 13 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.13.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.13-13.out 2> merge_links/links.13-13.out.err cat link_chunks/inter.3-6.links link_chunks/intra.3.links link_chunks/intra.6.links | linker4.py -d -a 3 -b 6 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.3.out refined.6.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.3-6.out 2> merge_links/links.3-6.out.err cat link_chunks/inter.13-14.links link_chunks/intra.13.links link_chunks/intra.14.links | linker4.py -d -a 13 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.13.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.13-14.out 2> merge_links/links.13-14.out.err cat link_chunks/inter.10-15.links link_chunks/intra.10.links link_chunks/intra.15.links | linker4.py -d -a 10 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.10.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.10-15.out 2> merge_links/links.10-15.out.err cat link_chunks/inter.5-9.links link_chunks/intra.5.links link_chunks/intra.9.links | linker4.py -d -a 5 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-9.out 2> merge_links/links.5-9.out.err cat link_chunks/inter.7-12.links link_chunks/intra.7.links link_chunks/intra.12.links | linker4.py -d -a 7 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.7.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.7-12.out 2> merge_links/links.7-12.out.err cat link_chunks/inter.6-13.links link_chunks/intra.6.links link_chunks/intra.13.links | linker4.py -d -a 6 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-13.out 2> merge_links/links.6-13.out.err cat link_chunks/inter.4-7.links link_chunks/intra.4.links link_chunks/intra.7.links | linker4.py -d -a 4 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-7.out 2> merge_links/links.4-7.out.err cat link_chunks/inter.5-15.links link_chunks/intra.5.links link_chunks/intra.15.links | linker4.py -d -a 5 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-15.out 2> merge_links/links.5-15.out.err cat link_chunks/inter.1-9.links link_chunks/intra.1.links link_chunks/intra.9.links | linker4.py -d -a 1 -b 9 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.1.out refined.9.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.1-9.out 2> merge_links/links.1-9.out.err cat link_chunks/inter.4-14.links link_chunks/intra.4.links link_chunks/intra.14.links | linker4.py -d -a 4 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.4.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.4-14.out 2> merge_links/links.4-14.out.err cat link_chunks/inter.10-11.links link_chunks/intra.10.links link_chunks/intra.11.links | linker4.py -d -a 10 -b 11 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.10.out refined.11.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.10-11.out 2> merge_links/links.10-11.out.err cat link_chunks/inter.0-14.links link_chunks/intra.0.links link_chunks/intra.14.links | linker4.py -d -a 0 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-14.out 2> merge_links/links.0-14.out.err cat link_chunks/inter.6-7.links link_chunks/intra.6.links link_chunks/intra.7.links | linker4.py -d -a 6 -b 7 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.7.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-7.out 2> merge_links/links.6-7.out.err cat link_chunks/inter.9-12.links link_chunks/intra.9.links link_chunks/intra.12.links | linker4.py -d -a 9 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.9.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.9-12.out 2> merge_links/links.9-12.out.err cat link_chunks/inter.2-13.links link_chunks/intra.2.links link_chunks/intra.13.links | linker4.py -d -a 2 -b 13 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.13.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-13.out 2> merge_links/links.2-13.out.err cat link_chunks/inter.2-15.links link_chunks/intra.2.links link_chunks/intra.15.links | linker4.py -d -a 2 -b 15 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.15.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-15.out 2> merge_links/links.2-15.out.err cat link_chunks/inter.0-5.links link_chunks/intra.0.links link_chunks/intra.5.links | linker4.py -d -a 0 -b 5 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.0.out refined.5.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.0-5.out 2> merge_links/links.0-5.out.err cat link_chunks/inter.5-6.links link_chunks/intra.5.links link_chunks/intra.6.links | linker4.py -d -a 5 -b 6 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.6.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-6.out 2> merge_links/links.5-6.out.err cat link_chunks/inter.5-14.links link_chunks/intra.5.links link_chunks/intra.14.links | linker4.py -d -a 5 -b 14 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.14.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-14.out 2> merge_links/links.5-14.out.err cat link_chunks/inter.6-6.links link_chunks/intra.6.links link_chunks/intra.6.links | linker4.py -d -a 6 -b 6 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.6.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-6.out 2> merge_links/links.6-6.out.err cat link_chunks/inter.6-12.links link_chunks/intra.6.links link_chunks/intra.12.links | linker4.py -d -a 6 -b 12 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.6.out refined.12.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.6-12.out 2> merge_links/links.6-12.out.err cat link_chunks/inter.2-5.links link_chunks/intra.2.links link_chunks/intra.5.links | linker4.py -d -a 2 -b 5 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.2.out refined.5.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.2-5.out 2> merge_links/links.2-5.out.err cat link_chunks/inter.5-5.links link_chunks/intra.5.links link_chunks/intra.5.links | linker4.py -d -a 5 -b 5 -Z component_x.txt -l broken_lengths.txt -p -L - -s <( cat refined.5.out refined.5.out ) --set_insert_size_dist_fit_params datamodel.out > merge_links/links.5-5.out 2> merge_links/links.5-5.out.err cat merge_links/links.0-0.out merge_links/links.0-1.out merge_links/links.1-1.out merge_links/links.0-2.out merge_links/links.1-2.out merge_links/links.2-2.out merge_links/links.0-3.out merge_links/links.1-3.out merge_links/links.2-3.out merge_links/links.3-3.out merge_links/links.0-4.out merge_links/links.1-4.out merge_links/links.2-4.out merge_links/links.3-4.out merge_links/links.4-4.out merge_links/links.0-5.out merge_links/links.1-5.out merge_links/links.2-5.out merge_links/links.3-5.out merge_links/links.4-5.out merge_links/links.5-5.out merge_links/links.0-6.out merge_links/links.1-6.out merge_links/links.2-6.out merge_links/links.3-6.out merge_links/links.4-6.out merge_links/links.5-6.out merge_links/links.6-6.out merge_links/links.0-7.out merge_links/links.1-7.out merge_links/links.2-7.out merge_links/links.3-7.out merge_links/links.4-7.out merge_links/links.5-7.out merge_links/links.6-7.out merge_links/links.7-7.out merge_links/links.0-8.out merge_links/links.1-8.out merge_links/links.2-8.out merge_links/links.3-8.out merge_links/links.4-8.out merge_links/links.5-8.out merge_links/links.6-8.out merge_links/links.7-8.out merge_links/links.8-8.out merge_links/links.0-9.out merge_links/links.1-9.out merge_links/links.2-9.out merge_links/links.3-9.out merge_links/links.4-9.out merge_links/links.5-9.out merge_links/links.6-9.out merge_links/links.7-9.out merge_links/links.8-9.out merge_links/links.9-9.out merge_links/links.0-10.out merge_links/links.1-10.out merge_links/links.2-10.out merge_links/links.3-10.out merge_links/links.4-10.out merge_links/links.5-10.out merge_links/links.6-10.out merge_links/links.7-10.out merge_links/links.8-10.out merge_links/links.9-10.out merge_links/links.10-10.out merge_links/links.0-11.out merge_links/links.1-11.out merge_links/links.2-11.out merge_links/links.3-11.out merge_links/links.4-11.out merge_links/links.5-11.out merge_links/links.6-11.out merge_links/links.7-11.out merge_links/links.8-11.out merge_links/links.9-11.out merge_links/links.10-11.out merge_links/links.11-11.out merge_links/links.0-12.out merge_links/links.1-12.out merge_links/links.2-12.out merge_links/links.3-12.out merge_links/links.4-12.out merge_links/links.5-12.out merge_links/links.6-12.out merge_links/links.7-12.out merge_links/links.8-12.out merge_links/links.9-12.out merge_links/links.10-12.out merge_links/links.11-12.out merge_links/links.12-12.out merge_links/links.0-13.out merge_links/links.1-13.out merge_links/links.2-13.out merge_links/links.3-13.out merge_links/links.4-13.out merge_links/links.5-13.out merge_links/links.6-13.out merge_links/links.7-13.out merge_links/links.8-13.out merge_links/links.9-13.out merge_links/links.10-13.out merge_links/links.11-13.out merge_links/links.12-13.out merge_links/links.13-13.out merge_links/links.0-14.out merge_links/links.1-14.out merge_links/links.2-14.out merge_links/links.3-14.out merge_links/links.4-14.out merge_links/links.5-14.out merge_links/links.6-14.out merge_links/links.7-14.out merge_links/links.8-14.out merge_links/links.9-14.out merge_links/links.10-14.out merge_links/links.11-14.out merge_links/links.12-14.out merge_links/links.13-14.out merge_links/links.14-14.out merge_links/links.0-15.out merge_links/links.1-15.out merge_links/links.2-15.out merge_links/links.3-15.out merge_links/links.4-15.out merge_links/links.5-15.out merge_links/links.6-15.out merge_links/links.7-15.out merge_links/links.8-15.out merge_links/links.9-15.out merge_links/links.10-15.out merge_links/links.11-15.out merge_links/links.12-15.out merge_links/links.13-15.out merge_links/links.14-15.out merge_links/links.15-15.out | hiriseJoin.py -m 20.0 -s <( cat refined.0.out refined.1.out refined.2.out refined.3.out refined.4.out refined.5.out refined.6.out refined.7.out refined.8.out refined.9.out refined.10.out refined.11.out refined.12.out refined.13.out refined.14.out refined.15.out) -l broken_lengths.txt > hirise.out cp hirise.out hirise_iter_0.out set_layout.py -i assembly1.hra -o hirise_iter_0.hra -L hirise_iter_0.out for k in {0..7};do { parallel_breaker.py -i hirise_iter_0.hra -o chicago_weak_segs_iter0_part$k.out -t 20 -T 30 -q $qual2 -j 2 -S $k,8 -H chicago_weak_segs_iter0_part$k.out.histogram > pb0-$k.out 2> pb0-$k.err } & done wait cat chicago_weak_segs_iter0_part0.out chicago_weak_segs_iter0_part1.out chicago_weak_segs_iter0_part2.out chicago_weak_segs_iter0_part3.out chicago_weak_segs_iter0_part4.out chicago_weak_segs_iter0_part5.out chicago_weak_segs_iter0_part6.out chicago_weak_segs_iter0_part7.out > chicago_weak_segs_iter0.out break_playout.py -T 0.0 -t 0.0 -i hirise_iter_0.out -o hirise_iter_broken_0.out -b chicago_weak_segs_iter0.out > hirise_iter_broken_0.log set_layout.py -i assembly1.hra -o r0.hra -L hirise_iter_broken_0.out for k in {0..15};do { if [ ! -e hirise_iter_broken_links_0 ] ; then mkdir hirise_iter_broken_links_0 ; fi ; export_links.py -q $qual2 -i r0.hra -c $k -C 16 > hirise_iter_broken_links_0/$k.links } & done wait for k in {0..15};do { cat hirise_iter_broken_0.out | local_oo_opt.py -N 16 -a $k -l ""hirise_iter_broken_links_0/*.links"" -M datamodel.out > merge_links_tmp/refined_0.$k.out } & done wait cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-11.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 3 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-3.out cat merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.9-13.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-8.out cat merge_links_tmp/refined_0.14.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 14 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.14-14.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.1.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 1 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-1.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-7.out cat merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.9-9.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-8.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 5 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-5.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-10.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-12.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-15.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-13.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 4 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-4.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-12.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 6 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-6.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-8.out cat merge_links_tmp/refined_0.15.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 15 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.15-15.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-12.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-11.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 4 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-4.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-15.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-7.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-15.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-10.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-11.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 6 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-6.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 6 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-6.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 4 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-4.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-13.out cat merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.9-11.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-7.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 5 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-5.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-14.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-13.out cat merge_links_tmp/refined_0.11.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.11-13.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 4 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-4.out cat merge_links_tmp/refined_0.10.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.10-10.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 2 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-2.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 4 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-4.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-14.out cat merge_links_tmp/refined_0.13.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.13-14.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-11.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-15.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-12.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 3 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-3.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-8.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 2 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-2.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 6 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-6.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-7.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-10.out cat merge_links_tmp/refined_0.11.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.11-12.out cat merge_links_tmp/refined_0.10.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.10-12.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-11.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-10.out cat merge_links_tmp/refined_0.12.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.12-12.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-14.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-14.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-13.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-10.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-14.out cat merge_links_tmp/refined_0.12.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.12-13.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-9.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-11.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-14.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-9.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-12.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-9.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-10.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-8.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-15.out cat merge_links_tmp/refined_0.11.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.11-11.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 6 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-6.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-8.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-14.out cat merge_links_tmp/refined_0.12.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.12-14.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 6 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-6.out cat merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.9-15.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-9.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-15.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-10.out cat merge_links_tmp/refined_0.13.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.13-15.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.0.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 0 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-0.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-15.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.1.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 1 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-1.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-9.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-7.out cat merge_links_tmp/refined_0.14.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 14 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.14-15.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-8.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 2 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-2.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-9.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-13.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-7.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-15.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-12.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 5 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-5.out cat merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.9-14.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-12.out cat merge_links_tmp/refined_0.10.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.10-14.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 3 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-3.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-14.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-12.out cat merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.5-14.out cat merge_links_tmp/refined_0.12.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.12-15.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-13.out cat merge_links_tmp/refined_0.11.out merge_links_tmp/refined_0.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 14 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.11-14.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-7.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-13.out cat merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.6-15.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-13.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-10.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 6 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-6.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 3 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-3.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-13.out cat merge_links_tmp/refined_0.10.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.10-15.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-10.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-12.out cat merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 5 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.2-5.out cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.0-11.out cat merge_links_tmp/refined_0.11.out merge_links_tmp/refined_0.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 15 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.11-15.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 5 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-5.out cat merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 10 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.9-10.out cat merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.7-11.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-9.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-9.out cat merge_links_tmp/refined_0.13.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.13-13.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-11.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 7 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-7.out cat merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.1-8.out cat merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 8 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.3-8.out cat merge_links_tmp/refined_0.10.out merge_links_tmp/refined_0.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 11 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.10-11.out cat merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 12 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.9-12.out cat merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 5 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.4-5.out cat merge_links_tmp/refined_0.10.out merge_links_tmp/refined_0.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 13 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.10-13.out cat merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 9 -L ""hirise_iter_broken_links_0/*.links"" -d -M datamodel.out > merge_links_tmp/links_0.8-9.out cat merge_links_tmp/links_0.0-0.out merge_links_tmp/links_0.0-1.out merge_links_tmp/links_0.1-1.out merge_links_tmp/links_0.0-2.out merge_links_tmp/links_0.1-2.out merge_links_tmp/links_0.2-2.out merge_links_tmp/links_0.0-3.out merge_links_tmp/links_0.1-3.out merge_links_tmp/links_0.2-3.out merge_links_tmp/links_0.3-3.out merge_links_tmp/links_0.0-4.out merge_links_tmp/links_0.1-4.out merge_links_tmp/links_0.2-4.out merge_links_tmp/links_0.3-4.out merge_links_tmp/links_0.4-4.out merge_links_tmp/links_0.0-5.out merge_links_tmp/links_0.1-5.out merge_links_tmp/links_0.2-5.out merge_links_tmp/links_0.3-5.out merge_links_tmp/links_0.4-5.out merge_links_tmp/links_0.5-5.out merge_links_tmp/links_0.0-6.out merge_links_tmp/links_0.1-6.out merge_links_tmp/links_0.2-6.out merge_links_tmp/links_0.3-6.out merge_links_tmp/links_0.4-6.out merge_links_tmp/links_0.5-6.out merge_links_tmp/links_0.6-6.out merge_links_tmp/links_0.0-7.out merge_links_tmp/links_0.1-7.out merge_links_tmp/links_0.2-7.out merge_links_tmp/links_0.3-7.out merge_links_tmp/links_0.4-7.out merge_links_tmp/links_0.5-7.out merge_links_tmp/links_0.6-7.out merge_links_tmp/links_0.7-7.out merge_links_tmp/links_0.0-8.out merge_links_tmp/links_0.1-8.out merge_links_tmp/links_0.2-8.out merge_links_tmp/links_0.3-8.out merge_links_tmp/links_0.4-8.out merge_links_tmp/links_0.5-8.out merge_links_tmp/links_0.6-8.out merge_links_tmp/links_0.7-8.out merge_links_tmp/links_0.8-8.out merge_links_tmp/links_0.0-9.out merge_links_tmp/links_0.1-9.out merge_links_tmp/links_0.2-9.out merge_links_tmp/links_0.3-9.out merge_links_tmp/links_0.4-9.out merge_links_tmp/links_0.5-9.out merge_links_tmp/links_0.6-9.out merge_links_tmp/links_0.7-9.out merge_links_tmp/links_0.8-9.out merge_links_tmp/links_0.9-9.out merge_links_tmp/links_0.0-10.out merge_links_tmp/links_0.1-10.out merge_links_tmp/links_0.2-10.out merge_links_tmp/links_0.3-10.out merge_links_tmp/links_0.4-10.out merge_links_tmp/links_0.5-10.out merge_links_tmp/links_0.6-10.out merge_links_tmp/links_0.7-10.out merge_links_tmp/links_0.8-10.out merge_links_tmp/links_0.9-10.out merge_links_tmp/links_0.10-10.out merge_links_tmp/links_0.0-11.out merge_links_tmp/links_0.1-11.out merge_links_tmp/links_0.2-11.out merge_links_tmp/links_0.3-11.out merge_links_tmp/links_0.4-11.out merge_links_tmp/links_0.5-11.out merge_links_tmp/links_0.6-11.out merge_links_tmp/links_0.7-11.out merge_links_tmp/links_0.8-11.out merge_links_tmp/links_0.9-11.out merge_links_tmp/links_0.10-11.out merge_links_tmp/links_0.11-11.out merge_links_tmp/links_0.0-12.out merge_links_tmp/links_0.1-12.out merge_links_tmp/links_0.2-12.out merge_links_tmp/links_0.3-12.out merge_links_tmp/links_0.4-12.out merge_links_tmp/links_0.5-12.out merge_links_tmp/links_0.6-12.out merge_links_tmp/links_0.7-12.out merge_links_tmp/links_0.8-12.out merge_links_tmp/links_0.9-12.out merge_links_tmp/links_0.10-12.out merge_links_tmp/links_0.11-12.out merge_links_tmp/links_0.12-12.out merge_links_tmp/links_0.0-13.out merge_links_tmp/links_0.1-13.out merge_links_tmp/links_0.2-13.out merge_links_tmp/links_0.3-13.out merge_links_tmp/links_0.4-13.out merge_links_tmp/links_0.5-13.out merge_links_tmp/links_0.6-13.out merge_links_tmp/links_0.7-13.out merge_links_tmp/links_0.8-13.out merge_links_tmp/links_0.9-13.out merge_links_tmp/links_0.10-13.out merge_links_tmp/links_0.11-13.out merge_links_tmp/links_0.12-13.out merge_links_tmp/links_0.13-13.out merge_links_tmp/links_0.0-14.out merge_links_tmp/links_0.1-14.out merge_links_tmp/links_0.2-14.out merge_links_tmp/links_0.3-14.out merge_links_tmp/links_0.4-14.out merge_links_tmp/links_0.5-14.out merge_links_tmp/links_0.6-14.out merge_links_tmp/links_0.7-14.out merge_links_tmp/links_0.8-14.out merge_links_tmp/links_0.9-14.out merge_links_tmp/links_0.10-14.out merge_links_tmp/links_0.11-14.out merge_links_tmp/links_0.12-14.out merge_links_tmp/links_0.13-14.out merge_links_tmp/links_0.14-14.out merge_links_tmp/links_0.0-15.out merge_links_tmp/links_0.1-15.out merge_links_tmp/links_0.2-15.out merge_links_tmp/links_0.3-15.out merge_links_tmp/links_0.4-15.out merge_links_tmp/links_0.5-15.out merge_links_tmp/links_0.6-15.out merge_links_tmp/links_0.7-15.out merge_links_tmp/links_0.8-15.out merge_links_tmp/links_0.9-15.out merge_links_tmp/links_0.10-15.out merge_links_tmp/links_0.11-15.out merge_links_tmp/links_0.12-15.out merge_links_tmp/links_0.13-15.out merge_links_tmp/links_0.14-15.out merge_links_tmp/links_0.15-15.out | grep '^link score\|^interc:' > iter_links_0.out dump_lengths.py -i r0.hra -o broken_lengths_0.out cat iter_links_0.out | hiriseJoin.py -m 30.0 -s <( cat merge_links_tmp/refined_0.0.out merge_links_tmp/refined_0.1.out merge_links_tmp/refined_0.2.out merge_links_tmp/refined_0.3.out merge_links_tmp/refined_0.4.out merge_links_tmp/refined_0.5.out merge_links_tmp/refined_0.6.out merge_links_tmp/refined_0.7.out merge_links_tmp/refined_0.8.out merge_links_tmp/refined_0.9.out merge_links_tmp/refined_0.10.out merge_links_tmp/refined_0.11.out merge_links_tmp/refined_0.12.out merge_links_tmp/refined_0.13.out merge_links_tmp/refined_0.14.out merge_links_tmp/refined_0.15.out |p2edges.py ) -l broken_lengths_0.out > hirise_iter_1.out set_layout.py -i assembly1.hra -o hirise_iter_1.hra -L hirise_iter_1.out for k in {0..7}; do { parallel_breaker.py -i hirise_iter_1.hra -o chicago_weak_segs_iter1_part$k.out -t 20 -T 30 -q $qual2 -j 2 -S $k,8 -H chicago_weak_segs_iter1_part$k.out.histogram > pb1-$k.out 2> pb1-$k.err } & done wait cat chicago_weak_segs_iter1_part0.out chicago_weak_segs_iter1_part1.out chicago_weak_segs_iter1_part2.out chicago_weak_segs_iter1_part3.out chicago_weak_segs_iter1_part4.out chicago_weak_segs_iter1_part5.out chicago_weak_segs_iter1_part6.out chicago_weak_segs_iter1_part7.out > chicago_weak_segs_iter1.out break_playout.py -T 0.0 -t 0.0 -i hirise_iter_1.out -o hirise_iter_broken_1.out -b chicago_weak_segs_iter1.out > hirise_iter_broken_1.log set_layout.py -i assembly1.hra -o r1.hra -L hirise_iter_broken_1.out for k in {0..15}; do { if [ ! -e hirise_iter_broken_links_1 ] ; then mkdir hirise_iter_broken_links_1 ; fi ; export_links.py -q $qual2 -i r1.hra -c $k -C 16 > hirise_iter_broken_links_1/$k.links } & done wait for k in {0..15}; do { cat hirise_iter_broken_1.out | local_oo_opt.py -N 16 -a $k -l ""hirise_iter_broken_links_1/*.links"" -M datamodel.out > merge_links_tmp/refined_1.$k.out } & done wait cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-9.out cat merge_links_tmp/refined_1.11.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.11-14.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-13.out cat merge_links_tmp/refined_1.12.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.12-12.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 6 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-6.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-12.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-8.out cat merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.9-9.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-14.out cat merge_links_tmp/refined_1.10.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.10-12.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-10.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-13.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 5 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-5.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 2 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-2.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-14.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-8.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-12.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-9.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 6 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-6.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-14.out cat merge_links_tmp/refined_1.13.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.13-14.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-10.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 4 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-4.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-15.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 5 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-5.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-7.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-11.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-11.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 2 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-2.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.1.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 1 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-1.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-15.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 6 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-6.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-12.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-8.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-13.out cat merge_links_tmp/refined_1.12.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.12-15.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-9.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 2 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-2.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-13.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-10.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-11.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-13.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-8.out cat merge_links_tmp/refined_1.14.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 14 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.14-14.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-12.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 5 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-5.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-15.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-14.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 4 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-4.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-10.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-13.out cat merge_links_tmp/refined_1.15.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 15 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.15-15.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-8.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-15.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 3 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-3.out cat merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.9-13.out cat merge_links_tmp/refined_1.10.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.10-10.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.1.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 1 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-1.out cat merge_links_tmp/refined_1.10.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.10-13.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-12.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-9.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-11.out cat merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.9-12.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 6 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-6.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-13.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-10.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-7.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-15.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-15.out cat merge_links_tmp/refined_1.11.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.11-13.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-10.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-11.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-7.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-7.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-9.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-14.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-13.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-10.out cat merge_links_tmp/refined_1.14.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 14 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.14-15.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 5 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-5.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-9.out cat merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.5-7.out cat merge_links_tmp/refined_1.11.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.11-15.out cat merge_links_tmp/refined_1.11.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.11-12.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.0.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 0 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-0.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-7.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-13.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 3 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-3.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 5 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-5.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-14.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-12.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-12.out cat merge_links_tmp/refined_1.10.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.10-11.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 4 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-4.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 6 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-6.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-9.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 3 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-3.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-11.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-7.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 4 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-4.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-8.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-12.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 6 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-6.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-8.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 6 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-6.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-8.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-15.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 5 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-5.out cat merge_links_tmp/refined_1.10.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.10-15.out cat merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.9-15.out cat merge_links_tmp/refined_1.12.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.12-14.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-14.out cat merge_links_tmp/refined_1.12.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.12-13.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-11.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-14.out cat merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.9-14.out cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.0-11.out cat merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.9-10.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 4 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-4.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-9.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 3 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-3.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-10.out cat merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 8 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.4-8.out cat merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 12 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.7-12.out cat merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.9-11.out cat merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.3-14.out cat merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 9 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.6-9.out cat merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 7 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.2-7.out cat merge_links_tmp/refined_1.11.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.11-11.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-15.out cat merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 11 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.1-11.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-15.out cat merge_links_tmp/refined_1.13.out merge_links_tmp/refined_1.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 13 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.13-13.out cat merge_links_tmp/refined_1.10.out merge_links_tmp/refined_1.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 14 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.10-14.out cat merge_links_tmp/refined_1.13.out merge_links_tmp/refined_1.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 15 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.13-15.out cat merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 10 -L ""hirise_iter_broken_links_1/*.links"" -d -M datamodel.out > merge_links_tmp/links_1.8-10.out dump_lengths.py -i r1.hra -o broken_lengths_1.out cat merge_links_tmp/links_1.0-0.out merge_links_tmp/links_1.0-1.out merge_links_tmp/links_1.1-1.out merge_links_tmp/links_1.0-2.out merge_links_tmp/links_1.1-2.out merge_links_tmp/links_1.2-2.out merge_links_tmp/links_1.0-3.out merge_links_tmp/links_1.1-3.out merge_links_tmp/links_1.2-3.out merge_links_tmp/links_1.3-3.out merge_links_tmp/links_1.0-4.out merge_links_tmp/links_1.1-4.out merge_links_tmp/links_1.2-4.out merge_links_tmp/links_1.3-4.out merge_links_tmp/links_1.4-4.out merge_links_tmp/links_1.0-5.out merge_links_tmp/links_1.1-5.out merge_links_tmp/links_1.2-5.out merge_links_tmp/links_1.3-5.out merge_links_tmp/links_1.4-5.out merge_links_tmp/links_1.5-5.out merge_links_tmp/links_1.0-6.out merge_links_tmp/links_1.1-6.out merge_links_tmp/links_1.2-6.out merge_links_tmp/links_1.3-6.out merge_links_tmp/links_1.4-6.out merge_links_tmp/links_1.5-6.out merge_links_tmp/links_1.6-6.out merge_links_tmp/links_1.0-7.out merge_links_tmp/links_1.1-7.out merge_links_tmp/links_1.2-7.out merge_links_tmp/links_1.3-7.out merge_links_tmp/links_1.4-7.out merge_links_tmp/links_1.5-7.out merge_links_tmp/links_1.6-7.out merge_links_tmp/links_1.7-7.out merge_links_tmp/links_1.0-8.out merge_links_tmp/links_1.1-8.out merge_links_tmp/links_1.2-8.out merge_links_tmp/links_1.3-8.out merge_links_tmp/links_1.4-8.out merge_links_tmp/links_1.5-8.out merge_links_tmp/links_1.6-8.out merge_links_tmp/links_1.7-8.out merge_links_tmp/links_1.8-8.out merge_links_tmp/links_1.0-9.out merge_links_tmp/links_1.1-9.out merge_links_tmp/links_1.2-9.out merge_links_tmp/links_1.3-9.out merge_links_tmp/links_1.4-9.out merge_links_tmp/links_1.5-9.out merge_links_tmp/links_1.6-9.out merge_links_tmp/links_1.7-9.out merge_links_tmp/links_1.8-9.out merge_links_tmp/links_1.9-9.out merge_links_tmp/links_1.0-10.out merge_links_tmp/links_1.1-10.out merge_links_tmp/links_1.2-10.out merge_links_tmp/links_1.3-10.out merge_links_tmp/links_1.4-10.out merge_links_tmp/links_1.5-10.out merge_links_tmp/links_1.6-10.out merge_links_tmp/links_1.7-10.out merge_links_tmp/links_1.8-10.out merge_links_tmp/links_1.9-10.out merge_links_tmp/links_1.10-10.out merge_links_tmp/links_1.0-11.out merge_links_tmp/links_1.1-11.out merge_links_tmp/links_1.2-11.out merge_links_tmp/links_1.3-11.out merge_links_tmp/links_1.4-11.out merge_links_tmp/links_1.5-11.out merge_links_tmp/links_1.6-11.out merge_links_tmp/links_1.7-11.out merge_links_tmp/links_1.8-11.out merge_links_tmp/links_1.9-11.out merge_links_tmp/links_1.10-11.out merge_links_tmp/links_1.11-11.out merge_links_tmp/links_1.0-12.out merge_links_tmp/links_1.1-12.out merge_links_tmp/links_1.2-12.out merge_links_tmp/links_1.3-12.out merge_links_tmp/links_1.4-12.out merge_links_tmp/links_1.5-12.out merge_links_tmp/links_1.6-12.out merge_links_tmp/links_1.7-12.out merge_links_tmp/links_1.8-12.out merge_links_tmp/links_1.9-12.out merge_links_tmp/links_1.10-12.out merge_links_tmp/links_1.11-12.out merge_links_tmp/links_1.12-12.out merge_links_tmp/links_1.0-13.out merge_links_tmp/links_1.1-13.out merge_links_tmp/links_1.2-13.out merge_links_tmp/links_1.3-13.out merge_links_tmp/links_1.4-13.out merge_links_tmp/links_1.5-13.out merge_links_tmp/links_1.6-13.out merge_links_tmp/links_1.7-13.out merge_links_tmp/links_1.8-13.out merge_links_tmp/links_1.9-13.out merge_links_tmp/links_1.10-13.out merge_links_tmp/links_1.11-13.out merge_links_tmp/links_1.12-13.out merge_links_tmp/links_1.13-13.out merge_links_tmp/links_1.0-14.out merge_links_tmp/links_1.1-14.out merge_links_tmp/links_1.2-14.out merge_links_tmp/links_1.3-14.out merge_links_tmp/links_1.4-14.out merge_links_tmp/links_1.5-14.out merge_links_tmp/links_1.6-14.out merge_links_tmp/links_1.7-14.out merge_links_tmp/links_1.8-14.out merge_links_tmp/links_1.9-14.out merge_links_tmp/links_1.10-14.out merge_links_tmp/links_1.11-14.out merge_links_tmp/links_1.12-14.out merge_links_tmp/links_1.13-14.out merge_links_tmp/links_1.14-14.out merge_links_tmp/links_1.0-15.out merge_links_tmp/links_1.1-15.out merge_links_tmp/links_1.2-15.out merge_links_tmp/links_1.3-15.out merge_links_tmp/links_1.4-15.out merge_links_tmp/links_1.5-15.out merge_links_tmp/links_1.6-15.out merge_links_tmp/links_1.7-15.out merge_links_tmp/links_1.8-15.out merge_links_tmp/links_1.9-15.out merge_links_tmp/links_1.10-15.out merge_links_tmp/links_1.11-15.out merge_links_tmp/links_1.12-15.out merge_links_tmp/links_1.13-15.out merge_links_tmp/links_1.14-15.out merge_links_tmp/links_1.15-15.out | grep '^link score\|^interc:' > iter_links_1.out cat iter_links_1.out | hiriseJoin.py -m 30.0 -s <( cat merge_links_tmp/refined_1.0.out merge_links_tmp/refined_1.1.out merge_links_tmp/refined_1.2.out merge_links_tmp/refined_1.3.out merge_links_tmp/refined_1.4.out merge_links_tmp/refined_1.5.out merge_links_tmp/refined_1.6.out merge_links_tmp/refined_1.7.out merge_links_tmp/refined_1.8.out merge_links_tmp/refined_1.9.out merge_links_tmp/refined_1.10.out merge_links_tmp/refined_1.11.out merge_links_tmp/refined_1.12.out merge_links_tmp/refined_1.13.out merge_links_tmp/refined_1.14.out merge_links_tmp/refined_1.15.out |p2edges.py ) -l broken_lengths_1.out > hirise_iter_2.out set_layout.py -i assembly1.hra -o hirise_iter_2.hra -L hirise_iter_2.out for k in {0..7}; do { parallel_breaker.py -i hirise_iter_2.hra -o chicago_weak_segs_iter2_part$k.out -t 20 -T 30 -q $qual2 -j 2 -S $k,8 -H chicago_weak_segs_iter2_part$k.out.histogram > pb2-$k.out 2> pb2-$k.err } & done wait cat chicago_weak_segs_iter2_part0.out chicago_weak_segs_iter2_part1.out chicago_weak_segs_iter2_part2.out chicago_weak_segs_iter2_part3.out chicago_weak_segs_iter2_part4.out chicago_weak_segs_iter2_part5.out chicago_weak_segs_iter2_part6.out chicago_weak_segs_iter2_part7.out > chicago_weak_segs_iter2.out break_playout.py -T 0.0 -t 0.0 -i hirise_iter_2.out -o hirise_iter_broken_2.out -b chicago_weak_segs_iter2.out > hirise_iter_broken_2.log set_layout.py -i assembly1.hra -o r2.hra -L hirise_iter_broken_2.out for k in {0..15}; do { if [ ! -e hirise_iter_broken_links_2 ] ; then mkdir hirise_iter_broken_links_2 ; fi ; export_links.py -q $qual2 -i r2.hra -c $k -C 16 > hirise_iter_broken_links_2/$k.links } & done wait for k in {0..15}; do { cat hirise_iter_broken_2.out | local_oo_opt.py -N 16 -a $k -l ""hirise_iter_broken_links_2/*.links"" -M datamodel.out > merge_links_tmp/refined_2.$k.out } & done wait cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-7.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-11.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-14.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 6 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-6.out cat merge_links_tmp/refined_2.10.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.10-11.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-13.out cat merge_links_tmp/refined_2.14.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 14 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.14-14.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-14.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.1.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 1 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-1.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-14.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 5 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-5.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 5 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-5.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-8.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-9.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 3 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-3.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-9.out cat merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.9-14.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-7.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-12.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-11.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 5 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-5.out cat merge_links_tmp/refined_2.11.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.11-13.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-11.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-13.out cat merge_links_tmp/refined_2.10.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.10-13.out cat merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.9-9.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-11.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-15.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-13.out cat merge_links_tmp/refined_2.14.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 14 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.14-15.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-8.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-9.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-9.out cat merge_links_tmp/refined_2.12.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.12-12.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-8.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-13.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 3 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-3.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 5 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-5.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-9.out cat merge_links_tmp/refined_2.12.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.12-13.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-11.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-11.out cat merge_links_tmp/refined_2.10.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.10-10.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-13.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-8.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-11.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 3 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-3.out cat merge_links_tmp/refined_2.13.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.13-13.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-10.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-10.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-8.out cat merge_links_tmp/refined_2.10.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.10-14.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 6 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-6.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 5 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-5.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 6 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-6.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-12.out cat merge_links_tmp/refined_2.10.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.10-15.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-12.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-10.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-9.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-14.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 6 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-6.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 6 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-6.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-11.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 6 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-6.out cat merge_links_tmp/refined_2.11.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.11-12.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 4 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-4.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-15.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-8.out cat merge_links_tmp/refined_2.10.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 10 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.10-12.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-7.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-7.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-7.out cat merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.9-12.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-8.out cat merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 4 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.4-12.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-8.out cat merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.9-13.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-10.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-15.out cat merge_links_tmp/refined_2.12.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.12-15.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.1.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 1 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-1.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-13.out cat merge_links_tmp/refined_2.13.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.13-14.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-12.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 2 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-2.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 4 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-4.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-13.out cat merge_links_tmp/refined_2.15.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 15 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.15-15.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.0.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 0 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-0.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.5.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 5 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-5.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.3.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 3 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-3.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 4 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-4.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-13.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-9.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-15.out cat merge_links_tmp/refined_2.13.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 13 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.13-15.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-15.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-12.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 2 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-2.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-7.out cat merge_links_tmp/refined_2.11.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.11-11.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-14.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 4 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-4.out cat merge_links_tmp/refined_2.11.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.11-14.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-12.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-15.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.8.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 8 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-8.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.13.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 13 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-13.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-15.out cat merge_links_tmp/refined_2.11.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 11 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.11-15.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-7.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-14.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-9.out cat merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.9-15.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-10.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-12.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-14.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-15.out cat merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.9-10.out cat merge_links_tmp/refined_2.12.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 12 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.12-14.out cat merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 7 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.7-10.out cat merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.7.out |p2edges.py |linker5.py --test_intercs -N 16 -a 5 -b 7 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.5-7.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-10.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-11.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.12.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 12 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-12.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.4.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 4 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-4.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.2.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 2 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-2.out cat merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 6 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.6-10.out cat merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.15.out |p2edges.py |linker5.py --test_intercs -N 16 -a 8 -b 15 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.8-15.out cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 0 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.0-14.out cat merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.9.out |p2edges.py |linker5.py --test_intercs -N 16 -a 1 -b 9 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.1-9.out cat merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.10.out |p2edges.py |linker5.py --test_intercs -N 16 -a 3 -b 10 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.3-10.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.14.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 14 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-14.out cat merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.6.out |p2edges.py |linker5.py --test_intercs -N 16 -a 2 -b 6 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.2-6.out cat merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.11.out |p2edges.py |linker5.py --test_intercs -N 16 -a 9 -b 11 -L ""hirise_iter_broken_links_2/*.links"" -d -M datamodel.out > merge_links_tmp/links_2.9-11.out dump_lengths.py -i r2.hra -o broken_lengths_2.out cat merge_links_tmp/links_2.0-0.out merge_links_tmp/links_2.0-1.out merge_links_tmp/links_2.1-1.out merge_links_tmp/links_2.0-2.out merge_links_tmp/links_2.1-2.out merge_links_tmp/links_2.2-2.out merge_links_tmp/links_2.0-3.out merge_links_tmp/links_2.1-3.out merge_links_tmp/links_2.2-3.out merge_links_tmp/links_2.3-3.out merge_links_tmp/links_2.0-4.out merge_links_tmp/links_2.1-4.out merge_links_tmp/links_2.2-4.out merge_links_tmp/links_2.3-4.out merge_links_tmp/links_2.4-4.out merge_links_tmp/links_2.0-5.out merge_links_tmp/links_2.1-5.out merge_links_tmp/links_2.2-5.out merge_links_tmp/links_2.3-5.out merge_links_tmp/links_2.4-5.out merge_links_tmp/links_2.5-5.out merge_links_tmp/links_2.0-6.out merge_links_tmp/links_2.1-6.out merge_links_tmp/links_2.2-6.out merge_links_tmp/links_2.3-6.out merge_links_tmp/links_2.4-6.out merge_links_tmp/links_2.5-6.out merge_links_tmp/links_2.6-6.out merge_links_tmp/links_2.0-7.out merge_links_tmp/links_2.1-7.out merge_links_tmp/links_2.2-7.out merge_links_tmp/links_2.3-7.out merge_links_tmp/links_2.4-7.out merge_links_tmp/links_2.5-7.out merge_links_tmp/links_2.6-7.out merge_links_tmp/links_2.7-7.out merge_links_tmp/links_2.0-8.out merge_links_tmp/links_2.1-8.out merge_links_tmp/links_2.2-8.out merge_links_tmp/links_2.3-8.out merge_links_tmp/links_2.4-8.out merge_links_tmp/links_2.5-8.out merge_links_tmp/links_2.6-8.out merge_links_tmp/links_2.7-8.out merge_links_tmp/links_2.8-8.out merge_links_tmp/links_2.0-9.out merge_links_tmp/links_2.1-9.out merge_links_tmp/links_2.2-9.out merge_links_tmp/links_2.3-9.out merge_links_tmp/links_2.4-9.out merge_links_tmp/links_2.5-9.out merge_links_tmp/links_2.6-9.out merge_links_tmp/links_2.7-9.out merge_links_tmp/links_2.8-9.out merge_links_tmp/links_2.9-9.out merge_links_tmp/links_2.0-10.out merge_links_tmp/links_2.1-10.out merge_links_tmp/links_2.2-10.out merge_links_tmp/links_2.3-10.out merge_links_tmp/links_2.4-10.out merge_links_tmp/links_2.5-10.out merge_links_tmp/links_2.6-10.out merge_links_tmp/links_2.7-10.out merge_links_tmp/links_2.8-10.out merge_links_tmp/links_2.9-10.out merge_links_tmp/links_2.10-10.out merge_links_tmp/links_2.0-11.out merge_links_tmp/links_2.1-11.out merge_links_tmp/links_2.2-11.out merge_links_tmp/links_2.3-11.out merge_links_tmp/links_2.4-11.out merge_links_tmp/links_2.5-11.out merge_links_tmp/links_2.6-11.out merge_links_tmp/links_2.7-11.out merge_links_tmp/links_2.8-11.out merge_links_tmp/links_2.9-11.out merge_links_tmp/links_2.10-11.out merge_links_tmp/links_2.11-11.out merge_links_tmp/links_2.0-12.out merge_links_tmp/links_2.1-12.out merge_links_tmp/links_2.2-12.out merge_links_tmp/links_2.3-12.out merge_links_tmp/links_2.4-12.out merge_links_tmp/links_2.5-12.out merge_links_tmp/links_2.6-12.out merge_links_tmp/links_2.7-12.out merge_links_tmp/links_2.8-12.out merge_links_tmp/links_2.9-12.out merge_links_tmp/links_2.10-12.out merge_links_tmp/links_2.11-12.out merge_links_tmp/links_2.12-12.out merge_links_tmp/links_2.0-13.out merge_links_tmp/links_2.1-13.out merge_links_tmp/links_2.2-13.out merge_links_tmp/links_2.3-13.out merge_links_tmp/links_2.4-13.out merge_links_tmp/links_2.5-13.out merge_links_tmp/links_2.6-13.out merge_links_tmp/links_2.7-13.out merge_links_tmp/links_2.8-13.out merge_links_tmp/links_2.9-13.out merge_links_tmp/links_2.10-13.out merge_links_tmp/links_2.11-13.out merge_links_tmp/links_2.12-13.out merge_links_tmp/links_2.13-13.out merge_links_tmp/links_2.0-14.out merge_links_tmp/links_2.1-14.out merge_links_tmp/links_2.2-14.out merge_links_tmp/links_2.3-14.out merge_links_tmp/links_2.4-14.out merge_links_tmp/links_2.5-14.out merge_links_tmp/links_2.6-14.out merge_links_tmp/links_2.7-14.out merge_links_tmp/links_2.8-14.out merge_links_tmp/links_2.9-14.out merge_links_tmp/links_2.10-14.out merge_links_tmp/links_2.11-14.out merge_links_tmp/links_2.12-14.out merge_links_tmp/links_2.13-14.out merge_links_tmp/links_2.14-14.out merge_links_tmp/links_2.0-15.out merge_links_tmp/links_2.1-15.out merge_links_tmp/links_2.2-15.out merge_links_tmp/links_2.3-15.out merge_links_tmp/links_2.4-15.out merge_links_tmp/links_2.5-15.out merge_links_tmp/links_2.6-15.out merge_links_tmp/links_2.7-15.out merge_links_tmp/links_2.8-15.out merge_links_tmp/links_2.9-15.out merge_links_tmp/links_2.10-15.out merge_links_tmp/links_2.11-15.out merge_links_tmp/links_2.12-15.out merge_links_tmp/links_2.13-15.out merge_links_tmp/links_2.14-15.out merge_links_tmp/links_2.15-15.out | grep '^link score\|^interc:' > iter_links_2.out cat iter_links_2.out | hiriseJoin.py -m 30.0 -s <( cat merge_links_tmp/refined_2.0.out merge_links_tmp/refined_2.1.out merge_links_tmp/refined_2.2.out merge_links_tmp/refined_2.3.out merge_links_tmp/refined_2.4.out merge_links_tmp/refined_2.5.out merge_links_tmp/refined_2.6.out merge_links_tmp/refined_2.7.out merge_links_tmp/refined_2.8.out merge_links_tmp/refined_2.9.out merge_links_tmp/refined_2.10.out merge_links_tmp/refined_2.11.out merge_links_tmp/refined_2.12.out merge_links_tmp/refined_2.13.out merge_links_tmp/refined_2.14.out merge_links_tmp/refined_2.15.out |p2edges.py ) -l broken_lengths_2.out > hirise_iter_3.out set_layout.py -i assembly1.hra -o hirise_iter_3.hra -L hirise_iter_3.out for k in {0..7};do { parallel_breaker.py -i hirise_iter_3.hra -o chicago_weak_segs_iter3_part$k.out -t 20 -T 30 -q $qual2 -j 2 -S $k,8 -H chicago_weak_segs_iter3_part$k.out.histogram > pb3-$k.out 2> pb3-$k.err } & done wait cat chicago_weak_segs_iter3_part0.out chicago_weak_segs_iter3_part1.out chicago_weak_segs_iter3_part2.out chicago_weak_segs_iter3_part3.out chicago_weak_segs_iter3_part4.out chicago_weak_segs_iter3_part5.out chicago_weak_segs_iter3_part6.out chicago_weak_segs_iter3_part7.out > chicago_weak_segs_iter3.out break_playout.py -T 0.0 -t 0.0 -i hirise_iter_3.out -o hirise_iter_broken_3.out -b chicago_weak_segs_iter3.out > hirise_iter_broken_3.log set_layout.py -i assembly1.hra -o hirise_iter_broken_3.hra -L hirise_iter_broken_3.out dump_broken_contigs.py -i hirise_iter_broken_3.hra -f $INPUT_FASTA -o hirise_iter_broken_3.broken.fa cat hirise_iter_broken_3.out | p2srf.py > hirise_iter_broken_3.srf for k in {0..15};do { if [ $k -lt 10 ] then cat hirise_iter_broken_3.out | place_gapper.py -b $SHOTGUN_BAM -f hirise_iter_broken_3.broken.fa -c 0$k -C 16 -K 51 | tee hirise_iter_broken_3.meraudierin.0$k.txt.inter | sort -k4,4 -k5,5 | format4merauder.py > hirise_iter_broken_3.meraudierin.0$k.txt merauder -A -c hirise_iter_broken_3.broken.fa -g hirise_iter_broken_3.meraudierin.0$k.txt -i 2000 -m 51 -P -s hirise_iter_broken_3.srf -D 3 > hirise_iter_broken_3.gapclose.0$k 2> hirise_iter_broken_3.gapclose.0$k.err else cat hirise_iter_broken_3.out | place_gapper.py -b $SHOTGUN_BAM -f hirise_iter_broken_3.broken.fa -c $k -C 16 -K 51 | tee hirise_iter_broken_3.meraudierin.$k.txt.inter | sort -k4,4 -k5,5 | format4merauder.py > hirise_iter_broken_3.meraudierin.$k.txt merauder -A -c hirise_iter_broken_3.broken.fa -g hirise_iter_broken_3.meraudierin.$k.txt -i 2000 -m 51 -P -s hirise_iter_broken_3.srf -D 3 > hirise_iter_broken_3.gapclose.$k 2> hirise_iter_broken_3.gapclose.$k.err fi } & done wait cat hirise_iter_broken_3.gapclose.00 hirise_iter_broken_3.gapclose.01 hirise_iter_broken_3.gapclose.02 hirise_iter_broken_3.gapclose.03 hirise_iter_broken_3.gapclose.04 hirise_iter_broken_3.gapclose.05 hirise_iter_broken_3.gapclose.06 hirise_iter_broken_3.gapclose.07 hirise_iter_broken_3.gapclose.08 hirise_iter_broken_3.gapclose.09 hirise_iter_broken_3.gapclose.10 hirise_iter_broken_3.gapclose.11 hirise_iter_broken_3.gapclose.12 hirise_iter_broken_3.gapclose.13 hirise_iter_broken_3.gapclose.14 hirise_iter_broken_3.gapclose.15 > hirise_iter_broken_3.gapclose cat hirise_iter_broken_3.out | grep '^p:' | p2fa2.py -l hirise_iter_broken_3.gapclosed.table --seed -1 -f $INPUT_FASTA -o /dev/stdout -g hirise_iter_broken_3.gapclose 2> hirise_iter_broken_3.gapclosed.fasta.out | add_short_contigs.py -b $INPUT_FASTA -o hirise_iter_broken_3.gapclosed.fasta ","Shell" "Conformation","wen-biao/OM-HiC-scaffolding","HiC-ImpScaffolding/run.sh",".sh","4947","90","### Improved Dovetail Hi-C Scaffolding workflow # Working directory: $your_working_directory/OM-HiC-scaffolding/HiCint # The final scaffolds are in the file ""HiCint/2-falconBroken/scafSeq/hybrid.map.scaffolds.fasta"" ## mapping Hi-C reads to input sequences of Falcon assembly contigs and PBcR assembly contigs, respectively. fCtg=$1 pCtg=$2 read1=$3 read2=$4 sread1=$5 sread2=$6 mkdir -p 0-falconHiC mkdir -p 0-pbcrHiC cd 0-falconHiC bwa index $fCtg bwa index $pCtg mkdir HiCMap shortMap cd HiCMap bwa aln $fCtg $read1 -f reads1_1.sai -t 20 bwa aln $fCtg $read2 -f reads1_2.sai -t 20 bwa sampe -a 300000 $fCtg reads_1.sai reads_2.sai reads_1.fq reads_2.fq |samblaster --addMateTags |samtools view -bS - -o reads.bam samtools sort reads.bam reads.srt samtools rmdup reads.srt.bam reads.srt.rmdup.bam samtools index reads.srt.rmdup.bam cd ../shortMap bwa aln $fCtg $sread1 -f reads1_1.sai -t 20 bwa aln $fCtg $sread2 -f reads1_2.sai -t 20 bwa sampe -a 300000 $fCtg reads_1.sai reads_2.sai reads_1.fq reads_2.fq |samblaster --addMateTags |samtools view -bS - -o reads.bam samtools sort reads.bam reads.srt samtools rmdup reads.srt.bam reads.srt.rmdup.bam samtools index reads.srt.rmdup.bam # run HiRise scaffolding cd ../scaffolding run hirise_commands.pa.sh ../HiCMap/reads.srt.rmdup.bam $fCtg ../shortMap/reads.srt.rmdup.bam 10 30 cd ../../0-pbcrHiC mkdir HiCMap shortMap cd HiCMap bwa aln $pCtg $read1 -f reads1_1.sai -t 20 bwa aln $pCtg $read2 -f reads1_2.sai -t 20 bwa sampe -a 300000 $pCtg reads_1.sai reads_2.sai reads_1.fq reads_2.fq |samblaster --addMateTags |samtools view -bS - -o reads.bam samtools sort reads.bam reads.srt samtools rmdup reads.srt.bam reads.srt.rmdup.bam samtools index reads.srt.rmdup.bam cd ../shortMap bwa aln $pCtg $sread1 -f reads1_1.sai -t 20 bwa aln $pCtg $sread2 -f reads1_2.sai -t 20 bwa sampe -a 300000 $pCtg reads_1.sai reads_2.sai reads_1.fq reads_2.fq |samblaster --addMateTags |samtools view -bS - -o reads.bam samtools sort reads.bam reads.srt samtools rmdup reads.srt.bam reads.srt.rmdup.bam samtools index reads.srt.rmdup.bam # run HiRise scaffolding cd ../scaffolding run hirise_commands.pa.sh ../HiCMap/reads.srt.rmdup.bam $pCtg ../shortMap/reads.srt.rmdup.bam 10 30 cd ../../ ## in-silico Optical Mapping scaffolding mkdir 1-falconScaf 1-pbcrScaf 2-falconBroken 2-pbcrBroken cp 0-falconHiC/scaffolding/hirise_iter_broken_3.gapclosed.fasta falcon.hirise.scaf.bwa.fasta cp 0-pbcrHiC/scaffolding/hirise_iter_broken_3.gapclosed.fasta pbcr.hirise.scaf.bwa.fasta #generate in-silico optical maps using Falcon or PBcR assembly contigs, use these maps as reference maps, do the initial alignment between falcon sequences and pbcr in-silico optical maps perl ../scripts/fa2cmap.pl -i pbcr.hirise.scaf.bwa.fasta -n BspQI -m 5 -M 50 -o ./ cd ../ perl hybridScaffold.pl -n ./HiCint/falcon.hirise.scaf.bwa.fasta -b ./HiCint/pbcr.hirise.scaf.bwa_BspQI_50Kb_5labels.cmap -c xml/hybridScaffold_config_out5.xml -o ./HiCint/1-falconScaf/output -f # find conflicts and split misassemblies perl ./HiCint/OM.find.conflict-regions.for.HiC.improved.pl -k HiCint/falcon.hirise.scaf.bwa_BspQI_0Kb_0labels_key.txt -d HiCint/1-falconScaf/output/ -o HiCint/2-falconBroken/split > HiCint/2-falconBroken/breaks.log perl ./HiCint/OM.split-misassembly.pl -key ./HiCint/falcon.hirise.scaf.bwa_BspQI_0Kb_0labels_key.txt -seq ./HiCint/falcon.hirise.scaf.bwa.fasta -seqMis ./HiCint/2-falconBroken/split/seq.assembly.conflicts.breaks3.flt -aln ./HiCint/1-falconScaf/output -OMmis ./HiCint/2-falconBroken/split/OM.assembly.conflicts.breaks3.flt -outDir ./HiCint/2-falconBroken/split/ > HiCint/2-falconBroken/split.log # realign to get hybrid consensus maps and do scaffolding perl hybridScaffold.pl -n HiCint/2-falconBroken/split/seq.assembly.conflicts.broken.fasta -b HiCint/2-falconBroken/split/BNG.assembly.conflicts.broken.cmap -c xml/hybridScaffold_config_out54.xml -o HiCint/2-falconBroken/output -f > HiCint/2-falconBroken/output.log cd HiCint RefAligner -f -ref ./2-falconBroken/output/align_final/step2.hybrid.cmap -i ./2-falconBroken/split/seq.assembly.conflicts.broken_BspQI_0Kb_0labels.cmap -o ./2-falconBroken/bScafSeq_HybridMap -endoutlier 1e-3 -outlier 1e-4 -extend 0 -FN 0.05 -FP 0.5 -sf 0.2 -sd 0.1 -sr 0.02 -res 0 -resSD 0.75 -mres 0 -A 5 -biaswt 0 -M 1 -Mfast 0 -maxmem 128 -maxthreads 20 -deltaX 9 -deltaY 9 -RepeatMask 2 0.01 -RepeatRec 0.7 0.6 -T 1e-9 -BestRef 1 -nosplit 2 -XmapStatWrite ./2-falconBroken/bScafSeq_HybridMap -stdout -stderr -hashgen 5 3 2.4 1.5 0.05 5.0 1 1 1 -hash -hashdelta 50 cd 2-falconBroken perl ../OM.scaffolding.pl -x bScafSeq_HybridMap.xmap -r bScafSeq_HybridMap_r.cmap -q bScafSeq_HybridMap_q.cmap -key split/seq.broken.new.key.txt -outdir scafSeq -seq split/seq.assembly.conflicts.broken.fasta -sID xcaf >scaf.log #the final scaffolds are in the file ""HiCint/2-falconBroken/scafSeq/hybrid.map.scaffolds.fasta"" ","Shell" "Conformation","wen-biao/OM-HiC-scaffolding","OM-ImpScaffolding/run.sh",".sh","7926","75","####Integrated Optical Mapping Scaffolding ## step 1: align CMAPs to sequence assemblies with low and high initial alignment p-value, respectively mkdir OMint mkdir OMint/1-falcon OMint/1-pbcr perl hybridScaffold.pl -n data/Cp.falcon.contig.fasta -b data/Cp.OM.cmap -c xml/hybridScaffold_config_out5.xml -o ./OMint/1-falcon/out5 perl hybridScaffold.pl -n data/Cp.pbcr.contig.fasta -b data/Cp.OM.cmap -c xml/hybridScaffold_config_out5.xml -o ./OMint/1-pbcr/out5 perl hybridScaffold.pl -n data/Cp.falcon.contig.fasta -b data/Cp.OM.cmap -c xml/hybridScaffold_config_out7.xml -o ./OMint/1-falcon/out7 perl hybridScaffold.pl -n data/Cp.pbcr.contig.fasta -b data/Cp.OM.cmap -c xml/hybridScaffold_config_out7.xml -o ./OMint/1-pbcr/out7 ## step 2: find conflict alignment regions between sequence assembly and optical consensus maps cd OMint perl ./OM.find.conflict.breaks.pl -k ../data/Cp.falcon.contig_BspQI_0Kb_0labels_key.txt -d ./1-falcon/out5/ -o ./1-falcon/out5/breaks perl ./OM.find.conflict.breaks.pl -k ../data/Cp.falcon.contig_BspQI_0Kb_0labels_key.txt -d ./1-falcon/out7/ -o ./1-falcon/out7/breaks perl ./OM.find.conflict.breaks.pl -k ../data/Cp.pbcr.contig_BspQI_0Kb_0labels_key.txt -d ./1-pbcr/out7/ -o ./1-pbcr/out7/breaks perl ./OM.find.conflict.breaks.pl -k ../data/Cp.pbcr.contig_BspQI_0Kb_0labels_key.txt -d ./1-pbcr/out5/ -o ./1-pbcr/out5/breaks ## step 3: Merge conflicting alignment regions found from previous aligments under low and high initial alignment p-value perl ./OM.merge.low-high.breaks.pl -a ./1-falcon/out5/breaks/seq.assembly.conflicts.breaks -b ./1-falcon/out7/breaks/seq.assembly.conflicts.breaks -c ./1-falcon/out5/breaks/OM.assembly.conflicts.breaks -d ./1-falcon/out7/breaks/OM.assembly.conflicts.breaks -o ./2-falconBroken/mergebreaks perl ./OM.merge.low-high.breaks.pl -a ./1-pbcr/out5/breaks/seq.assembly.conflicts.breaks -b ./1-pbcr/out7/breaks/seq.assembly.conflicts.breaks -c ./1-pbcr/out5/breaks/OM.assembly.conflicts.breaks -d ./1-pbcr/out7/breaks/OM.assembly.conflicts.breaks -o ./2-pbcrBroken/mergebreaks ## step 4: Assembly cross check and define the misassembled regions mkdir 1_pbcr-falcon_breaks perl ./OM.falcon.pbcr.misass.cross-check.pl -p ./2-pbcrBroken/mergebreaks/seq.breaks4 -x ./2-pbcrBroken/mergedbreaks/OM.breaks4 -f ./2-falconBroken/mergebreaks/seq.breaks4 -y ./2-falconBroken/mergebreaks/OM.breaks4 -pX ./1-pbcr/out5/align1/align1.xmap -fX 1-falcon/out5/align1/align1.xmap -pK ../data/Cp.pbcr.contig_BspQI_0Kb_0labels_key.txt -fK ../data/Cp.falcon.contig_BspQI_0Kb_0labels_key.txt -o ./1_pbcr-falcon_breaks/ >1_pbcr-falcon_breaks/pbcr-falcon.brk.log ## step 5: split the contig sequences based on the result of misassembled regions from previous step perl ./OM.split-misassembly.pl -k ../data/Cp.falcon.contig_BspQI_0Kb_0labels_key.txt -f ../data/Cp.falcon.contig.fasta -s ./1_pbcr-falcon_breaks/falcon.seq.breaks5 -m ./1_pbcr-falcon_breaks/falcon.BNG.breaks5 -o ./1-falcon/out5 -d ./2-falconBroken/ > 2-falconBroken/split.log ## step 6: Realign and scaffolding mkdir -p 2-falconBroken 2-pbcrBroken cd ../ perl hybridScaffold.pl -n OMint/2-falconBroken/seq.assembly.conflicts.broken.fasta -b OMint/2-falconBroken/BNG.assembly.conflicts.broken.cmap -c ./xml/hybridScaffold_config_out54.xml -o OMint/2-falconBroken/output1 -f >OMint/2-falconBroken/out1.log perl hybridScaffold.pl -n OMint/2-pbcrBroken/seq.assembly.conflicts.broken.fasta -b OMint/2-pbcrBroken/BNG.assembly.conflicts.broken.cmap -c ./xml/hybridScaffold_config_out54.xml -o OMint/2-pbcrBroken/output1 -f > OMint/2-pbcrBroken/out1.log cd OMint/ RefAligner -f -ref ./2-falconBroken/output1/align_final/step2.hybrid.cmap -i ./2-falconBroken/seq.assembly.conflicts.broken_BspQI_0Kb_0labels.cmap -o 2-falconBroken/bCtgSeq_HybridMap -endoutlier 1e-3 -outlier 1e-4 -extend 0 -FN 0.05 -FP 0.5 -sf 0.2 -sd 0.1 -sr 0.02 -res 0 -resSD 0.75 -mres 0 -A 5 -biaswt 0 -M 1 -Mfast 0 -maxmem 128 -maxthreads 20 -deltaX 9 -deltaY 9 -RepeatMask 2 0.01 -RepeatRec 0.7 0.6 -T 1e-9 -BestRef 1 -nosplit 2 -XmapStatWrite 2-falconBroken/bCtgSeq_HybridMap -stdout -stderr -hashgen 5 3 2.4 1.5 0.05 5.0 1 1 1 -hash -hashdelta 50 ## scaffolding perl ./OM.scaffolding.pl -x 2-falconBroken/bCtgSeq_HybridMap.xmap -r 2-falconBroken/bCtgSeq_HybridMap_r.cmap -q 2-falconBroken/bCtgSeq_HybridMap_q.cmap -key 2-falconBroken//seq.broken.new.key.txt -outdir 2-falconBroken/scafSeq -seq 2-falconBroken/seq.assembly.conflicts.broken.fasta -sID scaf >2-falconBroken/scaffolding.log #pbcr RefAligner -f -ref ./2-pbcrBroken/output1/align_final/step2.hybrid.cmap -i ./2-pbcrBroken/seq.assembly.conflicts.broken_BspQI_0Kb_0labels.cmap -o ./2-pbcrBroken/bCtgSeq_HybridMap -endoutlier 1e-3 -outlier 1e-4 -extend 0 -FN 0.05 -FP 0.5 -sf 0.2 -sd 0.1 -sr 0.02 -res 0 -resSD 0.75 -mres 0 -A 5 -biaswt 0 -M 1 -Mfast 0 -maxmem 128 -maxthreads 20 -deltaX 9 -deltaY 9 -RepeatMask 2 0.01 -RepeatRec 0.7 0.6 -T 1e-9 -BestRef 1 -nosplit 2 -XmapStatWrite ./2-pbcrBroken/bCtgSeq_HybridMap -stdout -stderr -hashgen 5 3 2.4 1.5 0.05 5.0 1 1 1 -hash -hashdelta 50 ## scaffolding perl ./OM.scaffolding.pl -x 2-pbcrBroken/bCtgSeq_HybridMap.xmap -r 2-pbcrBroken/bCtgSeq_HybridMap_r.cmap -q 2-pbcrBroken/bCtgSeq_HybridMap_q.cmap -key 2-pbcrBroken/seq.broken.new.key.txt -outdir 2-pbcrBroken/scafSeq -seq 2-pbcrBroken/seq.assembly.conflicts.broken.fasta -sID scaf >2-pbcrBroken/scaffolding.log ## step 7: falcon-scaffolds align with pbcr-hybridMap mkdir -p 3-pbcrHmap-falconScaf cp 2-pbcrBroken/output1/mergeNGS_BN/step2.hybrid.cmap 3-pbcrHmap-falconScaf/pbcr.hybrid.BN.naive.cmap grep -v '#' 2-pbcrBroken/output1/mergeNGS_BN/step1.BN.naive.cmap >>3-pbcrHmap-falconScaf/pbcr.hybrid.BN.naive.cmap cp 2-falconBroken/scafSeq/hybrid.map.scaffolds.fasta ./3-pbcrHmap-falconScaf/ cd ../ perl hybridScaffold.pl -n OMint/3-pbcrHmap-falconScaf/hybrid.map.scaffolds.fasta -b OMint/3-pbcrHmap-falconScaf/pbcr.hybrid.BN.naive.cmap -c xml/hybridScaffold_config_out5.xml -o OMint/3-pbcrHmap-falconScaf/output -f >OMint/3-pbcrHmap-falconScaf/output.log ## step 8: find the conflicting alignment and break the scaffold seq and v1.hybrid-cmap cd OMint perl ./OM.find.conflict-regions.pl -k 3-pbcrHmap-falconScaf/hybrid.map.scaffolds_BspQI_0Kb_0labels_key.txt -d 3-pbcrHmap-falconScaf/output/ -o 3-pbcrHmap-falconScaf/output/breaks perl ./OM.split-misassembly.pl -k ./3-pbcrHmap-falconScaf/hybrid.map.scaffolds_BspQI_0Kb_0labels_key.txt -f ./3-pbcrHmap-falconScaf/hybrid.map.scaffolds.fasta -s ./3-pbcrHmap-falconScaf/output/breaks/seq.assembly.conflicts.mrg.breaks -m ./3-pbcrHmap-falconScaf/output/breaks/OM.assembly.conflicts.mrg.breaks -o ./3-pbcrHmap-falconScaf/output -d ./3-pbcrHmap-falconScaf/output/breaks > 3-pbcrHmap-falconScaf/output/breaks/split.log ## step 9: 2nd round hybrid scaffolding cd ../ perl hybridScaffold.pl -n OMint/3-pbcrHmap-falconScaf/output/breaks/seq.assembly.conflicts.broken.fasta -b OMint/3-pbcrHmap-falconScaf/output/breaks/BNG.assembly.conflicts.broken.cmap -c xml/hybridScaffold_config_out54.xml -o OMint/3-pbcrHmap-falconScaf/outSplitRealign -f > OMint/3-pbcrHmap-falconScaf/outSplitRealign.log cd OMint/3-pbcrHmap-falconScaf/outSplitRealign RefAligner -f -ref align_final/step2.hybrid.cmap -i ../output/breaks/seq.assembly.conflicts.broken_BspQI_0Kb_0labels.cmap -o bScafSeq_HybridMap -endoutlier 1e-3 -outlier 1e-4 -extend 0 -FN 0.05 -FP 0.5 -sf 0.2 -sd 0.1 -sr 0.02 -res 0 -resSD 0.75 -mres 0 -A 5 -biaswt 0 -M 1 -Mfast 0 -maxmem 128 -maxthreads 20 -deltaX 9 -deltaY 9 -RepeatMask 2 0.01 -RepeatRec 0.7 0.6 -T 1e-9 -BestRef 1 -nosplit 2 -XmapStatWrite bScafSeq_HybridMap -stdout -stderr -hashgen 5 3 2.4 1.5 0.05 5.0 1 1 1 -hash -hashdelta 50 perl ../../OM.scaffolding.pl -x bScafSeq_HybridMap.xmap -r bScafSeq_HybridMap_r.cmap -q bScafSeq_HybridMap_q.cmap -key ../output/breaks/seq.broken.new.key.txt -outdir scafSeq -seq ../output/breaks/seq.assembly.conflicts.broken.fasta -sID xcaf > scaffolding.log ","Shell" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","LICENSE.md",".md","1075","22","MIT License Copyright (c) 2023 Flatiron Institute Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ","Markdown" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","src/tools/calc_weights.py",".py","1012","36","#!/usr/bin/env python import numpy as np import os, sys import csv from scipy.special import logsumexp N_center = 50 #dataset = 'r1' directory = ""./stan_output""#.format(dataset) log_weights = [] lp = [] files = sorted(os.listdir(directory))[-8:] log_weights_d = np.zeros((8,10000,N_center), dtype=float) i = 0 for file in files: log_weights_chain = [] # print(file) with open('%s/%s'%(directory,file), newline='') as csvfile: reader = csv.DictReader(filter(lambda row: row[0]!='#', csvfile), ) for row in reader: log_weights_row = [float(row[""log_weights.%d""%i]) for i in range(1,N_center+1)] log_weights_chain.append(log_weights_row) log_weights = np.array(log_weights_chain) log_weights_d[i,:,:] = log_weights i += 1 log_weights_d -= logsumexp(log_weights_d, axis=2)[:,:,None] weights_d = np.exp(log_weights_d) weights_d_mean = weights_d.mean((0,1)) weights_d_std = weights_d.std((0,1)) np.savetxt(""weights.txt"", weights_d_mean, fmt='%.6f') ","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","src/cryoER/analyze_mcmc.py",".py","3102","99","import argparse import os import csv import numpy as np from scipy.special import logsumexp def _parse_args(): """""" Parses command line arguments. """""" parser = argparse.ArgumentParser( prog=""cryoERMCMC"", description=""Perform MCMC sampling with Stan to sample posterior of weights "", # epilog = 'Text at the bottom of help' ) parser.add_argument( ""-o"", ""--outdir"", default=""./output/"", help=""directory for output files"" ) parser.add_argument( ""-fc"", ""--infileclustersize"", default=""cluster_size.txt"", help=""file containing the number of conformations in each cluster"", ) return parser def analyze_mcmc( output_directory = './output/', filename_cluster_counts = 'cluster_counts.txt', ): stan_directory = output_directory + 'Stan_output/' nm = np.loadtxt(filename_cluster_counts) N_center = len(nm) log_weights = [] lp = [] files = sorted(os.listdir(stan_directory)) print(files) nm /= np.sum(nm) log_nm = np.log(nm) log_weights_mc_chains = [] for file in files: log_weights_chain = [] lp_chain = [] with open('%s/%s'%(stan_directory, file), newline='') as csvfile: reader = csv.DictReader(filter(lambda row: row[0]!='#', csvfile), ) for row in reader: log_weights_row = [float(row[""log_weights.%d""%i]) for i in range(1,N_center+1)] lp_chain.append(float(row[""lp__""])) log_weights_chain.append(log_weights_row) log_weights = np.array(log_weights_chain) lp_chain = np.array(lp_chain) log_weights_mc_chains.append(log_weights) lp.append(lp_chain) log_weights_mc_chains = np.array(log_weights_mc_chains) log_factor = log_weights_mc_chains - logsumexp(log_weights_mc_chains, axis=2)[:,:,None] # not necessary, but just in case factor = np.exp(log_factor) # sampled reweighting factor factor_mean = factor.mean((0,1)) factor_std = factor.std((0,1)) factor_mean_std = np.vstack((factor_mean, factor_std)).T np.savetxt(output_directory+""reweighting_factor.txt"", factor_mean_std, fmt='%.6f') log_rewtprob = log_weights_mc_chains + log_nm[None,None,:] log_rewtprob -= logsumexp(log_rewtprob, axis=2)[:,:,None] rewtprob = np.exp(log_rewtprob) # reweighted probability rewtprob_mean = rewtprob.mean((0,1)) rewtprob_std = rewtprob.std((0,1)) rewtprob_mean_std = np.vstack((rewtprob_mean, rewtprob_std)).T np.savetxt(output_directory+""reweighted_prob.txt"", rewtprob_mean_std, fmt='%.6f') lp = np.array(lp) np.savetxt(output_directory+""lp.txt"", lp, fmt='%.6f') return factor_mean_std, rewtprob_mean_std, lp, log_weights_mc_chains if __name__ == ""__main__"": parser = _parse_args() args = parser.parse_args() output_directory = args.outdir filename_cluster_counts = args.infileclustersize analyze_mcmc( output_directory = output_directory, filename_cluster_counts = filename_cluster_counts, ) ","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","src/cryoER/tools.py",".py","656","18","import torch import MDAnalysis as mda def mdau_to_pos_arr(u, frame_cluster=None, select_ca=True): atoms = u.select_atoms(""protein and name CA"") if select_ca else u.atoms if frame_cluster is None: n_frame = len(u.trajectory) else: n_frame = len(frame_cluster) pos = torch.zeros((n_frame, len(atoms), 3), dtype=float) if frame_cluster is None: for i, ts in enumerate(u.trajectory): pos[i] = torch.from_numpy(atoms.positions) else: for i, ts in enumerate(u.trajectory[frame_cluster]): pos[i] = torch.from_numpy(atoms.positions) pos -= pos.mean(1).unsqueeze(1) return pos","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","src/cryoER/run_cryoER_mcmc.py",".py","6012","231","import os from cmdstanpy import CmdStanModel import importlib.resources import numpy as np import json import argparse from typing import Dict, Any def BuildCmdStanModel(stan_model_path: str = None, cpp_options: Dict[str, Any] = None): """""" Builds the Command Stan model from the script located at the given stan_model_path. Args: stan_model_path (str): Path to the stan model file. cpp_options (dict): Dictionary of options to compile the model with. Returns: CmdStanModel: CmdStan model object. """""" if cpp_options is None: cpp_options = { ""STAN_THREADS"": True, } if stan_model_path is None: module_path = importlib.resources.files(""cryoER"") path = os.path.join(module_path, ""cryo-er.stan"") else: path = stan_model_path my_model = CmdStanModel( stan_file=path, cpp_options=cpp_options, ) return my_model def _parse_args(): """""" Parses command line arguments. """""" parser = argparse.ArgumentParser( prog=""cryoERMCMC"", description=""Perform MCMC sampling with Stan to sample posterior of weights "", # epilog = 'Text at the bottom of help' ) parser.add_argument( ""-l"", ""--lmbd"", type=float, default=1e-6, help=""standard deviation of colorless pixel noise in cryo-EM images"", ) parser.add_argument( ""-fc"", ""--infileclustersize"", default=""cluster_size.txt"", help=""file containing the number of conformations in each cluster"", ) parser.add_argument( ""-fd"", ""--infileimagedistance"", default=[], action=""append"", help=""(list of) file(s) containing the matrix of size M times N of pairwise distance between M structures and N images"", ) parser.add_argument( ""-o"", ""--outdir"", default=""./output/"", help=""directory for output files"" ) parser.add_argument( ""-nc"", ""--chains"", type=int, default=1, help=""number of MCMC chains for posterior sampling"", ) parser.add_argument( ""-sf"", ""--sigfig"", type=int, default=6, help=""significant figures for MCMC outputs"", ) parser.add_argument( ""-pc"", ""--parallelchain"", type=int, default=1, help=""(for parallelization) number of chains in parallel for MCMC"", ) parser.add_argument( ""-tc"", ""--threadsperchain"", type=int, default=1, help=""(for parallelization) number of threads per chain for MCMC"", ) parser.add_argument( ""-iw"", ""--iterwarmup"", type=int, default=200, help=""number of MCMC warm-up steps"", ) parser.add_argument( ""-is"", ""--itersample"", type=int, default=2000, help=""number of MCMC warm-up steps"", ) return parser def run_cryoER_mcmc( lmbd = 1e-6, chains = 4, sig_figs = 6, parallel_chains = 4, threads_per_chain = 8, iter_warmup = 200, iter_sampling = 2000, infileclustersize = ""cluster_size.txt"", infileimagedistance = [], outdir = ""./output/"", ): ## Read N_m, the number of conformations that are in the mth cluster counts = np.loadtxt(infileclustersize).astype(float) counts /= np.sum(counts) log_Nm = np.log(counts) ## Read distance matrix between cryoEM images and MD structures distance = None for f in infileimagedistance: if distance is None: distance = np.load(f) else: data = np.load(f) distance = np.hstack((distance, data)) ## Write json files for reading into Stan program M = distance.shape[0] N = distance.shape[1] print(""Number of structures = %d, Number of images = %d."" % (M, N)) try: os.mkdir(outdir) except FileExistsError: pass ######## ######## ######## ######## ## Compile Stan script my_model = BuildCmdStanModel() print(my_model.exe_info()) json_filename = ""%s/Dmat.json"" % (outdir) stan_output_file = ""%s/Stan_output"" % (outdir) if lmbd == -1: norm = -1 else: norm = 0.5 / (lmbd**2) Dmat = -norm * distance.T dictionary = { ""M"": M, ""N"": N, ""logNm"": list(log_Nm), ""Dmat"": [list(a) for a in Dmat], } json_object = json.dumps(dictionary, indent=4) with open(json_filename, ""w"") as f: f.write(json_object) f.close() ## Run Stan model to perform MCMC sampling on posterior in Eq. 10 and 17 data_file = os.path.join(""."", json_filename) fit = my_model.sample( data=data_file, chains=chains, sig_figs=sig_figs, parallel_chains=parallel_chains, threads_per_chain=threads_per_chain, iter_warmup=iter_warmup, iter_sampling=iter_sampling, show_console=True, ) # Save Stan output, i.e., posterior samples, in CSV format, in a specified folder fit.save_csvfiles(dir=stan_output_file) print(""Done!"") pass if __name__ == ""__main__"": parser = _parse_args() args = parser.parse_args() lmbd = args.lmbd chains = args.chains sig_figs = args.sigfig parallel_chains = args.parallelchain threads_per_chain = args.threadsperchain iter_warmup = args.iterwarmup iter_sampling = args.itersample infileclustersize = args.infileclustersize infileimagedistance = args.infileimagedistance outdir = args.outdir run_cryoER_mcmc( lmbd = lmbd, chains = chains, sig_figs = sig_figs, parallel_chains = parallel_chains, threads_per_chain = threads_per_chain, iter_warmup = iter_warmup, iter_sampling = iter_sampling, infileclustersize = infileclustersize, infileimagedistance = infileimagedistance, outdir = outdir, ) ","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","src/cryoER/__init__.py",".py","0","0","","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","src/cryoER/imggen_torch.py",".py","14983","311","import numpy as np import torch, math from tqdm import tqdm def gen_grid(n_pixel, pixel_size): ## ## gen_grid : function : generate square grids of positions of each pixel ## ## Input: ## n_pixel : int : number of pixels of image i.e. the synthetic (cryo-EM) images are of shape (n_pixel, n_pixel) ## pixel_size : float : width of each pixel in physical space in Angstrom ## Output: ## grid : torch tensor of float of shape (N_pixel) : physical location of center of each pixel (in Angstrom) ## grid_min = -pixel_size*(n_pixel-1)*0.5 grid_max = -grid_min #pixel_size*(n_pixel-1)*0.5 grid = torch.linspace(grid_min, grid_max, n_pixel) return grid def gen_quat_torch(num_quaternions, device = ""cuda""): ## ## gen_quat_torch : function : sample quaternions from spherically uniform random distribution of directions ## ## Input: ## num_quaternions: int : number of quaternions generated ## Output: ## quat_out : tensor of shape (num_quaternions, 4) : quaternions generated ## over_produce = 5 ## for ease of parallelizing the calculation, it first produce much more than the needed amount of quanternion, then filter the ones that satisfy the condition quat = torch.rand((num_quaternions*over_produce, 4), dtype=torch.float64, device=device) * 2. - 1. norm = torch.linalg.vector_norm(quat, ord=2, dim=1) quat /= norm.unsqueeze(1) good_ones = torch.bitwise_and(torch.gt(norm,0.2), torch.lt(norm,1.0)) ## this condition, norm of quaternion has to be < 1.0 and > 0.2, has to be satisfied quat_out = quat[good_ones][:num_quaternions] ## just chop the ones needed return quat_out def quaternion_to_matrix(quaternions): ## ## quaternion_to_matrix : function : Convert rotations given as quaternions to rotation matrices ## ## Input: ## quaternions: tensor of float shape (4) : quaternions leading with the real part ## Output: ## rot_mat : tensor of shape (3, 3) : Rotation matrices ## r, i, j, k = torch.unbind(quaternions, -1) two_s = 2.0 / (quaternions * quaternions).sum(-1) o = torch.stack( ( 1 - two_s * (j * j + k * k), two_s * (i * j - k * r), two_s * (i * k + j * r), two_s * (i * j + k * r), 1 - two_s * (i * i + k * k), two_s * (j * k - i * r), two_s * (i * k - j * r), two_s * (j * k + i * r), 1 - two_s * (i * i + j * j), ), -1, ) rot_mat = o.reshape(quaternions.shape[:-1] + (3, 3)) return rot_mat def calc_ctf_torch_batch(freq2_2d, amp, gamma, b_factor): ## ## calc_ctf_torch_batch : function : generate random Contrast transfer function (CTF) ## ## Input : ## freq2_2d : torch tensor of float of shape (N_pixel, N_pixel) : square of modulus of spatial frequency in Fourier space ## amp : float : Amplitude constrast ratio ## gamma : torch tensor of float of shape (N_image) : gamma coefficient in SI equation 4 that include the defocus ## b_factor : float : B-factor ## Output : ## ctf : torch tensor of float of shape (N_image, N_pixel, N_pixel) : randomly generated CTF ## # env = torch.exp(- b_factor.view(-1,1,1) * freq2_2d.unsqueeze(0) * 0.5) # ctf = amp.view(-1,1,1) * torch.cos(gamma.view(-1,1,1) * freq2_2d * 0.5) - torch.sqrt(1 - amp.view(-1,1,1) **2) * torch.sin(gamma.view(-1,1,1) * freq2_2d * 0.5) + torch.zeros_like(freq2_2d) * 1j env = torch.exp(- b_factor * freq2_2d.unsqueeze(0) * 0.5) ctf = amp * torch.cos(gamma.view(-1,1,1) * freq2_2d * 0.5) - np.sqrt(1 - amp**2) * torch.sin(gamma.view(-1,1,1) * freq2_2d * 0.5) + torch.zeros_like(freq2_2d) * 1j ctf *= env return ctf def gen_img_torch_batch(coord, grid, sigma, norm, ctfs=None): ## ## gen_img_torch_batch : function : generate images from atomic coordinates ## ## Input : ## coord : numpy ndarray or torch tensor of float of shape (N_image, N_atom, 3) : 3D Cartesian coordinates of atoms of configuration aligned to generate the synthetic images ## grid : torch tensor of float of shape (N_pixel) : physical location of center of each pixel (in Angstrom) ## sigma : float : Gaussian width of each atom in the imaging model in Angstrom ## norm : float : normalization factor for image intensity ## ctfs : torch tensor of float of shape (N_image, N_pixel, N_pixel) : random generated CTF added to each of the synthetic image ## Output : ## image or image_ctf : torch tensor of float of shape (N_image, N_pixel, N_pixel) : synthetic images with or without randomly generated CTF applied ## gauss_x = -.5*((grid[:,:,None]-coord[:,:,0])/sigma)**2 ## gauss_y = -.5*((grid[:,:,None]-coord[:,:,1])/sigma)**2 ## pixels are square, grid is same for x and y directions gauss = torch.exp(gauss_x.unsqueeze(1) + gauss_y) image = gauss.sum(3)*norm image = image.permute(2,0,1) if ctfs is not None: ft_image = torch.fft.fft2(image, dim=(1,2), norm=""ortho"") image_ctf = torch.real(torch.fft.ifft2(ctfs * ft_image, dim=(1, 2), norm=""ortho"")) return image_ctf else: return image def circular_mask(n_pixel, radius=0.4): ## ## circular_mask : function : define a circular mask centered at center of the image for SNR calculation purpose (see Method for detail) ## ## Input : ## n_pixel : int : number of pixels of image i.e. the synthetic (cryo-EM) images are of shape (n_pixel, n_pixel) ## radius : float : radius of the circular mask relative to n_pixel, when radius = 0.5, the circular touches the edges of the image ## Output : ## mask : torch tensor of bool of shape (N_pixel, N_pixel) : circular mask to be applied onto the image ## grid = torch.linspace(-.5*(n_pixel-1), .5*(n_pixel-1), n_pixel) grid_x, grid_y = torch.meshgrid(grid, grid, indexing='ij') r_2d = grid_x**2 + grid_y**2 mask = r_2d < radius**2 return mask def add_noise_torch_batch(img, snr, device = ""cuda""): ## ## add_noise_torch_batch : function : add colorless Gaussian pixel noise to images ## ## Input : ## n_pixel : int : number of pixels of image i.e. the synthetic (cryo-EM) images are of shape (n_pixel, n_pixel) ## snr : float : Signal-to-noise (SNR) for adding noise to the image, if snr = np.infty, does not add noise to the images ## Output : ## image_noise : torch tensor of float of shape (N_image, N_pixel, N_pixel) : synthetic images with added noise ## n_pixel = img.shape[1] radius = n_pixel*0.4 mask = circular_mask(n_pixel, radius) image_noise = torch.empty_like(img, device=device) for i, image in enumerate(img): image_masked = image[mask] signal_std = image_masked.pow(2).mean().sqrt() noise_std = signal_std / np.sqrt(snr) noise = torch.distributions.normal.Normal(0, noise_std).sample(image.shape) image_noise[i] = image + noise return image_noise def generate_images( coord, n_pixel = 128, ## use power of 2 for CTF purpose pixel_size = 0.3, sigma = 1.0, snr = 1.0, rotation = True, add_ctf = False, defocus_min = 0.027, defocus_max = 0.090, batch_size = 8, device = ""cuda"", ): ## ## generate_images : function : generate synthetic cryo-EM images, at random orientation (and random CTF), given a set of structures ## ## Input : ## coord : numpy ndarray or torch tensor of float of shape (N_image, N_atom, 3) : 3D Cartesian coordinates of atoms of configuration aligned to generate the synthetic images ## n_pixel : int : number of pixels of image i.e. the synthetic (cryo-EM) images are of shape (n_pixel, n_pixel) ## pixel_size : float : width of each pixel in physical space in Angstrom ## sigma : float : Gaussian width of each atom in the imaging model in Angstrom ## snr : float : Signal-to-noise (SNR) for adding noise to the image, if snr = np.infty, does not add noise to the images ## add_ctf : bool : If True, add Contrast transfer function (CTF) to the synthetic images. ## batch_size : int : to split the set of images into batches for calculation, where structure in the same batch are fed into calculation at the same time, a parameter for computational performance / memory management ## device : str : ""cuda"" or ""cpu"", to be fed into pyTorch, see pyTorch manual for more detail ## Output : ## rot_mats : torch tensor of float of shape (N_image, 3, 3) : Rotational matrices randomly generated to orient the configraution during the image generation process ## ctfs_cpu : torch tensor of float of shape (N_image, N_pixel, N_pixel) : random generated CTF added to each of the synthetic image ## images_cpu : torch tensor of float of shape (N_image, N_pixel, N_pixel) : generated synthetic images ## if type(coord) == np.ndarray: coord = torch.from_numpy(coord).type(torch.float64) coord = coord.to(device) n_struc = coord.shape[0] n_atoms = coord.shape[1] norm = .5/(np.pi*sigma**2*n_atoms) N_images = n_struc n_batch = int(N_images / batch_size) if n_batch * batch_size < N_images: n_batch += 1 if rotation: quats = gen_quat_torch(N_images, device) rot_mats = quaternion_to_matrix(quats).type(torch.float64) rot_mats = rot_mats.to(device) coord_rot = coord.matmul(rot_mats) else: rot_mats = torch.eye(3).unsqueeze(0).repeat(N_images,1,1).type(torch.float64) coord_rot = coord grid = gen_grid(n_pixel, pixel_size).reshape(-1,1) grid = grid.to(device) ctfs_cpu = torch.empty((N_images, n_pixel, n_pixel), dtype=torch.complex64, device='cpu') images_cpu = torch.empty((N_images, n_pixel, n_pixel), dtype=torch.float64, device='cpu') if add_ctf: amp = 0.1 ## Amplitude constrast ratio b_factor = 1.0 ## B-factor defocus = torch.rand(N_images, dtype=torch.float64, device=device) * (defocus_max - defocus_min) + defocus_min ## defocus elecwavel = 0.019866 ## electron wavelength in Angstrom gamma = defocus * (np.pi * 2. * 10000 * elecwavel) ## gamma coefficient in SI equation 4 that include the defocus freq_pix_1d = torch.fft.fftfreq(n_pixel, d=pixel_size, dtype=torch.float64, device=device) freq_x, freq_y = torch.meshgrid(freq_pix_1d, freq_pix_1d, indexing='ij') freq2_2d = freq_x**2 + freq_y**2 ## square of modulus of spatial frequency for i in tqdm(range(n_batch), desc=""Generating images for batch""): start = i*batch_size end = (i+1)*batch_size coords_batch = coord_rot[start:end] coords_batch = coords_batch.to(device) if add_ctf: ctf_batch = calc_ctf_torch_batch(freq2_2d, amp, gamma[start:end], b_factor) ctfs_cpu[start:end] = ctf_batch image_batch = gen_img_torch_batch(coords_batch, grid, sigma, norm, ctf_batch.to(device)) else: image_batch = gen_img_torch_batch(coords_batch, grid, sigma, norm) if not np.isinf(snr): image_batch = add_noise_torch_batch(image_batch, snr, device) images_cpu[start:end] = image_batch.cpu() if device == ""cuda"": rot_mats = rot_mats.cpu() return rot_mats, ctfs_cpu, images_cpu def calc_struc_image_diff( coord, n_pixel = 128, ## use power of 2 for CTF purpose pixel_size = 0.3, sigma = 1.0, images = None, ctfs = None, batch_size = 8, device = ""cuda"", return_template = False, ): ## ## calc_struc_image_diff : function : calculate the difference between an image and a structure, given a set of images and a structure (= a set of N_image coordinates of the structure aligned to each of the images) ## ## Input : ## coord : numpy ndarray or torch tensor of float of shape (N_image, N_atom, 3) : 3D Cartesian coordinates of atoms of configuration aligned to each of the N_image synthetic images ## these N_image coordinates represent ONE single configuration that is rotated by N_image different rotation matrices to align the configuration to N_image different images ## n_pixel : int : number of pixels of image i.e. the synthetic (cryo-EM) images are of shape (n_pixel, n_pixel) ## pixel_size : float : width of each pixel in physical space in Angstrom ## sigma : float : Gaussian width of each atom in the imaging model in Angstrom ## images : torch tensor of float of shape (N_image, N_pixel, N_pixel) : Intensity of cryo-EM (synthetic) images to be compared to the structure ## ctfs : torch tensor of float of shape (N_image, N_pixel, N_pixel) : Contrast transfer function (CTF) for the synthetic images ## batch_size : int : to split the set of images into batches for calculation, where images in the same batch are fed into calculation at the same time, a parameter for computational performance / memory management ## device : str : ""cuda"" or ""cpu"", to be fed into pyTorch, see pyTorch manual for more detail ## Output : ## diff : torch tensor of float of shape (N_image) : L2-norm distances between the structure (that is converted into images) and the cryo-EM images ## if type(coord) == np.ndarray: coord = torch.from_numpy(coord).type(torch.float64) coord = coord.to(device) n_atoms = coord.shape[1] norm = .5/(np.pi*sigma**2*n_atoms) N_images = coord.shape[0] n_batch = int(N_images / batch_size) if n_batch * batch_size < N_images: n_batch += 1 grid = gen_grid(n_pixel, pixel_size).reshape(-1,1) grid = grid.to(device) if return_template: image_template = torch.empty(N_images, n_pixel, n_pixel, dtype=torch.float64, device=device) diff = torch.empty(N_images, dtype=torch.float64, device='cpu') for i in range(n_batch): start = i*batch_size end = (i+1)*batch_size if ctfs is not None: ctf_batch = ctfs[start:end] ctf_batch = ctf_batch.to(device) image_batch = gen_img_torch_batch(coord[start:end], grid, sigma, norm, ctf_batch) else: image_batch = gen_img_torch_batch(coord[start:end], grid, sigma, norm) image_batch = image_batch - image_batch.mean(dim=(1,2)).view(-1,1,1) diff[start:end] = torch.sum((image_batch - images[start:end].to(device))**2, dim=(1,2)) if return_template: image_template[start:end] = image_batch.cpu() if return_template: return diff, image_template else: return diff ","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","src/cryoER/run_stan_readLikeli.py",".py","1863","83","import os, sys #from cmdstanpy import cmdstan_path, CmdStanModel from cmdstanpy import CmdStanModel import importlib.resources from scipy.special import logsumexp import numpy as np import json import multiprocessing print(multiprocessing.cpu_count()) out_directory = './stan_output/' module_path = importlib.resources.files(""cryoER"") path = os.path.join(module_path, ""cryo-er.stan"") key = 'LogL' json_filename = os.path.join('.', '{}.json'.format(key)) # list files in directory negloglik = [] #filename = os.path.join('LogLikeMat', file) data = np.loadtxt('LogLikeMat') negloglik = np.array(data).T M = negloglik.shape[0] # Number of model N = negloglik.shape[1] # Number of images = print(""Struct-Images "", M, N) # if want to read Nm input Nm = np.loadtxt(""nm.txt"", dtype=float) Nm /= np.sum(Nm) log_Nm = np.log(Nm) #uniform Nm #Nm = np.ones(M)/M #log_Nm = np.log(Nm) # norm = .5/(sigma**2) # Dmat = -norm*distance.T Dmat = -negloglik.T dictionary = { ""M"": M, ""N"": N, ""logNm"": list(log_Nm), ""Dmat"": [list(a) for a in Dmat] } json_object = json.dumps(dictionary, indent=4) with open(json_filename, ""w"") as f: f.write(json_object) f.close() my_stanfile = os.path.join(module_path, 'cryo-er.stan') # my_stanfile = os.path.join('.', 'cryo-er.stan') my_model = CmdStanModel(stan_file=my_stanfile, cpp_options={""STAN_THREADS"": True, # ""STAN_MPI"": True, # ""CXX"": ""mpicxx"", # ""TBB_CXX_TYPE"": ""gcc"", }, # compile='force', ) # print(my_model.exe_info()) # for dataset in datasets: # N_center = int(sys.argv[1]) # dataset = ""replicakm%dtodesres""%N_center fit = my_model.sample(data=json_filename, chains=8, sig_figs=12, parallel_chains=8, threads_per_chain=15, iter_warmup=1000, iter_sampling=10000, show_console=True, ) fit.save_csvfiles(dir=out_directory) ","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","src/cryoER/run_cryoER_toymodel.py",".py","2269","97","import os, sys from cmdstanpy import cmdstan_path, CmdStanModel import numpy as np import json import multiprocessing print(multiprocessing.cpu_count()) my_stanfile = os.path.join('.', 'cryo-er.stan') my_model = CmdStanModel(stan_file=my_stanfile, cpp_options={""STAN_THREADS"": True, # ""STAN_MPI"": True, # ""CXX"": ""mpicxx"", # ""TBB_CXX_TYPE"": ""gcc"", }, # compile='force', ) print(my_model.exe_info()) dataset = ""toy_model"" output_directory = ""output"" filelabel = ""sigma1"" directory = ""%s/Dmat_%s_%s""%(output_directory,dataset,filelabel) filename = ""%s/Dmat_%s_%s/Dmat.json""%(output_directory,dataset,filelabel) try: os.makedirs(directory,exist_ok=True) except FileExistsError: pass ## 3D Toy model ## Generate Gaussian distributed data points as ""images"" np.random.seed(0) means = np.array([ [0.0,0.0,0.0], [2.0,4.0,-2.0], [4.0,0.0,0.0], ]) # Center of the Gaussians covariance = np.array([ [1.0,0.0,0.0], [0.0,1.0,0.0], [0.0,0.0,1.0], ]) # Width of the Gaussians data = np.array([]) sizes = [5000, 3000, 2000] # relative population of the 3 Gaussians in the data set log_sizes = np.log(sizes) #exit() for mean, size in zip(means, sizes): cluster = np.random.multivariate_normal(mean=mean,cov=covariance,size=size) if data.size: data = np.vstack((data,cluster)) else: data = cluster sample = np.array([ [0.0,0.0,0.0], # point A # [-0.1,0.0,0.0], # point A1 # [0.1,0.0,0.0], # point A2 [2.0,4.0,-2.0], # point B # [3.0,2.0,-1.0], # point D [4.0,0.0,0.0], # point C ]) distance = np.sum((sample[None,:] - data[:,None])**2,axis=-1) M = distance.shape[1] N = distance.shape[0] N_pix = 3 sigma = 1.0 norm = .5/(sigma**2) Dmat = -norm*distance dictionary = { ""M"": M, ""N"": N, ""logNm"": [float(a) for a in log_sizes], ""Dmat"": [list(a) for a in Dmat] } json_object = json.dumps(dictionary, indent=4) with open(filename, ""w"") as f: f.write(json_object) f.close() data_file = os.path.join('.', filename) fit = my_model.sample(data=data_file, chains=8, sig_figs=12, parallel_chains=8, threads_per_chain=20, iter_warmup=1000, iter_sampling=10000, ) fit.save_csvfiles(dir=directory) ","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","src/cryoER/approx_lmbd.py",".py","4600","168","import numpy as np import torch import argparse import MDAnalysis as mda import cryoER.imggen_torch as igt from cryoER.tools import mdau_to_pos_arr def circular_mask(n_pixels, radius): grid = torch.linspace(-.5*(n_pixels-1), .5*(n_pixels-1), n_pixels) grid_x, grid_y = torch.meshgrid(grid, grid, indexing='ij') r_2d = grid_x**2 + grid_y**2 mask = r_2d < radius**2 return mask def signal_std_torch_batch(img): n_pixels = img.shape[1] radius = n_pixels*0.4 mask = circular_mask(n_pixels, radius) image_masked = img[:, mask] signal_std = image_masked.pow(2).mean(1).sqrt() return signal_std def _parse_args(): parser = argparse.ArgumentParser( prog=""cryoERMCMC"", description=""Perform MCMC sampling with Stan to sample posterior of \ weights that reweights a conformational ensemble with cryo-EM \ particles"", # epilog = 'Text at the bottom of help' ) parser.add_argument( ""-sp"", ""--top_struc"", type=str, default=""struc.gro"", help=""topology file for structure trajectory"", ) parser.add_argument( ""-st"", ""--traj_struc"", type=str, default=""struc.xtc"", help=""trajectory file for structure trajectory"", ) parser.add_argument( ""-rm"", ""--rotmat_struc_imgstruc"", type=str, default=""rot_mats_struc_image.npy"", help="".npy file for rotation matrix that aligns structure trajectory to image-generating trajectory"", ) parser.add_argument( ""-o"", ""--outdir"", default=""./output/"", help=""directory for output files"" ) parser.add_argument( ""-np"", ""--n_pixel"", type=int, default=128, help=""number of image pixels, use power of 2 for CTF purpose"", ) parser.add_argument( ""-ps"", ""--pixel_size"", type=float, default=0.2, help=""pixel size in Angstrom"" ) parser.add_argument( ""-sg"", ""--sigma"", type=float, default=1.5, help=""radius of Gaussian atom"" ) parser.add_argument( ""-snr"", ""--signal_to_noise_ratio"", type=float, default=1e-2, help=""signal-to-noise ratio in synthetic images"", ) parser.add_argument( ""-ctf"", ""--add_ctf"", default=False, action=""store_true"", help=""introduce CTF modulation (if True)"", ) parser.add_argument( ""-dmin"", ""--defocus_min"", type=float, default=0.027, help=""Minimum defocus value in microns"", ) parser.add_argument( ""-dmax"", ""--defocus_max"", type=float, default=0.090, help=""Maximum defocus value in microns"", ) parser.add_argument( ""-dv"", ""--device"", type=str, default=""cpu"", help='hardware device for calculation: ""cuda"" for GPU, or ""cpu"" for CPU', ) parser.add_argument( ""-nips"", ""--n_image_per_struc"", type=int, default=100, help=""number of images per structure for lambda approximation"", ) parser.add_argument( ""-nb"", ""--n_batch"", type=int, default=10, help=""number of batch to separate the output files into for memory management"", ) return parser def approx_lmbd(top_struc, traj_struc, n_pixel, pixel_size, sigma, signal_to_noise_ratio, add_ctf, defocus_min, defocus_max, n_image_per_struc, n_batch, device): uStruc = mda.Universe(top_struc, traj_struc) posStruc = mdau_to_pos_arr(uStruc) posStruc = posStruc.repeat(n_image_per_struc, 1, 1) _, _, images = igt.generate_images( posStruc, n_pixel = n_pixel, pixel_size = pixel_size, sigma = sigma, snr = np.inf, rotation = True, add_ctf = add_ctf, defocus_min = defocus_min, defocus_max = defocus_max, batch_size = n_batch, device = device, ) signal_std = signal_std_torch_batch(images) snr = signal_to_noise_ratio noise_std = signal_std / np.sqrt(snr) lmbd = noise_std.mean().numpy() return lmbd if __name__ == ""__main__"": parser = _parse_args() args = parser.parse_args() _ = approx_lmbd( args.top_struc, args.traj_struc, args.n_pixel, args.pixel_size, args.sigma, args.signal_to_noise_ratio, args.add_ctf, args.defocus_min, args.defocus_max, args.n_image_per_struc, args.n_batch, args.device, ) pass","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","src/cryoER/make_synthetic_images.py",".py","4893","181","import numpy as np from tqdm import tqdm import torch import os import MDAnalysis as mda import argparse from cryoER.tools import mdau_to_pos_arr import cryoER.imggen_torch as igt def _parse_args(): parser = argparse.ArgumentParser( prog=""cryoERMCMC"", description=""Perform MCMC sampling with Stan to sample posterior of \ weights that reweights a conformational ensemble with cryo-EM \ particles"", # epilog = 'Text at the bottom of help' ) parser.add_argument( ""-ip"", ""--top_image"", type=str, default=""image.gro"", help=""topology file for image-generating trajectory"", ) parser.add_argument( ""-it"", ""--traj_image"", type=str, default=""image.xtc"", help=""trajectory file for image-generating trajectory"", ) parser.add_argument( ""-o"", ""--outdir"", default=""./output/"", help=""directory for output files"" ) parser.add_argument( ""-np"", ""--n_pixel"", type=int, default=128, help=""number of image pixels, use power of 2 for CTF purpose"", ) parser.add_argument( ""-ps"", ""--pixel_size"", type=float, default=0.2, help=""pixel size in Angstrom"" ) parser.add_argument( ""-sg"", ""--sigma"", type=float, default=1.5, help=""radius of Gaussian atom"" ) parser.add_argument( ""-snr"", ""--signal_to_noise_ratio"", type=float, default=1e-2, help=""signal-to-noise ratio in synthetic images"", ) parser.add_argument( ""-ctf"", ""--add_ctf"", default=False, action=""store_true"", help=""introduce CTF modulation (if True)"", ) parser.add_argument( ""-dmin"", ""--defocus_min"", type=float, default=0.027, help=""Minimum defocus value in microns"", ) parser.add_argument( ""-dmax"", ""--defocus_max"", type=float, default=0.090, help=""Maximum defocus value in microns"", ) parser.add_argument( ""-dv"", ""--device"", type=str, default=""cpu"", help='hardware device for calculation: ""cuda"" for GPU, or ""cpu"" for CPU', ) parser.add_argument( ""-nb"", ""--n_batch"", type=int, default=10, help=""number of batch to separate the output files into for memory management"", ) return parser ######## ######## ######## ######## def make_synthetic_images( top_image = ""image.gro"", traj_image = ""image.xtc"", n_pixel = 128, pixel_size = 0.2, sigma = 1.5, snr = 1e-2, n_image_per_struc = 1, add_ctf = False, defocus_min = 0.027, defocus_max = 0.090, device = ""cpu"", batch_size = 16, outdir = None ): ######## ######## ######## ######## file_prefix = ""npix%d_ps%.2f_s%.1f_snr%.1E"" % (n_pixel, pixel_size, sigma, snr) print(""Reading trajectory..."") ## Reading image trajectory print(""Reading image trajectory from %s and %s..."" % (top_image, traj_image)) uImg = mda.Universe(top_image, traj_image) coord_img = mdau_to_pos_arr(uImg) if n_image_per_struc > 1: coord_img = coord_img.repeat(n_image_per_struc, 1, 1) coord_img = coord_img.to(device) rot_mats, ctfs, images = igt.generate_images( coord_img, n_pixel=n_pixel, ## use power of 2 for CTF purpose pixel_size=pixel_size, sigma=sigma, snr=snr, add_ctf=add_ctf, defocus_min=defocus_min, defocus_max=defocus_max, batch_size=batch_size, device=device, ) if outdir is not None: print(""Saving images to %s..."" % outdir) np.save(""%s/rot_mats_%s.npy"" % (outdir, file_prefix), rot_mats.cpu().numpy()) np.save(""%s/ctf_%s.npy"" % (outdir, file_prefix), ctfs.cpu().numpy()) np.save(""%s/images_%s.npy"" % (outdir, file_prefix), images.cpu().numpy()) print(""Done!"") return rot_mats, ctfs, images if __name__ == ""__main__"": parser = _parse_args() args = parser.parse_args() top_image = args.top_image traj_image = args.traj_image outdir = args.outdir n_pixel = args.n_pixel pixel_size = args.pixel_size sigma = args.sigma snr = args.signal_to_noise_ratio add_ctf = args.add_ctf defocus_min = args.defocus_min defocus_max = args.defocus_max device = args.device batch_size = args.batch_size _, _, _ = make_synthetic_images( top_image = top_image, traj_image = traj_image, n_pixel = n_pixel, pixel_size = pixel_size, sigma = sigma, snr = snr, add_ctf = add_ctf, defocus_min = defocus_min, defocus_max = defocus_max, device = device, batch_size = batch_size, outdir = outdir ) pass ","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","src/cryoER/align_traj.py",".py","3103","117","import torch import numpy as np import argparse import MDAnalysis as mda from tqdm import tqdm from cryoER.tools import mdau_to_pos_arr def _parse_args(): parser = argparse.ArgumentParser( prog=""cryoERMCMC"", description=""Perform MCMC sampling with Stan to sample posterior of \ weights that reweights a conformational ensemble with cryo-EM \ particles"", # epilog = 'Text at the bottom of help' ) parser.add_argument( ""-ip"", ""--top_image"", type=str, default=""image.gro"", help=""topology file for image-generating trajectory"", ) parser.add_argument( ""-it"", ""--traj_image"", type=str, default=""image.xtc"", help=""trajectory file for image-generating trajectory"", ) parser.add_argument( ""-sp"", ""--top_struc"", type=str, default=""struc.gro"", help=""topology file for structure trajectory"", ) parser.add_argument( ""-st"", ""--traj_struc"", type=str, default=""struc.xtc"", help=""trajectory file for structure trajectory"", ) parser.add_argument( ""-o"", ""--outdir"", default=""./output/"", help=""directory for output files"" ) parser.add_argument( ""-dv"", ""--device"", type=str, default=""cpu"", help='hardware device for calculation: ""cuda"" for GPU, or ""cpu"" for CPU', ) return parser ######## ######## ######## ######## def align_traj( top_image=""image.gro"", traj_image=""image.xtc"", top_struc=""struc.gro"", traj_struc=""struc.xtc"", outdir=""./output/"", device=""cpu"", ): uImage = mda.Universe(top_image, traj_image) uStruc = mda.Universe(top_struc, traj_struc) posImage = mdau_to_pos_arr(uImage) posStruc = mdau_to_pos_arr(uStruc) nImage = posImage.shape[0] nStruc = posStruc.shape[0] output_directory = outdir device = torch.device(device) rot_mats = torch.empty((nStruc, nImage, 3, 3), dtype=torch.float64, device=""cpu"") posImage = posImage.to(device) posStruc = posStruc.to(device) n_batch = 1 batch_size = nStruc // n_batch print(""Calculating rotation matrices..."") for i_batch in tqdm(range(n_batch)): batch_start = i_batch*batch_size batch_end = (i_batch+1)*batch_size Hs = torch.einsum('nji,mjk->nmik', posImage, posStruc[batch_start:batch_end]) u, s, vh = torch.linalg.svd(Hs.flatten(0,1)) v = vh.transpose(1,2) R = torch.matmul(v, u.transpose(1,2)) rot_mats[batch_start:batch_end, :, :, :] = torch.reshape(R.cpu(), Hs.shape).transpose(0,1) rot_mats = rot_mats.cpu().numpy() np.save(output_directory + ""rot_mats_struc_image.npy"", rot_mats) print(""Done!"") return rot_mats if __name__ == ""__main__"": parser = _parse_args() args = parser.parse_args() _ = align_traj( args.top_image, args.traj_image, args.top_struc, args.traj_struc, args.outdir, args.device, ) pass","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","src/cryoER/calc_image_struc_distance.py",".py","7460","253","import numpy as np from tqdm import tqdm import torch import os import MDAnalysis as mda import argparse from cryoER.tools import mdau_to_pos_arr import cryoER.imggen_torch as igt def _parse_args(): parser = argparse.ArgumentParser( prog=""cryoERMCMC"", description=""Perform MCMC sampling with Stan to sample posterior of \ weights that reweights a conformational ensemble with cryo-EM \ particles"", # epilog = 'Text at the bottom of help' ) parser.add_argument( ""-i"", ""--images"", type=str, default=None, help="".npy file for images"", ) parser.add_argument( ""-c"", ""--ctfs"", type=str, default=None, help="".npy file for CTFs"", ) parser.add_argument( ""-ri"", ""--rot_mats_image"", type=str, default=None, help="".npy file for rotation matrix that specifies the orientation of each image"", ) parser.add_argument( ""-sp"", ""--top_struc"", type=str, default=""struc.gro"", help=""topology file for structure trajectory"", ) parser.add_argument( ""-st"", ""--traj_struc"", type=str, default=""struc.xtc"", help=""trajectory file for structure trajectory"", ) parser.add_argument( ""-rm"", ""--rotmat_struc_imgstruc"", type=str, default=""rot_mats_struc_image.npy"", help="".npy file for rotation matrix that aligns structure trajectory to image-generating trajectory"", ) parser.add_argument( ""-o"", ""--outdir"", default=""./output/"", help=""directory for output files"" ) parser.add_argument( ""-np"", ""--n_pixel"", type=int, default=128, help=""number of image pixels, use power of 2 for CTF purpose"", ) parser.add_argument( ""-ps"", ""--pixel_size"", type=float, default=0.2, help=""pixel size in Angstrom"" ) parser.add_argument( ""-sg"", ""--sigma"", type=float, default=1.5, help=""radius of Gaussian atom"" ) parser.add_argument( ""-snr"", ""--signal_to_noise_ratio"", type=float, default=1e-2, help=""signal-to-noise ratio in synthetic images"", ) parser.add_argument( ""-ctf"", ""--add_ctf"", default=False, action=""store_true"", help=""introduce CTF modulation (if True)"", ) parser.add_argument( ""-dmin"", ""--defocus_min"", type=float, default=0.027, help=""Minimum defocus value in microns"", ) parser.add_argument( ""-dmax"", ""--defocus_max"", type=float, default=0.090, help=""Maximum defocus value in microns"", ) parser.add_argument( ""-dv"", ""--device"", type=str, default=""cpu"", help='hardware device for calculation: ""cuda"" for GPU, or ""cpu"" for CPU', ) parser.add_argument( ""-nb"", ""--batch_size"", type=int, default=10, help=""number of batch to separate the output files into for memory management"", ) return parser ######## ######## ######## ######## def calc_image_struc_distance( images = None, ctfs = None, rot_mats_image = None, top_struc = ""struc.gro"", traj_struc = ""struc.xtc"", rotmat_struc_imgstruc = None, outdir = ""./output/"", n_pixel = 128, pixel_size = 0.2, sigma = 1.5, snr = 1e-2, add_ctf = False, defocus_min = 0.027, defocus_max = 0.090, device = ""cpu"", batch_size = 16 ): ######## ######## ######## ######## file_prefix = ""npix%d_ps%.2f_s%.1f_snr%.1E"" % (n_pixel, pixel_size, sigma, snr) print(""Reading trajectory from %s and %s..."" % (top_struc, traj_struc)) uStr = mda.Universe(top_struc, traj_struc) coord_str = mdau_to_pos_arr(uStr) n_struc = coord_str.shape[0] if rotmat_struc_imgstruc is not None: print(""Reading struc-images alignment matrices from %s..."" % rotmat_struc_imgstruc) rot_mats_align = torch.from_numpy(np.load(rotmat_struc_imgstruc)).to(device) else: print(""No struc-imgstruc alignment matrices specified, assume only using poses"") if images is None: print(""Loading images from %s/images_%s.npy..."" % (outdir, file_prefix)) images = np.load(""%s/images_%s.npy"" % (outdir, file_prefix)) if ctfs is None: print(""Loading CTFs from %s/ctf_%s.npy..."" % (outdir, file_prefix)) ctfs = np.load(""%s/ctf_%s.npy"" % (outdir, file_prefix)) if rot_mats_image is None: print(""Loading poses from %s/rot_mats_%s.npy..."" % (outdir, file_prefix)) rot_mats_image = np.load(""%s/rot_mats_%s.npy"" % (outdir, file_prefix)) if not torch.is_tensor(images): images = torch.from_numpy(images) if not torch.is_tensor(ctfs): ctfs = torch.from_numpy(ctfs) if not torch.is_tensor(rot_mats_image): rot_mats_image = torch.from_numpy(rot_mats_image) images = images.to(device) ctfs = ctfs.to(device) rot_mats_image = rot_mats_image.to(device) n_image = images.shape[0] diff = np.zeros((n_struc, n_image), dtype=float) for i in tqdm(range(n_struc), desc=""Computing image-structure distance for structure""): if rotmat_struc_imgstruc is not None: aligned_coord = coord_str[i].unsqueeze(0).matmul(rot_mats_align[i]).matmul(rot_mats_image) else: aligned_coord = coord_str[i].unsqueeze(0).matmul(rot_mats_image) diff[i] = igt.calc_struc_image_diff( aligned_coord, n_pixel=n_pixel, ## use power of 2 for CTF purpose pixel_size=pixel_size, sigma=sigma, images=images, ctfs=ctfs, batch_size=batch_size, device=device, ) print(""Saving..."") np.save(""%s/diff_%s.npy"" % (outdir, file_prefix), diff) print(""Done!"") return diff if __name__ == ""__main__"": parser = _parse_args() args = parser.parse_args() if args.images is not None: print(""Loading images from %s..."" % args.images) images = np.load(args.images) if args.ctfs is not None: print(""Loading CTFs from %s..."" % args.ctfs) ctfs = np.load(args.ctfs) if args.rot_mats_image is not None: print(""Loading poses from %s..."" % args.rot_mats_image) rot_mats_image = np.load(args.rot_mats_image) top_struc = args.top_struc traj_struc = args.traj_struc rotmat_struc_imgstruc = args.rotmat_struc_imgstruc outdir = args.outdir n_pixel = args.n_pixel pixel_size = args.pixel_size sigma = args.sigma snr = args.signal_to_noise_ratio add_ctf = args.add_ctf defocus_min = args.defocus_min defocus_max = args.defocus_max device = args.device batch_size = args.batch_size _ = calc_image_struc_distance( images = images, ctfs = ctfs, rot_mats_image = rot_mats_image, top_struc = top_struc, traj_struc = traj_struc, rotmat_struc_imgstruc = rotmat_struc_imgstruc, outdir = outdir, n_pixel = n_pixel, pixel_size = pixel_size, sigma = sigma, snr = snr, add_ctf = add_ctf, defocus_min = defocus_min, defocus_max = defocus_max, device = device, batch_size = batch_size ) pass ","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","tutorial/example.ipynb",".ipynb","2685752","1517","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Ensemble reweighting using Cryo-EM particles\n"", ""============================================\n"", ""\n"", ""This example shows how to generate synthetic cryo-EM images, and use these synthetic cryo-EM images to reweight MD simulations by Bayesian inference.\n"", ""\n"", ""First, setup the virtual environment and install the required packages.\n"", ""\n"", ""\n"", ""\n"", "" git clone https://github.com/flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles.git\n"", "" cd Ensemble-reweighting-using-Cryo-EM-particles\n"", "" \n"", "" # Python 3.10.10\n"", "" python3 -m venv ./venv/\n"", "" source ./venv/bin/activate\n"", "" pip install --upgrade pip\n"", "" pip install -e .\n"", "" pip install --upgrade MDAnalysis\n"", "" pip install ipykernel scipy\n"", "" pip3 install torch torchvision torchaudio\n"", "" pip install --upgrade cmdstanpy\n"", "" pip install corner\n"", ""\n"", "" # for Linux\n"", "" install_cmdstan\n"", "" # for Windows\n"", "" install_cmdstan --compiler\n"", ""\n"", "" # for corner plots in this notebook\n"", "" pip install corner\n"", ""\n"", ""In this example, the initial set of structures (and the cluster populations) are obtained from K-Medoids clustering. Example script to perform the clustering calculation is shown at the bottom of this notebook."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""We will run, analyze, and visualize along the way as we go through the process of running the Ensemble reweighting calculation."" ] }, { ""cell_type"": ""code"", ""execution_count"": 1, ""metadata"": {}, ""outputs"": [ { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""/Users/wtang/Code/git_repo/Ensemble-reweighting-using-Cryo-EM-particles/venv/lib/python3.11/site-packages/MDAnalysis/topology/TPRParser.py:161: DeprecationWarning: 'xdrlib' is deprecated and slated for removal in Python 3.13\n"", "" import xdrlib\n"" ] } ], ""source"": [ ""## import necessary modules\n"", ""import os, sys\n"", ""import csv\n"", ""from tqdm import tqdm\n"", ""import numpy as np\n"", ""import torch\n"", ""from scipy.special import logsumexp\n"", ""\n"", ""# check if cuda is available\n"", ""device = torch.device(\""cuda\"" if torch.cuda.is_available() else \""cpu\"")\n"", ""\n"", ""import cmdstanpy\n"", ""# cmdstanpy.install_cmdstan() # if you don't have cmdstan installed, uncomment this line\n"", ""# cmdstanpy.rebuild_cmdstan() # if cmdstan fails to compile, try uncommenting this line\n"", ""\n"", ""import MDAnalysis as mda\n"", ""from MDAnalysis.analysis import align\n"", ""\n"", ""## cryoER modules\n"", ""import cryoER\n"", ""from cryoER import imggen_torch as igt\n"", ""from cryoER.approx_lmbd import approx_lmbd\n"", ""from cryoER.align_traj import align_traj\n"", ""from cryoER.make_synthetic_images import make_synthetic_images\n"", ""from cryoER.calc_image_struc_distance import calc_image_struc_distance\n"", ""from cryoER.run_cryoER_mcmc import run_cryoER_mcmc\n"", ""from cryoER.analyze_mcmc import analyze_mcmc\n"", ""\n"", ""## test compile cmdstan model\n"", ""cryoER.run_cryoER_mcmc.BuildCmdStanModel()\n"", ""\n"", ""## cryoEM settings\n"", ""n_pixel = 128 # number of pixels\n"", ""pixel_size = 0.2 # pixel size in Angstrom\n"", ""sigma = 1.5 # width of atom in Angstrom\n"", ""snr = 1.0 # signal-to-noise ratio\n"", ""defocus_min = 0.027 # minimum defocus in micron\n"", ""defocus_max = 0.090 # maximum defocus in micron\n"", ""nCluster = 10 # number of clusters\n"", ""\n"", ""## plot settings\n"", ""from matplotlib import pyplot as plt\n"", ""import matplotlib as mpl\n"", ""\n"", ""mpl.rcParams['font.family'] = 'sans-serif'\n"", ""mpl.rcParams['axes.titlesize'] = 12\n"", ""mpl.rcParams['axes.labelsize'] = 12\n"", ""mpl.rcParams['lines.linewidth'] = 3\n"", ""mpl.rcParams['lines.markersize'] = 8\n"", ""mpl.rcParams['xtick.labelsize'] = 10\n"", ""mpl.rcParams['ytick.labelsize'] = 10\n"", ""mpl.rcParams['figure.figsize'] = [6.0, 4.0]\n"", ""mpl.rcParams['figure.dpi'] = 100\n"", ""\n"", ""cmap_fe = 'afmhot'\n"", ""\n"", ""## data directory\n"", ""data_directory = '../data/'\n"", ""## output directory\n"", ""output_directory = './output/'\n"", ""try:\n"", "" os.mkdir(output_directory)\n"", ""except:\n"", "" os.system('rm -rf ./output/*')\n"", "" pass"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# 0. Make inputs"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Make synthetic images from reference trajectory**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 2, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Reading trajectory...\n"", ""Reading image trajectory from ../data/image.pdb and ../data/image.xtc...\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""Generating images for batch: 100%|██████████| 165/165 [00:06<00:00, 27.01it/s]\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Saving images to ./output/...\n"", ""Done!\n"" ] } ], ""source"": [ ""rot_mats_image, ctfs, images = make_synthetic_images(\n"", "" top_image = data_directory + 'image.pdb',\n"", "" traj_image = data_directory + 'image.xtc',\n"", "" outdir = output_directory,\n"", "" n_pixel = n_pixel,\n"", "" pixel_size = pixel_size,\n"", "" sigma = sigma,\n"", "" snr = snr,\n"", "" n_image_per_struc = 1,\n"", "" add_ctf = True,\n"", "" defocus_min = defocus_min,\n"", "" defocus_max = defocus_max,\n"", "" device = device,\n"", "" batch_size = 32\n"", "")"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Inspect the Synthetic dataset**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 3, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""## Load the Synthetic images\n"", ""images = np.load('%s/images_npix%d_ps%.2f_s%.1f_snr%.1E.npy' % (output_directory, n_pixel, pixel_size, sigma, snr))\n"", ""\n"", ""## Inspect pixel intensities\n"", ""fig = plt.figure(figsize=(4, 3), dpi=100)\n"", ""hist, edges = np.histogram(images.flatten(), bins=100)\n"", ""ax = fig.add_subplot(111)\n"", ""ax.plot(edges[:-1], hist, color='k')\n"", ""ax.set_xlabel('Pixel Intensity')\n"", ""ax.set_ylabel('Counts')\n"", ""ax.set_title('synthetic particle set')\n"", ""plt.tight_layout()\n"", ""\n"", ""## Visualize the synthetic images\n"", ""fig = plt.figure(figsize=(6, 6), dpi=100)\n"", ""for i in range(16):\n"", "" ax = fig.add_subplot(4, 4, i+1)\n"", "" ax.imshow(images[i], cmap='gray', vmin=-5e-3, vmax=5e-3)\n"", "" ax.axis('off')\n"", ""plt.tight_layout()"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Load and visualize the MD cluster centers**"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Reading the trajectory files for inspection**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 4, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Number of reference structures: 10\n"", ""Number of images (1 synthetic image per structure): 5277\n"" ] } ], ""source"": [ ""# Structure for generating synthetic cryo-EM data (\""Ground Truth\"")\n"", ""uImage = mda.Universe(data_directory + 'image.pdb', data_directory + 'image.xtc')\n"", ""# Structure of Initial structural ensemble for reweighting (10 structures chosen by clustering)\n"", ""uStruc = mda.Universe(data_directory + 'struc.pdb', data_directory + 'struc.xtc')\n"", ""\n"", ""def mdau_to_pos_arr(u):\n"", "" protein_CA = u.select_atoms(\""protein and name CA\"")\n"", "" pos = torch.zeros((len(u.trajectory), len(protein_CA), 3), dtype=float)\n"", "" for i, ts in enumerate(u.trajectory):\n"", "" pos[i] = torch.from_numpy(protein_CA.positions)\n"", "" pos -= pos.mean(1).unsqueeze(1)\n"", "" return pos\n"", ""\n"", ""posStruc = mdau_to_pos_arr(uStruc)\n"", ""posImage = mdau_to_pos_arr(uImage)\n"", ""\n"", ""# check center of mass\n"", ""assert torch.allclose(posStruc.mean(1), torch.zeros_like(posStruc.mean(1)))\n"", ""assert torch.allclose(posImage.mean(1), torch.zeros_like(posImage.mean(1)))\n"", ""\n"", ""nStruc = posStruc.shape[0]\n"", ""nImage = posImage.shape[0]\n"", ""\n"", ""print('Number of reference structures: {}'.format(nStruc))\n"", ""print('Number of images (1 synthetic image per structure): {}'.format(nImage))"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# 1. Inspect landscapes"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Cluster centers and corresponding MD members for each cluster**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 5, ""metadata"": { ""scrolled"": true }, ""outputs"": [ { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""/var/folders/_8/h5rr6k3s2995tzxt8b9sqfgh0000gq/T/ipykernel_24568/1782210300.py:7: UserWarning: *c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n"", "" ax.scatter(posStruc[i, j, 0], posStruc[i, j, 1], posStruc[i, j, 2], s = 10, c = colors[j], marker='o')\n"" ] }, { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""fig = plt.figure(figsize=(15, 6), dpi=100)\n"", ""for i in range(nCluster):\n"", "" ax = fig.add_subplot(2, 5, i+1, aspect='equal', projection='3d', proj_type='ortho')\n"", "" nAtom = posStruc[i].shape[0]\n"", "" colors = plt.cm.rainbow(np.linspace(0, 1, nAtom))\n"", "" for j in range(nAtom):\n"", "" ax.scatter(posStruc[i, j, 0], posStruc[i, j, 1], posStruc[i, j, 2], s = 10, c = colors[j], marker='o')\n"", "" if j > 0:\n"", "" ax.plot([posStruc[i, j-1, 0], posStruc[i, j, 0]], [posStruc[i, j-1, 1], posStruc[i, j, 1]], [posStruc[i, j-1, 2], posStruc[i, j, 2]], color = colors[j], linewidth=2)\n"", "" if j < nAtom - 1:\n"", "" for k in range(j + 1, nAtom):\n"", "" dist = torch.norm(posStruc[i, j] - posStruc[i, k])\n"", "" if dist < 6.0:\n"", "" ax.plot([posStruc[i, j, 0], posStruc[i, k, 0]], [posStruc[i, j, 1], posStruc[i, k, 1]], [posStruc[i, j, 2], posStruc[i, k, 2]], color = plt.cm.Greys(dist / 12.0), linewidth=0.5)\n"", "" ax.grid(False)\n"", "" ax.set_xticks([])\n"", "" ax.set_yticks([])\n"", "" ax.set_zticks([])\n"", "" ax.set_xlim(-10, 10)\n"", "" ax.set_ylim(-10, 10)\n"", "" ax.set_zlim(-10, 10)\n"", "" ax.set_title('Cluster %d'%i)\n"", ""plt.tight_layout()\n"", ""plt.show()\n"", ""\n"", ""## Initial structural ensemble, the origin trajectory file is not included in the data set\n"", ""## We only put the CVs of the structural ensemble here for analysis and visualization of the results\n"", ""## CVs of the structural ensemble where the reference structures are chosen from by clustering\n"", ""rmsdTrajFolded = np.loadtxt(data_directory + 'rmsdStrucFolded.txt')\n"", ""rmsdTrajMisfolded = np.loadtxt(data_directory + 'rmsdStrucMisfolded.txt')\n"", ""\n"", ""## Load the cluster labels and counts\n"", ""filename_cluster_labels = data_directory + 'cluster_labels.txt'\n"", ""cluster_labels = np.loadtxt(filename_cluster_labels, dtype=int)\n"", ""filename_cluster_counts = data_directory + 'cluster_counts.txt'\n"", ""cluster_counts = np.loadtxt(filename_cluster_counts)\n"", ""nCluster = len(cluster_counts)\n"", ""\n"", ""fig = plt.figure(figsize=(15, 6), dpi=100)\n"", ""xbins = np.linspace(0, 10, 100)\n"", ""ybins = np.linspace(0, 10, 100)\n"", ""for i in range(nCluster):\n"", "" ax = fig.add_subplot(2, 5, i+1)\n"", "" hist, xedges, yedges = np.histogram2d(rmsdTrajFolded[cluster_labels == i], rmsdTrajMisfolded[cluster_labels == i], bins=(xbins,ybins), density=True)\n"", "" ax.imshow(hist, cmap='afmhot', origin='lower', extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]], aspect='equal')\n"", "" # ax.axis('off')\n"", "" ax.set_xlabel('RMSD Folded')\n"", "" ax.set_ylabel('RMSD Misfolded')\n"", "" ax.set_title('Cluster %d'%i)\n"", ""plt.tight_layout()\n"", ""plt.show()"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Plotting script for 2D free energy landscape given two collective variables**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 6, ""metadata"": {}, ""outputs"": [], ""source"": [ ""def plot2DFreeEnergy(fig, cv1, cv2, weights = None, \n"", "" nameCV1 = 'CV1', nameCV2 = 'CV2', title = None,\n"", "" cv1Min = 0, cv1Max = 10, cv2Min = 0, cv2Max = 10, \n"", "" n_bin = 50, cmap=cmap_fe, vmin=0, vmax=6, alpha=1.0):\n"", ""\n"", "" xedges = np.linspace(cv1Min, cv1Max, n_bin)\n"", "" yedges = np.linspace(cv2Min, cv2Max, n_bin)\n"", "" \n"", "" if weights is None:\n"", "" H_init, xedges, yedges = np.histogram2d(cv1, cv2, bins=(xedges, yedges), density=True)\n"", "" else:\n"", "" H_init, xedges, yedges = np.histogram2d(cv1, cv2, bins=(xedges, yedges), density=True, weights=weights)\n"", "" \n"", "" y_init = -np.log(H_init)\n"", "" y_init -= np.amin(y_init)\n"", "" y_init[np.isinf(y_init)] = 1e99\n"", ""\n"", "" # Plot the RMSD\n"", "" xa = .5*(xedges[1:]+xedges[:-1])\n"", "" ya = .5*(yedges[1:]+yedges[:-1])\n"", ""\n"", "" ax = fig.add_subplot()\n"", "" ax.set_position([0.14,0.12,0.85*0.8,0.85])\n"", "" ai = ax.imshow(y_init, interpolation='none', origin='lower', cmap=cmap_fe, vmin=vmin, vmax=vmax,\n"", "" extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]], aspect='equal', alpha=alpha)\n"", ""\n"", "" cax = fig.add_subplot()\n"", "" cbar = fig.colorbar(ai, cax=cax, ax=ax)\n"", "" cax.set_position([0.14+0.85*0.8+0.02,0.12,0.05,0.85])\n"", "" cbar.set_label(\""Free Energy\"")\n"", ""\n"", "" ax.set_xlabel(nameCV2)\n"", "" ax.set_ylabel(nameCV1)\n"", ""\n"", "" if title is not None:\n"", "" ax.set_title(title)\n"", ""\n"", "" return ax"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Inspect MD landscape and cluster centers**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 7, ""metadata"": {}, ""outputs"": [ { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""/Users/wtang/Code/git_repo/Ensemble-reweighting-using-Cryo-EM-particles/venv/lib/python3.11/site-packages/MDAnalysis/analysis/align.py:732: DeprecationWarning: The `rmsd` attribute was deprecated in MDAnalysis 2.0.0 and will be removed in MDAnalysis 3.0.0. Please use `results.rmsd` instead.\n"", "" warnings.warn(wmsg, DeprecationWarning)\n"", ""/var/folders/_8/h5rr6k3s2995tzxt8b9sqfgh0000gq/T/ipykernel_24568/59564236.py:14: RuntimeWarning: divide by zero encountered in log\n"", "" y_init = -np.log(H_init)\n"" ] }, { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""## Reference structures of folded and misfolded states for visualizing 2D Free Energy Landscape\n"", ""uStrucFolded = mda.Universe(data_directory + 'folded.pdb')\n"", ""uStrucMisfolded = mda.Universe(data_directory + 'misfolded.pdb')\n"", ""\n"", ""## Ensure center of mass is at origin\n"", ""uStrucFolded.atoms.translate(-uStrucFolded.select_atoms('protein and name CA').center_of_mass())\n"", ""uStrucMisfolded.atoms.translate(-uStrucMisfolded.select_atoms('protein and name CA').center_of_mass())\n"", ""uImage.atoms.translate(-uImage.select_atoms('protein and name CA').center_of_mass())\n"", ""uStruc.atoms.translate(-uStruc.select_atoms('protein and name CA').center_of_mass())\n"", ""\n"", ""## Calculate the RMSD between the first frame of the trajectory and the reference structure\n"", ""rmsdImageFolded = align.AlignTraj(uImage, uStrucFolded, select='protein and name CA', in_memory=True).run().rmsd\n"", ""rmsdImageMisfolded = align.AlignTraj(uImage, uStrucMisfolded, select='protein and name CA', in_memory=True).run().rmsd\n"", ""\n"", ""rmsdStrucFolded = align.AlignTraj(uStruc, uStrucFolded, select='protein and name CA', in_memory=True).run().rmsd\n"", ""rmsdStrucMisfolded = align.AlignTraj(uStruc, uStrucMisfolded, select='protein and name CA', in_memory=True).run().rmsd\n"", ""\n"", ""fig = plt.figure(figsize=(6, 4), dpi=100)\n"", ""ax = plot2DFreeEnergy(fig, rmsdTrajFolded, rmsdTrajMisfolded, nameCV1 = \""RMSD to folded\"", nameCV2 = \""RMSD to misfolded\"", title = \""Initial structural ensemble\"")\n"", ""ax.scatter(rmsdStrucMisfolded, rmsdStrucFolded, s=10, c='g', marker='X', label='Reference structure')\n"", ""for i in range(nStruc):\n"", "" ax.annotate(i, (rmsdStrucMisfolded[i], rmsdStrucFolded[i]), fontsize=12)\n"", ""plt.show()\n"", ""\n"", ""fig = plt.figure(figsize=(6, 4), dpi=100)\n"", ""ax = plot2DFreeEnergy(fig, rmsdImageFolded, rmsdImageMisfolded, nameCV1 = \""RMSD to folded\"", nameCV2 = \""RMSD to misfolded\"", title = \""Synthetic Cryo-EM Data\"")\n"", ""ax.scatter(rmsdStrucMisfolded, rmsdStrucFolded, s=10, c='g', marker='X', label='Reference structure')\n"", ""for i in range(nStruc):\n"", "" ax.annotate(i, (rmsdStrucMisfolded[i], rmsdStrucFolded[i]), xytext=(rmsdStrucMisfolded[i]+0.1, rmsdStrucFolded[i]+0.1), fontsize=12)\n"", ""plt.show()\n"", ""\n"", ""bins = np.linspace(0,10,101)\n"", ""fig = plt.figure(figsize=(6, 4), dpi=100)\n"", ""ax = fig.add_subplot(111)\n"", ""ax.hist(rmsdTrajFolded, bins=bins, alpha=0.5, label='Reference ensemble', density=True)\n"", ""ax.hist(rmsdImageFolded, bins=bins, alpha=0.5, label='Ground truth ensemble', density=True)\n"", ""ax.set_xlabel('RMSD to folded')\n"", ""ax.set_ylabel('Density')\n"", ""ax.set_xlim(0,10)\n"", ""ax.legend()\n"", ""plt.show()\n"", ""\n"", ""fig = plt.figure(figsize=(6, 4), dpi=100)\n"", ""ax = fig.add_subplot(111)\n"", ""ax.hist(rmsdTrajMisfolded, bins=bins, alpha=0.5, label='Reference ensemble', density=True)\n"", ""ax.hist(rmsdImageMisfolded, bins=bins, alpha=0.5, label='Ground truth ensemble', density=True)\n"", ""ax.set_xlabel('RMSD to misfolded')\n"", ""ax.set_ylabel('Density')\n"", ""ax.set_xlim(0,10)\n"", ""ax.legend()\n"", ""plt.show()"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# 2. Likelihood Calculation\n"", ""\n"", ""In the cryoER posterior $p(\\alpha|y)$\n"", ""$$\n"", "" p(\\alpha|y)\\propto (2 \\pi \\lambda^2)^{-N_\\mathrm{pix}/2} \\prod_{i=1}^{N_{\\mathrm{image}}} \\sum_{m=1}^{N_{\\mathrm{clust}}} \\exp\\left[-\\frac{||y_i-F(x_m)||^2}{2\\lambda^2}\\right] \\cdot (\\alpha_m N_m),\n"", ""$$\n"", ""we evaluate the likelihood $p(y_i|x_m)$ before sampling the posterior for $\\alpha_m$ using MCMC. To evalulate the likelihood, we need the noise standard deviation $\\lambda$ and the image-structure distance $||y_i-F(x_m)||^2$. To do os, we approximate $\\lambda$ by calculating the noise standard deviation in the templates given the SNR level. We then calculate the image-structure distance $||y_i-F(x_m)||^2$ by evaluating the l2-distance between the cryo-EM image and the 'template' generated from the reference structure using the forward model and pose parameters."" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Align MD clusters to reference map**\n"", ""\n"", ""This step calculates the rotational matrix that aligns each structure to the reference, i.e. the reference map that generated the synthetic images. This means that we have knowledge of the pose each images associated. For non-synthetic data, this step would be replaced by pose estimation and then alignement of cluster centers to the reference."" ] }, { ""cell_type"": ""code"", ""execution_count"": 8, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Calculating rotation matrices...\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""100%|██████████| 1/1 [00:00<00:00, 12.64it/s]"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Done!\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""\n"" ] } ], ""source"": [ ""rot_mats_align = align_traj(\n"", "" top_image = data_directory + 'image.pdb',\n"", "" traj_image = data_directory + 'image.xtc',\n"", "" top_struc = data_directory + 'struc.pdb',\n"", "" traj_struc = data_directory + 'struc.xtc',\n"", "" outdir = output_directory,\n"", "" device = device\n"", "")\n"", ""## The command line equivalent of the code:\n"", ""# os.system(\""python3 -m cryoER.align_traj \\\n"", ""# --top_image data_directoryimage.pdb \\\n"", ""# --traj_image data_directoryimage.xtc \\\n"", ""# --top_struc data_directorystruc.pdb \\\n"", ""# --traj_struc data_directorystruc.xtc \\\n"", ""# --outdir %s \\\n"", ""# --device %s\""%(output_directory, device))"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""We approximate $\\lambda$ by calculating the noise standard deviation in the templates given the SNR level. Here, we assume that all images have the same $\\lambda$. Note that this might not be the case for real images. "" ] }, { ""cell_type"": ""code"", ""execution_count"": 9, ""metadata"": {}, ""outputs"": [ { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""Generating images for batch: 100%|██████████| 100/100 [00:00<00:00, 125.40it/s]"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Approximated lambda at SNR 1.0e+00: 1.072e-03\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""\n"" ] } ], ""source"": [ ""lmbd = approx_lmbd(\n"", "" top_struc = data_directory + 'struc.pdb',\n"", "" traj_struc = data_directory + 'struc.xtc',\n"", "" n_pixel = n_pixel,\n"", "" pixel_size = pixel_size,\n"", "" sigma = sigma,\n"", "" signal_to_noise_ratio = snr,\n"", "" add_ctf = True,\n"", "" defocus_min = defocus_min,\n"", "" defocus_max = defocus_max,\n"", "" n_image_per_struc = 100,\n"", "" n_batch = 10,\n"", "" device = device\n"", "")\n"", ""print(\""Approximated lambda at SNR %.1e: %.3e\"" % (snr, lmbd))\n"", ""\n"", ""## The command line equivalent of the code:\n"", ""# os.system(\""python3 -m cryoER.approx_lmbd \\\n"", ""# --top_struc data_directorystruc.pdb \\\n"", ""# --traj_struc data_directorystruc.xtc \\\n"", ""# --n_pixel %d \\\n"", ""# --pixel_size %.1f \\\n"", ""# --sigma %.1f \\\n"", ""# --signal_to_noise_ratio %.1f \\\n"", ""# --add_ctf \\\n"", ""# --defocus_min %.3f \\\n"", ""# --defocus_max %.3f \\\n"", ""# --n_image_per_struc 100 \\\n"", ""# --n_batch 1 \\\n"", ""# --device cuda\"" % (n_pixel, pixel_size, sigma, snr, defocus_min, defocus_max))"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Calculate image-structure distance matrix**\n"", ""\n"", ""The image-structure distance $||y_i-F(x_m)||^2$ is calculated using l2-distance between the cryo-EM image and the 'template' generated from the reference structure using the forward model and pose parameters."" ] }, { ""cell_type"": ""code"", ""execution_count"": 10, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Reading trajectory from ../data/struc.pdb and ../data/struc.xtc...\n"", ""Reading struc-images alignment matrices from ./output//rot_mats_struc_image.npy...\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""Computing image-structure distance for structure: 100%|██████████| 10/10 [00:29<00:00, 2.92s/it]"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Saving...\n"", ""Done!\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""\n"" ] } ], ""source"": [ ""diff_mat = calc_image_struc_distance(\n"", "" images = images,\n"", "" ctfs = ctfs,\n"", "" rot_mats_image = rot_mats_image,\n"", "" top_struc = data_directory + 'struc.pdb',\n"", "" traj_struc = data_directory + 'struc.xtc',\n"", "" rotmat_struc_imgstruc = '%s/rot_mats_struc_image.npy'%output_directory,\n"", "" outdir = output_directory,\n"", "" n_pixel = n_pixel,\n"", "" pixel_size = pixel_size,\n"", "" sigma = sigma,\n"", "" snr = snr,\n"", "" add_ctf = True,\n"", "" defocus_min = defocus_min,\n"", "" defocus_max = defocus_max,\n"", "" batch_size = 32\n"", "")\n"", ""## The command line equivalent of the code:\n"", ""# image_filename = '%s/images_npix%d_ps%.2f_s%.1f_snr%.1E.npy' % (output_directory, n_pixel, pixel_size, sigma, snr)\n"", ""# ctfs_filename = '%s/ctfs_npix%d_ps%.2f_s%.1f_snr%.1E.npy' % (output_directory, n_pixel, pixel_size, sigma, snr)\n"", ""# rot_mats_image_filename = '%s/rot_mats_image_npix%d_ps%.2f_s%.1f_snr%.1E.npy' % (output_directory, n_pixel, pixel_size, sigma, snr)\n"", ""# os.system(\""python3 -m cryoER.calc_image_struc_distance \\\n"", ""# --images %s\n"", ""# --ctfs %s\n"", ""# --rot_mats_image %s\n"", ""# --top_struc data_directorystruc.pdb \\\n"", ""# --traj_struc data_directorystruc.xtc \\\n"", ""# --rotmat_struc_imgstruc ./output/rot_mats_struc_image.npy \\\n"", ""# --outdir ./output/ \\\n"", ""# --n_pixel %d \\\n"", ""# --pixel_size %.1f \\\n"", ""# --sigma %.1f \\\n"", ""# --signal_to_noise_ratio %.1f \\\n"", ""# --add_ctf \\\n"", ""# --defocus_min %.3f \\\n"", ""# --defocus_max %.3f \\\n"", ""# --n_batch 1\"" % (image_filename, ctfs_filename, rot_mats_image_filename, \\\n"", ""# n_pixel, pixel_size, sigma, snr, defocus_min, defocus_max))"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Inspect the image-structure distance**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 11, ""metadata"": {}, ""outputs"": [ { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"" ] }, { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""bins = np.linspace(0.0,0.12,101)\n"", ""diff = np.load(output_directory + \""diff_npix%d_ps%.2f_s%.1f_snr%.1E.npy\"" % (n_pixel, pixel_size, sigma, snr))\n"", ""fig = plt.figure(figsize=(8, 6), dpi=100)\n"", ""ax = fig.add_subplot(111)\n"", ""ax.imshow(diff, cmap='afmhot', origin='lower', aspect='auto', interpolation='none',\n"", "" extent=[-0.5, nImage-0.5, -0.5, nCluster-0.5], vmin=0, vmax=0.12)\n"", ""ax.set_yticks(np.arange(nCluster))\n"", ""ax.set_xlabel('Image')\n"", ""ax.set_ylabel('Cluster center')\n"", ""ax.legend(\n"", "" loc='upper right', \n"", "" frameon=False,\n"", "")\n"", ""plt.show()"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Inspect the image-structure distance distribution**"" ] }, { ""cell_type"": ""code"", ""execution_count"": 12, ""metadata"": { ""scrolled"": true }, ""outputs"": [ { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" }, { ""data"": { ""text/plain"": [ """" ] }, ""execution_count"": 12, ""metadata"": {}, ""output_type"": ""execute_result"" }, { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""bins = np.linspace(0.0,0.12,101)\n"", ""diff = np.load(output_directory + \""diff_npix%d_ps%.2f_s%.1f_snr%.1E.npy\"" % (n_pixel, pixel_size, sigma, snr))\n"", ""fig = plt.figure(figsize=(8, 6), dpi=100)\n"", ""ax = fig.add_subplot(111)\n"", ""for i in range(nCluster):\n"", "" hist, edges = np.histogram(diff[i], bins=bins, density=True)\n"", "" ax.plot(edges[:-1], hist, label='Cluster center %d'%i)\n"", ""ax.set_xlim(edges[0], edges[-1])\n"", ""ax.set_ylim(0, 50)\n"", ""ax.set_xlabel('Image-structure distance')\n"", ""ax.set_ylabel('Density')\n"", ""ax.legend(\n"", "" loc='upper right', \n"", "" frameon=False,\n"", "")\n"", ""plt.show()\n"", ""\n"", ""bins = np.linspace(0,55000,101)\n"", ""nll = diff / (2 * lmbd**2)\n"", ""fig = plt.figure(figsize=(8, 6), dpi=100)\n"", ""ax = fig.add_subplot(111)\n"", ""for i in range(nCluster):\n"", "" hist, edges = np.histogram(nll[i], bins=bins, density=True)\n"", "" ax.plot(edges[:-1], hist, label='Cluster center %d'%i)\n"", ""ax.set_xlim(bins[0], bins[-1])\n"", ""# ax.set_ylim(0, 0.00012)\n"", ""ax.set_xlabel('Negative log likelihood')\n"", ""ax.set_ylabel('Density')\n"", ""ax.legend(\n"", "" loc='upper right', \n"", "" frameon=False,\n"", "")"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# 3. Plug everything into the posterior and run MCMC\n"", ""\n"", ""We have gathered all the ingredients, we need to put together the cryoER posterior \n"", ""$$\n"", "" p(\\alpha|y)\\propto (2 \\pi \\lambda^2)^{-N_\\mathrm{pix}/2} \\prod_{i=1}^{N_{\\mathrm{image}}} \\sum_{m=1}^{N_{\\mathrm{clust}}} \\exp\\left[-\\frac{||y_i-F(x_m)||^2}{2\\lambda^2}\\right] \\cdot (\\alpha_m N_m)~.\n"", ""$$\n"", ""Let's start cooking by putting the image-structure distance matrix, the estimated image pixel standard deviation $\\lambda$, and the cluster counts $N_m$ into the MCMC function and sampling the posterior with Stan (the MCMC software)."" ] }, { ""cell_type"": ""code"", ""execution_count"": 13, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Number of structures = 10, Number of images = 5277.\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""15:00:21 - cmdstanpy - INFO - CmdStan start processing\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""{'stan_version_major': '2', 'stan_version_minor': '33', 'stan_version_patch': '0', 'STAN_THREADS': 'true', 'STAN_MPI': 'false', 'STAN_OPENCL': 'false', 'STAN_NO_RANGE_CHECKS': 'false', 'STAN_CPP_OPTIMS': 'false'}\n"", ""method = sample (Default)\n"", ""sample\n"", ""num_samples = 1000 (Default)\n"", ""num_warmup = 100\n"", ""save_warmup = 0 (Default)\n"", ""thin = 1 (Default)\n"", ""adapt\n"", ""engaged = 1 (Default)\n"", ""gamma = 0.050000000000000003 (Default)\n"", ""delta = 0.80000000000000004 (Default)\n"", ""kappa = 0.75 (Default)\n"", ""t0 = 10 (Default)\n"", ""init_buffer = 75 (Default)\n"", ""term_buffer = 50 (Default)\n"", ""window = 25 (Default)\n"", ""algorithm = hmc (Default)\n"", ""hmc\n"", ""engine = nuts (Default)\n"", ""nuts\n"", ""max_depth = 10 (Default)\n"", ""metric = diag_e (Default)\n"", ""metric_file = (Default)\n"", ""stepsize = 1 (Default)\n"", ""stepsize_jitter = 0 (Default)\n"", ""num_chains = 4\n"", ""id = 1 (Default)\n"", ""data\n"", ""file = ././output//Dmat.json\n"", ""init = 2 (Default)\n"", ""random\n"", ""seed = 60518\n"", ""output\n"", ""file = /var/folders/_8/h5rr6k3s2995tzxt8b9sqfgh0000gq/T/tmph0litvrk/cryo-erquzigtdd/cryo-er-20231122150021.csv\n"", ""diagnostic_file = (Default)\n"", ""refresh = 100 (Default)\n"", ""sig_figs = 6\n"", ""profile_file = profile.csv (Default)\n"", ""num_threads = 32 (Default)\n"", ""\n"", ""\n"", ""Gradient evaluation took 0.000522 seconds\n"", ""1000 transitions using 10 leapfrog steps per transition would take 5.22 seconds.\n"", ""Adjust your expectations accordingly!\n"", ""\n"", ""\n"", ""WARNING: There aren't enough warmup iterations to fit the\n"", ""three stages of adaptation as currently configured.\n"", ""Reducing each adaptation stage to 15%/75%/10% of\n"", ""the given number of warmup iterations:\n"", ""init_buffer = 15\n"", ""adapt_window = 75\n"", ""term_buffer = 10\n"", ""\n"", ""\n"", ""Gradient evaluation took 0.000333 seconds\n"", ""1000 transitions using 10 leapfrog steps per transition would take 3.33 seconds.\n"", ""Adjust your expectations accordingly!\n"", ""\n"", ""\n"", ""WARNING: There aren't enough warmup iterations to fit the\n"", ""three stages of adaptation as currently configured.\n"", ""Reducing each adaptation stage to 15%/75%/10% of\n"", ""the given number of warmup iterations:\n"", ""init_buffer = 15\n"", ""adapt_window = 75\n"", ""term_buffer = 10\n"", ""\n"", ""\n"", ""Gradient evaluation took 0.000368 seconds\n"", ""1000 transitions using 10 leapfrog steps per transition would take 3.68 seconds.\n"", ""Adjust your expectations accordingly!\n"", ""\n"", ""\n"", ""WARNING: There aren't enough warmup iterations to fit the\n"", ""three stages of adaptation as currently configured.\n"", ""Reducing each adaptation stage to 15%/75%/10% of\n"", ""the given number of warmup iterations:\n"", ""init_buffer = 15\n"", ""adapt_window = 75\n"", ""term_buffer = 10\n"", ""\n"", ""\n"", ""Gradient evaluation took 0.000288 seconds\n"", ""1000 transitions using 10 leapfrog steps per transition would take 2.88 seconds.\n"", ""Adjust your expectations accordingly!\n"", ""\n"", ""\n"", ""WARNING: There aren't enough warmup iterations to fit the\n"", ""three stages of adaptation as currently configured.\n"", ""Reducing each adaptation stage to 15%/75%/10% of\n"", ""the given number of warmup iterations:\n"", ""init_buffer = 15\n"", ""adapt_window = 75\n"", ""term_buffer = 10\n"", ""\n"", ""Chain [4] Iteration: 1 / 1100 [ 0%] (Warmup)\n"", ""Chain [3] Iteration: 1 / 1100 [ 0%] (Warmup)\n"", ""Chain [1] Iteration: 1 / 1100 [ 0%] (Warmup)\n"", ""Chain [2] Iteration: 1 / 1100 [ 0%] (Warmup)\n"", ""Chain [1] Iteration: 100 / 1100 [ 9%] (Warmup)\n"", ""Chain [1] Iteration: 101 / 1100 [ 9%] (Sampling)\n"", ""Chain [2] Iteration: 100 / 1100 [ 9%] (Warmup)\n"", ""Chain [2] Iteration: 101 / 1100 [ 9%] (Sampling)\n"", ""Chain [4] Iteration: 100 / 1100 [ 9%] (Warmup)\n"", ""Chain [4] Iteration: 101 / 1100 [ 9%] (Sampling)\n"", ""Chain [3] Iteration: 100 / 1100 [ 9%] (Warmup)\n"", ""Chain [3] Iteration: 101 / 1100 [ 9%] (Sampling)\n"", ""Chain [1] Iteration: 200 / 1100 [ 18%] (Sampling)\n"", ""Chain [2] Iteration: 200 / 1100 [ 18%] (Sampling)\n"", ""Chain [4] Iteration: 200 / 1100 [ 18%] (Sampling)\n"", ""Chain [3] Iteration: 200 / 1100 [ 18%] (Sampling)\n"", ""Chain [1] Iteration: 300 / 1100 [ 27%] (Sampling)\n"", ""Chain [2] Iteration: 300 / 1100 [ 27%] (Sampling)\n"", ""Chain [3] Iteration: 300 / 1100 [ 27%] (Sampling)\n"", ""Chain [4] Iteration: 300 / 1100 [ 27%] (Sampling)\n"", ""Chain [1] Iteration: 400 / 1100 [ 36%] (Sampling)\n"", ""Chain [2] Iteration: 400 / 1100 [ 36%] (Sampling)\n"", ""Chain [3] Iteration: 400 / 1100 [ 36%] (Sampling)\n"", ""Chain [4] Iteration: 400 / 1100 [ 36%] (Sampling)\n"", ""Chain [1] Iteration: 500 / 1100 [ 45%] (Sampling)\n"", ""Chain [2] Iteration: 500 / 1100 [ 45%] (Sampling)\n"", ""Chain [3] Iteration: 500 / 1100 [ 45%] (Sampling)\n"", ""Chain [4] Iteration: 500 / 1100 [ 45%] (Sampling)\n"", ""Chain [1] Iteration: 600 / 1100 [ 54%] (Sampling)\n"", ""Chain [2] Iteration: 600 / 1100 [ 54%] (Sampling)\n"", ""Chain [3] Iteration: 600 / 1100 [ 54%] (Sampling)\n"", ""Chain [4] Iteration: 600 / 1100 [ 54%] (Sampling)\n"", ""Chain [1] Iteration: 700 / 1100 [ 63%] (Sampling)\n"", ""Chain [2] Iteration: 700 / 1100 [ 63%] (Sampling)\n"", ""Chain [3] Iteration: 700 / 1100 [ 63%] (Sampling)\n"", ""Chain [4] Iteration: 700 / 1100 [ 63%] (Sampling)\n"", ""Chain [1] Iteration: 800 / 1100 [ 72%] (Sampling)\n"", ""Chain [2] Iteration: 800 / 1100 [ 72%] (Sampling)\n"", ""Chain [3] Iteration: 800 / 1100 [ 72%] (Sampling)\n"", ""Chain [4] Iteration: 800 / 1100 [ 72%] (Sampling)\n"", ""Chain [1] Iteration: 900 / 1100 [ 81%] (Sampling)\n"", ""Chain [2] Iteration: 900 / 1100 [ 81%] (Sampling)\n"", ""Chain [3] Iteration: 900 / 1100 [ 81%] (Sampling)\n"", ""Chain [4] Iteration: 900 / 1100 [ 81%] (Sampling)\n"", ""Chain [1] Iteration: 1000 / 1100 [ 90%] (Sampling)\n"", ""Chain [3] Iteration: 1000 / 1100 [ 90%] (Sampling)\n"", ""Chain [2] Iteration: 1000 / 1100 [ 90%] (Sampling)\n"", ""Chain [1] Iteration: 1100 / 1100 [100%] (Sampling)\n"", ""\n"", ""Elapsed Time: 9.074 seconds (Warm-up)\n"", ""89.449 seconds (Sampling)\n"", ""98.523 seconds (Total)\n"", ""\n"", ""Chain [4] Iteration: 1000 / 1100 [ 90%] (Sampling)\n"", ""Chain [2] Iteration: 1100 / 1100 [100%] (Sampling)\n"", ""\n"", ""Elapsed Time: 9.995 seconds (Warm-up)\n"", ""92.054 seconds (Sampling)\n"", ""102.049 seconds (Total)\n"", ""\n"", ""Chain [3] Iteration: 1100 / 1100 [100%] (Sampling)\n"", ""\n"", ""Elapsed Time: 10.942 seconds (Warm-up)\n"", ""91.382 seconds (Sampling)\n"", ""102.324 seconds (Total)\n"", ""\n"" ] }, { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""15:02:05 - cmdstanpy - INFO - CmdStan done processing\n"" ] }, { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""Chain [4] Iteration: 1100 / 1100 [100%] (Sampling)\n"", ""\n"", ""Elapsed Time: 10.526 seconds (Warm-up)\n"", ""93.652 seconds (Sampling)\n"", ""104.178 seconds (Total)\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""\n"", ""Done!\n"" ] } ], ""source"": [ ""os.system(\""rm -rf %s/Stan_output/*\""%output_directory) ## remove the stan output from previous runs\n"", ""\n"", ""n_MCMC_chains = 4\n"", ""n_MCMC_warmup = 100\n"", ""n_MCMC_iter = 1000\n"", ""\n"", ""run_cryoER_mcmc(\n"", "" infileclustersize = filename_cluster_counts,\n"", "" infileimagedistance = ['%s/diff_npix%d_ps%.2f_s%.1f_snr%.1E.npy' % (output_directory, n_pixel, pixel_size, sigma, snr)],\n"", "" outdir = output_directory,\n"", "" lmbd = lmbd,\n"", "" chains = n_MCMC_chains,\n"", "" iter_warmup = n_MCMC_warmup,\n"", "" iter_sampling = n_MCMC_iter,\n"", "" parallel_chains = 4,\n"", "" threads_per_chain = 8\n"", "")\n"", ""## The command line equivalent of the code:\n"", ""# os.system(\"" python3 -m cryoER.run_cryoER_mcmc \\\n"", ""# --infileclustersize %s \\\n"", ""# --infileimagedistance %s/diff_npix%d_ps%.2f_s%.1f_snr%.1E.npy \\\n"", ""# --outdir output/ \\\n"", ""# --lmbd %.1e \\\n"", ""# --chains 4 \\\n"", ""# --iterwarmup 10 \\\n"", ""# --itersample 100 \\\n"", ""# --parallelchain 4 \\\n"", ""# --threadsperchain 8\"" % (filename_cluster_counts, output_directory, n_pixel, pixel_size, sigma, snr, lmbd))"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# 4. Analyze MCMC output\n"", ""\n"", ""We take the output from the MCMC sampling and calculate the average and standard deviation for the reweighting factors $\\{\\alpha_m\\}$. "" ] }, { ""cell_type"": ""code"", ""execution_count"": 19, ""metadata"": {}, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""['cryo-er-20231122150021_1.csv', 'cryo-er-20231122150021_2.csv', 'cryo-er-20231122150021_3.csv', 'cryo-er-20231122150021_4.csv']\n"" ] }, { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""# This function takes the Stan MCMC output and convert to average weights with standard deviation\n"", ""factor_mean_std, rewtprob_mean_std, lp, log_weights_mc_chains = analyze_mcmc(\n"", "" output_directory = output_directory,\n"", "" filename_cluster_counts = filename_cluster_counts,\n"", "")\n"", ""Nm = cluster_counts.astype(float)\n"", ""Nm /= np.sum(Nm)\n"", ""\n"", ""# factor_mean, factor_std = np.loadtxt(output_directory+\""reweighting_factor.txt\"", unpack=True)\n"", ""factor_mean = factor_mean_std[:,0]\n"", ""factor_std = factor_mean_std[:,1]\n"", ""M = len(factor_mean)\n"", ""\n"", ""fig = plt.figure(figsize=(8, 4), dpi=100)\n"", ""ax1 = fig.add_subplot(121)\n"", ""ax1.errorbar(np.arange(M), factor_mean, yerr=factor_std, fmt='o')\n"", ""ax1.set_xlabel(\""Cluster\"")\n"", ""ax1.set_ylabel(r\""Reweighting factor $\\alpha_m$\"")\n"", ""\n"", ""ax1.set_xticks(np.arange(0, M, 1))\n"", ""ax1.set_yticks(np.arange(0,1.01,0.2))\n"", ""ax1.set_xlim(-0.5, M-0.5)\n"", ""ax1.set_ylim(0, 1.0)\n"", ""\n"", ""# rewtprob_mean, rewtprob_std = np.loadtxt(output_directory+\""reweighted_prob.txt\"", unpack=True)\n"", ""rewtprob_mean = rewtprob_mean_std[:,0]\n"", ""rewtprob_std = rewtprob_mean_std[:,1]\n"", ""ax2 = fig.add_subplot(122)\n"", ""ax2.plot(np.arange(M), Nm, 'o', label=r\""Initial $N_m$\"")\n"", ""ax2.errorbar(np.arange(M), rewtprob_mean, yerr=rewtprob_std, fmt='o', label=r\""Reweighted $\\alpha_m N_m$\"")\n"", ""ax2.set_xlabel(\""Cluster\"")\n"", ""ax2.set_ylabel(\""Probability\"")\n"", ""ax2.legend(\n"", "" loc='upper left',\n"", "" frameon=False,\n"", "")\n"", ""ax2.set_xticks(np.arange(0, M, 1))\n"", ""ax2.set_yticks(np.arange(0,1.01,0.2))\n"", ""ax2.set_xlim(-0.5, M-0.5)\n"", ""ax2.set_ylim(0, 1.0)\n"", ""\n"", ""plt.show()"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Inspect the MCMC chain samples**\n"", ""\n"", ""This shows the sampled weights for each cluster center of each iteration in the MCMC chain."" ] }, { ""cell_type"": ""code"", ""execution_count"": 15, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""fig = plt.figure(figsize=(8, 6), dpi=100)\n"", ""ax1 = fig.add_subplot(111)\n"", ""for i in range(nCluster):\n"", "" ax1.scatter(range(n_MCMC_iter), np.exp(log_weights_mc_chains[0,:,i]), s = 2, label='Cluster %d'%i)\n"", ""ax1.set_xlim(0, n_MCMC_iter)\n"", ""ax1.set_ylim(0, 0.40)\n"", ""ax1.set_xlabel(\""MCMC iteration (Chain 0)\"")\n"", ""ax1.set_ylabel(r\""weight $\\alpha_m$\"")\n"", ""ax1.legend(\n"", "" bbox_to_anchor=(1.01, 1),\n"", "" frameon=False,\n"", "")\n"", ""plt.show()"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Inspect the log posterior of each MCMC chain**\n"", ""\n"", ""There is nothing interesting for this example, it should be a straight line because the MCMC chains already converged by the end of the warmup phase"" ] }, { ""cell_type"": ""code"", ""execution_count"": 16, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""fig = plt.figure(figsize=(8, 6), dpi=100)\n"", ""ax1 = fig.add_subplot(111)\n"", ""lp_norm = lp - (n_pixel ** 2 / 2 * np.log(2 * np.pi * lmbd ** 2)) # properly normalized log posterior\n"", ""for i in range(n_MCMC_chains):\n"", "" ax1.plot(range(n_MCMC_iter), lp_norm[i,:], lw = 2, label='Chain %d'%i)\n"", ""# ax1.set_ylim(np.amin(lp_norm), np.amax(lp_norm))\n"", ""ax1.set_xlim(0, n_MCMC_iter)\n"", ""ax1.set_xlabel(\""MCMC iteration\"")\n"", ""ax1.set_ylabel(\""Log posterior\"")\n"", ""ax1.legend(\n"", "" bbox_to_anchor=(1.01, 1),\n"", "" frameon=False,\n"", "")\n"", ""plt.show()"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Inspect the posterior distribution of log weights sampled by MCMC**\n"", ""\n"", ""A converged set of weights should have a monomodal distribution of posterior samples. Otherwise, one should either increase the MCMC samples (continue doing the sampling), or investigate if there is something wrong with the dataset (is it too noisy?), the structures (indistinguishable from each other?), or the forward model (is the pose / CTF estimation too inaccurate?)."" ] }, { ""cell_type"": ""code"", ""execution_count"": 17, ""metadata"": {}, ""outputs"": [ { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""import corner # pip install corner\n"", ""figure = corner.corner(\n"", "" log_weights_mc_chains.reshape((-1, nCluster)),\n"", "" labels=[r\""log($\\alpha_{%d}$)\""%i for i in range(nCluster)],\n"", "" quantiles=[0.16, 0.5, 0.84], # 1-sigma contours\n"", "" show_titles=True,\n"", "" title_kwargs={\""fontsize\"": 12},\n"", "" label_kwargs={\""fontsize\"": 12},\n"", "" title_fmt='.3f',\n"", "" truth_color='r',\n"", "" hist_kwargs={\""density\"": True},\n"", "" max_n_ticks=3,\n"", "" smooth=1.0\n"", "")"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# 5. Visualize the reweighted FE\n"", ""\n"", ""Now we can use this to reweight the landscape. Recall that $\\alpha_m N_m$ is the probability of cluster $m$. We assume that every MD structure $x_t$ in the same cluster $m$ shares the same probability, i.e. $p(x_t | \\{\\alpha_m\\}) = \\alpha_m N_m / N_m = \\alpha_m$ for $x_t$ in cluster $m$. To reweight the MD landscape, we calculate the probability of each structure $x_t$, which is given by $\\alpha_m$. Therefore, it is as simple as multiplying the reweighting factor $\\alpha_m$ by the ensemble probability of each structure $x_t$ in the MD landscape to obtain the reweighted landscape."" ] }, { ""cell_type"": ""code"", ""execution_count"": 20, ""metadata"": {}, ""outputs"": [ { ""name"": ""stderr"", ""output_type"": ""stream"", ""text"": [ ""/var/folders/_8/h5rr6k3s2995tzxt8b9sqfgh0000gq/T/ipykernel_24568/59564236.py:14: RuntimeWarning: divide by zero encountered in log\n"", "" y_init = -np.log(H_init)\n"" ] }, { ""data"": { ""image/png"": ""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"", ""text/plain"": [ ""
    "" ] }, ""metadata"": {}, ""output_type"": ""display_data"" } ], ""source"": [ ""# Reweighted structural ensemble\n"", ""cluster_labels = np.loadtxt(filename_cluster_labels, dtype=int) # m of each structure x_t\n"", ""weights = np.array(factor_mean)[cluster_labels] # weight \\alpha_t = \\alpha_m\n"", ""fig = plt.figure()\n"", ""ax = plot2DFreeEnergy(fig, rmsdTrajFolded, rmsdTrajMisfolded, weights = weights, nameCV1 = \""RMSD to folded\"", nameCV2 = \""RMSD to misfolded\"", title = \""Reweighted structural ensemble\"")\n"", ""ax.scatter(rmsdStrucMisfolded, rmsdStrucFolded, s=10, c='g', marker='X', label='Reference structure')\n"", ""for i in range(nStruc):\n"", "" ax.annotate(i, (rmsdStrucMisfolded[i], rmsdStrucFolded[i]), fontsize=12)\n"", ""plt.show()"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""**Example script for perform K-Medoids clustering on trajectory**"" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""metadata"": {}, ""outputs"": [], ""source"": [ ""### EXAMPLE ONLY, NOT RUNNABLE HERE, REQUIRES THE LONG TRAJECTORY FILE ###\n"", ""\n"", ""import numpy as np\n"", ""from tqdm import tqdm\n"", ""import numpy as np\n"", ""import time, os\n"", ""import sys\n"", ""\n"", ""### extra modules needed for this part\n"", ""import mdtraj as md\n"", ""import kmedoids\n"", ""###\n"", ""\n"", ""# load the trajectory\n"", ""\n"", ""gro_file = \""struc.gro\""\n"", ""xtc_file = \""struc_whole_traj.xtc\""\n"", ""t = md.load(xtc_file, top=top_file)\n"", ""atom_indices = [a.index for a in t.topology.atoms if a.name == 'CA']\n"", ""\n"", ""# calculate pairwise RMSD\n"", ""distances = np.empty((t.n_frames, t.n_frames), dtype=np.float32)\n"", ""for i in tqdm(range(t.n_frames)): # this is a long calculation!!\n"", "" distances[i,:] = md.rmsd(t, t, i, atom_indices=atom_indices, parallel=True)\n"", ""print('Max pairwise rmsd: %f nm' % np.max(distances))\n"", ""np.save(\""distances_self_pairwise.npy\"", distances)\n"", ""\n"", ""# perform k-medoids clustering\n"", ""nCluster = 10\n"", ""c = kmedoids.fasterpam(distances, nCluster)\n"", ""labels = c.labels\n"", ""medoids = c.medoids\n"", ""unique, counts = np.unique(labels, return_counts=True)\n"", ""\n"", ""np.savetxt(\""cluster_labels.txt\"", labels, fmt=\""%d\"") # save the cluster labels for each frame in the trajectory\n"", ""np.savetxt(\""cluster_medoids.txt\"", medoids, fmt=\""%d\"") # save the medoids as frame numbers in the trajectory\n"", ""np.savetxt(\""cluster_counts.txt\"", counts, fmt=\""%d\"") # save the number of members in each cluster"" ] }, { ""cell_type"": ""code"", ""execution_count"": null, ""metadata"": {}, ""outputs"": [], ""source"": [] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""venv"", ""language"": ""python"", ""name"": ""python3"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 3 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython3"", ""version"": ""3.11.6"" } }, ""nbformat"": 4, ""nbformat_minor"": 2 } ","Unknown" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","tests/plot_weights.py",".py","1985","64","import numpy as np from matplotlib import pyplot as plt import matplotlib as mpl mpl.rcParams['font.family'] = 'serif' mpl.rcParams['font.size'] = 18 N_center = 50 filename_nm = 'Test_Sep2023/nm.txt' output_name = 'Test_NotUni' output_directory = './output_%s/'%output_name key = ""Test_uniform_random_lik_1e6_s1_N100000"" title = key nm = np.loadtxt(""%s/nm.txt""%key) weights_mean, weights_std = np.loadtxt(""%s/weights_am.txt""%key, unpack=True) # output_directory = ""./Test_Sep2023/realikeli_script/"" # nm = np.loadtxt(""Test_Sep2023/nm.txt"") # nm /= np.sum(nm) # weights_mean, weights_std = np.loadtxt(""Test_Sep2023/realikeli_script/weights_am_LogLikeMat.txt"", unpack=True) # title = ""LogLikeMat_realikeli_script"" M = len(weights_mean) fig = plt.figure(figsize=(8,6)) ax = fig.add_subplot(111) ax.errorbar(np.arange(M), weights_mean, yerr=weights_std, fmt='o', label=""amNm"") ax.set_xlabel(""Model"") ax.set_ylabel(""a_m"") ax.set_title(title) ax.set_xticks(np.arange(0,M,5)) # ax.set_yticks(np.arange(0,0.21,0.05)) ax.set_xlim(-0.5, M-0.5) # ax.set_ylim(0, 0.4) plt.tight_layout() plt.savefig(""%s/weights_am.png""%key, dpi=300) # plt.savefig(""Test_Sep2023/realikeli_script/weights_am_LogLikeMat.png"", dpi=300) weights_mean, weights_std = np.loadtxt(""%s/weights_amnm.txt""%key, unpack=True) # weights_mean, weights_std = np.loadtxt(""Test_Sep2023/realikeli_script/weights_amnm_LogLikeMat.txt"", unpack=True) fig = plt.figure(figsize=(8,6)) ax = fig.add_subplot(111) ax.plot(np.arange(M)+0.1, nm, 'o', label=""Nm"") ax.errorbar(np.arange(M)-0.1, weights_mean, yerr=weights_std, fmt='o', label=""amNm"") ax.set_xlabel(""Model"") ax.set_ylabel(""Weight"") ax.set_title(title) ax.legend( loc='upper left', frameon=False, ) ax.set_xticks(np.arange(0,M,5)) ax.set_yticks(np.arange(0,0.21,0.05)) ax.set_xlim(-0.5, M-0.5) ax.set_ylim(0, 0.2) plt.tight_layout() plt.savefig(""%s/weights_amnm.png""%key, dpi=300) # plt.savefig(""Test_Sep2023/realikeli_script/weights_amnm_LogLikeMat.png"", dpi=300) ","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","tests/calc_weights.py",".py","1583","59","#!/usr/bin/env python import numpy as np import os, sys import csv from scipy.special import logsumexp N_center = 50 filename_nm = 'Test_Sep2023/nm.txt' output_name = 'Test_LogLikeMat' output_directory = './output_%s/'%output_name stan_directory = output_directory + 'stan_output/' nm = np.loadtxt(filename_nm) log_weights = [] lp = [] files = sorted(os.listdir(stan_directory)) print(files) nm /= np.sum(nm) log_nm = np.log(nm) log_weights_d = np.zeros((8,10000,N_center), dtype=float) i = 0 for file in files: log_weights_chain = [] # print(file) with open('%s/%s'%(stan_directory, file), newline='') as csvfile: reader = csv.DictReader(filter(lambda row: row[0]!='#', csvfile), ) for row in reader: log_weights_row = [float(row[""log_weights.%d""%i]) for i in range(1,N_center+1)] log_weights_chain.append(log_weights_row) log_weights = np.array(log_weights_chain) log_weights_d[i,:,:] = log_weights i += 1 # log_weights_d = log_weights_d[:,5000:,:] log_am = log_weights_d - logsumexp(log_weights_d, axis=2)[:,:,None] am = np.exp(log_am) am_mean = am.mean((0,1)) am_std = am.std((0,1)) am_mean_std = np.vstack((am_mean, am_std)).T np.savetxt(output_directory+""weights_am.txt"", am_mean_std, fmt='%.6f') log_amnm = log_weights_d + log_nm[None,None,:] log_amnm -= logsumexp(log_amnm, axis=2)[:,:,None] amnm = np.exp(log_amnm) amnm_mean = amnm.mean((0,1)) amnm_std = amnm.std((0,1)) amnm_mean_std = np.vstack((amnm_mean, amnm_std)).T np.savetxt(output_directory+""weights_amnm.txt"", amnm_mean_std, fmt='%.6f') ","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","tests/run_stan.py",".py","1637","76","import os, sys from cmdstanpy import cmdstan_path, CmdStanModel from scipy.special import logsumexp import numpy as np import json import multiprocessing print(multiprocessing.cpu_count()) filename_nm = 'Test_Sep2023/nm.txt' filename_loglik = 'Test_Sep2023/NotUni-LogLikeMat' output_name = 'Test_NotUni' Nm = np.loadtxt(filename_nm) Nm /= np.sum(Nm) log_lik_mat = np.loadtxt(filename_loglik) log_lik_mat = np.array(log_lik_mat) print(Nm.shape) print(log_lik_mat.shape) out_directory = './output_%s/'%output_name try: os.mkdir(out_directory) except: pass stan_output = out_directory + 'stan_output/' try: os.mkdir(stan_output) except: pass json_filename = out_directory + 'stan_input.json' M = log_lik_mat.shape[1] # Number of model N = log_lik_mat.shape[0] # Number of images log_Nm = np.log(Nm) Dmat = log_lik_mat dictionary = { ""M"": M, ""N"": N, ""logNm"": list(log_Nm), ""Dmat"": [list(a) for a in Dmat] } json_object = json.dumps(dictionary, indent=4) with open(json_filename, ""w"") as f: f.write(json_object) f.close() my_stanfile = os.path.join('.', 'cryo-er.stan') # my_stanfile = os.path.join('.', 'cryo-er.stan') my_model = CmdStanModel(stan_file=my_stanfile, cpp_options={""STAN_THREADS"": True, # ""STAN_MPI"": True, # ""CXX"": ""mpicxx"", # ""TBB_CXX_TYPE"": ""gcc"", }, # compile='force', ) print(my_model.exe_info()) fit = my_model.sample(data=json_filename, chains=8, sig_figs=12, parallel_chains=8, threads_per_chain=4, iter_warmup=1000, iter_sampling=10000, show_console=True, ) fit.save_csvfiles(dir=stan_output)","Python" "Conformation","flatironinstitute/Ensemble-reweighting-using-Cryo-EM-particles","tests/plot_fe_2d.py",".py","3081","89","# Example script to plot 2D free energy surface with and without reweighting # This projects the weights of 10 representative structures back to the original MD trajectory with 120 thousand frames # The 2D free energy surface is visualized on the two CVs of choice import numpy as np from matplotlib import pyplot as plt import matplotlib as mpl mpl.rcParams['font.family'] = 'sans-serif' mpl.rcParams['axes.titlesize'] = 24 mpl.rcParams['axes.labelsize'] = 20 mpl.rcParams['lines.linewidth'] = 3 mpl.rcParams['lines.markersize'] = 10 mpl.rcParams['xtick.labelsize'] = 24 mpl.rcParams['ytick.labelsize'] = 24 cmap_fe = 'afmhot' _, cv1, cv2, cluster_labels = np.loadtxt(""Test_Sep2023/frame-cvs-clusternum"", dtype = float, unpack = True) cluster_labels = cluster_labels.astype(int)-1 # I assume the cluster labels are 1-indexed weights_cluster = np.loadtxt(""output_Test_NotUni/weights_am.txt"", dtype = float, usecols = 0) weights = weights_cluster[cluster_labels] n_bin = 50 # xedges = np.linspace(0, 10, 101) # yedges = np.linspace(0, 10, 101) H_init, xedges, yedges = np.histogram2d(cv1, cv2, bins=n_bin, density=True) y_init = -np.log(H_init) y_init -= np.amin(y_init) y_init[np.isinf(y_init)] = np.amax(y_init[np.isfinite(y_init)]) H_rewt, xedges, yedges = np.histogram2d(cv1, cv2, bins=(xedges, yedges), weights = weights, density=True) y_rewt = -np.log(H_rewt) y_rewt -= np.amin(y_rewt) y_rewt[np.isinf(y_rewt)] = np.amax(y_rewt[np.isfinite(y_rewt)]) xa = .5*(xedges[1:]+xedges[:-1]) ya = .5*(yedges[1:]+yedges[:-1]) fig = plt.figure(figsize=(10, 8)) ax = fig.add_subplot() ax.set_position([0.14,0.12,0.85*0.8,0.85]) ai = ax.imshow(y_init, interpolation='none', origin='lower', cmap=cmap_fe, #vmin=0, vmax=5, aspect='auto', extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]]) cax = fig.add_subplot() cbar = fig.colorbar(ai, cax=cax, ax=ax) cax.set_position([0.14+0.85*0.8+0.02,0.12,0.05,0.85]) cbar.set_label(""Initial Free Energy"",fontsize=30) # ax.text(.02, .98, ""Structure"", fontsize=30, ha='left', va='top', transform=ax.transAxes) # ax.set_xticks(np.arange(0,11,2)) # ax.set_yticks(np.arange(0,11,2)) # ax.set_xlim(0,10) # ax.set_ylim(0,10) ax.set_xlabel(""CV1"", fontsize=30) ax.set_ylabel(""CV2"", fontsize=30) plt.savefig(""output_Test_NotUni/fe_init.png"", dpi=300) plt.close() fig = plt.figure(figsize=(10, 8)) ax = fig.add_subplot() ax.set_position([0.14,0.12,0.85*0.8,0.85]) ai = ax.imshow(y_rewt, interpolation='none', origin='lower', cmap=cmap_fe, #vmin=0, vmax=5, aspect='auto', extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]]) cax = fig.add_subplot() cbar = fig.colorbar(ai, cax=cax, ax=ax) cax.set_position([0.14+0.85*0.8+0.02,0.12,0.05,0.85]) cbar.set_label(""Free Energy"",fontsize=30) # ax.text(.02, .98, ""Structure"", fontsize=30, ha='left', va='top', transform=ax.transAxes) # ax.set_xticks(np.arange(0,11,2)) # ax.set_yticks(np.arange(0,11,2)) # ax.set_xlim(0,10) # ax.set_ylim(0,10) ax.set_xlabel(""CV1"", fontsize=30) ax.set_ylabel(""CV2"", fontsize=30) plt.savefig(""output_Test_NotUni/fe_rewt.png"", dpi=300) plt.close() ","Python" "Conformation","js2264/OHCA","LICENSE.md",".md","1074","22","# MIT License Copyright (c) 2023 Jacques Serizay Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ""Software""), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ","Markdown" "Conformation","Team-SKI/Publications","Profiling_prediction_of_kinase_inhibitors/Build_ABL1_model.ipynb",".ipynb","58783","608","{ ""cells"": [ { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""# Example for building an activity prediction model for the kinase ABL1"" ] }, { ""cell_type"": ""code"", ""execution_count"": 1, ""metadata"": { ""collapsed"": false }, ""outputs"": [], ""source"": [ ""import pandas as pd\n"", ""import numpy as np\n"", ""\n"", ""from rdkit import Chem, DataStructs\n"", ""from rdkit.Chem.Draw import IPythonConsole\n"", ""from rdkit.Chem import PandasTools\n"", ""from rdkit.Chem import AllChem\n"", ""\n"", ""from sklearn.ensemble import RandomForestClassifier\n"", ""from sklearn.cross_validation import StratifiedKFold\n"", ""from imblearn.under_sampling import RandomUnderSampler\n"", ""from sklearn.metrics import recall_score, cohen_kappa_score, roc_auc_score"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""### Helper functions"" ] }, { ""cell_type"": ""code"", ""execution_count"": 2, ""metadata"": { ""collapsed"": false }, ""outputs"": [], ""source"": [ ""class FP:\n"", "" \""\""\""\n"", "" Molecular fingerprint class that packs fingerprints in pandas df\n"", ""\n"", "" Parameters\n"", "" ----------\n"", "" fp : np.array\n"", "" Features stored in numpy array\n"", "" \""\""\""\n"", "" def __init__(self, fp):\n"", "" self.fp = fp\n"", "" def __str__(self):\n"", "" return \""%d bit FP\"" % len(self.fp)\n"", "" def __len__(self):\n"", "" return len(self.fp)\n"", ""\n"", ""def get_fp(mol):\n"", "" \""\""\""\n"", "" Generate concatenated connectivity- and feature-based RDKit Morgan fingerprint\n"", "" with fixed length and radius\n"", "" \n"", "" Parameters\n"", "" ----------\n"", "" mol : ROMol\n"", "" Input molecule\n"", "" \n"", "" Returns\n"", "" -------\n"", "" ML.FP\n"", "" Fingerprint (feature) object\n"", "" \""\""\""\n"", "" info = {}\n"", "" arr = np.zeros((1,))\n"", "" fp = AllChem.GetMorganFingerprintAsBitVect(mol, 4, nBits=4096,\n"", "" useFeatures=False, bitInfo=info)\n"", "" DataStructs.ConvertToNumpyArray(fp, arr)\n"", "" arr = np.array([len(info[x]) if x in info else 0 for x in range(4096)])\n"", "" \n"", "" info2 = {}\n"", "" arr2 = np.zeros((1,))\n"", "" fp2 = AllChem.GetMorganFingerprintAsBitVect(mol, 4, nBits=4096,\n"", "" useFeatures=True, bitInfo=info2)\n"", "" DataStructs.ConvertToNumpyArray(fp2, arr2)\n"", "" arr2 = np.array([len(info2[x]) if x in info2 else 0 for x in range(4096)])\n"", "" \n"", "" fp_out = np.concatenate([arr, arr2])\n"", "" return FP(fp_out)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 3, ""metadata"": { ""collapsed"": true }, ""outputs"": [], ""source"": [ ""def get_binary_class(x, threshold=6.3):\n"", "" \""\""\""\n"", "" For binarization of (pIC50) data. 6.3 corresponds to 500 nM\n"", "" \""\""\""\n"", "" if np.isnan(x):\n"", "" return None\n"", "" elif x < threshold:\n"", "" return 0\n"", "" else:\n"", "" return 1"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""### Data preparation"" ] }, { ""cell_type"": ""code"", ""execution_count"": 4, ""metadata"": { ""collapsed"": true }, ""outputs"": [], ""source"": [ ""df = pd.read_csv(\""ABL1.csv\"", index_col=0)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 5, ""metadata"": { ""collapsed"": false }, ""outputs"": [ { ""data"": { ""text/html"": [ ""
    \n"", ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
    ABL1smiles
    05.599999Brc1ccc2cnc(Nc3ccncn3)cc2c1
    16.199998Brc1cnc2[nH]cc(-c3ccccc3)c2c1
    26.199998C#Cc1cc2c(cc1OC)-c1[nH]nc(-c3ccc(C#N)nc3)c1C2
    35.539102C#Cc1cccc(Nc2ncnc3cc(OC)c(OCCCCCCC(=O)NO)cc23)c1
    45.562959C#Cc1cccc(Nc2ncnc3ccc(OCCCCNCCS(C)(=O)=O)cc23)c1
    \n"", ""
    "" ], ""text/plain"": [ "" ABL1 smiles\n"", ""0 5.599999 Brc1ccc2cnc(Nc3ccncn3)cc2c1\n"", ""1 6.199998 Brc1cnc2[nH]cc(-c3ccccc3)c2c1\n"", ""2 6.199998 C#Cc1cc2c(cc1OC)-c1[nH]nc(-c3ccc(C#N)nc3)c1C2\n"", ""3 5.539102 C#Cc1cccc(Nc2ncnc3cc(OC)c(OCCCCCCC(=O)NO)cc23)c1\n"", ""4 5.562959 C#Cc1cccc(Nc2ncnc3ccc(OCCCCNCCS(C)(=O)=O)cc23)c1"" ] }, ""execution_count"": 5, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""df.head()"" ] }, { ""cell_type"": ""code"", ""execution_count"": 6, ""metadata"": { ""collapsed"": true }, ""outputs"": [], ""source"": [ ""df['ABL1'] = df['ABL1'].astype(float)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Remove lines without compound information (SMILES)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 7, ""metadata"": { ""collapsed"": true }, ""outputs"": [], ""source"": [ ""df = df[~df.smiles.isnull()]"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Build ROMol objects"" ] }, { ""cell_type"": ""code"", ""execution_count"": 8, ""metadata"": { ""collapsed"": true }, ""outputs"": [], ""source"": [ ""PandasTools.AddMoleculeColumnToFrame(df, smilesCol='smiles')"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Remove compounds where molecule object construction failed"" ] }, { ""cell_type"": ""code"", ""execution_count"": 9, ""metadata"": { ""collapsed"": true }, ""outputs"": [], ""source"": [ ""df = df[~df.ROMol.isnull()]"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Remove salts and recreate SMILES"" ] }, { ""cell_type"": ""code"", ""execution_count"": 10, ""metadata"": { ""collapsed"": true }, ""outputs"": [], ""source"": [ ""PandasTools.RemoveSaltsFromFrame(df)\n"", ""df['smiles'] = df['ROMol'].map(Chem.MolToSmiles)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 11, ""metadata"": { ""collapsed"": false }, ""outputs"": [ { ""data"": { ""text/plain"": [ ""(2323, 3)"" ] }, ""execution_count"": 11, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""df.shape"" ] }, { ""cell_type"": ""code"", ""execution_count"": 12, ""metadata"": { ""collapsed"": false }, ""outputs"": [ { ""data"": { ""text/html"": [ ""\n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", "" \n"", ""
    ABL1smilesROMol
    05.599999Brc1ccc2cnc(Nc3ccncn3)cc2c1\""Mol\""/
    16.199998Brc1cnc2[nH]cc(-c3ccccc3)c2c1\""Mol\""/
    "" ], ""text/plain"": [ "" ABL1 smiles ROMol\n"", ""0 5.599999 Brc1ccc2cnc(Nc3ccncn3)cc2c1 \""Mol\""/\n"", ""1 6.199998 Brc1cnc2[nH]cc(-c3ccccc3)c2c1 \""Mol\""/"" ] }, ""execution_count"": 12, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""df.head(2)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Calculate fingerprints and store in data frame"" ] }, { ""cell_type"": ""code"", ""execution_count"": 13, ""metadata"": { ""collapsed"": false }, ""outputs"": [], ""source"": [ ""df['fp'] = df.apply(lambda x: get_fp(x['ROMol']), axis=1)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""### Generation of machine learning models"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Define X variable (fingerprint data)"" ] }, { ""cell_type"": ""code"", ""execution_count"": 14, ""metadata"": { ""collapsed"": false }, ""outputs"": [], ""source"": [ ""X = np.array([x.fp for x in df.fp])"" ] }, { ""cell_type"": ""code"", ""execution_count"": 15, ""metadata"": { ""collapsed"": false }, ""outputs"": [ { ""data"": { ""text/plain"": [ ""(2323, 8192)"" ] }, ""execution_count"": 15, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""X.shape"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Extract target values (y) form data frame and binarize at pIC50 = 6.3"" ] }, { ""cell_type"": ""code"", ""execution_count"": 16, ""metadata"": { ""collapsed"": true }, ""outputs"": [], ""source"": [ ""y = np.array([get_binary_class(yi, threshold=6.3) for yi in df['ABL1'].values])"" ] }, { ""cell_type"": ""code"", ""execution_count"": 17, ""metadata"": { ""collapsed"": false }, ""outputs"": [ { ""data"": { ""text/plain"": [ ""(2323,)"" ] }, ""execution_count"": 17, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""y.shape"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Count actives in data set"" ] }, { ""cell_type"": ""code"", ""execution_count"": 18, ""metadata"": { ""collapsed"": false }, ""outputs"": [ { ""data"": { ""text/plain"": [ ""621"" ] }, ""execution_count"": 18, ""metadata"": {}, ""output_type"": ""execute_result"" } ], ""source"": [ ""sum(y)"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""### Validation: 5-fold cross-validation of random forest classifier"" ] }, { ""cell_type"": ""code"", ""execution_count"": 19, ""metadata"": { ""collapsed"": false }, ""outputs"": [], ""source"": [ ""# Create index arrays for 5-fold cross-validation split\n"", ""kf = StratifiedKFold(y, n_folds=5, shuffle=True, random_state=123)\n"", ""\n"", ""# Initialize variables\n"", ""sens = np.array([])\n"", ""spec = np.array([])\n"", ""mean_auc = np.array([])\n"", ""kappa = np.array([])\n"", ""\n"", ""for train, test in kf:\n"", "" # Split data to training and test set\n"", "" X_train, X_test, y_train, y_test = X[train], X[test], y[train], y[test] \n"", ""\n"", "" # Random undersampling of training set\n"", "" US = RandomUnderSampler(ratio=1., replacement=False)\n"", "" X_train, y_train = US.fit_sample(X_train, y_train)\n"", "" \n"", "" # Random undersampling of test set\n"", "" US = RandomUnderSampler(ratio=1., replacement=False)\n"", "" X_test, y_test = US.fit_sample(X_test, y_test)\n"", "" \n"", "" # Training of random forest classifier\n"", "" clf = RandomForestClassifier(n_estimators=2500, max_features='log2',\n"", "" class_weight='auto', n_jobs=1)\n"", "" clf.fit(X_train, y_train)\n"", "" \n"", "" # Prediction of test set\n"", "" y_pred = clf.predict(X_test)\n"", "" y_pred_proba = clf.predict_proba(X_test).T[1]\n"", "" \n"", "" # Saving validation parameters\n"", "" # Criteria: AUC, sensitiviy, specificity and kappa\n"", "" sens = np.append(sens, recall_score(y_test, y_pred, pos_label=1))\n"", "" spec = np.append(spec, recall_score(y_test, y_pred, pos_label=0))\n"", "" mean_auc = np.append(mean_auc, roc_auc_score(y_test, y_pred_proba))\n"", "" kappa = np.append(kappa, cohen_kappa_score(y_test, y_pred))"" ] }, { ""cell_type"": ""markdown"", ""metadata"": {}, ""source"": [ ""Results of 5-fold cross-validation"" ] }, { ""cell_type"": ""code"", ""execution_count"": 20, ""metadata"": { ""collapsed"": false }, ""outputs"": [ { ""name"": ""stdout"", ""output_type"": ""stream"", ""text"": [ ""AUC:\t\t0.92 +/- 0.02\n"", ""Sensitivity:\t0.78 +/- 0.03\n"", ""Specificity:\t0.88 +/- 0.03\n"", ""Kappa:\t\t0.66 +/- 0.05\n"" ] } ], ""source"": [ ""print 'AUC:\\t\\t%.2f +/- %.2f' % (mean_auc.mean(), mean_auc.std())\n"", ""print 'Sensitivity:\\t%.2f +/- %.2f' % (sens.mean(), sens.std())\n"", ""print 'Specificity:\\t%.2f +/- %.2f' % (spec.mean(), spec.std())\n"", ""print 'Kappa:\\t\\t%.2f +/- %.2f' % (kappa.mean(), kappa.std())"" ] }, { ""cell_type"": ""markdown"", ""metadata"": { ""collapsed"": true }, ""source"": [ ""Copyright (C) 2016 by Benjamin Merget, BioMed X Innovation Center"" ] } ], ""metadata"": { ""kernelspec"": { ""display_name"": ""Python 2"", ""language"": ""python"", ""name"": ""python2"" }, ""language_info"": { ""codemirror_mode"": { ""name"": ""ipython"", ""version"": 2 }, ""file_extension"": "".py"", ""mimetype"": ""text/x-python"", ""name"": ""python"", ""nbconvert_exporter"": ""python"", ""pygments_lexer"": ""ipython2"", ""version"": ""2.7.11"" } }, ""nbformat"": 4, ""nbformat_minor"": 0 } ","Unknown"