From fee50cdf5555538874c51175912f726c4822f969 Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Wed, 18 Sep 2019 11:56:29 -0400 Subject: [PATCH 01/18] ignore pycharm --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index e08538a58..8120d6173 100644 --- a/.gitignore +++ b/.gitignore @@ -98,5 +98,8 @@ ENV/ # mkdocs documentation /site +# pycharm +.idea + # mypy .mypy_cache/ From 143e0674cdefc7dbc4325d6a450eeb6a534e4664 Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Wed, 18 Sep 2019 12:04:01 -0400 Subject: [PATCH 02/18] add utility for generating solvent-solute splitting string --- openmmtools/utils.py | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/openmmtools/utils.py b/openmmtools/utils.py index 4db4cf1e9..b622c03cf 100644 --- a/openmmtools/utils.py +++ b/openmmtools/utils.py @@ -961,6 +961,37 @@ def _compute_class_hash(openmm_class): return float(zlib.adler32(openmm_class.__name__.encode())) +def generate_solvent_solute_splitting_string(base_integrator="VRORV", K_p=1, K_r=3): + """Generate string representing sequence of V0, V1, R, O steps, where: + * force group 1 is assumed to contain fast-changing, cheap-to-evaluate forces, and + * force group 0 is assumed to contain slow-changing, expensive-to-evaluate forces. + + Currently only supports solvent-solute splittings of the VRORV (BAOAB / g-BAOAB) + integrator. + + Parameters + ----------- + base_integrator: string + Currently only supports VRORV + K_p: int + Number of times to evaluate force group 1 per timestep. + K_r: int + Number of inner-loop iterations + + Returns + ------- + splitting_string: string + Sequence of V0, V1, R, O steps, to be passed to LangevinSplittingIntegrator + + TODO: add doctests + """ + assert (base_integrator == "VRORV" or base_integrator == "BAOAB") + Rs = "R " * K_r + inner_loop = "V1 " + Rs + "O " + Rs + "V1 " + s = "V0 " + inner_loop * K_p + "V0" + return s + + if __name__ == '__main__': import doctest doctest.testmod() From 3fe3b6b2b9f59cd9de3a3655faee2ca4c45183e2 Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Wed, 18 Sep 2019 12:13:26 -0400 Subject: [PATCH 03/18] add force factory for solvent-solute-splitting using exceptions --- openmmtools/forcefactories.py | 97 +++++++++++++++++++++++++++++++++++ 1 file changed, 97 insertions(+) diff --git a/openmmtools/forcefactories.py b/openmmtools/forcefactories.py index 3dfece81d..38f9ccf81 100644 --- a/openmmtools/forcefactories.py +++ b/openmmtools/forcefactories.py @@ -174,6 +174,103 @@ def restrain_atoms(thermodynamic_state, sampler_state, restrained_atoms, sigma=3 thermodynamic_state.system = system +from openmmtools.constants import ONE_4PI_EPS0 +default_energy_expression = "(4*epsilon*((sigma/r)^12-(sigma/r)^6) + k * chargeprod/r); sigma=0.5*(sigma1+sigma2); epsilon=sqrt(epsilon1*epsilon2); chargeprod=charge1*charge2; k={};".format(ONE_4PI_EPS0) + + +def clone_nonbonded_parameters(nonbonded_force, energy_expression=default_energy_expression): + """Creates a new CustomNonbonded force with the same global parameters, + per-particle parameters, and exception parameters as """ + + #TODO: assert that nonbonded_force.getNonbondedMethod() indicates reaction field + + # call constructor + new_force = openmm.CustomNonbondedForce(energy_expression) + new_force.addPerParticleParameter('charge') + new_force.addPerParticleParameter('sigma') + new_force.addPerParticleParameter('epsilon') + + # go through all of the setter and getter methods + new_force.setCutoffDistance(nonbonded_force.getCutoffDistance()) + #new_force.setEwaldErrorTolerance(nonbonded_force.getEwaldErrorTolerance()) + #new_force.setForceGroup(nonbonded_force.getForceGroup()) + #new_force.setNonbondedMethod(nonbonded_force.getNonbondedMethod()) # If PME, will be an Illegal value for CustomNonbonded + #new_force.setPMEParameters(*nonbonded_force.getPMEParameters()) + #new_force.setReactionFieldDielectric(nonbonded_force.getReactionFieldDielectric()) + #new_force.setReciprocalSpaceForceGroup(nonbonded_force.getReciprocalSpaceForceGroup()) + new_force.setSwitchingDistance(nonbonded_force.getSwitchingDistance()) + #new_force.setUseDispersionCorrection(nonbonded_force.getUseDispersionCorrection()) + new_force.setUseSwitchingFunction(nonbonded_force.getUseSwitchingFunction()) + + # now add all the particle parameters + num_particles = nonbonded_force.getNumParticles() + for i in range(num_particles): + new_force.addParticle(nonbonded_force.getParticleParameters(i)) + + # now add all the exceptions + # for exception_index in range(nonbonded_force.getNumExceptions()): + # new_force.addException(nonbonded_force.getExceptionParameters(exception_index)) + + # TODO: There's probably a cleaner, more Pythonic way to do this + # (this was the most obvious way, but may not work in the future if the OpenMM API changes) + + return new_force + +from copy import deepcopy +from openmmtools.forces import find_forces + +def split_using_exceptions(system, md_topology): + """Construct a new system where force group 0 contains slow, expensive solvent-solvent + interactions, and force group 1 contains fast, cheaper solute-solute and solute-solvent + interactions. + + TODO: correct this: + Force group 0: default nonbonded force with exceptions for solute-solvent pairs + Force group 1: + * CustomNonbonded force with interaction group for solute-solvent pairs + * non-Nonbonded forces + + TODO: more informative docstring + """ + + # create a copy of the original system: only touch this + new_system = deepcopy(system) + + # find the default nonbonded force + force_index, nb_force = find_forces(new_system, openmm.NonbondedForce, only_one=True) + # assert('Cutoff' in nb_force.getNonbondedMethod()) # TODO: this, less jankily + + # create copies containing + nb_except_solute_solvent = nb_force + nb_only_solute_solvent = clone_nonbonded_parameters(nb_force) + + nb_except_solute_solvent.setForceGroup(0) + + # identify solvent-solute pairs + # find the pairs (i,j) where i in solute, j in solvent + + # NOTE: these need to be python ints -- not np.int64s -- when passing to addInteractionGroup later! + solvent_indices = list(map(int, md_topology.select('water'))) + solute_indices = list(map(int, md_topology.select('not water'))) + + # for each (i,j) set chargeprod, sigma, epsilon to 0, causing these pairs to be omitted completely from force calculation + for i in solvent_indices: + for j in solute_indices: + nb_except_solute_solvent.addException(i, j, 0, 0, 0) + + nb_only_solute_solvent.addInteractionGroup(set1=solute_indices, set2=solvent_indices) + + nb_except_solute_solvent.setForceGroup(0) + nb_only_solute_solvent.setForceGroup(1) + + # handle non-NonbondedForce's + for force in new_system.getForces(): + if 'Nonbonded' not in force.__class__.__name__: + force.setForceGroup(1) + + return new_system + + if __name__ == '__main__': import doctest doctest.testmod() From 40bc8ed6222acca879d35735e6ac0f99be682db3 Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Wed, 18 Sep 2019 12:15:39 -0400 Subject: [PATCH 04/18] [WIP] add example script for g-BAOAB using solvent-solute splitting --- .../gbaoab_with_solvent_solute_splitting.py | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 examples/mts/gbaoab_with_solvent_solute_splitting.py diff --git a/examples/mts/gbaoab_with_solvent_solute_splitting.py b/examples/mts/gbaoab_with_solvent_solute_splitting.py new file mode 100644 index 000000000..4b3ed06da --- /dev/null +++ b/examples/mts/gbaoab_with_solvent_solute_splitting.py @@ -0,0 +1,39 @@ +from openmmtools import testsystems +from openmmtools.forcefactories import split_using_exceptions + +testsystem = testsystems.AlanineDipeptideExplicit() # using PME! should be starting with reaction field + +new_system = split_using_exceptions(testsystem.system, testsystem.mdtraj_topology) + +from simtk.openmm.app import Simulation +from openmmtools.integrators import LangevinIntegrator +from simtk import unit + +collision_rate = 1/unit.picoseconds +#langevin = LangevinIntegrator(splitting='V R O R V', timestep=6 * unit.femtosecond) +mts = LangevinIntegrator(splitting="V0 V1 R R O R R V1 V1 R R O R R V1 V0", collision_rate=collision_rate, timestep=8 * unit.femtosecond) +sim = Simulation(testsystem.topology, new_system, mts) +sim.context.setPositions(testsystem.positions) + +print('minimizing energy') +sim.minimizeEnergy(maxIterations=5) + +print('first step') +sim.step(1) +pos = sim.context.getState(getPositions=True).getPositions(asNumpy=True) +print(pos) + +print('second step') +sim.step(2) +pos = sim.context.getState(getPositions=True).getPositions(asNumpy=True) +print(pos) + +print('next 10 steps') +sim.step(10) +pos = sim.context.getState(getPositions=True).getPositions(asNumpy=True) +print(pos) + +print('next 1000 steps') +sim.step(1000) +pos = sim.context.getState(getPositions=True).getPositions(asNumpy=True) +print(pos) From 00dde8d08e0ae50c91d5d42f24cf46f146d3535e Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Wed, 18 Sep 2019 16:25:09 -0400 Subject: [PATCH 05/18] rename --- examples/mts/gbaoab_with_solvent_solute_splitting.py | 4 ++-- openmmtools/forcefactories.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/examples/mts/gbaoab_with_solvent_solute_splitting.py b/examples/mts/gbaoab_with_solvent_solute_splitting.py index 4b3ed06da..63763292d 100644 --- a/examples/mts/gbaoab_with_solvent_solute_splitting.py +++ b/examples/mts/gbaoab_with_solvent_solute_splitting.py @@ -1,9 +1,9 @@ from openmmtools import testsystems -from openmmtools.forcefactories import split_using_exceptions +from openmmtools.forcefactories import split_nb_using_exceptions testsystem = testsystems.AlanineDipeptideExplicit() # using PME! should be starting with reaction field -new_system = split_using_exceptions(testsystem.system, testsystem.mdtraj_topology) +new_system = split_nb_using_exceptions(testsystem.system, testsystem.mdtraj_topology) from simtk.openmm.app import Simulation from openmmtools.integrators import LangevinIntegrator diff --git a/openmmtools/forcefactories.py b/openmmtools/forcefactories.py index 38f9ccf81..d7a4f4a07 100644 --- a/openmmtools/forcefactories.py +++ b/openmmtools/forcefactories.py @@ -219,7 +219,7 @@ def clone_nonbonded_parameters(nonbonded_force, energy_expression=default_energy from copy import deepcopy from openmmtools.forces import find_forces -def split_using_exceptions(system, md_topology): +def split_nb_using_exceptions(system, md_topology): """Construct a new system where force group 0 contains slow, expensive solvent-solvent interactions, and force group 1 contains fast, cheaper solute-solute and solute-solvent interactions. From 1d803c39167d28a0c065627041aa37b1ae151233 Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Wed, 18 Sep 2019 16:26:44 -0400 Subject: [PATCH 06/18] another attempt to split nonbonded force using subtraction --- openmmtools/forcefactories.py | 67 +++++++++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) diff --git a/openmmtools/forcefactories.py b/openmmtools/forcefactories.py index d7a4f4a07..b25cc1a86 100644 --- a/openmmtools/forcefactories.py +++ b/openmmtools/forcefactories.py @@ -271,6 +271,73 @@ def split_nb_using_exceptions(system, md_topology): return new_system + +# surrogate could deviate in functional form from the NonbondedForce defaults (e.g. using soft-core) +surrogate_energy_expression = default_energy_expression +half_surrogate_energy_expression = '0.5*' + surrogate_energy_expression +minus_surrogate_energy_expression = '-' + surrogate_energy_expression +minus_half_surrogate_energy_expression = '-' + half_surrogate_energy_expression + +# TODO: different energy expressions for protein-protein and protein-solvent interactions? + +from copy import deepcopy +def split_nb_using_subtraction(system, md_topology, + cutoff=10.0 * unit.angstrom # TODO: use the cutoff! + ): + """ + Force group 0: default NonbondedForce minus surrogate + Force group 1: surrogate + non-Nonbonded""" + + new_system = deepcopy(system) + + + # find the default nonbonded force + force_index, force = find_forces(new_system, openmm.NonbondedForce, only_one=True) + force.setForceGroup(0) + + # find atom indices for solvent, atom indices for solute + # NOTE: these need to be python ints -- not np.int64s -- when passing to addInteractionGroup later! + solvent_indices = list(map(int, md_topology.select('water'))) + solute_indices = list(map(int, md_topology.select('not water'))) + # TODO: handle counterions + + # TODO: smooth cutoff, and check how bad this is with very small cutoff (setUseSwitchingFunction(True) + # TODO: soft-core LJ or other variants (maybe think about playing with effective vdW radii? + + # define surrogate forces that need to be added + protein_protein_force = clone_nonbonded_parameters(force, half_surrogate_energy_expression) + protein_solvent_force = clone_nonbonded_parameters(force, surrogate_energy_expression) + + # define surrogate forces that need to be subtracted + minus_protein_protein_force = clone_nonbonded_parameters(force, minus_half_surrogate_energy_expression) + minus_protein_solvent_force = clone_nonbonded_parameters(force, minus_surrogate_energy_expression) + + # add forces to new_system + for new_force in [protein_protein_force, protein_solvent_force, minus_protein_protein_force, minus_protein_solvent_force]: + new_system.addForce(new_force) + + # set interaction groups + protein_protein_force.addInteractionGroup(set1=solute_indices, set2=solute_indices) + protein_solvent_force.addInteractionGroup(set1=solute_indices, set2=solvent_indices) + + minus_protein_protein_force.addInteractionGroup(set1=solute_indices, set2=solute_indices) + minus_protein_solvent_force.addInteractionGroup(set1=solute_indices, set2=solvent_indices) + + # set force groups + minus_protein_protein_force.setForceGroup(0) + minus_protein_solvent_force.setForceGroup(0) + + protein_protein_force.setForceGroup(1) + protein_solvent_force.setForceGroup(1) + + # handle non-NonbondedForce's + for force in new_system.getForces(): + if 'Nonbonded' not in force.__class__.__name__: + force.setForceGroup(1) + + return new_system + + if __name__ == '__main__': import doctest doctest.testmod() From b503ebf365770265c816f9d32388ed1c022f81c7 Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Fri, 20 Sep 2019 08:11:28 -0400 Subject: [PATCH 07/18] add tests (currently failing!) test_split_nb_using_exceptions is failing with: Exception: Maximum allowable relative force error exceeded (was 0.02369251; allowed 0.00000100). test_split_nb_using_subtraction is failing with: Exception: Maximum allowable relative force error exceeded (was 0.00001687; allowed 0.00000100) --- openmmtools/tests/test_forcefactories.py | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/openmmtools/tests/test_forcefactories.py b/openmmtools/tests/test_forcefactories.py index ed4bbbdcd..5831d941a 100644 --- a/openmmtools/tests/test_forcefactories.py +++ b/openmmtools/tests/test_forcefactories.py @@ -196,3 +196,25 @@ def test_replace_reaction_field(): name=test_name, platform=platform) f.description = "Testing replace_reaction_field on system {} with shifted=True".format(test_name) yield f + + +def check_force_group_decomposition_valid(testsystem, force_group_splitter): + """force_group_splitter(system, md_topology) returns a copy of system that + splits system's forces in some convenient way. + + Check that the copy describes the same system overall, by checking whether it + produces identical forces as the original on a slightly randomized configuration. + """ + new_system = force_group_splitter(testsystem.system, testsystem.mdtraj_topology) + positions = generate_new_positions(testsystem.system, testsystem.positions, nsteps=5) + compare_system_forces(testsystem.system, new_system, positions) + + +def test_split_nb_using_exceptions(): + testsystem = testsystems.AlanineDipeptideExplicit() + check_force_group_decomposition_valid(testsystem, split_nb_using_exceptions) + + +def test_split_nb_using_subtraction(): + testsystem = testsystems.AlanineDipeptideExplicit() + check_force_group_decomposition_valid(testsystem, split_nb_using_subtraction) From a380cf17603c40d5cc5543e5d6846000bbcf3dd8 Mon Sep 17 00:00:00 2001 From: c-matthews Date: Wed, 25 Sep 2019 05:09:19 -0400 Subject: [PATCH 08/18] Modified split_nb_using_exceptions The fn split_nb_using_exceptions now works as intended, to split into protein/solvent forces. --- openmmtools/forcefactories.py | 45 ++++++++++++++++++++++------------- 1 file changed, 29 insertions(+), 16 deletions(-) diff --git a/openmmtools/forcefactories.py b/openmmtools/forcefactories.py index b25cc1a86..1a90bd584 100644 --- a/openmmtools/forcefactories.py +++ b/openmmtools/forcefactories.py @@ -178,14 +178,17 @@ def restrain_atoms(thermodynamic_state, sampler_state, restrained_atoms, sigma=3 default_energy_expression = "(4*epsilon*((sigma/r)^12-(sigma/r)^6) + k * chargeprod/r); sigma=0.5*(sigma1+sigma2); epsilon=sqrt(epsilon1*epsilon2); chargeprod=charge1*charge2; k={};".format(ONE_4PI_EPS0) -def clone_nonbonded_parameters(nonbonded_force, energy_expression=default_energy_expression): +def clone_nonbonded_parameters(nonbonded_force, + energy_expression=default_energy_expression, + energy_prefactor=''): """Creates a new CustomNonbonded force with the same global parameters, per-particle parameters, and exception parameters as """ #TODO: assert that nonbonded_force.getNonbondedMethod() indicates reaction field # call constructor - new_force = openmm.CustomNonbondedForce(energy_expression) + # The 'energy_prefactor' allows us to easily change sign, or e.g. halve the energy if needed + new_force = openmm.CustomNonbondedForce(energy_prefactor+energy_expression) new_force.addPerParticleParameter('charge') new_force.addPerParticleParameter('sigma') new_force.addPerParticleParameter('epsilon') @@ -225,9 +228,9 @@ def split_nb_using_exceptions(system, md_topology): interactions. TODO: correct this: - Force group 0: default nonbonded force with exceptions for solute-solvent pairs + Force group 0: default nonbonded force with exceptions for solute-{solute,solvent} pairs Force group 1: - * CustomNonbonded force with interaction group for solute-solvent pairs + * CustomNonbonded force with interaction group for solute-{solute,solvent} pairs * non-Nonbonded forces TODO: more informative docstring @@ -240,11 +243,10 @@ def split_nb_using_exceptions(system, md_topology): force_index, nb_force = find_forces(new_system, openmm.NonbondedForce, only_one=True) # assert('Cutoff' in nb_force.getNonbondedMethod()) # TODO: this, less jankily - # create copies containing - nb_except_solute_solvent = nb_force - nb_only_solute_solvent = clone_nonbonded_parameters(nb_force) - - nb_except_solute_solvent.setForceGroup(0) + # create copies for each interaction. Only half in solute/solute as we double count. + nb_only_solvent_solvent = nb_force + nb_only_solvent_solute = clone_nonbonded_parameters(nb_force) + nb_only_solute_solute = clone_nonbonded_parameters(nb_force,energy_prefactor='0.5*') # identify solvent-solute pairs # find the pairs (i,j) where i in solute, j in solvent @@ -254,15 +256,26 @@ def split_nb_using_exceptions(system, md_topology): solute_indices = list(map(int, md_topology.select('not water'))) # for each (i,j) set chargeprod, sigma, epsilon to 0, causing these pairs to be omitted completely from force calculation + # Remove solute-solute interactions + for i in solute_indices: + for j in solute_indices: + nb_only_solvent_solvent.addException(i, j, 0, 0, 0, replace=True) + + # Remove solvent-solute interactions for i in solvent_indices: for j in solute_indices: - nb_except_solute_solvent.addException(i, j, 0, 0, 0) - - nb_only_solute_solvent.addInteractionGroup(set1=solute_indices, set2=solvent_indices) - - nb_except_solute_solvent.setForceGroup(0) - nb_only_solute_solvent.setForceGroup(1) - + nb_only_solvent_solvent.addException(i, j, 0, 0, 0,replace=True) + + + # Add appropriate interaction groups + nb_only_solvent_solute.addInteractionGroup(set1=solute_indices, set2=solvent_indices) + nb_only_solute_solute.addInteractionGroup(set1=solute_indices, set2=solute_indices) + + # Set solvent-solvent to fg 0, everything else to fg1 + nb_only_solvent_solvent.setForceGroup(0) + nb_only_solvent_solute.setForceGroup(1) + nb_only_solute_solute.setForceGroup(1) + # handle non-NonbondedForce's for force in new_system.getForces(): if 'Nonbonded' not in force.__class__.__name__: From c0a28e1e3ae346ebd25daeb1994d1a982215b6cc Mon Sep 17 00:00:00 2001 From: c-matthews Date: Wed, 25 Sep 2019 15:48:45 +0100 Subject: [PATCH 09/18] Added some results for g-baoab --- examples/mts/Results.ipynb | 321 +++++++++++++++++++++++++++++++++++++ 1 file changed, 321 insertions(+) create mode 100644 examples/mts/Results.ipynb diff --git a/examples/mts/Results.ipynb b/examples/mts/Results.ipynb new file mode 100644 index 000000000..5c7beb013 --- /dev/null +++ b/examples/mts/Results.ipynb @@ -0,0 +1,321 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Solvent/Solute splitting using g-BAOAB\n", + "\n", + "### Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import time\n", + "from openmmtools import testsystems \n", + "from openmmtools.forcefactories import split_nb_using_exceptions,split_nb_using_subtraction\n", + "from simtk.openmm.app import Simulation\n", + "from openmmtools.integrators import LangevinIntegrator\n", + "from simtk import unit\n", + "import simtk.openmm as mm\n", + "import mdtraj as md\n", + "from mdtraj.reporters import HDF5Reporter\n", + "import h5py\n", + "import seaborn as sbn\n", + "# Set seaborn constants\n", + "sbn.set()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the test system (Solvated alanine dipeptide)" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [], + "source": [ + "# Test system defined here\n", + "testsystem = testsystems.AlanineDipeptideExplicit() \n", + "\n", + "# Split the system into the different interactions using the\n", + "# routine from forcefactories.py\n", + "# This creates a copy of the system, with defined exceptions\n", + "new_system = split_nb_using_exceptions(testsystem.system, testsystem.mdtraj_topology) \n", + "\n", + "# Set gamma\n", + "collision_rate = 1/unit.picoseconds\n", + "\n", + "# Set precision. Double takes ages, so we use mixed.\n", + "myprecision='mixed'\n", + "platform=mm.Platform.getPlatformByName('OpenCL')\n", + "platform.setPropertyDefaultValue('OpenCLPrecision', myprecision)\n", + "\n", + "# We define four splittings, and loop over them\n", + "midstr = ' V1 R R O R R V1' \n", + "splitting0='V0'+midstr*1+' V0' # K_p=1, i.e. BAOAB\n", + "splitting1='V0'+midstr*2+' V0' # K_p=2, i.e. B_s (B_p A O A B_p)^2 B_s\n", + "splitting2='V0'+midstr*3+' V0' # K_p=3, i.e. B_s (B_p A O A B_p)^3 B_s\n", + "splitting3='O V R R V O' # The OBABO scheme\n", + "\n", + "splittings = [splitting0,\n", + " splitting1,\n", + " splitting2,\n", + " splitting3]\n", + "\n", + "# We look at the properties of simulations from seven stepsizes, given in fs\n", + "dts = np.array([2.0,3.0,4.0,6.0,8.0,9.0,10.0])\n", + "\n", + "# Set the constraint tolerance. \n", + "tol = 1e-8\n", + "\n", + "# Total simulation time in ps\n", + "T = 1000" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Run the simulations" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Splitting #0 at 2.0fs took 618.79s, average time per step: 0.0012375768299102783\n", + "Splitting #0 at 3.0fs took 419.7s, average time per step: 0.0012591124179602267\n", + "Splitting #0 at 4.0fs took 307.78s, average time per step: 0.0012311247854232788\n", + "\n", + "Splitting #1 at 2.0fs took 829.53s, average time per step: 0.0016590503101348876\n", + "Splitting #1 at 3.0fs took 536.57s, average time per step: 0.0016097264982896545\n", + "Splitting #1 at 4.0fs took 400.66s, average time per step: 0.0016026454448699952\n", + "Splitting #1 at 6.0fs took 270.65s, average time per step: 0.0016239209086589459\n", + "Splitting #1 at 8.0fs took 197.85s, average time per step: 0.0015828157482147217\n", + "Splitting #1 at 9.0fs took 173.9s, average time per step: 0.0015651141959583121\n", + "Splitting #1 at 10.0fs took 156.01s, average time per step: 0.0015600841689109802\n", + "\n", + "Splitting #2 at 2.0fs took 949.43s, average time per step: 0.0018988531966209411\n", + "Splitting #2 at 3.0fs took 631.43s, average time per step: 0.0018943008173164118\n", + "Splitting #2 at 4.0fs took 469.36s, average time per step: 0.001877444519996643\n", + "Splitting #2 at 6.0fs took 312.41s, average time per step: 0.0018744935681303699\n", + "Splitting #2 at 8.0fs took 233.06s, average time per step: 0.0018645147571563722\n", + "Splitting #2 at 9.0fs took 209.39s, average time per step: 0.0018844717681521118\n", + "Splitting #2 at 10.0fs took 184.32s, average time per step: 0.0018431902170181274\n", + "\n", + "Splitting #3 at 2.0fs took 478.9s, average time per step: 0.0009577935538291931\n", + "Splitting #3 at 3.0fs took 318.65s, average time per step: 0.0009559477940882817\n", + "Splitting #3 at 4.0fs took 240.24s, average time per step: 0.0009609520568847656\n", + "\n", + "\n", + "Total time: 7945.799\n" + ] + } + ], + "source": [ + "start_time=time.time()\n", + "for split_i,splitting in enumerate(splittings):\n", + " for dt_j,dt in enumerate(dts): \n", + " \n", + " integrator = LangevinIntegrator(splitting=splitting, \n", + " collision_rate=collision_rate, \n", + " timestep= dt * unit.femtosecond,\n", + " constraint_tolerance=tol) \n", + "\n", + " # Set up the simulation\n", + " sim = Simulation(testsystem.topology, \n", + " new_system, \n", + " integrator,\n", + " platform=platform)\n", + " sim.context.setPositions(testsystem.positions) \n", + " sim.context.setVelocitiesToTemperature(298*unit.kelvin)\n", + " path = 'x_'+str(split_i)+'_'+str(dt_j)\n", + " sim.reporters.append(HDF5Reporter('Results/'+path+'.h5', 50))\n", + "\n", + " N = int(1000*T/dt)\n", + " st=time.time()\n", + " try: \n", + " sim.step(N) \n", + " completed=True\n", + " except:\n", + " completed=False\n", + " \n", + " wall_time = time.time()-st \n", + " \n", + " if (completed):\n", + " print('Splitting #'+str(split_i) +\n", + " ' at '+str(dt)+'fs took '+str(np.round(wall_time,2))+\n", + " 's, average time per step: '+str(wall_time/N))\n", + " print('')\n", + " \n", + "print('')\n", + "print('Total time: '+str(np.round(time.time()-start_time,3)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Look at the average PE of the system" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2gAAAFSCAYAAACHaPzfAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xd8jef/+PHXyVkZkogYCUKJvYOgdiixq7SqaqtW0aKp1arSltRoo19V1SIa5WN0GElUUTGqitojRmySWBHZZ/7+yM8h4iQhORm8n4+HR537uq/7ep8rpx55n+u+3rfCbDabEUIIIYQQQghR4OwKOgAhhBBCCCGEEOkkQRNCCCGEEEKIQkISNCGEEEIIIYQoJCRBE0IIIYQQQohCQhI0IYQQQgghhCgkJEETQgghhBBCiEJCEjQhhBBFxsqVK2nevDk+Pj7ExcUVdDjPpQ0bNjB06FCbXHvSpEkEBQU9dX8fHx+uXLmShxEJIUT+kwRNCCEKmQEDBuDr64tOpyvoUPLEgAEDqFu3Lj4+PjRt2pTRo0dz48YNIP0X8jp16uDj42P506NHj8deR6/X8+WXX7J06VIOHTqEm5tbfr6NJxYeHk7fvn2pX78+AwYMyNR+6tQpevXqRf369enVqxenTp2ytJnNZubMmUPTpk1p2rQps2fP5uHHlmbV19Z69OjB0qVL8208awYMGMDatWszHDt06BBeXl4FFJEQQuQNSdCEEKIQuXr1KgcOHEChULBt2zabjGEwGGxy3axMnTqVQ4cOsXnzZu7du0dgYKClbdiwYRw6dMjyZ8OGDY+9xu3bt0lLS6NKlSqPbS+I95WV4sWLM3DgQIYPH56pTafTMXLkSHr06MH+/fvp2bMnI0eOtCTlq1evZuvWraxfv54NGzYQERHBqlWrctRXCCFE0SYJmhBCFCLr1q2jfv36vPLKK6xbt85y/PDhw7Ro0QKj0Wg5tmXLFrp37w6AyWTihx9+4KWXXqJp06aMGTOGu3fvAulJX/Xq1Vm7di1t27Zl0KBBALz//vu0aNGCRo0a8eabb3L27FnLtePi4hgxYgQNGzakd+/eBAUF8cYbb1jao6KiGDJkCE2aNMHf35/w8PAcvb/ixYvj7++fYaycuHDhAp06dQLA19eXgQMHAlC9enVWrFhBx44d6dixIwAHDx6kd+/eNGrUiN69e3Pw4EHLdQYMGEBQUBB9+/bFx8eHESNGEBcXR0BAgOW9Xr161WocWc3Zo5o3b06XLl0oU6ZMprZ9+/ZhMBgYNGgQGo2GgQMHYjab2bt3L5D+ORg6dCgeHh6UKVOGIUOG8Pvvv+eo76RJk5g6dSpDhgzBx8eH/v37c+3aNSB9ZW7mzJm8+OKLNGrUiO7du3PmzJnHxv/bb7/Rvn17fHx8aNeunSVx/u233zJ8Fh7+Gfj4+DBv3jwuX77M66+/TsOGDRkzZowleXy07/3+ly5dyjR+fHw877zzDs2aNcPX15d33nmHmJgYAIKCgjhw4ACfffYZPj4+fPbZZ5mulZCQwIQJE2jWrBl+fn589913mEymDHHMmjULX19f2rVrx44dO6z+LIUQIj9JgiaEEIXI+vXr6d69O927d2f37t3cunULgAYNGuDg4GD5JRxg48aNlgQtJCSErVu38vPPP7Nr1y5cXV0tv7Tet3//fsLDw1myZAkArVu3ZvPmzfzzzz/UqlWLDz/80HLuZ599hoODA3///TezZs3KkCwmJyczdOhQunXrxp49e/j666+ZPn16jpKuO3fusHnzZmrWrPlE81KpUiVCQ0Mt7yMkJMTStnXrVtasWUN4eDh3797lnXfeYcCAAfz7778MGTKEd955J8N+tfDwcGbPns3OnTu5fPkyffv2pXfv3uzbtw9vb28WLFhgNY6s5uxJnDt3jurVq6NQKCzHqlevzrlz5wA4e/YsNWrUsLTVqFHDMr/Z9YX0z8bIkSP5999/qVGjhiXO3bt3c+DAATZv3syBAweYN28exYsXzxRfcnIyX3zxBT/++COHDh1i1apVWf7Mdu3axW+//caaNWtYvHgxn3zyCXPnzmXHjh2cPXuWsLCwJ54jk8lEr1692L59O9u3b0er1Vo+0+PGjaNx48aWldmpU6dm6v/555+TkJDA1q1bWb58OevXr+fXX3+1tB89epRKlSqxd+9e3nrrLT7++OMMt5EKIURBkQRNCCEKiQMHDnD9+nU6d+5MnTp18PLysiQlAF27drW8TkxMZOfOnXTt2hVIvyVu3LhxeHh4oNFoGD16NJs3b85w2997772Ho6Mj9vb2ALz66qsUK1YMjUbDe++9R2RkJAkJCRiNRv7880/ee+89HBwcqFKlCj179rRcJyIignLlytG7d29UKhW1a9fG39+fzZs3W31vX3zxBY0bN+bll1+mVKlSTJ482dK2dOlSGjdubPkzceLEJ5q3t99+m+LFi2Nvb09ERAQVK1akZ8+eqFQqunXrRuXKldm+fbvl/F69elGhQgWcnZ1p3bo1Xl5eNG/eHJVKRadOnTh58qTVsazN2ZNKSkrC2dk5w7FixYqRlJQEpCdIxYoVs7Q5OzuTnJyM2WzOti9A27Zt8fX1RaPRMG7cOA4fPkx0dDQqlYqkpCTOnz+P2WzG29ub0qVLPzZGOzs7zp49S2pqKqVLl6Zq1apW38/w4cMpVqwYVatWpVq1arRo0QIvLy/LHGc1p9a4ubnh7++Pg4MDxYoV491332X//v056ms0GgkPDycgIIBixYpRvnx5hgwZkuH22bJly9KnTx+USiWvvPIKN2/etHwhIoQQBUlV0AEIIYRIt27dOlq0aEGJEiUA6NatG7///juDBw8GoHv37vTt25fp06ezZcsWatWqRbly5QC4fv06o0aNws7uwfdudnZ23L592/Law8PD8nej0UhQUBB//PEHd+7csfSLi4sjNTUVg8GAp6en5fyH/37t2jWOHj1K48aNM1zPWnEPgClTpvDaa689tm3o0KGMGzcu2/mx5uHYbty4QdmyZTO0ly1bltjYWMvrkiVLWv6u1WozvLa3tyc5Ofmx42Q1Z48mTNlxcnIiMTExw7GkpCScnJwAcHR0zJBwJSYm4ujoiEKhyLYvZPxZOzk54erqyo0bN3jxxRd58803+eyzz7h+/TodOnRg4sSJGZLB++MHBQWxdOlSPv74Yxo2bMjEiRPx9vZ+7PvJak61Wu1TJT4pKSkEBgaya9cu4uPjLe/TaDSiVCqz7BsXF4der8/wWcjqc+Dg4ABg9WcvhBD5SVbQhBCiEEhNTWXTpk3s37+fFi1a0KJFC3766SciIyOJjIwEoEqVKpQtW5adO3cSGhpKt27dLP09PDz48ccfOXDggOXPsWPHMux/eviWuI0bN7Jt2zaCg4P577//+Ouvv4D0PUolSpRApVJZ9vsAREdHW/7u6emJr69vhrEOHTrE9OnTbTY/WXn4fZUuXZrr169naI+Ojn7sPrAnldWcPakqVapw+vTpDH1Pnz5tKYBStWpVy88dIDIy0rKClV1fIMPPLikpifj4eMtK2cCBA/ntt98ICwvj4sWLLF68+LExtmrViuDgYHbv3k3lypX55JNPnvh9PsrBwYHU1FTL65s3b1o9d+nSpVy4cIE1a9Zw8OBBVqxYAeRsvt3c3FCr1Rk+C3n1ORBCCFuTBE0IIQqBrVu3olQqCQsLY926daxbt47w8HAaN26cYf9Xt27dCAkJYf/+/ZaiGQBvvPEG8+bNsxSDuHPnDlu3brU6XlJSEhqNBjc3N1JSUvj6668tbUqlkg4dOvDtt9+SkpJCVFQU69evt7S3bduWixcvsm7dOvR6PXq9nqNHjxIVFZWXU/JU2rRpw8WLF9m4cSMGg4Hw8HDOnTtH27Ztc33trObscYxGI2lpaRgMBkwmE2lpaej1egCaNGmCUqkkJCQEnU7Hzz//DECzZs0AePnllwkODiY2NpbY2FiCg4N55ZVXctQXYMeOHRw4cACdTsc333xD/fr18fT05OjRoxw5cgS9Xo+DgwMajeaxq1G3bt1i27ZtJCcno9FocHR0zHbVKifu76U7deoUaWlpzJ8/3+q5SUlJaLVaXFxcuHv3Lt9++22G9pIlS1p95plSqaRTp04EBQWRmJjItWvXCA4OznKVVwghCgtJ0IQQohD4/fff6dWrF2XLlqVUqVKWP2+++aYl2YD0BG3fvn00a9bMciskpK+KtGvXjqFDh+Lj40OfPn04evSo1fF69uxJ2bJladWqFV27dqVBgwYZ2qdOnUpCQgItWrRgwoQJdO3aFY1GA6Tvd1qyZAnh4eG0atWKli1bMnfu3Kcu875kyZIMz0Fr2rTpU10H0ldOvv/+e4KDg2natCmLFy/m+++/zzBXTyu7OXvU+vXrqVevHtOmTePAgQPUq1fPsgql0WhYsGAB69evp3Hjxvz6668sWLDAMsd9+/bFz8/PUjCmTZs29O3bN0d9If1zsmDBApo2bcqJEyeYM2cOkJ70TJkyhSZNmuDn50fx4sUf+9Bpk8lEcHAwrVq1okmTJuzfv59PP/0013NYqVIlRo0axeDBg+nYsSONGjWyeu6gQYNIS0ujWbNmvP7667Rq1SpD+8CBA9m8eTO+vr588cUXmfp/8sknODg48NJLL9GvXz+6detG7969c/0ehBDC1hRmKVkkhBAiG3PmzOHWrVvMmjWroEMR2Zg0aRJlypTJ1b4+IYQQBUdW0IQQQmQSFRVFZGQkZrOZo0eP8ssvv9ChQ4eCDksIIYR45kkVRyGEEJkkJSUREBDAjRs3cHd3Z+jQobRv376gwxJCCCGeeXKLoxBCCCGEEEIUEnKLoxBCCCGEEEIUEpKgCSGEEEIIIUQhIQmaEEIIIYQQQhQSUiQkF+LikjCZCv8WPnf3Yty+nVjQYTyTZG5tR+bWdmRubUPm1XZkbm1H5tZ2cju3l+9dZfHx5bzs3ZVGZepZPc949QSpu4LRthqMqnydpx6vKCkqn1s7OwVubk5P3E8StFwwmcxFIkEDikycRZHMre3I3NqOzK1tyLzajsyt7cjc2k5u5nb75b+5l5ZITbdqWV4n5ehmTHo9Co8az9XP8ll+r3KLoxBCCCGEEIVIiiGFgzeO0LhMA+xVWqvnmRJvY7xyFHX1VijslPkYobAlSdCEEEIIIYQoRA7EHkFn0tO8bJMsz9NH7gQzqGu0yafIRH6QWxzzkNlsJjExnpSUREwmY0GHY3Hjhh0mk6mgw3gmPTy3KpUGN7dSKJXyv5UQQgghnt4/1/dT1smDis5eVs8xm4zoI3eg9KqLnXPJfIxO2Jr8JpmH4uJuolAoKFGiDEqlCoVCUdAhAaBS2WEwSIJmC/fn1mw2k5R0j7i4m5Qs6VnQYQkhhBCiiLqacJ1LCVd4tWqPLH+XNFw+gjn5LuqWA/MxOpEf5BbHPKTTpVK8uDsqlbrQJGcifygUCpycXDAYdAUdihBCCCGKsD3R+1EplPh6+GR5nv5UBArH4qgq1M+nyER+kQQtT5lRKJ5uSmetOMisFQfzOB6RnyQpF0IIIURu6Ix69sUcpH6pOhRTWy/Pbkq4hfHKMdQ1WktxkGeQJGhCCCGEEEIUAkduHifFkJJ9cZDTOwEpDvKskgRNCCGEEEKIQmBP9H7c7UtQzc3b6jnpxUF2phcHKeaej9GJ/CIJWiHwz4kYoq7Hc/rKXcZ/9zf/nIgpkDhefbU7/fr1ZvDgfvTr15tZs77AYDBkOOe7776hbdtmxMXFZTiu0+mYPz+IPn1epl+/3gwZ0o+dOyMyjfHbb2tp2bIxZ8+eznB89Oi3ee21lxk8uB/9+7/Gxx+PJzHx8U+IHz36bf7+excARqORGTOm8cEH75GampqLd5+1lSuX88YbvWjVytcythBCCCFEXrmZfJszced40dMXuyy2zNwvDqKp6ZeP0Yn8JAlaAfvnRAw/bYrEYEx/Gvrte2n8tCmywJK0L76YxbJlK1m+fA0XLpxnx46/LG0Gg4HNmzdRr14DNm8Oy9Dvq6++5ObNGyxfvoaVK3/lk08+IyhoNocPZ9xXFxa2gUaNfAkL25Bp7LFjP7SMrVSqWLfulyxj1ev1TJ06iZSUZGbN+hp7e/tcvPOs+fg0ZM6cb6hfP+sNu0IIIYQQT+Of6P0oUNDMs1GW5+lPRaBwckNZoV4+RSbym5TZt6G/j0Wz+2h0ludEXY+3JGf36QwmgsNPsfPwdav9WtbzpEXd7Mu5R0Rs48cfF6LRaPDze4kffviOP//ciaOjY5b9dDodOl0azs4ulmN79/5NuXLlGTZsBHPnzqRv3/4AxMRE89dfW/j111C02vSn3VeuXIWBA4cSHPwj33yzMP29Rp3j7t04ZsyYzVtvDWDkyDFoNJpMYxuNRlJTUzOM/ajU1BQmTBhLqVKlmThxCkql9Q2y0dHXeeutAXTu3J0jRw6SlpZGQMCkJ0q2atasneNzhRBCCCGehNFkZG/0fmq7V8fNvrjV80wJNzFeOYamYQ8pDvIMkwStgD2anGV3/EnExd1h9uyZLF78E2XLlmf16hXZ9pkyZSIajZZr167SpElTmjRpZmkLC9tAly7dqV+/AXq9gZMnj1OrVh2ios5RrpwXLi6uGa5Vu3YdFi9eaHkdGrqezp274eHhSZUq1di1awft23ewtM+bN5cff1xIbGwMFSpUpHPnblbj/PrrWbz4YksmT56ao+qJ8fHxeHtXYfTosRw69B/Tpn3M6tXr0Gg0jBgx9LG3Rzo7OzN//qJsry2EEEIIkRsn75wmXpfA69kVB4ncCQpQ12idT5GJgiAJmg21qJv9Ktf47/7m9r20TMfdXbRMfLNhrsY/ceIY1apVp0KFChgMJrp2fZn584Oy7PPFF7OoXLkKaWlpTJkygTVrVtKnTz/i4u5w6NB/fPLJZwB07tyVsLAN1KpVB7M5+2RSr9ezZcsfLFoUDECXLt0JC9uQIUEbO/ZDWrRohdFoZO7cQBYunM+YMQGPvV7Tps05cGAfFy9eoFKlytmOr1ar8ffvAoCPTyO0Wi2XL1+iSpWqfP/90mz7CyGEEELYyp7r+3HWFKOOe02r55hNBvSnd6H0qifFQZ5xkqAVsF5tvPlpUyQ6g8lyTKOyo1cb69V7cspsNltdXQoL28DatasA6NdvAB07ds7QrtVqad68FXv27KJPn35s2hSG0Whk4MC+QPptiCkpKbz//gd4e1fh2rUr3LsXn2EV7cSJ43h7VwVg9+4dJCcnMWbMuwCYTCbi4u4QGxtDmTIeGcZWKpW0bu3HggXfWH1v7dt3pGnTFxk3bhRBQQtylKRZmxtZQRNCCCFEQYlPu8fx26do79UaZRa3LT4oDjIoH6MTBUEStAL2Yu305CQ4/BQGoxl3Fy292nhbjudG7dp1CQz8nCtXLuPpWZ7w8I2Wtq5de9C1aw+rfU0mE4cP/4eXVwUAwsM3MnPmXHx9m1rO+eCD0URE/IW/fxf8/F5i7twv+fjjaWi1Ws6fP0dIyFKmTv0cSE8Ix42bQPfuPS39Z8+ewaZNoQwe/Fam8Q8dOmAZ2xp//y6YzWbGjh3JvHnfZZmk3V/B8/fvwpEjh9DpdFSoUBFAVtCEEEIIUWD+jf4Pk9nEi2V9szzPUhzES4qDPOskQSsEXqztYSkIktvbGh9WooQ7H344mYCAMbi6utK8eWtUKlWW1Q7v70EzGPRUquTN4MHDOXHiOAkJ92jUKOM/HB06dCIsbAP+/l0ICJjEokXf0r9/H9RqFRqNljFjAvDxacStWzc5fPggn346I0P/jh07M3PmdAYNGgY82INmMBgoU8aD8eMnZ/seO3XqmqMkzdXVlatXrzB8+CDS0lKZNm0GarU62+vft3JlCGvXruLu3ThmzpyGRqPl55/X4OpqvZCJEEIIIURWzGYze6L3UaV4Jco4lrJ6XnpxkONSHOQ5oTDnZAOReKzbtxMxmR5MX0zMJTw8KhZgRJklJyfh4uKMwWAiLGwDoaHrWbhwSUGHla/uV3EMC9uW59dWqewwPHR7amH8DBRVpUo5c/NmQkGH8UySubUNmVfbkbm1HZlb28nJ3J6Ni2LeoUUMrPk6TbMor5+2/1d0h0NxemOu7D+j6Hxu7ewUuLsXe+J+soL2jFu7dhUREdswGAy4uLgyceKUgg5JCCGEEEIAf1/fj4PKHp/Sda2eYzYZ0EfulOIgzxFJ0J5xgwYNY9iw4RlWeZ5Vc+bM5MSJ4xmOKZVKlixZbpPVMyGEEEKIp5WsT+bwzaM08/RFo8z8XNj7DJeOYE6JR1Ozbf4FJwqUJGjimTF+/EcFHYIQQgghRI7sjz2M3mSgebbFQbajcCohxUGeI3YFHQDA9OnT6dSpEz169KBv374cO3bM0nb48GFee+01evbsSdeuXfnf//5nabt16xZDhw7F39+fHj16cOTIkVy3CSGEEEIIYWt7ru/Dq1hZKjiXt3qO6d5NjFdPoK7RWoqDPEcKRYLWunVrNm7cyIYNG3jnnXcYN26cpe3TTz9l5MiRrFu3juDgYGbPns2tW7cA+Oqrr2jcuDGbN29m6tSpfPjhh5aHJj9tW0FJ3hhI8sbAAo1BCCGEEELY3uWEq1xNvE7zsk2yPE8fuQMUoK7eOp8iE4VBoUjQ/Pz8LCXPGzRoQExMDCZT+p4phUJBQkJ6lZbk5GScnJxwcHAA4I8//qBv3/QHJzdu3BitVmtZfXvaNiGEEEIIIWxpz/X9qO1UNC7jY/Ucs8mA/vQulF71sStWIh+jEwWtUCRoD1uxYgVt27bFzi49tMDAQIKCgmjbti2vvPIK06ZNw8nJibi4OMxmMyVKPPjAenp6EhMT89RtQgghhBBC2JLOqGN/zCEalKqHo9rB6nmGS4elOMhzKl+KhLzyyitcv379sW179uxBqUy/pzYsLIyNGzeyYsUKS/vixYsZP348Xbp04fz58wwePJhatWpZVtEK0qPPNbhxww6V6slz3rQzezDeiAKjgaSVAdg3ew1tteZ5FSZAjuLq2bMrWq0WjUaDTqejfn0fJkyYhEr14IHO8+fPY/XqlWzcuBk3NzfLcZ1Ox8KF37JzZwQqlQqtVsuwYW/Tpo1fhjF++WUNc+d+SUjI/6hWrbrl+LvvDic2NgYnJyf0ej0vvFCJKVM+pVgx50xxvvvucN58cwAtW7bGaDQyY8Zn3Llziy+/nIu9fd5/LkwmEx99NIHz56PQaDS4uZVg4sSPKF/eC8g4t3Z2dpQqlTlm8XRkLm1H5tY2ZF5tR+bWdmRu8960v75O/2+7DzK17biwl1RjKl1rtcly7qO37kLp7I5Hw+ay/+wxnuXPbb4kaL///nu252zZsoWgoCCWLVtGyZIlAbhz5w5bt27lq6++AqBy5cpUq1aNI0eO0LlzZ8s591fDoqOj8fDwsCQOT9r2pB59ULXJZHricva6s3tI27UMjIb0ayTeJjliKUajCU3VvEnSHn2YclY+//xLKleugtFoZNSo4Wzbto327TsCYDAY+OOPcOrVa0BY2Eb69u1v6Tdr1kxSUlIICVmNVqvl/PlzBAS8j5OTMw0aNLSct3Hjeho18mXDhnWMHTvectxsNjNmzIe0aNEKs9nMp59+xC+/rKV//8GZYjSbzRiNZlJS0pg27SMUCgWBgV+jUqlt8jgBk8lEp05dad68FXZ2dvz662oCA7/gm28WZppbk8lUJB6cWBQUlYdQFkUyt7Yh82o7Mre2I3NrG3q9EbVa+di5/eP0Tko5uFMSD6tzb7p3k5TzR9A06smt28m2DrfIKSqf2yL9oOrt27cTGBhIcHAw5cs/qGTj6uqKRqNh//79+Pr6cvPmTSIjI6lSpQoAnTp1YtWqVYwcOZIDBw6QmppKnTp1ctWWl/Rn/kZ/emeW5xhjo8BkyHjQoCNtx1IMkTus9lNXb426WotsY4iI2MaPPy5Eo9Hg5/cSP/zwHX/+uRNHR8cs++l0OnS6NJydXSzH9u79m3LlyjNs2Ajmzp1pSdBiYqL5668t/PprKFqtFoDKlaswcOBQgoN/5JtvFgIQFXWOu3fjmDFjNm+9NYCRI8eg0WR+7ofRaCQ1NTXD2I9KTU1hwoSxlCpVmokTp1hWYR8nOvo6b701gM6du3PkyEHS0tIICJhE/frW7/t+mJ2dHS1btrG8rl27HmvW/C+LHkIIIYQQmcUm3yQq/gIve3dGoVBYPS+9OIhCioM8pwpFgjZ58mTUajXvv/++5diyZctwc3MjKCiImTNnYjQaMZlMvPfee1StWhWAgIAAxo8fz7p169BqtcyePduyd+1p2/Ldo8lZdsefQFzcHWbPnsnixT9Rtmx5Vq9ekW2fKVMmotFouXbtKk2aNKVJk2aWtrCwDXTp0p369Rug1xs4efI4tWrVISrqHOXKeeHi4prhWrVr12Hx4oWW16Gh6+ncuRseHp5UqVKNXbt20L59B0v7vHlz+fHHhcTGxlChQkU6d+5mNc6vv57Fiy+2ZPLkqVn+A3dffHw83t5VGD16LIcO/ce0aR+zevU6NBoNI0YMJTU1NVMfZ2dn5s9flOn4b7+toWVL+QdTCCGEEE/mn+v7sVPY0dSjsdVz0ouD7JTiIM+xQpGg7d2712pby5Ytadmy5WPbSpUqxbJly/K0LS+pq7XIdpUrcWUA5sTbmY4rirnj2H1yrsY/ceIY1apVp0KFChgMJrp2fZn584Oy7PPFF7OoXLkKaWlpTJkygTVrVtKnTz/i4u5w6NB/fPLJZwB07tyVsLAN1KpVJ0ePKNDr9WzZ8geLFgUD0KVLd8LCNmRI0MaOTb/F0Wg0MnduIAsXzmfMmIDHXq9p0+YcOLCPixcvUKlS5WzHV6vV+Pt3AcDHpxFarZbLly9RpUpVvv9+abb971u5MoSLFy/wf//3fY77CCGEEEIYTUb2Rh+grntNXLXW908ZLh7CnHIPTa22+RecKFQKRYL2PNP49k7fg2bQPTio0qDx7Z3ra5vNZqurS2FhG1i7dhUA/foNoGPHzhnatVotzZu3Ys+eXfTp049Nm8IwGo0MHJj+eAKj0UhKSgrvv/8B3t5VuHbtCvfuxWdYRTtx4jje3umrnbt37yBrO3zuAAAgAElEQVQ5OYkxY94F0vdqxcXdITY2hjJlMu7/UyqVtG7tx4IF31h9b+3bd6Rp0xcZN24UQUELcpSkWZubnK6g/frrarZs+YNvvlmIvb39E40nhBBCiOfbsdunSNAn8mJZ3yzP00fuQOFUAmX5evkUmShsJEErYPcLgaTtWAomA4pi7mh8e+dJgZDatesSGPg5V65cxtOzPOHhGy1tXbv2oGvXHlb7mkwmDh/+Dy+vCgCEh29k5sy5+Po2tZzzwQejiYj4C3//Lvj5vcTcuV/y8cfTLEVCQkKWMnXq50B6Qjhu3AS6d+9p6T979gw2bQpl8OC3Mo1/6NABy9jW+Pt3wWw2M3bsSObN+y7LJO3+Cp6/fxeOHDmETqejQoWKADlaQVu//jfWr/+Nb775PtOtnEIIIYQQ2dlzfR+uGhdqlahu9RzTvRsYrx5H0+gVFAW1/UYUOEnQCgFN1eaWgiC5va3xYSVKuPPhh5MJCBiDq6srzZu3RqVSZbn6c38PmsGgp1IlbwYPHs6JE8dJSLhHo0YZv/Hp0KETYWEb8PfvQkDAJBYt+pb+/fugVqvQaLSMGROAj08jbt26yeHDB/n00xkZ+nfs2JmZM6czaNAw4MEeNIPBQJkyHowfn/1cdOrUNUdJmqurK1evXmH48EGkpaUybdoMy8PRs5OcnMTcuYF4eHgybtwoIP2WyR9//ClH/YUQQgjxfItLvcvJ26fxr+iHMouS+ZbiIDVkr/vzTGHOyQYi8ViPltmPibmEh0fFAowos+TkJFxcnDEYTISFbSA0dD0LFy4p6LDy1f0qjmFh2/L82o+W2S+Mn4GiqqiU0C2KZG5tQ+bVdmRubUfm1jbmHfwetVrJqLrDAdh0YRuhFzYz/cWJlHRwf2wfs9FA0soPUJb2xsF/TH6GW+QUlc9tkS6zL2xn7dpVRERsw2Aw4OLiysSJUwo6JCGEEEKI54bJbOKf6H1Ud6tiNTkDMFxKLw6irtk2/4IThZIkaM+4QYOGMWzYcJs8wLmwmTNnJidOHM9wTKlUsmTJcpusngkhhBBCZOdMXBS3U+PoUblTlufpT0WgKOaOsnzdfIpMFFaSoIlnxvjxHxV0CEIIIYQQGey5vg9HlQP1S9Wxeo7p3g2M106gaSzFQQTIJ0AIIYQQQggbSNQnceTmcZp4NESttF6cLL04iB3q6lIcREiCJoQQQgghhE3sjzmEwWykedkmVs8xGw3oT+9CVaE+dk5u+RidKKwkQSsk5h38nnkHvy/oMIQQQgghRB4wm83sub6Pii5elCvmafU8w6WD/784iF8+RicKM0nQhBBCCCGEyGMphjSuJ8XQ3NM3y/P0p3b8/+Ig1veoieeLJGiFwL6Yg1yIv8zZu+eZ8vdM9sUcLOiQhBBCCCFELtxNjUdjp6ZRmQZWzzHFx2K8dgJ1jTZSHERYSBXHArYv5iArI3/FYDYAEJd2l5WRvwLQxKNhvsby6qvd0Wg0aDRadLo06tf3ISBgEirVg4/Jd999w5o1/+P33zfh5vbgPmmdTseiRQvYtSsClUqFVqtlyJC3ad26bYYxfvttLV9/PYvg4BVUrVrdcnz06LeJjY3FyckJg0FPxYovMHnypxQrlvnhfqNHv80bbwygRYtWGI1Gvvzyc27fvs3MmXOwt7fP+4kB5s79kmPHDqNQ2KFSqRgxYjSNG1u/n1wIIYQQz6f0L94vYTAb0dhpOHbrpNXf6R4UB2mVz1GKwkwSNBv6N/o//onen+U5F+IvW5Kz+/QmPStO/cKe6/us9nvR05emno3yJM6HffHFLCpXroLRaGTUqOHs2PEX7dt3BMBgMLB58ybq1WvA5s1h9O3b39Lvq6++JCUlheXL16DVajl//hwBAe/j4uJCgwYP/lEKC9tAo0a+hIVtYOzY8RnGHjv2Q1q0aIXZbObTTz9i3bpf6N9/sNVY9Xo906Z9hEKhYNasr1GrrVdHyq0RI0ZbksWzZ88wduy7hIZutdl4QgghhCh6HnzxbgRAZ9JZ/eLdbDSgP7MbVcUGUhxEZCBrqQXs0eQsu+NPKiJiG6+/3oshQ/oRErKUli0bk5ycnG0/nU6HTpeGs7OL5djevX9Trlx5hg0bQVjYBsvxmJho/vprCx9+OAmtVgtA5cpVGDhwKMHBP1rOi4o6x927cUyePJWtWzej0+keO7bRaCQ1NTXD2I9KTU1hwoSxODkVY/r0wCyTs+jo63Tt2p5vv53H8OEDGTjwdY4cOZTtHDzs4ZW8pKREFArFE/UXQgghxLNvQ9Qf6E36DMf0Jj0bov7IdO6D4iBt8yk6UVTICpoNNfVslO0q15S/ZxKXdjfTcTdtccY2HJGr8ePi7jB79kwWL/6JsmXLs3r1imz7TJkyEY1Gy7VrV2nSpClNmjSztIWFbaBLl+7Ur98Avd7AyZPHqVWrDlFR5yhXzgsXF9cM16pduw6LFy+0vA4NXU/nzt3w8PCkSpVq7Nq1g/btO1ja582by48/LiQ2NoYKFSrSuXM3q3F+/fUsXnyxJZMnT81RshQfH4+3dxVGjx7LoUP/MW3ax6xevQ6NRsOIEUNJTU3N1MfZ2Zn58xdZXi9e/D1//rmJhIQEZsyYLUmaEEIIITJ43O901o7rT0WkFwcpJ8VBREayglbAenh3Qm2XcfVHbaemh3enXF/7xIljVKtWnQoVKgDQtevL2fb54otZLFu2ktDQLeh0OtasWQmkJ3uHDv1Hu3YvAdC5c1fLKprZbM72unq9ni1b/rAkXV26dM+wCgfptzjeH7tyZW8WLpxv9XpNmzbnwIF9XLx4IduxAdRqNf7+XQDw8WmEVqvl8uVLAHz//VKWLVuZ6c/DyRnAW2+NYM2a9XzxxSwWLvw/9Hp9pnGEEEII8Xw6d/cCCh7/5a2btniG1+nFQU5KcRDxWDlaQdPr9Vy4cIF79+7h4uJCpUqVbLrf53ly/37kFad+wWA24KYtTg/vTnlSIMRsNltd5QkL28DatasA6NdvAB07ds7QrtVqad68FXv27KJPn35s2hSG0Whk4MC+QPptiCkpKbz//gd4e1fh2rUr3LsXn2EV7cSJ43h7VwVg9+4dJCcnMWbMuwCYTCbi4u4QGxtDmTIeGcZWKpW0bu3HggXfWH1v7dt3pGnTFxk3bhRBQQuoVKnyU89NTlfQ7mvUyJekpCSios5Rp07tJxpXCCGEEM+ev6//y+rT6yimdiLVmIre9GCryuO+eJfiICIrWSZoERERrFq1in/++QeVSoWTkxNJSUkYDAaaNWtG37598fOTh+rlVhOPhpaCILm9rfFhtWvXJTDwc65cuYynZ3nCwzda2rp27UHXrj2s9jWZTBw+/B9eXumrb+HhG5k5cy6+vk0t53zwwWgiIv7C378Lfn4vMXful3z88TRLkZCQkKVMnfo5kJ4Qjhs3ge7de1r6z549g02bQhk8+K1M4x86dMAytjX+/l0wm82MHTuSefO+yzJJu7+C5+/fhSNHDqHT6ahQoSKQvoKWFbPZzOXLl6hY8QUAIiNPEhcXR9my5bLsJ4QQQohnm9Fk5LdzoURc/ZuaJaoxtHY/jt+OzPKLd7PRgP70LlQVfaQ4iHgsqwla3759cXV1pVu3bkyfPp0yZcpY2m7cuMG+fftYtWoVixYtYtWqVfkSrHgyJUq48+GHkwkIGIOrqyvNm7dGpVJlWYr+/h40g0FPpUreDB48nBMnjpOQcI9GjTI+aLFDh06EhW3A378LAQGTWLToW/r374NarUKj0TJmTAA+Po24desmhw8f5NNPZ2To37FjZ2bOnM6gQcOAB3vQDAYDZcp4MH785GzfY6dOXXOUpLm6unL16hWGDx9EWloq06bNyPEqsNlsZvbsGdy7F49Smf4Igc8+C8TFxXoREyGEEEI825L0ySw9voLIuLO082pFT+8uKO2UNPFoyK5jv6BQqPmgxUeZ+hkuHsScmoC6ZpsCiFoUBQqzlQ1Ep0+fpnr16o9ryuDMmTNUq1YtzwMrCm7fTsRkejB9MTGX8PCoWIARZZacnISLizMGg4mwsA2Ehq5n4cIlBR1WvoqOvs5bbw0gLGxbnl9bpbLDYDBZXhfGz0BRVaqUMzdvJhR0GM8kmVvbkHm1HZlb25G5fTrRSbF8f3QZd1Pv0rd6L14sm/FL7K+2pD8G6IOXZmTqmxw6C1PCTZz6zkahkP1nT6OofG7t7BS4u2d+pm92rK6g5SQ5A57b5KyoWLt2FRER2zAYDLi4uDJx4pSCDkkIIYQQosg6fusUwSdWolaqGdPwHSq7vpDjvqb4GIzXT6Hx7S3JmbDKaoL2zTfWCzQ8bMyYMXkWjMh7gwYNY9iw4RlWeZ5Vc+bM5MSJ4xmOKZVKlixZbpPVMyGEEEI8P8xmM1sv72B91CbKO5flnbqDcLMvnn3Hh+hO7QCFUoqDiCxZTdBiYmLyMw4hcm38+Mz3eQshhBBC5JbOqGdl5C/sjz1Ew9L1GFCzDxql5omuYTbqMZzZjapiA+wcnyyxE88XqwlaYGBgfsYhhBBCCCFEoXM3LZ4fjoZwKeEK3Sv741+xndXHGGXlQXGQtnkfpHim5Og5aAAXL14kNDSUGzduULp0abp168YLL7xgw9CeL1dmpyfEXhOyr1wohBBCCCFs7+K9y/xw9CdSjWm8XXcQ9Us9/fNP9aciUDiXRFlenqEqspaj3Yl//fUXvXr14sKFC7i6unLhwgV69+7Ntm2yr0cIIYQQQjx79sUcJOjg96js1AQ0GpWr5Mx0N704iLpGGykOIrKVoxW0oKAgvvvuO5o1a2Y59u+///L555/Tvn17mwUn8o9Op2PRogXs2hWBSpX+rK8hQ96mdeu2ABw8eIDx48fg5ZVeQt5kMjJo0DDat+9ouYbRaKR3727UrFmLwMCvLMez62symfj552WEh4eiVNqhUCjo06cfPXq8kk/vXgghhBAinclsYkPUH2y5HEHV4pV5q84AimmccnVNXWSEFAcROZajBC0mJobGjRtnONaoUSMpJJJH7u3dQ+r5KMwGA+cnBFCyV29cmjXP1xi++upLUlJSWL58DVqtlvPnzxEQ8D4uLi40aNAQgBdeqMySJcsBuHDhPG+/PQg/v5ews0v/Jmjv3j2ULFmKI0cOc+fObUqUcLdcP6u+ISFLOXBgHz/8EIyLiyuxsTEEBLyPVqvF379Lvs6DEEIIIZ5fKYYUgk/8jxO3I2lV7kVeq9oDpZ0yV9dMLw7ytxQHETmWozXWGjVqsHTp0gzHgoODqVmzpk2Cep7c27uH2JBlmA0GAAx3bhMbsox7e/fkyfUjIrbx+uu9GDKkHyEhS2nZsjHJyckZzomJieavv7bw4YeT0Gq1AFSuXIWBA4cSHPzjY6+blJSIk1MxS3IGEBa2gZ49e9G6dVv++CPcakwP99XpdCxfHsz48R/h4uIKQJkyHowaNYYlSxbl9u0LIYQQQuTIjeSbzDmwgFN3zvB6tVfoW/2VXCdnAIYL/6UXB6nllwdRiudBjlbQpk2bxrvvvktISAienp5ER0fj6OjIwoULbR1fkXZvz9/E796Z5Tn3V84eZtbpiF22lPidO6z2c23ZGpfmLbK8dlzcHWbPnsnixT9Rtmx5Vq9e8djzoqLOUa6clyVBuq927TosXvzgZ3zx4nkGD+6HTpdGTEwMn3wy/aGx4jh48ABTpkyjQoUXmD17Bv36Dci279Wrl1Gr1VSs+MIjY9fl+vVrJCcn4eiYu9sKhBBCCCGycurOGZYcX4GdQsF7DYZTzc07z66dXhykFMpytfLsmuLZlqMEzdvbm/DwcA4fPmyp4li/fn3UarWt43vmPZqcZXf8SZw4cYxq1apToUIFDAYTXbu+zPz5QZnHMptzdL2Hb1O8ePEC7733DnXq1KNUqdJs3hxGixatcHR0ol69BhgMRo4fP0adOnWz7Gtt6Afla5+8jK0QQgghRE6YzWYirv7Nb+dC8XAszTv1BlPSoUSeXd90NwZjdCQa31elOIjIsRyX2VepVJn2oYmsuTRvke0q1/kJARju3M50XFXCPdcl981m82Of0xEevoHQ0A0A9Os3gLp163Pt2hXu3YvPsIp24sRxvL2rPvbaL7xQCQ8PT44dO0q7di8RHr6Ru3fv8uqr3QFITEwkLGyDJUGz1rdFi1bo9XouXbqYYRXt+PGjeHqWw9HRMTdTIIQQQgjxWHqTgTWnf2dP9H7qlazNoFqvY6+yz9MxHhQHaZmn1xXPthwlaJGRkcycOZPIyEjL/qX7v/wfP37cpgE+60r26p2+B02nsxxTaDSU7NU719euXbsugYGfc+XKZTw9yxMevhGALl168OqrfTOc6+f3EnPnfsnHH0+zFAkJCVnK1KmfP/bat27d5MqVy3h5eXHy5HESExNZv/4PS0J48+YNBgx4nTFjArLsq9VqefPNQcyZM5OZM+fi4uJCbGwM3333DUOHDs/1HAghhBBCPCpBl8gPx0I4H3+RTi+0p2ulDtjl8QqXndmM4fRuVC/4SHEQ8URylKB98MEHdOzYkSlTpmBvn7ffLDzv7ldrjF22FLPBgKqEe55VcSxRwp0PP5xMQMAYXF1dad68NSqV6rE/w4CASSxa9C39+/dBrVah0WgZMyYAH59GlnPu7yMDMBj0DB8+gqpVqzN3biAvveSfYbWuVKnSVKtWne3bt1KmjIfVvgCDB7+FnZ0db789CKUyfTPua6/1pXPnbrmeAyGEEEKIh11JuM6io8tI1CcxtHY/GpVpYJNxKiWlYE5LRF2zrU2uL55dCnMONiA1adKEf//997G3yz3Pbt9OxGR6MH0xMZfw8Kj4VNe6MjsQINe3NT4qOTkJFxdnDAYTYWEbCA1dz8KFS/J0jOeZSmWHwWCyvM7NZ0BkVKqUMzdvJhR0GM8kmVvbkHm1HZlb23ne5vbgjaMsP7kaR7Uj79QbRAXn8jYZJ3ljIKY7V0DjhFPfWbL/LI8Vlc+tnZ0Cd/diT9wvRytoPXv2ZOPGjfTo0eOJBxA5k9eJ2X1r164iImIbBoMBFxdXJk6cYpNxhBBCCCEKK5PZRPiFrWy6uJVKLhUZXncgrlpnm4ylO7sHY+w5MBnBDPpze9FUzd/n24qiLUcraLdu3eL111/H3t4ed3f3DG0hISE2C66wy8sVNFt6dJVH5B1ZQbOdovLtWFEkc2sbMq+2I3NrO8/D3KYa0lh+ajWHbx6nmUdj+tbohdoux3Xynoju7B7Sdi0Dw4PaAqg0aFsNliQtDxWVz61NV9Def/99ypcvT4cOHSwPMhZCCCGEEKIwu51yh0XHfuJ6Ygy9q3bHr3xLm27Z0e3/NWNyBmDQodv/qyRoIsdylKCdOnWKf//9F41GY+t4ijgFZrNJ7jN+TuX0eXJCCCGEsL2zcedZfHw5RrOJUfWHUdO9mk3HM5tMmBMzPzoJsHpciMfJUSbRuHFjoqKibB1LkafR2HP37i0MBr38sv6cMZvNJCXdQ6WSLzGEEEKIgrb72l7+7/APOKkdGd94tO2Ts9REUjZ9ZbVdUczdapsQj8rRClr58uUZOnQoHTp0yLQHbcyYMTYJrChycytFYmI8d+7EYjIZCzocCzs7O0wm2YNmCw/PrUqlwc2tVAFHJIQQQjy/jCYjv57byI6re6hVojpDavfDUe1g2zFvXSTlz/mYk+NRVm+NMWpvpj1oGt/cP99WPD9ylKClpqbStm1b9Ho9MTExto6pyFIoFDg7F8fZuXA9jLCobKQsimRuhRBCiMIhUZ/EkuMrOBN3jvYVWtPTu0ueP3z6Ufozf5O6axkKe2cce3yEsnRldGVrkLZjKZgMKIq5o/HtLfvPxBPJMkG7dOkSFStWJDAwML/iEUIIIYQQ4olcT4xh0dFl3E2LZ2DN12nq2cim45mNBtL2/g/9iW0oPWtg/9JI7BxcANBUbY4hcgdqtQp1p/E2jUM8m7JM0N5++20AWrduTdu2bfH19ZVCIUIIIYQQotA4duskwSdWolVqGdtwBJVcbfu4G1PyXVK3focx5gzquv5om/ZBYae06Zji+ZJlgrZ582auXLlCREQEwcHBBAQE4OPjQ9u2bWnTpg0eHh75FacQQgghhBAWZrOZLZci2HD+D7ycy/J23UG42dt2m4kx9hwpW77FnJaMfbsRqKs0s+l44vmU7R40Ly8vBgwYwIABA0hNTeWff/5hx44dLFq0CCcnJ9q0aUOvXr2oXLnyUwcxffp0/vnnHzQaDY6Ojnz88cfUrVsXgMOHDzNjxgz0ej16vZ7+/fvzxhtvYDKZGDNmDGfOnEGr1eLu7s706dOpUKECABcuXGDSpEncvXuX4sWLM2vWLF544YVs24QQQgghROGmM+pZEbmWA7GHaVymAW/WeA2NUm2z8cxmM/pT20nbswKFUwkce36C0t3LZuOJ59sTPUbd3t4ePz8//Pz8ADhz5gw7d+7kzJkzuUrQWrduzUcffYRarWb79u2MGzeOrVu3AvDpp58yduxY/Pz8uHHjBv7+/nTo0IESJUrQs2dP/Pz8sLOz4+eff+aTTz7hp59+svTr168fL7/8MuvXr2fq1KmEhIRk2yaEEEIIIQqvuNS7/HDsJ64kXOflyp3pULGtTR8+bTboSN29HMOZXSi96uHQ7h0UWiebjSdElqVtTCZTln+qVq3KW2+9RadOnXIVhJ+fH2p1+rceDRo0ICYmxlK6XKFQkJCQXiUvOTkZJycnHBwcsLOzo3379tjZ2Vn6Xb9+HYDbt29z8uRJunXrBkC3bt04efIkd+7cybJNCCGEEEIUXhfiLzH7wHxik2/yTr1BdHzBz6bJmSnxNskbAzGc2YWmYQ8c/MdKciZsLssVtFq1amX7oXd2dqZOnTpMnjyZqlWr5jqgFStW0LZtW0viFRgYyMiRI/n666+Jj49nzpw5ODll/h9jxYoVtGvXDoDo6GjKlCmDUpm+YVOpVFK6dGmio6Mxm81W20qUKPFEsbq7F8vNW81XpUo5F3QIzyyZW9uRubUdmVvbkHm1HZlb2ykqc7vjwl4WHVqBu0NxPm03Fi/XsjYdL+XiMWLXfY3ZoKfMqxNxqt4kx32vq9N/xS4qc1sUPctzm2WCtm3btmwvkJiYSHh4OJMnT+aXX3557DmvvPKKZXXrUXv27LEkS2FhYWzcuJEVK1ZY2hcvXsz48ePp0qUL58+fZ/DgwdSqVYuyZctmOCcqKspye2N+uX07EZPJnK9jPg15VpftyNzajsyt7cjc2obMq+3I3NpOUZhbk9nEuqhwtl3eSbXi3gyr2x97nZPN4jabzeiP/UHav2uwc/XEsdt7JBf3JPkJxtPrDajVqkI/t0VVUfjcAtjZKZ5qQSfLBK1cuXIAxMbGUqZMmUztJ0+epFatWlStWpV169ZZvc7vv/+ebSBbtmwhKCiIZcuWUbJkSQDu3LnD1q1b+eqrrwCoXLky1apV48iRI5YE7eeffyY0NJRly5bh4JD+pHhPT09iY2MxGo0olUqMRiM3btzA09MTs9lstU0IIYQQQhQeyfoUgk+s5OSd07Qp35zeVbqjtGFJe7M+jdQdSzCc34eqUmPs2wxDoXGw2XhCPE6OHq8+bNgw7t69m+HY0aNHLc9Js7OzY8eOHU8dxPbt2wkMDGTJkiWUL1/ectzV1RWNRsP+/fsBuHnzJpGRkVSpUgWA1atXs3r1apYuXUrx4g/Kqrq7u1OzZk1CQ0MBCA0NpWbNmpQoUSLLNiGEEEIIUTjEJt9k7n/fEhl3ljeq96JPtZ42Tc5M8bEkr/scw4X9aJq8iv1LoyQ5EwVCYTabs71HLyQkhHXr1rF8+XKcnJw4ePAg7733HjNnzqRNmza5DqJZs2ao1eoMSdKyZctwc3Nj9+7dfPXVVxiNRkwmEwMGDOD1118nMTGRxo0bU7ZsWZyd0+9B1Wg0rF27FoCoqCgmTZrEvXv3cHFxYdasWZZKk1m1PQm5xVHI3NqOzK3tyNzahsyr7cjc2k5hndtTt8+w5MTPKBVK3qozgKpuT18tPCcMlw+T8tciUNjh0P5dVOXr5Op6yRsDUatVqDuNz6MIxcMK6+f2UU97i2OOEjSABQsWsGfPHt5++20mT57M3Llzad68+RMP+CyRBE3I3NqOzK3tyNzahsyr7cjc2k5hm1uz2cz2q7v57WwoZYt58E7dQbg72O4uJ7PZhO7gRnT/rcPO3QuHDu9h51Iq19eVBM22Ctvn1hqb7EF72KhRo0hISGDcuHEsWrQIX1/fJx5MCCGEEEKIx9GbDKw6/Rt7ow9Qv1QdBtZ8HXuV1mbjmXXJpPz1A8bLh1FVbY59q0EobDieEDllNUFr06ZNphL7JpMJs9nM+PEPvg2IiIiwWXBCCCGEEOLZF5+WwI/HQrhw7xJdXniJzpVewk6Ro1IJT8V45xopW/4P871baJu/ibr2SzZ9npoQT8JqgjZnzpz8jEMIIYQQQjyHLidcZdHRn0jSJzOsTn8alq5n0/H05/eRGrEEhVqLQ7cJqDyr23Q8IZ6U1QStSZOcP4xPCCGEEEKIJ/Vf7GGWn1pLMbUTAY1G4uVczmZjmU1GdPt/RXckHLvS3jh0GI2dk5tNxnLsPrnI7JMShY/VteOQkBB0Ol2WnXU6HSEhIXkelBBCCCGEeHaZzCY2nt/M0hMr8XIuxwTf92yanJlSE0jZ9DW6I+Goa/rh2H2SzZIzIXLL6grarVu36NChA23atMHX15dKlSrh5OREUlISFy9eZN++fezcuZOXX345P+MVQgghhBBFWKohlZ9OruborRM09/SlT/VXUNvluG7dEzPeukjKn/Mxp8Rj33oo6hqtbTaWEHnB6v8NH3zwAYMHD+b333/nl19+4cyZMyQkJODi4kL16tVp06YN48aNw81Nvn0QQgghhBDZu5Vyh0VHlxGTfIPXqr5Mm/LNbVqcQ3/mb1J3LUNh7z51FOYAACAASURBVIxj949Qlrbt89SEyAtZfl1RokQJhg0bxrBhw/IrHiGEEEII8Qw6ExfF4uPLMZnNjKo/jBolqtpsLLPRQNo//0N/chtKzxrYvzQSOwcXm40nRF6y3XqyEEIIIYQQwK5r/7DmzHpKOZRkRL1BlHbM/cOgrTEl3yV1ywKMsWdR1+uEtslrKOyUNhtPiLwmCZoQQgghhLAJo8nI2rMb2HXtH2q712BI7TdwUDnYbryYs6RsXYBZl4x9uxGoqzSz2VhC2IokaEIIIYQQIs8l6pJYfHw5Z++ep0OFtvTw7mSzh0+bzWb0p7aTtmcFimLuOHYOQOnuZZOxhLA1SdCEEEIIIUSeupYYzaKjy4jXJTCoVl+aeDS02Vhmg47U3SEYzuxG6VUPh3bvoNA62Ww8IWwtR19jBAYGcurUKVvHIoQQQgghirgjN0/w1X8LMJgMjGs4wqbJmSnxNskbZmI4sxtNw5dx6DRWkjNR5OVoBc1gMDBs2DBKlChBjx496NGjBx4eHraOTQghhBBC2Mi8g9+jVisZVXd4nlzPbDaz+dJfbDy/mYrOXrxdbyDFta55cu3HMVw7Seq2hZiNBhw6/j/27jw+qvLeH/jnnNm3LJNtJiRhS2ISFJRdUSAqghTtVbpp5VerXUTR6lW8KlqrXqXqRW+vtS61EOlF21KLreAGioAiIlotFwiGfcmeyZ7ZzvL7YyYnCwkMkMlMks+7r7wyc86ZmW9O4zCfPOf5Pr+AfsQFUXstov4U0QjaQw89hC1btuDuu+9GaWkprrzyStx4441488030draGu0aiYiIiCiOBeQAVux6DW8deA+TMi7AneNviVo4U1UVga/fgfftpyGYHbBd80uGMxpUIp6pqdPpUFxcjGeeeQZ/+ctf4PF4cN999+Hiiy/GkiVLUFVVFc06iYiIiCgO1fsa8MyXL+DL6n/h30bPxY+KfgCjzhCV11KDPvg+eAH+z/4M/YgJsP7bQxCT3FF5LaJYiTigtbS0YPXq1ViwYAFuuOEGjBs3DqtWrcLbb78Nq9WKn/zkJ9Gsk4iIiIjizIHGw3hyx/+gpq0WPx/7I8waPhOCIETltZTGKrS9+Z+QDn4O4+Tvwnz5bRCM0WvZTxQrEc1Bu+OOO7BlyxZMmjQJ1113HS6//HIYjUZt//33348JEyZErUgiIiIiii+fVuzAn0rfQJI5Cb+44Odw2zKi9lrSka/g/fAlQBBhufJu6LPOjdprEcVaRAFt3LhxeOihh5CW1vOq76IoYuvWrX1aGBERERHFH1mR8eb+t/Hh0S04JzkXN597A2wGa1ReS1UVBL78BwJfvAkxZTgsVyyC6Oj58yjRYBFRQLv55ptPeYzFwiFmIiIiosGsLdiG5btewx7PN5iZNQ3X5s6DTtRF5bVUfyu8G1+GfORr6PMugvmSGyHojad+INEAF1FAmzFjRo/XExuNRmRkZOCKK67AddddB72e614TERERDUZVrdV4cWcJ6rz1uL5gPqZlTonaa8me4/Cu/x+oTbUwXXQDDGMui9rcNqJ4E1GiWrBgAf7xj39gwYIFcLvdqKiowKpVqzBnzhwkJiZixYoVqKiowL333hvteomIiIion+2q24sVu1ZBJ+hwxwU/Q27SyKi9VvDAdvg++gMEgwmWefdC7z4naq9FFI8iCmhr1qzB8uXLkZHRMflz+vTpuOmmm7Bu3TpMmTIFP/7xjxnQiIiIiAYRVVXxwdHNeHPf28i0u/Dz825EiiU5Oq+lyPBv/yuC/3oHYkYuLJffBtEWndciimcRBbSamhrYbLYu2ywWC6qrqwEAI0eORFNTU99XR0REREQxEZSDeH3v3/BZ5Rc4P+08/L+i78Oki84cMMXXDN8HL0A+vhuGwmKYLvohBB2nztDQFNFvfnFxMRYuXIiFCxciIyMDVVVVeOmll1BcXAwA+Oc//4msrKyoFkpERERE/aPR34Tf71yJg01HMHfkLFw54jKIQsTL554WueYQvOufg+pthHn6TTAUTI/K6xANFBEFtEcffRTPPfccfvnLX6K6uhrp6emYM2cObrvtNgBAdnY2XnrppagWSkRDx9GnlqLSqIfrzsWxLoWIaMg53HQUL+9cibZgG35y7gJckH5e1F4r+M3H8G0pgWBOgPXqJdClRW9uG9FAccqAJssy3nrrLdx+++245557ejymt/XRiIiIiGjg2FH5T/xv6WrYDXbcPeE2ZDkyo/I6qizB/+nrCO7+ALrMQpgvWwjRkhCV1yIaaE4Z0HQ6HX7961/jO9/5Tn/UQ0RERET9TFEVrD3wPt47/CFGJ47ET89bAIfRHp3XamuAb/3zkKvKYBg7B6bJ34UQpbXUiAaiiOegffjhh7j00kujXQ8RERERRdn2yi9xsPEIJFXCkk8eh91gw7GWckzLnIzv5f8b9GJ0GnTIlWXwbngeaqAN5ssWwjA6emupEQ1UEf3X5/f7cccdd+CCCy6Ay+XqslDgU089FbXiiIiIiKhvba/8Eq+VvgFJlQAADf5GNPgbMdk1HtedMz8qC0Krqorg7g/h//Q1CPYUWOfeDZ0zu89fh2gwiCig5efnIz8/P9q1EBEREVGU/WP/uwgqwRO2l9UfiE44kwLwfbwS0jcfQ5c9FpZLfw7BZDv1A4mGqIgC2qJFi6JdBxERERFFSVCRcLDxEPZ4ylDvb+jxmN62nw2luRbe9b+FUnsIxvHfhnHCtyFEqV0/0WAR8QXGn3zyCdatWwePx4MXX3wRO3fuREtLCy688MJo1kdEREREp0lVVZS3VqLUU4ZSTxn2NRxAQAlCFEToBR0kVT7hMcmmpD6tQTq+G74Nv4OqyLDM/gX0wy/o0+cnGqwiCmh//OMfsXLlSnz3u9/Fe++9BwAwm814/PHHGdCIiIiI4kCjvwmlnjLs8ZRhb30ZmgLNAIAMaxouzJyEguQ85CWPxs7a3Xit9I0ulzkaRAOuHj2nT+pQVRXBf70D//bVEJPcsM66A2KSq0+em2goiCigvfrqqygpKUFWVhZ+//vfAwBGjRqFgwcPRrU4IiIiIuqZXw5gX8MBbZSsvLUSAGA32HBOci4KnPkocObCaU7u8rjJrvEAgFW7/gQJQLI5CVePnqNtPxtq0Affpj9AOvA59CMnwjzjZghGy1k/L9FQElFAa21thdvtBgBt8qgkSTAYDNGrjIiIiIg0iqrgaPNx7PGUodTzDQ42HoakytCLeuQmjsRk13gUOPMwzO6GeIp5XpNd47Fl518hCAL+fdoDfVNfYyW87z8HpaEcxsnfg3HclVFpOkI02EUU0CZNmoSXX34ZCxcu1LatXLkSU6Zw7QoiIiKiaKn1elDq+QalnjJ8U78frVIbAGCY3Y0Z2dNQmJyP0UkjYdTF9o/m0uGv4N34EgRBB8uV90CfNSam9RANZBEFtAcffBC33HILVq9ejdbWVsyePRt2ux0vvvhitOsjIiIiGjLagl5807A/fNniN6jx1gEAkkyJOC+1CAXOPJzjzEWC0RHjSkNUVUHgi78j8OXfIaYMh+WKRRAdabEui2hAiyigpaen44033sC//vUvlJeXw+12Y+zYsRBFtkklIiIiOlOyIuNg0xFtlOxQ01GoUGHSGZGXNBozsqah0JmHDGt63F0uqPpb4d34MuQjX0OfNw3mS34EQW+MdVlEA17EbfYFQcC4ceNw3nnnadsURWFIIyIiIoqQqqqoaqsOzyMrQ1nDfvjlAAQIGJ6QjdkjLkWhMx8jErKhFyP+mNbvZM8xeN9/DmpzLUzTboCh6LK4C5BEA1VE/+Xv2rULjz76KPbu3Qu/3w8g9AYjCAL27NkT1QKJiIiIBrLmQAv2htvfl9aXocHfCABItaRgkms8CpPzkJ88GlaDNcaVRia4fzt8m/4AwWCG5ar/gN6VH+uSiAaViALafffdh+LiYjzxxBMwm83RromIiIhowArIQexvPKi1vz/WUg4AsOot4fb3eShw5iPV4oxxpadHVWT4t69G8F/vQszIheXy2yDakk/9QCI6LREFtOPHj+Ouu+7i0DURERFRN4qq4HhLhRbI9jUehKRI0Ak6jEocjqtGzUGhMw/ZjmGnbH8frxRfM3wfvAD5+G4Yii6F6cLrIeji9xJMooEsov+yZs2ahY8//hiXXHJJtOshoiGuadtW+A7sh1eS0Hbv3Ui9dj4Spl4U67KIiLqo9zVo65Htrd+HlmArAMBty8Alw6aiIDkPuUmjYNabYlzp2ZNrDsG7/jmo3kaYZ9wMwzn8PEgUTREFNL/fj0WLFmHChAlITU3tsu+pp56KSmFENPQ0bduKqpUlUCUJACB56lC1sgQAGNKIKKZ8kg9lDQe0UFbVVgMASDA6UOg8B4Xh9vdJpsQYV9q3gnu3wPfxqxDMCbBevQS6tJGxLolo0IsooOXm5iI3NzdqRTzyyCP49NNPYTQaYbVasWTJEq1b5FdffYXHH38cwWAQwWAQN9xwA6677rouj1+zZg3uu+8+vPjiiyguLgYAHDx4EPfddx8aGhqQlJSEJ598EiNGjDjlPiKKndo3/go1EOiyTQ0EUPu3NxjQiKhfyYqMw83HtPb3B5uOQFEVGEQD8pJGYVrmFBQ485Bpcw3KKSCqLMH/6WsI7v4QusxCmC9bCNGSEOuyiIaEiALaokWLolrE9OnT8cADD8BgMGDjxo246667sGHDBgDAww8/jDvvvBPFxcWorq7G7NmzMWvWLG0kr7KyEn/+859x/vnnd3nOhx9+GNdffz2+/e1v4+9//zt++ctfYuXKlafcR0T9z3foEBo3b4RU7+lxv+Sp6+eKiGioUVUVNd5abR7ZNw374ZV8ECAg2zEMl+fMQKEzDyMTR8AQx+3v+4LSWg/vhuehVO2DYewcmCZ/F4Koi3VZREPGSd9h/vCHP+Dmm2/W7n/yySeYNm2adn/p0qW4//77z7qI9lEvADj//PNRWVmprbEmCAKam5sBAG1tbbDZbLBYLNrxDz30EO6//37813/9l7atrq4Ou3fvxooVKwAA8+bNw2OPPQaPxwNVVXvd53QOrG5KRAOZ4vOi6bPP0LhpI/xHDkMwGiGYTFDDS3l0pnemxKBCIhrsWoKt2OvZFwpl9WXw+OoBAE5zMi5IG4uC8GWLdoMtxpX2H6myDL71v4Ua9MJ82UIYRk+JdUlEQ85JA9rzzz/fJaDddddd2L59u3Z/9erVfRLQOlu1ahVmzpypLYC9dOlS3HrrrXjmmWfQ2NiIp59+GjZb6I3ytddeQ25uLsaNG9flOSoqKpCRkQGdLvTXHp1Oh/T0dFRUVEBV1V73nW5AS0mxn+2P22/S0hyxLmHQ4rk9PS379qPy/fWo2bQFis8H6/AcjPrZT5A2czo8O77A/udfhNIppIkmE0beeAPPcx/j+YwOntfo6YtzG5SD2Ft7AP+q2oN/Ve7BwfqjUKHCYjDj3PRzcE3GbIx1FcJlTxuUly121/4zpqU5oKoqmr54F83rV0CfmAbXDb+CMT0nxhUOfHxPiJ7BfG5PGtBUVT2t+7255pprUF5e3uO+rVu3amFp3bp1eOutt7Bq1Spt/yuvvILFixdj7ty5OHDgAG688UYUFRVBlmWsXr0ar7/+ekQ1RENdXQsUJbJzEEtpaQ7U1DTHuoxBiec2Mj2NljkmTUHijJkwjxwFQRBQ36ZAKLoA6Qt+hKqS5VAlCXpnClKvnQ+h6AKe5z7E39vo4HmNnjM9t6qqory1sqP9fcMBBJQgREHEyIQczB15OQqc+RjuyIKu/RI+H1Dra+njnyD+BMq24geHK2GXZRz8758CjhSolWXQ5YyDufhnaBRsAH+fzwrfE6JnoJxbURTOaEDnpAGt+1+PTnW/N2vWrDnlMevXr8ezzz6LkpISbX6Zx+PBhg0bsGzZMgDAqFGjkJ+fj6+//hqSJKG6uhpz584FANTU1GDJkiX493//dxQXF6OqqgqyLEOn00GWZVRXV8PtdkNV1V73EVHfCs0t+whNn22D6vfBOCwL6dffAMfUi6CzWnt8TMLUi9C4eRMMRj1cdy7u54qJaKBr9Deh1FOGPZ4y7K0vQ1Mg9CEuw5qGCzMno9AZan9v0ZtjXGnsBMq2wr+lBA5ZBgCorR6g1QPd8PGwXLEIwgBdq41osDjlCNrRo0e1+4qidLkf6QjaqWzcuBFLly7FihUrkJWVpW1PTEyE0WjE559/jkmTJqGmpgalpaXIzc1FXl4errrqKu3YBQsW4KabbtLmsxUWFmLt2rX49re/jbVr16KwsFC7hPFk+4jo7GijZZs/gv/woY7RsukzYB41ekhcNkRE/ccvB1BWvx+l9aFRsorWKgCA3WDDOcm5KHDmo9CZh2RzUowrjR+B7X8FpMAJ25W6wwxnRHHgpAHN6/Xiiiuu6BLEZs2apd3uqw9a999/PwwGA+644w5tW0lJCZKTk/Hss8/iiSeegCzLUBQFt99+O/Ly8k75nL/61a9w33334Xe/+x0SEhLw5JNPRrSPiM6M7/AhNG7qabTsQuisQ2eCPRFFl6IqONp8XFuP7EDjYciqDL2oR27iSExxTUCBMw/D7G6IDBtQfS2Q645AqTsS/n40NGLW07Et7JhLFA8Eta+GwYYgzkGjoX5uFZ8XTds/Q+OmTqNlEyeH5padxWjZ0aeW8hLHKBrqv7fRwvMaParFj0/2/ROlnjLsrd+HNskLAMiyZ6LAmYcCZx5GJ46EUWeIcaWxo6oK1KZqLYT1FMYEaxLElBzIlWVA0HvCcwj2FNivX9afZQ9qfE+InoFybqMyB42IqCccLSOiaGoLevFN/T7sCV+2WOsNjewkmRIxNnWMFsocxoHTTbkvqZIfiucY5NojUDwdYQxSuAOuIEJMyoTOfQ50KTkQU3IgpmRrC023z0Hrcpmj3gjjpPn9/8MQ0QkY0IgoItpo2eZN8B862GejZUREsiLjYNMRlHq+wR5PGQ43hdrfm3RG5CWNxryCS5FtzEGGNX1Ivdeoqgq1raHTiFj4q7EKQPgKHoMFutQcGM65JBTGUnMgJmVC0Bt7fV5j3kUAAP+m5YAiQbCnwDhpvradiGKLAY2ITsp3ONyJcVvHaFna9TcggaNlRJr//vJFGAw63HbeT2NdyoCgqiqq2qrD88jKUNawH345AAECRiRkY86IS1HgzMfIhBzoRN2AuZzpbKiKBKWhsstcMaXuCFRfx88tONKgS8mGPncqxJRs6FJyINhTzyi0GvMuglS6CQaDHoY5vJycKJ4woBHRCRSfD03bt3G0jIj6THOgRVuPrLS+DA3+RgBAmiUFk8ONPfKTRsNqsMS40uhTA22QwwFMC2T1xwFZCh2g00NMzoJ++PnhyxNzoHNmQTDxj2JEQwEDGhFpfEcOo3HTRo6WEdFZC8hB7G84iD3136DUU4bjLRUAAKveEm5/n4cCZz5SLYN3mRtVVaG21IYCWKf5YmpzrXaMYHZATMmBYczlHfPFklwQRH5EIxqqev2vf8aMGRH9lfyjjz7qy3qIqJ9xtIyI+oKiKjjeUqGNku1rPAhJkaATdBiVOBxXjZqDQmcesh3DBmX7e1UKQKkv7xgRC4cxBNq7JQoQEzOgSxsFsWCmNl9MsCTyfZaIuug1oD399NP9WQfRgHP0qaWoHMCt4DlaRkRnq97XoK1Htrd+H1qCrQCATJsL04ddiAJnHnKTRsGk671hxUCkeJvClyd2dFBUGsoBVQkdoDdBTMmGIffC0OWJKdkQk7MgGEyxLZyIBoReA9rkyZP7sw4i6geKz4fm7Z+hYfNHodEygwGOSZOROKOYo2VEdEpeyYey+v0oDbe/r2qrAQAkGB0odJ6DwnD7+0RTQowr7RuqokBtquq2ttgRqG0N2jGCzQkxJRvGERdoYUxISIcwCEcJiah/RHyB8549e7Bjxw7U19ej89rWv/jFL6JSGBH1ndBo2Udo/uxTKD4fjJnDkHbdD5Ew9SLobBwtI6KeyYqMw81HtW6Lh5qOQFEVGEQD8pJGYVrmFBQ485Bpcw34P/CoQV9obbHOjTs8xzrWChN0EJMzoRs2JjQilpIT6qJoHpprsRFR9EQU0P785z9j6dKlmDZtGjZv3ozp06fjk08+wWWXXRbt+ojoDPU6WjZ9Jsyjcwf8hyki6nuqqqLGW6vNI9tbvx8+2QcBArIdw3B5zgwUOvMwMnEEDAO0iYWqqlBb66F4joQWeq47AtlzFGpjNbS1xUw26JzZMBTM1MKYmJwJQWeIae1ENDRE9O76yiuv4JVXXsHEiRMxadIkPP/889i0aRPefvvtaNdHRKeJo2VE/U+uOwJFEIDzYl3J6WsJtmKvZ5/W/t7jqwcApJiTMSFjLAqc+chPHg27YeC9f6iKBKW+otPaYqFLFVV/i3aMkJAOnTMbYt5F0DnDjTtsTv4Ri4hiJqKAVldXh4kTJwIARFGEoiiYMWMGFi8emM0RiAYbjpYRUaSCioQDDYfC88i+wdHmcqhQYdaZcU7yaMzKmYkCZx7SLCkD6r1D9bd2ujwxvMZYfTmgtK8tZoDozIJ+5Pjw2mLDQ2uLGQf/umtENLBEFNBcLheOHTuGrKwsjBgxAh988AGSk5NhMHConyiWOFpGRKeiqirKWyuxxxNaj2xfw0EElSBEQcTIhBzMHXk5Cpz5GO7Igk7UxbrcU1JVBWpzbZcRMbnuCNSWOu0YwZIAMSUHxqxztYWexcQMCAPg5yMiiiig/eQnP8H+/fuRlZWFW2+9Fb/4xS8QDAaxZMmSaNdHRN0oPh+aP/8MDZs6jZa1r1s2SEbLsu+9H2lpDtTUNMe6FKIBqcHfiL2efdjjKcPe+jI0BUL/LWVY03FR5mQUOvOQlzQKZr05xpWenCoFoHiOoelYDXyHvtHmiyHoCx0gCBAT3dBl5EEsuiw8XywbojUptoUTEZ2FiALatddeq92eMWMGtm/fjmAwCBv/Qk/Ub04cLctE2g9+iIQLOVpGNNT55UCX9vcVrVUAALvBhgJnHgqSQ+3vk83xG1yUtsZOc8XClyg2VgCqijYAMJihS8mBIW8axNSc0LwxZxYE/eBaY42IqNeApqqq9pd4RVG6Pkivh16vh6IoEEWu80EULe2jZY2bN8F38EDHaNn0mTDnDo7RMiI6fYqq4EjzMa3b4oHGw5BVGXpRj9zEkZjimoACZx6G2d0Q42w9LlWRoTRWhS9P7GjeoXqbtGMEewp0KTnQj5oIMSUHaXmFqA9auLYYEQ0JvQa0CRMm4MsvvwQAFBUVnfBBsD3A7dmzJ7oVEg1BviOH0bh5E5q3beVoGREBAGq9HpSG55Htrd+HNskLAMiyZ6I4+2IUOPMwOnEkjHHUCl4NeCF7jnYKY0dDa4vJwdABog5i8jDossd2rC3mzD5hbTFDsgMCL3kmoiGi14C2bt067fYHH3zQL8UQDWWK34/m7ds4WkZEAIC2oBff1O/DnvBli7XeUBOMJFMixqaNQWFyHs5x5sFhjP1CyaG1xTxQao9A9hwJfz8KtalaO0Yw2SGmZMNQdCl07Y07ktwQdANzPTUiomjp9V3R7XZrt999913cfPPNJxyzYsUK/PjHP45OZURDhP/oETRs+ujE0bKpF0Jnj/0HLyLqH5Ii4WDjEW0e2eGmo1ChwqQzIi9pNIqzQqNkGda0mP7BRpUlKPXHu7Szlz1HAX9r+AgBQmI6dKnDIeZfDF1qDkRnDgRbMv/QFGesV7EhE1E8iujPVs8//3yPAe2FF15gQCM6AyeMlun1sE+ajKTpxRwtIxoiVFVFVVs19nhC65GVNRyAXw5AgIARCdmYM+JSFDjzMTIhJ2bt71VfS6e1xcLNO+rLAVUOHaAzQkzJgmHUpNDliSk5ocYdhvjuDklEFM9OGtA+/fRTAKEmIdu2bYOqqtq+Y8eOsYsj0WnqebTs+tC6ZRwtIxr0mgMtWmOP0voyNPgbAQBplhRMDjf2yE8aDauhfxdPVlUFalN1x4hYOIyprR7tGMGaFFpbLGccxJRs6FJyICRkQGCzMCKiPnXSgNa+zpnf78cDDzygbRcEAWlpaXjwwQejWx3RIKD4/aFOjJs+4mgZ0SC0vfJLHBElSAAe/OQJXD16Dia7xgMAAnIQ+xsOYk99qLnH8ZYKAIBNb0W+MxeF4fb3KRZnv9WrSn4onmOQa49A8RzVwhgkf+gAQYSYlAmd+5yOuWIp2RAtCf1WIxHRUHbSgPbhhx8CAO6991489dRT/VIQ0WDhP3oEDZs/QvO2T6F4vTC6OVpGNNhsr/wSr5W+ASn8d5Z6fwNWlf4VO2t3ozXYhv2NhyApEnSCDqMSh+OqUXNQ6MxDtmNY1Nvfq6oK1dsYatgRvkxRqTsCpakKaL8ixmCBLjUHhnMuCYWx1ByISZlcW4yIKIYimoPWOZx1XxON66ARdeh9tGwmzLl5HC0jGkRUVcWb+99GUAl22S4pEr6s/hcybS5MH3YhCpx5yE0aBZMueqFHVSQoDZUnLPSs+jqaPwiO1NDaYrlTOy5RtKfyfYmIKM5EFNB27dqFRx99FHv37oXfH7oEguug0VDWtG0rfAf2wytJaLv3biTOnAmpvp6jZUSDVGuwDeUtlahorcTx1kpUtFSivLUK3vBaZD1ZMuXfo1KLGmjT5oppnRTrjwGyFDpAp4eYnAX98PPDlyfmQOfMgmDivHEiooEgooB23333obi4GE888QTMZnZmoqGtadtWVK0sgSqFPgxJnjrU/e0NQBDgmDIVSTOKOVp2ltreWopygx6GOYtjXQoNMQE5gIrWKpS3VoVDWCXKWyrRGGjSjrHozci0uTAhYxy+rPpaWzC6s2RT0lnXoqoq1JbaLiNict0RqM212jGC2QExJQeGMZd3WlvMBUHk2mJERANVRO/gx48fx1133cUPnDSkqbIM36GDqF71R6iBwAn79UlJcP/k5zGoCFxwGwAAIABJREFUjIhOl6zIqPHWory1CuUtFdr3Wq8HKkLzs/SiHm5rOgqceXDbMpBpdyPTloEkU6L27+HoxBF4rfSNLpc5GkQDrh4957TqUaUAlIbyjvli4eYdCLSHPwFiYgZ0aaMgFswMh7FsCNYk/ttMRDTIRBTQZs2ahY8//hiXXHJJtOshihuqqiJYVYm23bvQunsXvHtLoXh7v5xJqq/vx+qIKBKqqsLja0BFa8doWHlrJapaqyGF1/ISICDdmoph9kxMco1Hps2FTLsLaZaUUzbyaO/WuGrXnyABSDYndeni2BPF2xS+PLGjg6LSUA6o4TneehPElGwYci+E6MwOLfScnAXBYOqTc0JERPEtooDm9/uxaNEiTJgwAampqV32sbtjfDv61FJUGvVw3clLxSIhNTairXQ32nbvRtueXZA8oTWA9KmpcEyaDGvhGNT85fUew5jemdLf5RJRJy2B1i4hrH3OmE/2a8ckmRKRaXeh0JmvBbEMazqMOsMZv+75zT5kHaqDXZYh2mUY032AC1AVBWpTlRbC2jspqm0N2mMFmxNiSjaMIy4IL/ScDSEhHUKUOzwSEVH8iiig5ebmIjc3N9q1EPU7xe+H95u9oVGyPbsROHYUACBabbAWFsL6ratgLRoDY1q69hhVlkJz0Dpd5igYjUi9dn6/1080FPkkPyrbqlDeUoXy1gpUtFTheGsFmgMt2jFWvQWZdhcmuyYg056BTJsbbltGny8AHSjbCv/mEjjk0Gic2lIH/0evwL9jDeBtBKTw+4Sgg5icCd2wMdClZIfDWA4EM5sIERFRVxEFtEWLFkW7DqJ+0T6PrG3PbrTt3gXv/n2ALEPQ62HJy0fCtd+BtWgMTDnDIfSyhETC1IsAAFUly6FKEvTOFKReO1/bTkR9Q1ZkVLXVoDzcNbG9e2Ktz6MdYxANcNsyMMZZgEy7C5k2F9z2DCQaE85qbpYqB6F6m6C2NYbWEtNuN0H1Nmr7lMYqIDxnrePBCtBaD0PRpVoYE5MzIZzFKB0REQ0dEbd5+uSTT7Bu3Tp4PB68+OKL2LlzJ1paWnDhhRdGsz6isxKaR1aFtt3/h9Y9u+Et3aPNIzPlDEfyrNmwFhbBkpsH0RT5/I6EqRehcfMmGHj5KNFZU1RFmyd2PHxZYnlLJaraaiCH54mJgoh0SypyErIw1T0RmXYX3DYXUi3OiBd87j10tQevcOjyNnZqztGN0QrRkgDBmggxJRtKY2UvP5QE80XXn8npICKiIS6igPbHP/4RK1euxHe/+1289957AACz2YzHH3+cAY3iTmge2R607d7V6zwya0EhdA5HjCslGnqaAy043lIRamUf7p5Y0VoJv9xxybDTnIxMWwbOTS0MdU+0uZBhS4ehh9bxqhQIBa3wyJbS0yhX+H5koSsHOksChPb7lkTttmB2QNB3XWy65bW7obbUnfCUgp1zUomI6MxEFNBeffVVlJSUICsrC7///e8BAKNGjcLBgwejWhxRJBS/H96yvWjbdZJ5ZIVjYEhLYzvqAeIFczMEQUB0lvml/uCTfOEQ1rV7YkuwVTvGbrAh0+bCVPckDLO54La74LZlwAyx64hW/TdQvDvg8zZqlxlGFLqsoXClS8kJhayeQpcl4awuPTROmg//lpKOuWYAoDfCOIlzUomI6MxEFNBaW1vhdrsBQPuAK0kSDAZeT0/9T5Vl+A4fCo2QdZtHZs7NQ2oE88iIqG9IihSaJ9YtiHl8HZ1OjToj3NZ0nJc4Ci69HW6Y4VJE2PxeoK0Zat1RqN5dULxNkNoa0RLsJXSZbKGRrvbQ1R6wLAmh0NXpfn/N9zLmheae1m7+Q7iLYwqMk+Zr24mIiE5XRAFt0qRJePnll7Fw4UJt28qVKzFlypSoFUZ9Q647AnWAjxpp88j27Aq1vy/d3XUe2eVXwFo05rTnkRFR5BRVQZ23HuWtFVr3xPKWSlR7a6GE1+8SISBdtCAHBkxREpHhl5De1oqkljqIwWMnPGcQODF0ZXcKXdZECJb+D12ny5h3EV4/tDY06nv547Euh4iIBriIAtqDDz6IW265BatXr0Zraytmz54Nu92OF198Mdr10RAlNTWFOi2GQ5nkCc3x0KekwD5xEmyFY2ApLITekRCzGgdD+CXqTgn60dhUjvKGwzjeXI4Kby0qAg2oklsR6NSt0BlUkOEPojAgISMgwRWQkBqQQ/+oaKErEUJyGoRhiZ1GuRIGROgiIiKKlYgCWnp6Ot544w3s3LkTx48fh9vtxtixYyHy8jHqI9o8svAC0f6j3eaRzf1WaB5ZejrnkRGdJlXyQ21r0joXNh31w19djbY2Dyp8HlQEm1CheFEpSqgyiGjTdby32yUZroCMSbIAN0xw6+1wmZJgdiRDSE8MN9doD13tc7oibhBMRERE3UT0r+jChQvxwgsvYOzYsRg7dqy2fdGiRfjtb38bteJo8FIVBb5Dh9C2+//Qtmc3fPv3QZWkrvPICotgGj6C88iIetA9dPW4Rlf4flDyocagR6VJjyqjDpVGPSqNejQadIAOgA4wqQJcYgLGGhLgNqdgmN0Fd2IOEhwZDF1ERET9KKJ/cT/77LMet2/fvr1Pi6HBS1VVBKurQiNku3ehbe8eKG1tAABTdg6SLpvFeWQ05HUNXY3h2+HQ1b17YdB3wuMVAHU2O6ptdlSaTaiyW1ApGlGr+qGEj9EJIobZ05FvcSHT7obbnoFMmxtOcxJHp4mIiOLASQPab37zGwBAMBjUbrc7evQoMjMzo1cZ9Ql/QAZi9JlLampCW2k4kHWeR+ZMgX38RNiKYj+P7GyUizIEADmxLoTimhr0a6NaHaGrsdOCyeHt3qYeQxeA0JyucMMMXdoIwOxAk8WCKh1QiQAq5DZUBBpR6atFUJEAKBDgQ6rFiUybC+PtLmTaXMi0u5BuSYUrIwk1Nc39eRqIiIgoQicNaJWVlQBCox/tt9u53W7cfvvt0auM+kStKTSp/5x+eK3QPLJvwo09Os8js8JaUAjrld+CtYjzyGjg6xK62ho7Apd2aWHH/d5Cl2Cya3O3dGkjQ/O3rAnd1uhKhFenR4WvVlvUubylEhWtZWhr6GhFn2h0INPuxiUpeVoQc9kyYNIZe3xtIiIiil8nDWhLly4FAFxwwQX43ve+1y8F0cChzSPbsys0j2xfWZd5ZCnXzIe1cAzMIziPjOKfFro6zd3qaZRLbWsEJH+Pz9E5dIlpo8JBqz10de5g6IAgdn37DchBVLZWhdYSaz2Kcs/nqGitQoO/UTvGojfDbXNhfPpYZNrdyLRlwG13wW6wRfXcEBERUf+JaA7a9773PRw6dAhr165FdXU10tPTMW/ePIwYMSLK5VE86TKPbM8utJV2n0d2OayFY2DJy+c8MjpjgbKtuO5IFeyyjJbX7j6rRX/VoO+EhhkdzTTaLzkMX1540tAVbhOvha7EjjbyJwldPZEVGdXeOm1R54rw9xpvHdRwG3u9qIfbmo785NHaiFimzYUkUyJHn4mIiAa5iALahx9+iHvuuQfFxcXIzMzEwYMHMX/+fDz11FO47LLLol0jxZDUHF6PLBzKpLqu88isRUWwFhRBnzAw55FRfAmUbYV/SwkcsgwAUFvq4N9SAgBaSOsaurqOcnXvaNhr6DI7OhZDTh/dEcC00NW+Tldkoasnqqqi3t8QDmFVOB4OY5Vt1ZAUKVQHBKRZU5Bpd2Fixvlw210YZnMh1ZICnag7o9clIiKigS2iTx7PPvssfve732Hq1Knats8++wyPPfZYnwS0Rx55BJ9++imMRiOsViuWLFmC8847DwDw1Vdf4fHHH0cwGEQwGMQNN9yA6667DgCgKAr+53/+B++88w6MRiPcbjdefvllAEBtbS3uvfdeHD9+HCaTCY899hjGjRt3yn1DneL3w7uvLNT+fvdu+I8eAdBpHtmcb8FaVARDegb/kk99SpX8CHz2F0AKdN0hBeDftByBHWtC3Qu77w/rEroyRmtrcomd5nOdbejqTUuwFeUtlShvrURF+Ht5SxV8csf8syRTIjJtLpzjzMUwW6h7osuaASMXaiYiIqJOIvqUUllZiYkTJ3bZNmHChBMah5yp6dOn44EHHoDBYMDGjRtx1113YcOGDQCAhx9+GHfeeSeKi4tRXV2N2bNnY9asWUhNTcWrr76KgwcPYu3atTAYDKitrdWec9myZZg4cSKWL1+OHTt24J577sH7778PQRBOum+oURUF/sOH0Lq7h3lko3M5j+wkVLX9gjSKhBrwQmmphdpcB6W5Nny7FkpLHdSWutCIV28UCbrOoUsb4Ype6OqJXw6E5olpISz0vSnQ0RHRorcg0+bCZNcFcGuXJ2bAarBGvT6KnYU+BwwGrhVHRERnL6J/TQoKCrB8+XL87Gc/07atWLEChYWFfVJEcXGxdvv8889HZWUlFEWBKIoQBAHNzaEPP21tbbDZbLBYLACA5cuX47XXXoPBEPoLdGpqqvY87777Lj744AMAwMSJE2EymbBz506MHTv2pPsGk6ZtW+H0BCEqwIF770bqtfPhmHIhgtXVWqfFrvPIspF06eWh9cg4j+yUNl3iBARgWqwLiQOqqgL+VigttVCa66C21EJproXa0h7G6gB/a9cH6fQQ7KkQ7SnQDc+BYE9BYOf7gL/lhOcX7CmwXHpLP/007fPEunZOLG+tRJ3Xo80TM4h6uG0ZKHTma3PEMu0uJBoThuQfe4iIiKhvRBTQfvWrX2HhwoVYuXIl3G43KioqYLVa8cILL/R5QatWrcLMmTMhhkdrli5diltvvRXPPPMMGhsb8fTTT8Nms6GlpQX19fV45513sH79eoiiiJ/+9Ke4/PLLUV9fD1VV4XQ6ted1u92orKxEdnZ2r/sGU0Br2rYVVStLoAuvTit56lC5/BVUvb4Kamvog7Le6YR9/ARYi8ZwHhmdlKqqoTle4cClhoOYNiLWUntiO3m9CaIjFYI9BYaM3FAYc6Ro2wRLAgSh66is4EgNzTnrfBmj3gjjpPlR+bkUVUG9r6HLaFh5SyWq2mogq6F5cKIgIs2SimzHMExxjde6J6ZaUiAKHFUmIiKivhVRQBs9ejTefvttfPXVV1oXx3HjxmkjV6dyzTXXoLy8vMd9W7duhU4Xmgy/bt06vPXWW1i1apW2/5VXXsHixYsxd+5cHDhwADfeeCOKiopgsVgQDAahKApWr16Nw4cP4/rrr0d+fj4cDkdEdZ2tlBR7v7zOmTj8979BDXSbq6MoEIJBjPz5T5F0/liY3W7+pf9shE9dWlr//L5Fk6oqkJvrITXWQGqsQbCxOny7/Xst1G5zv0SzDfrEdOjT3NDnjoU+MR2GxLTQtsQ0iBb76f9+pc1Gc4IF+9c+B4eswJCQiuTiH8Jx7vSz/hkbfU042liOI+Gvo+EvX6dGIqlWJ7ITMzEpeyyyEzORkzgMmQmDc57YYPi9jSfl4csbeV6jh+c2enhuo4fnNnoG87k9aUBTVRV/+ctfUFZWhqKiIlx77bVn9CJr1qw55THr16/Hs88+i5KSEu1SRY/Hgw0bNmDZsmUAgFGjRiE/Px9ff/01rrzySlitVlx99dUAgOHDh6OoqAi7d+/GnDlztMe3j5RVVFTA5XIhOTm5132nq66uBYoSn7OQ/DW1PW5XAgHoJ01DC4CW2hMvJaPToAIQgJqa5lMeGmuqIkNt9XS67LDzSFgt1FYPoMhdHiOYHRAcqRATMqEfNhaivX30KzQSJhg75lSpAILhLwBAK4DWM/z9yrgAr7rSAAF4YO6T8AHwncY59kk+VLRWo7y1AhUtVTgebtzRHOyox2awItPmwhTXBO3SRLctAxa9peuTSUCjxweg58WmB6q0NMeA+L0dSIJBCQaDnuc1Svg7Gz08t9HDcxs9A+XciqJwRgM6Jw1oTz75JNauXYsJEybgmWeewbFjx3DHHXeccZG92bhxI5YuXYoVK1YgKytL256YmAij0YjPP/8ckyZNQk1NDUpLS5GbmwsAmDdvHrZs2YLvf//7qKurQ2lpKfLy8gAAc+bMwZ/+9Cfceuut2LFjB3w+H84999xT7hss9M4USJ66HrfT4KPKwY7g1bn5Rvv3Vg+gdv1jgmBNguBIhS59FETHZAidA5g9BYIhNnMQt1d+iUqTClkAHvzkCVw9eg4mu8afcJykSKhqq0FFS2UohIUvT6zz1WvHGEUD3DYXzk0tRKYtA5l2N9w2FxKMZzC6R3QS1qvuHzAfGIiIKL4Jqqr2OgQ0Y8YMlJSUYOTIkdi3bx9uvfVWvP/++31exNSpU2EwGLrMCyspKUFycjI+/vhjLFu2DLIsQ1EULFiwAN///vcBhEbBHnjgARw7dgyCIOCmm27CNddcAwCoqanB4sWLUV5eDpPJhEceeQTjx48/5b7TEc8jaO1z0Dpf5igYjcj4fzciYeqZLfpLXT2x7j+0UZ5oUyV/qPlGt+6H7SFMbWvo+gBBgGBzavO9tO/21PBtJ4Q4vGxve+WXeK30DQQVbSwOBtGAq0bNRqolRQth5a2heWKKGppkKQoiMqxpnUbDXBhmd8FpTuY8sR4wSEQHz2v08NxGD89t9PDcRs9AObdRGUFrbm7GyJEjAQC5ublobGw8s+pOYdu2bb3uu/jii3HxxRf3uM/pdOLFF1/scV9aWhpKSkpOe99gkTD1IkiVZfC8txFKENCZRCTPmsZwFqfUQFuX7oddRr+aa6H6ur0Jibpw4EqBLvu88GWH7WEsBYItuV/azvcFRVXQGmxDU6AZfytb2yWcAUBQCeJv+9Zq91PMyci0u3BeahGG2Vxw213IsKZBP0B+XiIiIqKTOeUctKNHj2r3ZVnuch8AsrOzo1MZnZVA2VYYPJ8g44L2LQrg+QSBsjwY8xjSzlagbCt+VFkDh6yg5bW7YZw0v9fzqrWg10a/Ol+GGOqGiEBb1wfpDFrg0qUO7+iAaE+F4EgNLbwc5yNDfjmAJn8zmgLNaAw0oSnQjObw/Y6vFjQFmrWRsJO5Z8IiuG3pMOvN/VA9ERERUWycNKB5vV5cccUV6HwV5KxZs7TbgiBgz5490auOzljg8ze6tioHACkA/+YVkA/uAAQx/CV0ui1CEAUAIiB23yeEAoEQ3gchfEz4cd2fS+zhcd2eD2IPj+v+eqLYY61dHid23X/Cvk619kWoCZRthX9LCRLkUKhQW+rg37wCSlM1dEnuHtcBQ6dOgQAAgzkctlJgyMgPhbHOAczsiMs5UrIiozkYClWh8BW+HWjSwlj7l18OnPB4AQISjHYkGB1wmBzItLuRaExAgtGBBJMDf9n7ZpdmHu2STUkYmZjTHz8iERERUUydNKCVlpb2Vx3Ux9SWExuEAADkIJSmakBVAFWFqiqAomj3Q9+77YPa6ZjwcYjPuXcR6TEUnioQhkMeRCiNFSd0PIQcRPCLNzu6GJpsofleiS7oho0JXXboSNXmgMFojZsApqoqvJIvFLK04NU5fIVHwfxNaA22aQs1d2bRm5FgTECC0Y4cRxYSTI5Q6Ap/JZpCIcxmsJ50TpikSD3OQbt69Jyo/OxERERE8YaTNgYpwZ7SY0gT7Cmwfec/z/r51S5hrlO4U5RQsOsh8EEN71NO3N6xr6dAqHR9vW7HqD29ltLD47q/Xo/BtIeA2u25lfpjvZ4X63f+M9QB0Wjp9Zj+EpSDJ4SsJn9Tj+FLUqQTHq8XdHCER7ac5mSMSMhBYvh+5/DlMDr6bJ2w9m6N//t/f4IsAMnmpF67OBIRERENRgxog5Rx0nx4N62A2GkkQhENsEya3yfPLwgCIOgA6E7c1yevEL9aXru71/Crc2b18Ii+07mhRvdLCttHudrDl1fy9vgcdoNNC1fpSandRro6blv0lpiM8k12jceGL/4c6pB52QP9/vpEREREscSANkh9ERiFTfpCNLrL0aQXkCCpSKzIxIzAKFwY6+IGOOOk+dj25Sq8l2RGg15EkqRgdoMPU8efefj1Sf5uI10nhq8mfzOagy09NtQwigYkhC8jdNsyUODM7RK82ud4OQx26MQTQzURERERxQcGtEHqz19+hMCwagi60HyfJoOAxmHVeP2Lj3DuyGthMemh18V3F8B49ZXDjL+lJyCohuahNRh0+Ft6AswOMyZ3Ok5rqOHvPsp1YvgK9NBQQxREOAx27ZLCLHtml7DVOXyZ9bFZVJqIiIiI+hYD2iDlT90NUdd1pEXQKZAy/4l7P9jXvgWi0P4lQieGvotix32dKEIUQt/b7+t1Yvh+aJteDDXRECAAggAxfJFjaJsY6rXR/j9BgBDeB+3+ifva/wcBECF2er7Oj+m6DQi/dvvrnXB8+/N1fm30UIOgXdonhn+mzvveKHtLC2ftgqqM10vfwGcVX2ihqyXY2uP/Nxa9JRys7BiRkN3jSFckDTWIiIiIaPCJKKDNmDGjx7koRqMRGRkZuOKKK3DddddBr2feixei0dfjdkFQ4U50QlYUyIoa+q4qUMK3JUWFElQgq0Eoiqp17BOETp37tNtqeMKZClEQOrrnC+EGiKEcBEFQO91uryP8+G7Pp0IN9eSAAhXhZiRQoaqhSlTtdvx1kQwoQfhkP1ItKRiVOLxT2EroFMDsMPRRQw0iIiIiGnwiSlQLFizAP/7xDyxYsAButxsVFRVYtWoV5syZg8TERKxYsQIVFRW49957o10vRcimc6BVae5x+0PTb434eSRZgS8gw+uX4PVLHbcDEnx+Gd6ABK9fhq99X0CCzy/BGz7O1+l7JIx6EWaTHhajTvtuMelhNuphMelC382h72ajCItRD5NJB7NJhNmgg8mkg8kgwqAXgXCMaw907eEOABRVi3sd+1XtEVDaQ6D22I7n+e1Xr6ApcOK5TTYlYfHERRGfWyIiIiKi7iIKaGvWrMHy5cuRkZGhbZs+fTpuuukmrFu3DlOmTMGPf/xjBrQ48p2Cb+F/d/8VMjrap+ugx3cKvnVaz6PXibBbRNgtZzfqo6gq/J1DW3vA6xb2OkJf6DifX0Jto69L2JOVU4+eiYLQEehM7WFP33WbsVMQ7CUUmo06iGLX0ePzzBfjY+97EDpdQqrKIopMbL9CRERERGcnooBWU1MDm83WZZvFYkF1dTUAYOTIkWhqaur76uiMta8btfqLVWgzi0g2J8d0PalQYAoFobOhqiokWYHX3zXk9Th61y3sNbcFUN0gwxd+nD8Y2aieyaCD2aTTAt7RagFq4rnQZ38DweiDGjBDOpqPT/5PRELgEPS60AieQS9CrxNC93Ui9Hqx0+1O28P7DOFj9frQvD8iIiIiGnoi+rRcXFyMhQsXYuHChcjIyEBVVRVeeuklFBcXAwD++c9/Iisruus/0emb7BqP4JYXAADTfv10jKvpG4IgwKDXwaDXIcFmPKvnkhUlPKrX++hdx6WaknacJCuAJxOyJ7PL83kh42+bD5xVTe10ohAObZ1CXjjghYKd0C3whY4zaGGvc/ALP0fn7ToRhnBI7PrcQihcdguU3UcRo+nTXZU4VDodUtCMxYc+wbUzRuPCMa5+e30iIiKiWIoooD366KN47rnn8Mtf/hLV1dVIT0/HnDlzcNtttwEAsrOz8dJLL0W1UKK+phNFWM0irObTu3xz8e8+QV2T/4TtzgQTlv5sKoJSaJRPkhUEZQWSpECS1U63w9tlFZLUflvRbgfDx3d9vIJg+Pj25/YHZbR6pU7P1/4cqna7r1qpiIIAvV7oEvC6j/oZuoQ9IaJRQ+248P19xxrw/udHIckWAEBdkx+vvlMKAAxpRERENCREFNBMJhPuuece3HPPPT3uT0tL69OiiOLZtTNG49V3ShGQOuagGfUi5s8YHR7di2FxnaiqCllRw4Gvl5B4ivDYNfyFnku730OY9PqlHsNkMPx4RT39yBiQFPxt034GNCIiIhoSIvooefXVV+Pqq6/GvHnz4HLxQxINbe1BYcW7X0AKmpGSYI7Ly/AEQdAuj4wXiqJ2He2TOgVCWcFjr+7o8XE9jVgSERERDUYRBbTbb78da9euxfPPP48xY8Zg3rx5mDNnDpKSkqJdH1FcunCMCxsPbQYE4IG5T8a6nAFDFAWYRB1MBl2P+1MSTD2GsZQEU7RLIyIiIooLEf1pfdasWfjNb36DLVu2YP78+Vi/fj1mzpyJW265Jdr10VnadIkTm6Y7Y10GUUSunTEaRn3XtyWjXsS1M0bHqCIiIiKi/nVas2XsdjvmzZsHh8MBSZKwefPmaNVFRENQ+2Wir7z7T6hBY9xePkpEREQULREFNFVVsW3bNrz11lvYsGEDMjMzMW/ePPz617+Odn1ENMRcOMaF1Uf+D4Io4OnZPTcmIiIiIhqsIgpol1xyCaxWK+bOnYvXX38do0fzciMiIiIiIqK+FlFAe/755zFu3LgTtiuKAlGMnw5xRDQ4ZHgug8HYcyMRIiIiosEsonTVPZzt3bsXTz75JKZPnx6VooiIiIiIiIaiiJuEeDwevPXWW3jzzTdRWlqKiRMnYsmSJdGsjfpArZgKQRRiXQYREREREUXgpAEtGAziww8/xJo1a/Dxxx8jJycH3/rWt1BeXo7//u//RkpKSn/VSRR3GH6JiIiIqK+dNKBNmzYNgiDg2muvxe23344xY8YAAF5//fV+KY6IiIiIiGgoOekctHPOOQfNzc34+uuvsXPnTjQ2NvZXXUREREREREPOSQPaH//4R6xfvx7Tpk3D8uXLMW3aNNxyyy1oa2uDJEn9VSMREREREdGQcMoujsOGDcNtt92G999/HyUlJUhLS4Moirj66qvx1FNP9UeNREREREREQ0LEXRwBYOLEiZg4cSIefPBBrF+/Hm+++Wa06qI+8syVi5GW5kBNTXOsSyEiIiIiolM4rYDWzmQyYd68eZg3b15f10NERERERDRknVFAIyIgw3MZDEaxFSaGAAARvUlEQVRdrMsgIiIiokGEAY3oDP3HD8fz8lEiIiIi6lOnbBJCRERERERE/YMjaEQUdzg6SUREREMVR9CIiIiIiIjiBAMaERERERFRnGBAIyIiIiIiihMMaERERERERHGCAY2IiIiIiChOMKARERERERHFCQY0IiIiIiKiOMGARkREREREFCcY0IiIiIiIiOIEAxoREREREVGcYEAjIiIiIiKKE/pYFwAAjzzyCD799FMYjUZYrVYsWbIE5513HgDgq6++wuOPP45gMIhgMIgbbrgB11133Sn31dbW4t5778Xx48dhMpnw2GOPYdy4cafcR0REREREFCtxEdCmT5+OBx54AAaDARs3bsRdd92FDRs2AAAefvhh3HnnnSguLkZ1dTVmz56NWbNmITU19aT7li1bhokTJ2L58uXYsWMH7rnnHrz//vsQBOGk+4iIiIiIiGIlLi5xLC4uhsFgAACcf/75qKyshKIoAABBENDc3AwAaGtrg81mg8ViOeW+d999Fz/4wQ8AABMnToTJZMLOnTtPuY+IiIiIiChW4mIErbNVq1Zh5syZEMVQdly6dCluvfVWPPPMM2hsbMTTTz8Nm8120n319fVQVRVOp1N7XrfbjcrKSmRnZ/e6b+zYsadVa0qKvQ9+4v6RluaIdQmDFs9t9PDcRg/PbXTwvEYPz2308NxGD89t9Azmc9svAe2aa65BeXl5j/u2bt0KnU4HAFi3bh3eeustrFq1Stv/yiuvYPHixZg7dy4OHDiAG2+8EUVFRcjMzOx1X/soWrTV1bVAUdR+ea2zkZbmQE1Nc6zLGJR4bqOH5zZ6eG6jg+c1enhuo4fnNnp4bqNnoJxbURTOaECnXwLamjVrTnnM+vXr8eyzz6KkpASpqakAAI/Hgw0bNmDZsmUAgFGjRiE/Px9ff/01zGZzr/uuvPJK7fHtI2UVFRVwuVxITk7udR8REREREVEsxcUctI0bN2Lp0qX4wx/+gKysLG17YmIijEYjPv/8cwBATU0NSktLkZube9J9ADBnzhz86U9/AgDs2LEDPp8P55577in3ERERERERxYqgqmrMr9GbOnUqDAZDl3lhJSUlSE5Oxscff4xly5ZBlmUoioIFCxbg+9//PgCcdF9NTQ0WL16M8vJymEwmPPLIIxg/fvwp950OXuJIPLfRw3MbPTy30cHzGj08t9HDcxs9PLfRM1DO7Zle4hgXAW2gYkAjntvo4bmNHp7b6OB5jR6e2+jhuY0entvoGSjn9kwDWlxc4khEREREREQMaERERERERHGDAY2IiIiIiChOMKARERERERHFCQY0IiIiIiKiOMGARkREREREFCcY0IiIiIiIiOIEAxoREREREVGcYEAjIiIiIiKKEwxoREREREREcYIBjYiIiIiIKE4woBEREREREcUJBjQiIiIiIqI4wYBGREREREQUJxjQiIiIiIiI4gQDGhERERERUZxgQCMiIiIiIooTDGhERERE/7+9u4+psv7/OP4EjgdFQRQHWt4hm2UWStx5z75430AtzUydK21OERSQksTuUHFUhg5N8WYrN6duoSlqkxmaw8rwZmIqauAIkJtAUTjeAuf3h+vs68q+1Q+6DqfX469zAdd1Xuc9GLz5vK/PERGxE2rQRERERERE7IQaNBERERERETthMjpAa+bs7GR0hD+tNWVtbVTblqPathzVtmWori1HtW05qm3LUW1bTmuo7d/N6GS1Wq3NnEVERERERET+Bo04ioiIiIiI2Ak1aCIiIiIiInZCDZqIiIiIiIidUIMmIiIiIiJiJ9SgiYiIiIiI2Ak1aCIiIiIiInZCDZqIiIiIiIidUIMmIiIiIiJiJ9SgiYiIiIiI2AmT0QGk5dy4cYO33nqLn3/+GbPZTK9evUhOTqZz585GR2v1oqKiKC0txdnZGTc3N9555x369etndCyHsm7dOtLT08nKyqJv375Gx3EI4eHhmM1mXF1dAUhISGD48OEGp3IM9+7dIyUlhe+++w5XV1cGDhzI8uXLjY7V6pWWlrJgwQLbcV1dHfX19fzwww8GpnIMR44cYe3atVitVpqamoiJiWHMmDFGx3IIR48eZe3atTQ0NNCxY0dWrVpFjx49jI7VKqWmpnLo0CHKysoe+Xvg6tWrJCYmUltbi6enJ6mpqfTu3dvYsM3IyWq1Wo0OIS2jtraWS5cuERoaCjz8Jr958yYpKSkGJ2v96urqcHd3B+Dw4cOsX7+ePXv2GJzKcZw/f560tDQKCwvJyMhQg9ZMwsPD2bhxo+rZAlasWIGzszNvv/02Tk5OVFdX06VLF6NjOZyVK1fS2NjIu+++a3SUVs1qtRISEsL27dvp27cvBQUFvPrqq5w6dQpnZw1X/X/cvHmTMWPGsHPnTnx9fdm7dy/79u1j69atRkdrlU6ePMmTTz7JjBkzHvn9NWvWLCZPnszEiRPZu3cvmZmZbNu2zeC0zUc/hQ7M09PT1pwBDBw4kGvXrhmYyHH82pwB1NfX4+TkZGAax3L//n2Sk5N57733VFdpFSwWC19++SWLFi2yfc+qOWt+9+/fJysri8mTJxsdxSE4OztTV1cHPPyno7e3t5qzZlBcXEyXLl3w9fUFICwsjNzcXK5fv25wstYpKCiIbt26PfKxmpoaLly4QEREBAARERFcuHDBoWqsEcd/iaamJnbs2EF4eLjRURxGUlISx48fx2q1smXLFqPjOIy1a9cyYcIEjYO0kISEBKxWK4GBgcTHx+Ph4WF0pFavpKQET09P1q1bx4kTJ2jfvj2LFi0iKCjI6GgOJScnBx8fH/r37290lFbPycmJNWvWEBUVhZubGxaLhYyMDKNjOQRfX1+qq6vJz8/H39+frKwsAMrLy3WLSTMpLy/Hx8cHFxcXAFxcXPD29naoGutfJf8Sy5cvx83NjZkzZxodxWGsXLmSo0ePEhcXx4cffmh0HIdw5swZzp07x/Tp042O4pC2b9/Ovn37yMzMxGq1kpycbHQkh9DQ0EBJSQnPPPMMu3fvJiEhgZiYGOrr642O5lAyMzO1etZMGhoayMjI4NNPP+XIkSNs2LCBuLg4LBaL0dFaPXd3d9LS0li1ahUvvfQSNTU1eHh4YDJpTUT+PDVo/wKpqakUFxezZs0ajS+0gEmTJnHixAlu3LhhdJRWLy8vj6KiIkaOHEl4eDgVFRXMmTOH3Nxco6M5hF/HRMxmM9OnT+f06dMGJ3IMTzzxBCaTyTZuM2DAADp16sTVq1cNTuY4KisrycvLIzIy0ugoDuHixYtUVVURGBgIQGBgIO3ataOwsNDgZI5hyJAh7Nixg927dzNz5kzu3r2rqZBm1K1bNyorK2lsbASgsbGRqqqq34xCtmb6a93BpaWl8eOPP7J+/XrMZrPRcRyCxWKhvLzcdpyTk0PHjh3x9PQ0MJVjmDt3Lrm5ueTk5JCTk0PXrl3ZunUrw4YNMzpaq3f79m3b/SZWq5WDBw9q59Fm0rlzZ0JDQzl+/DjwcHexmpoaevXqZXAyx7Fnzx7CwsLo1KmT0VEcQteuXamoqKCoqAiAwsJCqqur6dmzp8HJHMMvv/wCPLy95JNPPmHatGm4ubkZnMpxeHl50a9fP/bv3w/A/v376devn8OMN4J2cXRoV65cISIigt69e9O2bVsAunfvzvr16w1O1rpVV1cTFRXFnTt3cHZ2pmPHjixZskT3RbQA7TrYfEpKSoiJiaGxsZGmpib8/PxYtmwZ3t7eRkdzCCUlJSxdupTa2lpMJhOxsbGEhYUZHcthjB07lqSkJEaMGGF0FIexb98+Nm/ebNvYZuHChYwaNcrgVI4hKSmJ06dP8+DBA4YOHcrSpUttb28if82KFSvIzs6murqaTp064enpyYEDBygsLCQxMZFbt27h4eFBamoqffr0MTpus1GDJiIiIiIiYic04igiIiIiImIn1KCJiIiIiIjYCTVoIiIiIiIidkINmoiIiIiIiJ1QgyYiIiIiImIn1KCJiIjD2LhxI0lJSUbHaHbx8fEcPnzYdpyWlkZoaChDhw79w/Oio6M5duxYS8cTEZFmpG32RUSk1QgICLA9vnPnDmazGRcXFwA++OADJkyY8I9nSkxMxMfHh7i4uBa5fkFBAfHx8Rw4cAAnJyfKy8sZO3YsR44cwcvL6w/Pzc/P5/3332f37t0tkk1ERJqfyegAIiIif9aZM2dsj8PDw1mxYgVDhgwxMFHL27VrF5GRkbY3FC4rK8PT0/N/NmcA/v7+1NfXc+7cOZ577rmWjioiIs1AI44iIuIw0tPTSUhIAKC0tJSnnnqKzMxMwsLCCA4OZseOHeTn5xMZGUlQUBDJycmPnP/FF18wfvx4goODmTNnDmVlZQBYrVZSUlIYPHgwgYGBREZGcvnyZXbt2kVWVhZbt24lICCAefPmAVBZWUlMTAyDBg0iPDycbdu2PZJx4cKFxMbGEhAQwIsvvkhBQcFjX9OxY8cIDg4G4Ntvv2X27NlUVVUREBBAYmIi9+7dIyEhgdDQUIKCgpg8eTLV1dW280NCQvjmm2+ap8AiItLitIImIiIO7ezZs2RnZ5OXl8f8+fMZPnw4n332GQ0NDUyaNIlx48YREhLC4cOHycjIYOPGjfTq1YtNmzaxePFidu7cSW5uLidPnuTQoUO4u7tTVFSEu7s7r7zyCmfOnHlkxLGpqYn58+cTHh7O6tWrqays5LXXXsPX15fhw4cD8PXXX7N69Wo++ugjtm3bRlRUFIcOHaJNmzaPZL99+zalpaX06dMHgCFDhrB582befPNN271lO3fupL6+nqNHj2I2m7l48SJt27a1XcPPz49Tp079E6UWEZFmoBU0ERFxaAsWLMDV1ZVhw4bh5uZGREQEXl5e+Pj4EBQUxIULF4CHjc7cuXPx8/PDZDIxb948Ll68SFlZGSaTCYvFQlFREVarFT8/P7y9vX/3+c6dO8f169eJjo7GbDbTo0cPpk6dysGDB21f079/f8aNG0ebNm14/fXXuX//PmfPnv3Nterq6gBo3779Y1+fyWSitraW4uJiXFxcePbZZ+nQoYPt8+3bt+fWrVt/q3YiIvLP0wqaiIg4tP++V8vV1fU3x7dv3wbg2rVrpKSkkJqaavu81WqlsrKSwYMHM2PGDJKTk7l27RqjR49myZIljzRCvyorK6OqqoqgoCDbxxobGx857tq1q+2xs7MzPj4+VFVV/eZa7u7uAFgsFlxdXX/39U2cOJGKigri4+O5desWEyZMIC4uzrYaZ7FY8PDw+OMiiYiI3VCDJiIiAnTr1o158+Y9difIWbNmMWvWLGpqaoiNjWXLli3ExsbaNu/47+t0796d7Ozsxz5XRUWF7XFTUxOVlZW/uyLn5uZGz549uXr1Kp07d/7da7Vp04bo6Giio6MpLS1l7ty5+Pr68vLLLwNQWFjI008//T9fv4iI2AeNOIqIiADTpk1j06ZNXLlyBXg4XvjVV18BD7erP3v2LA8ePKBdu3aPbO/v5eVFaWmp7Tr+/v506NCBTZs2cffuXRobG7l8+TL5+fm2rzl//jzZ2dk0NDTw+eefYzabGTBgwO/mCgsLIy8v77G5v//+ey5dukRjYyMdOnTAZDLZsgHk5eUxYsSIv18YERH5R6lBExERAUaPHs0bb7xBfHw8zz//PBEREbaNOCwWC8uWLSMkJIT//Oc/eHp6Mnv2bACmTJnCTz/9RFBQEFFRUbi4uLBhwwYKCgoYOXIkgwYNYtmyZdTX19uea+TIkRw8eJDg4GD27t1Lenr6bzYI+dXUqVPJysricW9bWl1dzcKFCwkMDOSFF14gJCTEtgqYn59Pu3bt8Pf3b85SiYhIC9IbVYuIiPyD0tPTKS4u5uOPP/7T5yxevJjx48czatSov/RcMTExTJkyhbCwsL8aU0REDKJ70EREROzc6tWr/9Z56enpzZxERERamkYcRURERERE7IRGHEVEREREROyEVtBERERERETshBo0ERERERERO6EGTURERERExE6oQRMREREREbETatBERERERETshBo0ERERERERO/F/W2seIiMPqYgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "batches=4\n", + "split_str = ['g-BAOAB K_p=1','g-BAOAB K_p=2','g-BAOAB K_p=3','g-OBABO']\n", + "plt.figure(figsize=[14,5])\n", + "H = []\n", + "\n", + "for ii in range(len(split_str)):\n", + " res=[]\n", + " err=[]\n", + " h = []\n", + " for jj in range(len(dts)): \n", + " try:\n", + " y=h5py.File('Results/x_'+str(ii)+'_'+str(jj)+'.h5')\n", + " pe = np.array(y['potentialEnergy'])\n", + " pe = pe[len(pe)//10:]\n", + " if(len(pe)<2):\n", + " raise\n", + " \n", + " h += [ np.histogram(pe, np.linspace(-29500,-26000,25),density=True)[0]]\n", + " pe=pe[:batches*(len(pe)//batches)].reshape(-1,batches)\n", + " y.close()\n", + " if (np.mean(pe)>-2000):\n", + " res+=[np.nan]\n", + " err+=[np.nan]\n", + " else:\n", + " res += [np.mean(pe)]\n", + " err += [np.std(np.mean(pe,1))/np.sqrt(batches)]\n", + " except:\n", + " res += [np.nan]\n", + " err += [np.nan]\n", + " \n", + " plt.errorbar(dts,res,err,None,'o-',label=split_str[ii])\n", + " H+=[h]\n", + "plt.legend()\n", + "plt.grid(1)\n", + "plt.ylim([-28900,-27900])\n", + "plt.xlim([1.5,10.5])\n", + "plt.title('Average PE from a '+str(T)+'ps simulation')\n", + "plt.xlabel('Timestep (fs)')\n", + "plt.ylabel('Avg Potential Energy (kJ/mol)')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### PE Distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "xx=np.linspace(-30000,-27000,24)\n", + "plt.figure(figsize=[16,10])\n", + "for jj in range(4):\n", + " plt.subplot(2,2,jj+1)\n", + " for ii in range(7):\n", + " try:\n", + " plt.plot( xx,H[jj][ii],label='dt='+str(dts[ii])+'fs')\n", + " plt.fill( xx,H[jj][ii],alpha=0.25 )\n", + " except:\n", + " break\n", + " plt.xlabel('Potential Energy (kJ/mol)')\n", + " plt.title(split_str[jj])\n", + " plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} From 7be261189521bcc3c39104dc27f15beeddf7ae20 Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Wed, 25 Sep 2019 15:44:54 -0400 Subject: [PATCH 10/18] use CutoffPeriodic in nb_split tests --- openmmtools/tests/test_forcefactories.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/openmmtools/tests/test_forcefactories.py b/openmmtools/tests/test_forcefactories.py index 5831d941a..dde39cafb 100644 --- a/openmmtools/tests/test_forcefactories.py +++ b/openmmtools/tests/test_forcefactories.py @@ -210,11 +210,12 @@ def check_force_group_decomposition_valid(testsystem, force_group_splitter): compare_system_forces(testsystem.system, new_system, positions) +from simtk.openmm import app def test_split_nb_using_exceptions(): - testsystem = testsystems.AlanineDipeptideExplicit() + testsystem = testsystems.AlanineDipeptideExplicit(nonbondedMethod=app.CutoffPeriodic) check_force_group_decomposition_valid(testsystem, split_nb_using_exceptions) def test_split_nb_using_subtraction(): - testsystem = testsystems.AlanineDipeptideExplicit() + testsystem = testsystems.AlanineDipeptideExplicit(nonbondedMethod=app.CutoffPeriodic) check_force_group_decomposition_valid(testsystem, split_nb_using_subtraction) From ac330abe83476fa38461577dc26c50164d57ee05 Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Wed, 25 Sep 2019 15:45:07 -0400 Subject: [PATCH 11/18] generate a slightly different conformation for testing --- openmmtools/tests/test_forcefactories.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/openmmtools/tests/test_forcefactories.py b/openmmtools/tests/test_forcefactories.py index dde39cafb..b305490dc 100644 --- a/openmmtools/tests/test_forcefactories.py +++ b/openmmtools/tests/test_forcefactories.py @@ -206,7 +206,7 @@ def check_force_group_decomposition_valid(testsystem, force_group_splitter): produces identical forces as the original on a slightly randomized configuration. """ new_system = force_group_splitter(testsystem.system, testsystem.mdtraj_topology) - positions = generate_new_positions(testsystem.system, testsystem.positions, nsteps=5) + positions = generate_new_positions(testsystem.system, testsystem.positions, nsteps=50) compare_system_forces(testsystem.system, new_system, positions) From 8ec3266a7c30ec4622a13e7137652b62e8e66a84 Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Wed, 25 Sep 2019 15:45:51 -0400 Subject: [PATCH 12/18] update clone_nonbonded_parameters fxn --- openmmtools/forcefactories.py | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/openmmtools/forcefactories.py b/openmmtools/forcefactories.py index 1a90bd584..718879a6e 100644 --- a/openmmtools/forcefactories.py +++ b/openmmtools/forcefactories.py @@ -184,7 +184,9 @@ def clone_nonbonded_parameters(nonbonded_force, """Creates a new CustomNonbonded force with the same global parameters, per-particle parameters, and exception parameters as """ - #TODO: assert that nonbonded_force.getNonbondedMethod() indicates reaction field + allowable_nb_methods = {openmm.NonbondedForce.CutoffPeriodic, openmm.NonbondedForce.CutoffNonPeriodic} + assert(nonbonded_force.getNonbondedMethod() in allowable_nb_methods) + # call constructor # The 'energy_prefactor' allows us to easily change sign, or e.g. halve the energy if needed @@ -193,24 +195,26 @@ def clone_nonbonded_parameters(nonbonded_force, new_force.addPerParticleParameter('sigma') new_force.addPerParticleParameter('epsilon') + # go through all of the setter and getter methods new_force.setCutoffDistance(nonbonded_force.getCutoffDistance()) #new_force.setEwaldErrorTolerance(nonbonded_force.getEwaldErrorTolerance()) #new_force.setForceGroup(nonbonded_force.getForceGroup()) - #new_force.setNonbondedMethod(nonbonded_force.getNonbondedMethod()) # If PME, will be an Illegal value for CustomNonbonded + new_force.setNonbondedMethod(nonbonded_force.getNonbondedMethod()) #new_force.setPMEParameters(*nonbonded_force.getPMEParameters()) #new_force.setReactionFieldDielectric(nonbonded_force.getReactionFieldDielectric()) #new_force.setReciprocalSpaceForceGroup(nonbonded_force.getReciprocalSpaceForceGroup()) - new_force.setSwitchingDistance(nonbonded_force.getSwitchingDistance()) - #new_force.setUseDispersionCorrection(nonbonded_force.getUseDispersionCorrection()) new_force.setUseSwitchingFunction(nonbonded_force.getUseSwitchingFunction()) + new_force.setSwitchingDistance(nonbonded_force.getSwitchingDistance()) + new_force.setUseLongRangeCorrection(nonbonded_force.getUseDispersionCorrection()) + # now add all the particle parameters num_particles = nonbonded_force.getNumParticles() for i in range(num_particles): new_force.addParticle(nonbonded_force.getParticleParameters(i)) - # now add all the exceptions + # now add all the exceptions? # TODO: check if we want to do this... # for exception_index in range(nonbonded_force.getNumExceptions()): # new_force.addException(nonbonded_force.getExceptionParameters(exception_index)) From b30ae5e2f0f305c6096a7db5ca537c086416095d Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Wed, 25 Sep 2019 15:54:54 -0400 Subject: [PATCH 13/18] add `split_nb_using_interaction_groups` fxn JDC suggested to use interaction groups only here, instead of a mixture of interaction groups and exceptions. this appears cleaner and passes quick test that the cloned system is equivalent to the original system. Co-Authored-By: John Chodera --- openmmtools/forcefactories.py | 38 ++++++++++++++++++++++++ openmmtools/tests/test_forcefactories.py | 5 ++++ 2 files changed, 43 insertions(+) diff --git a/openmmtools/forcefactories.py b/openmmtools/forcefactories.py index 718879a6e..478820954 100644 --- a/openmmtools/forcefactories.py +++ b/openmmtools/forcefactories.py @@ -225,6 +225,44 @@ def clone_nonbonded_parameters(nonbonded_force, from copy import deepcopy from openmmtools.forces import find_forces +def split_nb_using_interaction_groups(system, md_topology): + """Construct a copy of system where its nonbonded force has been replaced + with three nonbonded forces, each using an interaction group restricted to + water-water, water-solute, or solute-solute interactions. Water-water + interactions are in force group 0, and all other interactions are in force + group 1. + """ + + # create a copy of the original system: only touch this + new_system = copy.deepcopy(system) + + # find the default nonbonded force + force_index, nb_force = forces.find_forces(new_system, openmm.NonbondedForce, only_one=True) + # create copies for each interaction. Only half in solvent/solvent and solute/solute as we double-count. + nb_only_solvent_solvent = clone_nonbonded_parameters(nb_force, energy_prefactor='0.5*') + nb_only_solvent_solute = clone_nonbonded_parameters(nb_force) + nb_only_solute_solute = clone_nonbonded_parameters(nb_force, energy_prefactor='0.5*') + + # NOTE: these need to be python ints -- not np.int64s -- when passing to addInteractionGroup later! + solvent_indices = list(map(int, md_topology.select('water'))) + solute_indices = list(map(int, md_topology.select('not water'))) + + nb_only_solvent_solvent.addInteractionGroup(set1=solvent_indices, set2=solvent_indices) + nb_only_solvent_solute.addInteractionGroup(set1=solute_indices, set2=solvent_indices) + nb_only_solute_solute.addInteractionGroup(set1=solute_indices, set2=solute_indices) + + # Set solvent-solvent to fg 0, everything else to fg1 + nb_only_solvent_solvent.setForceGroup(0) + nb_only_solvent_solute.setForceGroup(1) + nb_only_solute_solute.setForceGroup(1) + + # handle non-NonbondedForce's + for force in new_system.getForces(): + if 'Nonbonded' not in force.__class__.__name__: + force.setForceGroup(1) + + return new_system + def split_nb_using_exceptions(system, md_topology): """Construct a new system where force group 0 contains slow, expensive solvent-solvent diff --git a/openmmtools/tests/test_forcefactories.py b/openmmtools/tests/test_forcefactories.py index b305490dc..1d0d0709d 100644 --- a/openmmtools/tests/test_forcefactories.py +++ b/openmmtools/tests/test_forcefactories.py @@ -211,6 +211,11 @@ def check_force_group_decomposition_valid(testsystem, force_group_splitter): from simtk.openmm import app +def test_split_nb_using_interaction_groups(): + testsystem = testsystems.AlanineDipeptideExplicit(nonbondedMethod=app.CutoffPeriodic) + check_force_group_decomposition_valid(testsystem, split_nb_using_interaction_groups) + + def test_split_nb_using_exceptions(): testsystem = testsystems.AlanineDipeptideExplicit(nonbondedMethod=app.CutoffPeriodic) check_force_group_decomposition_valid(testsystem, split_nb_using_exceptions) From fb0ce288868184704119691fd2ba1a7c73be26ae Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Wed, 25 Sep 2019 15:55:35 -0400 Subject: [PATCH 14/18] remove redundant imports --- openmmtools/forcefactories.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/openmmtools/forcefactories.py b/openmmtools/forcefactories.py index 478820954..1f1ad2227 100644 --- a/openmmtools/forcefactories.py +++ b/openmmtools/forcefactories.py @@ -223,8 +223,7 @@ def clone_nonbonded_parameters(nonbonded_force, return new_force -from copy import deepcopy -from openmmtools.forces import find_forces + def split_nb_using_interaction_groups(system, md_topology): """Construct a copy of system where its nonbonded force has been replaced with three nonbonded forces, each using an interaction group restricted to @@ -279,10 +278,10 @@ def split_nb_using_exceptions(system, md_topology): """ # create a copy of the original system: only touch this - new_system = deepcopy(system) + new_system = copy.deepcopy(system) # find the default nonbonded force - force_index, nb_force = find_forces(new_system, openmm.NonbondedForce, only_one=True) + force_index, nb_force = forces.find_forces(new_system, openmm.NonbondedForce, only_one=True) # assert('Cutoff' in nb_force.getNonbondedMethod()) # TODO: this, less jankily # create copies for each interaction. Only half in solute/solute as we double count. @@ -335,7 +334,6 @@ def split_nb_using_exceptions(system, md_topology): # TODO: different energy expressions for protein-protein and protein-solvent interactions? -from copy import deepcopy def split_nb_using_subtraction(system, md_topology, cutoff=10.0 * unit.angstrom # TODO: use the cutoff! ): @@ -343,11 +341,11 @@ def split_nb_using_subtraction(system, md_topology, Force group 0: default NonbondedForce minus surrogate Force group 1: surrogate + non-Nonbonded""" - new_system = deepcopy(system) + new_system = copy.deepcopy(system) # find the default nonbonded force - force_index, force = find_forces(new_system, openmm.NonbondedForce, only_one=True) + force_index, force = forces.find_forces(new_system, openmm.NonbondedForce, only_one=True) force.setForceGroup(0) # find atom indices for solvent, atom indices for solute From 458ebeae4fa8b71ec9df30d8ff71c5097735db77 Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Wed, 25 Sep 2019 17:38:48 -0400 Subject: [PATCH 15/18] modified forces weren't in fact being added to the system! Thanks to JDC for spotting this. This affected `split_nb_using_interaction_groups` and `split_nb_using_exceptions` but not `split_nb_using_subtraction`... Co-Authored-By: John Chodera --- openmmtools/forcefactories.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/openmmtools/forcefactories.py b/openmmtools/forcefactories.py index 1f1ad2227..645e1f1e9 100644 --- a/openmmtools/forcefactories.py +++ b/openmmtools/forcefactories.py @@ -250,6 +250,12 @@ def split_nb_using_interaction_groups(system, md_topology): nb_only_solvent_solute.addInteractionGroup(set1=solute_indices, set2=solvent_indices) nb_only_solute_solute.addInteractionGroup(set1=solute_indices, set2=solute_indices) + # remove original force, add new forces + new_system.removeForce(force_index) + new_system.addForce(nb_only_solvent_solvent) + new_system.addForce(nb_only_solute_solute) + new_system.addForce(nb_only_solvent_solute) + # Set solvent-solvent to fg 0, everything else to fg1 nb_only_solvent_solvent.setForceGroup(0) nb_only_solvent_solute.setForceGroup(1) @@ -311,6 +317,10 @@ def split_nb_using_exceptions(system, md_topology): # Add appropriate interaction groups nb_only_solvent_solute.addInteractionGroup(set1=solute_indices, set2=solvent_indices) nb_only_solute_solute.addInteractionGroup(set1=solute_indices, set2=solute_indices) + + # add new forces + new_system.addForce(nb_only_solute_solute) + new_system.addForce(nb_only_solvent_solute) # Set solvent-solvent to fg 0, everything else to fg1 nb_only_solvent_solvent.setForceGroup(0) From 05b735a5c0da555fef07901ff22fac30ec22dbec Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Wed, 25 Sep 2019 17:45:25 -0400 Subject: [PATCH 16/18] don't use dispersion correction in test_split_nb_* Current test behavior: 1. test_split_nb_using_interaction_groups() Exception: Maximum allowable relative force error exceeded (was 740.98931192; allowed 0.00000100). E alchemical_force = 651130.50822817, reference_force = 878.74004125, difference = 651136.97852131 2. test_split_nb_using_exceptions(): Exception: Maximum allowable relative force error exceeded (was 746.21620950; allowed 0.00000100). E alchemical_force = 662413.13233660, reference_force = 887.70499600, difference = 662419.85727222 3. test_split_nb_using_subtraction() Exception: Maximum allowable relative force error exceeded (was 0.00001820; allowed 0.00000100). E alchemical_force = 878.52677463, reference_force = 878.52663474, difference = 0.01599347 --- openmmtools/tests/test_forcefactories.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/openmmtools/tests/test_forcefactories.py b/openmmtools/tests/test_forcefactories.py index 1d0d0709d..3f7c076db 100644 --- a/openmmtools/tests/test_forcefactories.py +++ b/openmmtools/tests/test_forcefactories.py @@ -212,15 +212,15 @@ def check_force_group_decomposition_valid(testsystem, force_group_splitter): from simtk.openmm import app def test_split_nb_using_interaction_groups(): - testsystem = testsystems.AlanineDipeptideExplicit(nonbondedMethod=app.CutoffPeriodic) + testsystem = testsystems.AlanineDipeptideExplicit(nonbondedMethod=app.CutoffPeriodic, use_dispersion_correction=False) check_force_group_decomposition_valid(testsystem, split_nb_using_interaction_groups) def test_split_nb_using_exceptions(): - testsystem = testsystems.AlanineDipeptideExplicit(nonbondedMethod=app.CutoffPeriodic) + testsystem = testsystems.AlanineDipeptideExplicit(nonbondedMethod=app.CutoffPeriodic, use_dispersion_correction=False) check_force_group_decomposition_valid(testsystem, split_nb_using_exceptions) def test_split_nb_using_subtraction(): - testsystem = testsystems.AlanineDipeptideExplicit(nonbondedMethod=app.CutoffPeriodic) + testsystem = testsystems.AlanineDipeptideExplicit(nonbondedMethod=app.CutoffPeriodic, use_dispersion_correction=False) check_force_group_decomposition_valid(testsystem, split_nb_using_subtraction) From 256f190f085e55f86e5c3c9206c6614cd3b074c5 Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Wed, 25 Sep 2019 17:58:56 -0400 Subject: [PATCH 17/18] allow cutoff and switching distance to be modified when splitting nb forces using a surrogate force Current test behavior: Exception: Maximum allowable relative force error exceeded (was 0.00001101; allowed 0.00000100). E alchemical_force = 881.84056569, reference_force = 881.84068232, difference = 0.00971232 --- openmmtools/forcefactories.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/openmmtools/forcefactories.py b/openmmtools/forcefactories.py index 645e1f1e9..b1a449e99 100644 --- a/openmmtools/forcefactories.py +++ b/openmmtools/forcefactories.py @@ -345,7 +345,8 @@ def split_nb_using_exceptions(system, md_topology): # TODO: different energy expressions for protein-protein and protein-solvent interactions? def split_nb_using_subtraction(system, md_topology, - cutoff=10.0 * unit.angstrom # TODO: use the cutoff! + switching_distance=4.0 * unit.angstrom, + cutoff_distance=5.0 * unit.angstrom, ): """ Force group 0: default NonbondedForce minus surrogate @@ -362,6 +363,7 @@ def split_nb_using_subtraction(system, md_topology, # NOTE: these need to be python ints -- not np.int64s -- when passing to addInteractionGroup later! solvent_indices = list(map(int, md_topology.select('water'))) solute_indices = list(map(int, md_topology.select('not water'))) + # TODO: handle counterions # TODO: smooth cutoff, and check how bad this is with very small cutoff (setUseSwitchingFunction(True) @@ -377,6 +379,8 @@ def split_nb_using_subtraction(system, md_topology, # add forces to new_system for new_force in [protein_protein_force, protein_solvent_force, minus_protein_protein_force, minus_protein_solvent_force]: + new_force.setSwitchingDistance(switching_distance) + new_force.setCutoffDistance(cutoff_distance) new_system.addForce(new_force) # set interaction groups From be65ec6b48ff54328af247ba5d3c85e4f5c6a46f Mon Sep 17 00:00:00 2001 From: Josh Fass Date: Thu, 26 Sep 2019 13:21:59 -0400 Subject: [PATCH 18/18] attempted simplification of interaction-group splitting attempted simplification Exception: Maximum allowable relative force error exceeded (was 1554.77679366; allowed 0.00000100). E alchemical_force = 1372003.46106334, reference_force = 882.44334338, difference = 1372002.43200366 Co-Authored-By: John Chodera --- openmmtools/forcefactories.py | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/openmmtools/forcefactories.py b/openmmtools/forcefactories.py index b1a449e99..250dfa90f 100644 --- a/openmmtools/forcefactories.py +++ b/openmmtools/forcefactories.py @@ -226,8 +226,9 @@ def clone_nonbonded_parameters(nonbonded_force, def split_nb_using_interaction_groups(system, md_topology): """Construct a copy of system where its nonbonded force has been replaced - with three nonbonded forces, each using an interaction group restricted to - water-water, water-solute, or solute-solute interactions. Water-water + with two nonbonded forces, one using an interaction group restricted to + water-water interactions, and the other using interaction groups + restricted to water-solute and solute-solute interactions. Water-water interactions are in force group 0, and all other interactions are in force group 1. """ @@ -239,27 +240,29 @@ def split_nb_using_interaction_groups(system, md_topology): force_index, nb_force = forces.find_forces(new_system, openmm.NonbondedForce, only_one=True) # create copies for each interaction. Only half in solvent/solvent and solute/solute as we double-count. nb_only_solvent_solvent = clone_nonbonded_parameters(nb_force, energy_prefactor='0.5*') - nb_only_solvent_solute = clone_nonbonded_parameters(nb_force) - nb_only_solute_solute = clone_nonbonded_parameters(nb_force, energy_prefactor='0.5*') + nb_solute = clone_nonbonded_parameters(nb_force) # NOTE: these need to be python ints -- not np.int64s -- when passing to addInteractionGroup later! solvent_indices = list(map(int, md_topology.select('water'))) solute_indices = list(map(int, md_topology.select('not water'))) + #all_indices = list(range(md_topology.n_atoms)) + nb_only_solvent_solvent.addInteractionGroup(set1=solvent_indices, set2=solvent_indices) - nb_only_solvent_solute.addInteractionGroup(set1=solute_indices, set2=solvent_indices) - nb_only_solute_solute.addInteractionGroup(set1=solute_indices, set2=solute_indices) + + nb_solute.addInteractionGroup(set1=solute_indices, set2=solute_indices) + nb_solute.addInteractionGroup(set1=solute_indices, set2=solvent_indices) + + #nb_solute.addInteractionGroup(set1=solute_indices, set2=all_indices) # remove original force, add new forces new_system.removeForce(force_index) + new_system.addForce(nb_solute) new_system.addForce(nb_only_solvent_solvent) - new_system.addForce(nb_only_solute_solute) - new_system.addForce(nb_only_solvent_solute) # Set solvent-solvent to fg 0, everything else to fg1 nb_only_solvent_solvent.setForceGroup(0) - nb_only_solvent_solute.setForceGroup(1) - nb_only_solute_solute.setForceGroup(1) + nb_solute.setForceGroup(1) # handle non-NonbondedForce's for force in new_system.getForces():