diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml new file mode 100644 index 0000000..c2e8cd8 --- /dev/null +++ b/.github/workflows/python-publish.yml @@ -0,0 +1,32 @@ +# This workflow will upload a Python Package using Twine when a release is created +# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries + +name: Upload Python Package + +on: + release: + types: [created] + +jobs: + deploy: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + - name: Set up Python + uses: actions/setup-python@v2 + with: + python-version: '3.x' + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install setuptools wheel twine + - name: Build package + run: | + python setup.py sdist bdist_wheel + - name: Publish package + uses: pypa/gh-action-pypi-publish@release/v1 + with: + user: __token__ + password: ${{ secrets.PYPI_API_TOKEN }} diff --git a/changelog.txt b/changelog.txt new file mode 100644 index 0000000..d7e625d --- /dev/null +++ b/changelog.txt @@ -0,0 +1,32 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to [Explicit Versioning](https://github.com/exadra37-versioning/explicit-versioning). + +## [0.1.5.0] +### Added +- added optional flag on the 'BodyForce' constructor to coose whether to + simplify the resulting expresion +### Changed +- updated octave / python print methods to utilise common sub expersion + decompositon. This significantly increase the performance of the generated + EoMs +### Deprecated +### Removed +### Fixed + +## [0.1.4.2] - 2021-04-07 +### Added +- first commit to moyra: this software was created to easily create the EoMs of + basic nonlinear aeroelastic systems using the symbolic library sympy +- added methods the create multibody elements and forces and create the EoMs via + the Euler-Lagrange method +- support to generate forces from basic strip theory +- ability to print the generated symbolic EoMs to either numpy or MATLAB/Octave + to use the EoM with numerical methods +### Changed +### Deprecated +### Removed +### Fixed \ No newline at end of file diff --git a/moyra/__init__.py b/moyra/__init__.py index 61c87f1..e004aaa 100644 --- a/moyra/__init__.py +++ b/moyra/__init__.py @@ -1,4 +1,4 @@ -from .model_parameters import ModelParameters, ModelMatrix, ModelSymbol,ModelMatrixSymbol, ModelExpr +from .model_parameters import ModelParameters, ModelMatrix, ModelSymbol,ModelMatrixSymbol, ModelExpr, ModelValue from .dynamic_model_parameters import DynamicModelParameters from .helper_funcs import linearise_matrix, extract_eigen_value_data from .symbolic_model import SymbolicModel diff --git a/moyra/dynamic_model_parameters.py b/moyra/dynamic_model_parameters.py index 6caf947..2cf3f72 100644 --- a/moyra/dynamic_model_parameters.py +++ b/moyra/dynamic_model_parameters.py @@ -34,10 +34,10 @@ def print_python(self): else: string += f'\np.{name} = ma.ModelMatrix(value={value.value}, string=\'{value._matrix_symbol}\', length={len(value)})' elif isinstance(value,sym.Symbol): - string += f'\np.{name} = sym.Symbol(\'{value.name}\')' + string += f'\np.{name} = Symbol(\'{value.name}\')' return string def to_file(self,filename,file_dir=''): - string = 'import moyra as ma\n\ndef get_p():\n\t' + self.print_python().replace('\n','\n\t') + '\n\treturn p\n' + string = 'import moyra as ma\nfrom sympy import *\n\ndef get_p():\n\t' + self.print_python().replace('\n','\n\t') + '\n\treturn p\n' with open(os.path.join(file_dir,filename),'w') as file: file.write(string) \ No newline at end of file diff --git a/moyra/forces/aero_force.py b/moyra/forces/aero_force.py index 1051376..69c04a2 100644 --- a/moyra/forces/aero_force.py +++ b/moyra/forces/aero_force.py @@ -34,12 +34,46 @@ def PerUnitSpan(cls,p,Transform,C_L,alphadot,M_thetadot,e,rootAlpha,alpha_zero = """ ## force per unit length will following theredosons pseado-steady theory + BodyJacobian = sym.simplify(cls._trigsimp(Transform.BodyJacobian(p.q))) + + (wrench,dAlpha) = cls.get_wrench(p,BodyJacobian,C_L,alphadot,M_thetadot,e, + rootAlpha,alpha_zero,stall_angle,c_d_max,w_g, + V,c,linear,z_inverted) + + _Q = BodyJacobian.T*wrench + + return cls(_Q,dAlpha) + + def __init__(self,Q,dAlpha): + self.dAlpha = dAlpha + super().__init__(Q) + + @staticmethod + def _trigsimp(expr): + return sym.trigsimp(sym.powsimp(sym.cancel(sym.expand(expr)))) + + def linearise(self,x,x_f): + Q_lin = linearise_matrix(self.Q(),x,x_f) + dAlpha_lin = linearise_matrix(self.dAlpha,x,x_f) + return AeroForce(Q_lin,dAlpha_lin) + + def subs(self,*args): + return AeroForce(self._Q.subs(*args),self.dAlpha.subs(*args)) + + def msubs(self,*args): + return AeroForce(me.msubs(self._Q,*args),me.msubs(self.dAlpha,*args)) + + def integrate(self,*args): + return AeroForce(self._Q.integrate(*args),self.dAlpha) + + @staticmethod + def get_wrench(p,BodyJacobian,C_L,alphadot,M_thetadot,e,rootAlpha,alpha_zero = 0,stall_angle=0.24,c_d_max = 1,w_g = 0,V=None,c=None,linear=False,z_inverted=False): + """ + see the class method PerUnitSpan for a explaination of terms + """ if c is None: c=p.c - # add z velocity due to motion - BodyJacobian = sym.simplify(cls._trigsimp(Transform.BodyJacobian(p.q))) - v_z_eff = (BodyJacobian*p.qd)[2] if z_inverted: v_z_eff *= -1 @@ -58,13 +92,11 @@ def PerUnitSpan(cls,p,Transform,C_L,alphadot,M_thetadot,e,rootAlpha,alpha_zero = else: c_l = C_L*(1/p.clip_factor*sym.ln((1+sym.exp(p.clip_factor*(dAlpha+stall_angle)))/(1+sym.exp(p.clip_factor*(dAlpha-stall_angle))))-stall_angle) - c_d = c_d_max*sym.Rational(1,2)*(1-sym.cos(2*dAlpha)) - - ang = rootAlpha - v_z_eff/V - if linear: c_n = c_l else: + c_d = c_d_max*sym.Rational(1,2)*(1-sym.cos(2*dAlpha)) + ang = rootAlpha - v_z_eff/V c_n = c_l*sym.cos(ang)+c_d*sym.sin(ang) F_n = dynamicPressure*c*c_n @@ -77,32 +109,8 @@ def PerUnitSpan(cls,p,Transform,C_L,alphadot,M_thetadot,e,rootAlpha,alpha_zero = wrench = sym.Matrix([0,0,-F_n,0,M_w,0]) else: wrench = sym.Matrix([0,0,F_n,0,M_w,0]) + return (wrench,dAlpha) - _Q = BodyJacobian.T*wrench - - return cls(_Q,dAlpha) - - def __init__(self,Q,dAlpha): - self.dAlpha = dAlpha - super().__init__(Q) - - @staticmethod - def _trigsimp(expr): - return sym.trigsimp(sym.powsimp(sym.cancel(sym.expand(expr)))) - - def linearise(self,x,x_f): - Q_lin = linearise_matrix(self.Q(),x,x_f) - dAlpha_lin = linearise_matrix(self.dAlpha,x,x_f) - return AeroForce(Q_lin,dAlpha_lin) - - def subs(self,*args): - return AeroForce(self._Q.subs(*args),self.dAlpha.subs(*args)) - - def msubs(self,*args): - return AeroForce(me.msubs(self._Q,*args),me.msubs(self.dAlpha,*args)) - - def integrate(self,*args): - return AeroForce(self._Q.integrate(*args),self.dAlpha) diff --git a/moyra/forces/body_force.py b/moyra/forces/body_force.py index 2241775..e7ad6e6 100644 --- a/moyra/forces/body_force.py +++ b/moyra/forces/body_force.py @@ -5,7 +5,7 @@ class BodyForce(ExternalForce): """A class used to represent Forces and moment in a particular reference frame""" - def __init__(self,p,Transform,Fx=0,Fy=0,Fz=0,Mx=0,My=0,Mz=0): + def __init__(self,p,Transform,Fx=0,Fy=0,Fz=0,Mx=0,My=0,Mz=0,simplify=True): """ Constructor for a body force, with the following parameters: @@ -20,7 +20,11 @@ def __init__(self,p,Transform,Fx=0,Fy=0,Fz=0,Mx=0,My=0,Mz=0): My - (default = 0) the moment applied to the body about the local y axis Mz - (default = 0) the moment applied to the body about the local z axis """ - BodyJacobian = sym.simplify(self._trigsimp(Transform.BodyJacobian(p.q))) + + if simplify: + BodyJacobian = sym.simplify(self._trigsimp(Transform.BodyJacobian(p.q))) + else: + BodyJacobian = Transform.BodyJacobian(p.q) wrench = sym.Matrix([Fx,Fy,Fz,Mx,My,Mz]) super().__init__(BodyJacobian.T*wrench) diff --git a/moyra/model_parameters.py b/moyra/model_parameters.py index ee96713..ae130d1 100644 --- a/moyra/model_parameters.py +++ b/moyra/model_parameters.py @@ -36,7 +36,7 @@ def __eq__(self,other): def __hash__(self): return hash(sym.Symbol(self.name)) def _octave(self,printer): - return f'p.{self.name}' + return f'{self.name}' class ModelMatrixSymbol(ModelSymbol): def __init__(self,string,**kwarg): @@ -46,7 +46,7 @@ def __init__(self,string,**kwarg): def __new__(cls,string,**kwarg): return super().__new__(cls,string,**kwarg) def _octave(self,printer): - return f'p.{self._matrix}({self._index+1})' + return f'{self._matrix}({self._index+1})' class ModelMatrix(sym.Matrix,ModelValue): """ diff --git a/moyra/symbolic_model.py b/moyra/symbolic_model.py index f2ef342..0e221e7 100644 --- a/moyra/symbolic_model.py +++ b/moyra/symbolic_model.py @@ -11,6 +11,8 @@ import pickle from .forces import ZeroForce from .printing import model as print_model +from .model_parameters import ModelSymbol, ModelMatrix,ModelMatrixSymbol, ModelValue +from time import time, ctime class SymbolicModel: """ @@ -283,6 +285,15 @@ def to_matlab_file(self,p,file_dir): with open(file_dir+f"{func_name}.m",'w') as file: file.write(self._gen_octave(matrix,p,func_name)) p.to_matlab_class(file_dir=file_dir) + + def to_matlab_file_linear(self,p,file_dir): + mats = self.extract_matrices(p) + names = ['A','B','C','D','E'] + funcs = list(zip([f'get_{i}' for i in names],mats)) + for func_name,matrix in funcs: + with open(file_dir+f"{func_name}.m",'w') as file: + file.write(self._gen_octave(matrix,p,func_name)) + p.to_matlab_class(file_dir=file_dir) def _gen_octave(self,expr,p,func_name): # convert states to non-time dependent variable @@ -290,17 +301,55 @@ def _gen_octave(self,expr,p,func_name): l = dict(zip(p.x,U)) expr = me.msubs(expr,l) + # get parameter replacements + param_string = '%% extract required parameters from structure\n\t' + matries = [] + for var in expr.free_symbols: + if isinstance(var,ModelValue): + if isinstance(var,ModelMatrixSymbol): + if var._matrix not in matries: + param_string += f'{var._matrix} = p.{var._matrix};\n\t' + matries.append(var._matrix) + elif isinstance(var,ModelSymbol): + param_string += f'{var.name} = p.{var.name};\n\t' + elif isinstance(var,ModelMatrix): + param_string += f'{var._matrix_symbol} = p.{var._matrix_symbol};\n\t' + + + # split expr into groups + replacments, exprs = sym.cse(expr,symbols=(sym.Symbol(f'rep_{i}')for i in range(10000))) + if isinstance(expr,tuple): + expr = tuple(exprs) + elif isinstance(expr,list): + expr = exprs + else: + expr = exprs[0] + + group_string = '%% create common groups\n\t' + for variable, expression in replacments: + group_string +=f'{variable} = {sym.printing.octave.octave_code(expression)};\n\t' + # convert to octave string and covert states to vector form - out = sym.printing.octave.octave_code(expr) + out = '%% create output vector\n\tout = ' + sym.printing.octave.octave_code(expr) + + #convert state vector calls my_replace = lambda x: f'U({int(x.group(1))+1})' out = re.sub(r"u_(?P\d+)",my_replace,out) + group_string = re.sub(r"u_(?P\d+)",my_replace,group_string) # make the file pretty... out = out.replace(',',',...\n\t\t').replace(';',';...\n\t\t') + file_sig = f'%{func_name.upper()} Auto-generated function from moyra\n\t' + file_sig += f'%\n\t' + file_sig += f'%\tCreated at : {ctime(time())} \n\t' + file_sig += f'%\tCreated with : moyra https://pypi.org/project/moyra/\n\t' + file_sig += f'%\n\t' + + # wrap output in octave function signature - signature = f'function out = {func_name}(U,p)' - octave_string = signature + '\n\t'+ 'out = ' + out + ';\nend' + signature = f'function out = {func_name}(U,p)\n\t' + octave_string = signature + file_sig + param_string + group_string + out + ';\nend' return octave_string diff --git a/readme.ipynb b/readme.ipynb index 91ca572..91dedc6 100644 --- a/readme.ipynb +++ b/readme.ipynb @@ -61,6 +61,8 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "moyra is built upon 3 simple constructs\n", "\n", @@ -68,9 +70,7 @@ "\n", "model parameters are used to define the symbols used in the generateion of the EoM. The primary class is 'ModelParameters' which can be used to collect all the parameters used.\n", "The 'DynamicModel' static constructer is availible to create the nessacary state paraemters" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -78,14 +78,14 @@ "metadata": {}, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "dict_keys(['qs', 'q', 'qd', 'qdd', 'x'])" ] }, + "execution_count": 2, "metadata": {}, - "execution_count": 2 + "output_type": "execute_result" } ], "source": [ @@ -112,19 +112,21 @@ "metadata": {}, "outputs": [ { - "output_type": "execute_result", "data": { + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}\\operatorname{q_{0}}{\\left(t \\right)}\\\\\\frac{d}{d t} \\operatorname{q_{0}}{\\left(t \\right)}\\\\\\operatorname{q_{1}}{\\left(t \\right)}\\\\\\frac{d}{d t} \\operatorname{q_{1}}{\\left(t \\right)}\\end{matrix}\\right]$" + ], "text/plain": [ "Matrix([\n", "[ q0(t)],\n", "[Derivative(q0(t), t)],\n", "[ q1(t)],\n", "[Derivative(q1(t), t)]])" - ], - "text/latex": "$\\displaystyle \\left[\\begin{matrix}\\operatorname{q_{0}}{\\left(t \\right)}\\\\\\frac{d}{d t} \\operatorname{q_{0}}{\\left(t \\right)}\\\\\\operatorname{q_{1}}{\\left(t \\right)}\\\\\\frac{d}{d t} \\operatorname{q_{1}}{\\left(t \\right)}\\end{matrix}\\right]$" + ] }, + "execution_count": 3, "metadata": {}, - "execution_count": 3 + "output_type": "execute_result" } ], "source": [ @@ -132,12 +134,12 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "next we will add the nesscacary parameters for our double pendulum\n", "(note we add a value to each symbol - this is used later to inject numerical values on each paramter)" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -233,19 +235,22 @@ "metadata": {}, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "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\n", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}L_{1}^{2} m_{1} + L_{1}^{2} m_{2} + 2 L_{1} L_{2} m_{2} \\cos{\\left(q_{1} \\right)} + L_{2}^{2} m_{2} & L_{1} L_{2} m_{2} \\cos{\\left(q_{1} \\right)} + L_{2}^{2} m_{2}\\\\L_{1} L_{2} m_{2} \\cos{\\left(q_{1} \\right)} + L_{2}^{2} m_{2} & L_{2}^{2} m_{2}\\end{matrix}\\right]$" + ], "text/plain": [ "⎡ 2 2 2 2 ⎤\n", "⎢L₁ ⋅m₁ + L₁ ⋅m₂ + 2⋅L₁⋅L₂⋅m₂⋅cos(q₁) + L₂ ⋅m₂ L₁⋅L₂⋅m₂⋅cos(q₁) + L₂ ⋅m₂⎥\n", "⎢ ⎥\n", "⎢ 2 2 ⎥\n", "⎣ L₁⋅L₂⋅m₂⋅cos(q₁) + L₂ ⋅m₂ L₂ ⋅m₂ ⎦" - ], - "text/latex": "$\\displaystyle \\left[\\begin{matrix}L_{1}^{2} m_{1} + L_{1}^{2} m_{2} + 2 L_{1} L_{2} m_{2} \\cos{\\left(q_{1} \\right)} + L_{2}^{2} m_{2} & L_{1} L_{2} m_{2} \\cos{\\left(q_{1} \\right)} + L_{2}^{2} m_{2}\\\\L_{1} L_{2} m_{2} \\cos{\\left(q_{1} \\right)} + L_{2}^{2} m_{2} & L_{2}^{2} m_{2}\\end{matrix}\\right]$" + ] }, + "execution_count": 8, "metadata": {}, - "execution_count": 8 + "output_type": "execute_result" } ], "source": [ @@ -263,8 +268,11 @@ "metadata": {}, "outputs": [ { - "output_type": "execute_result", "data": { + "image/png": "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\n", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}- 2 L_{1} L_{2} m_{2} \\sin{\\left(q_{1} \\right)} \\dot{q}_{0} \\dot{q}_{1} - L_{1} L_{2} m_{2} \\sin{\\left(q_{1} \\right)} \\dot{q}_{1}^{2} + L_{1} g m_{1} \\sin{\\left(q_{0} \\right)} - g m_{2} \\left(- L_{1} \\sin{\\left(q_{0} \\right)} - L_{2} \\left(\\sin{\\left(q_{0} \\right)} \\cos{\\left(q_{1} \\right)} + \\sin{\\left(q_{1} \\right)} \\cos{\\left(q_{0} \\right)}\\right)\\right)\\\\- L_{1} L_{2} m_{2} \\sin{\\left(q_{1} \\right)} \\dot{q}_{0} \\dot{q}_{1} + L_{2} g m_{2} \\left(\\sin{\\left(q_{0} \\right)} \\cos{\\left(q_{1} \\right)} + \\sin{\\left(q_{1} \\right)} \\cos{\\left(q_{0} \\right)}\\right) - m_{2} \\left(- L_{1} L_{2} \\sin{\\left(q_{1} \\right)} \\dot{q}_{0}^{2} - L_{1} L_{2} \\sin{\\left(q_{1} \\right)} \\dot{q}_{0} \\dot{q}_{1}\\right)\\end{matrix}\\right]$" + ], "text/plain": [ "⎡ 2 \n", "⎢-2⋅L₁⋅L₂⋅m₂⋅sin(q₁)⋅q₀̇⋅q₁̇ - L₁⋅L₂⋅m₂⋅sin(q₁)⋅q₁̇ + L₁⋅g⋅m₁⋅sin(q₀) - g⋅m₂⋅\n", @@ -277,11 +285,11 @@ " ⎥\n", " ⎛ 2 ⎞ ⎥\n", "- m₂⋅⎝- L₁⋅L₂⋅sin(q₁)⋅q₀̇ - L₁⋅L₂⋅sin(q₁)⋅q₀̇⋅q₁̇⎠ ⎦" - ], - "text/latex": "$\\displaystyle \\left[\\begin{matrix}- 2 L_{1} L_{2} m_{2} \\sin{\\left(q_{1} \\right)} \\dot{q}_{0} \\dot{q}_{1} - L_{1} L_{2} m_{2} \\sin{\\left(q_{1} \\right)} \\dot{q}_{1}^{2} + L_{1} g m_{1} \\sin{\\left(q_{0} \\right)} - g m_{2} \\left(- L_{1} \\sin{\\left(q_{0} \\right)} - L_{2} \\left(\\sin{\\left(q_{0} \\right)} \\cos{\\left(q_{1} \\right)} + \\sin{\\left(q_{1} \\right)} \\cos{\\left(q_{0} \\right)}\\right)\\right)\\\\- L_{1} L_{2} m_{2} \\sin{\\left(q_{1} \\right)} \\dot{q}_{0} \\dot{q}_{1} + L_{2} g m_{2} \\left(\\sin{\\left(q_{0} \\right)} \\cos{\\left(q_{1} \\right)} + \\sin{\\left(q_{1} \\right)} \\cos{\\left(q_{0} \\right)}\\right) - m_{2} \\left(- L_{1} L_{2} \\sin{\\left(q_{1} \\right)} \\dot{q}_{0}^{2} - L_{1} L_{2} \\sin{\\left(q_{1} \\right)} \\dot{q}_{0} \\dot{q}_{1}\\right)\\end{matrix}\\right]$" + ] }, + "execution_count": 9, "metadata": {}, - "execution_count": 9 + "output_type": "execute_result" } ], "source": [ @@ -289,11 +297,11 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "We can then either convert these matricies into a numeric form (python or MATLAB) or save them to file, which we will do here" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -308,6 +316,50 @@ ] }, { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/latex": [ + "$\\displaystyle \\left[\\begin{matrix}L_{1}^{2} m_{1} + L_{1}^{2} m_{2} + 2 L_{1} L_{2} m_{2} \\cos{\\left(q_{1} \\right)} + L_{2}^{2} m_{2} & L_{1} L_{2} m_{2} \\cos{\\left(q_{1} \\right)} + L_{2}^{2} m_{2}\\\\L_{1} L_{2} m_{2} \\cos{\\left(q_{1} \\right)} + L_{2}^{2} m_{2} & L_{2}^{2} m_{2}\\end{matrix}\\right]$" + ], + "text/plain": [ + "⎡ 2 2 2 2 ⎤\n", + "⎢L₁ ⋅m₁ + L₁ ⋅m₂ + 2⋅L₁⋅L₂⋅m₂⋅cos(q₁) + L₂ ⋅m₂ L₁⋅L₂⋅m₂⋅cos(q₁) + L₂ ⋅m₂⎥\n", + "⎢ ⎥\n", + "⎢ 2 2 ⎥\n", + "⎣ L₁⋅L₂⋅m₂⋅cos(q₁) + L₂ ⋅m₂ L₂ ⋅m₂ ⎦" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sm_mini = sm.subs(0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, "source": [ "## Save to a MATLAB file \n", "The following function creates 4 files in the specified directory:\n", @@ -316,9 +368,7 @@ " - U: the state vector p.x\n", " - p: an instance of the parameter class (see the next file)\n", "- Parameters.m: a matlab class with all the parameters and default values. Allowing you to easily change parameters in MATLAB simulations" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -330,12 +380,12 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "## Convert to numpy matrices\n", "The following code converts the symbolic matrices to numpy matrices" - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -343,7 +393,6 @@ "metadata": {}, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "{'ExtForces': ,\n", @@ -353,8 +402,9 @@ " 'ke': }" ] }, + "execution_count": 12, "metadata": {}, - "execution_count": 12 + "output_type": "execute_result" } ], "source": [ @@ -363,6 +413,8 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "This instance of the 'NumericModel' class has 5 parameters as shown above. It also has the method 'nm.deriv(x,tup,t)' to calculate the derivative of the state vector.\n", "All these functions have the same signature (x,tup,[t]). Where t is only for the ExtForces and deriv functions. Theses variables are:\n", @@ -374,9 +426,7 @@ "- t: the time \n", "\n", "As an example let us find the derivate of our double pendulum from the following initial positon." - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -384,8 +434,8 @@ "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "(0, 3.2700000000000005, 0, -12.51895669792004)\n" ] @@ -400,12 +450,12 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "## Numerical Integration\n", "By utilising scipy we can intregrate this " - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -426,25 +476,1433 @@ "metadata": {}, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "Text(0, 0.5, 'angle [deg]')" ] }, + "execution_count": 15, "metadata": {}, - "execution_count": 15 + "output_type": "execute_result" }, { - "output_type": "display_data", "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n \n \n \n \n 2021-04-23T14:21:30.845990\n image/svg+xml\n \n \n Matplotlib v3.4.1, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "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\n" + "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2021-04-23T14:21:30.845990\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.4.1, https://matplotlib.org/\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n" + ], + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } ], "source": [ @@ -457,6 +1915,8 @@ ] }, { + "cell_type": "markdown", + "metadata": {}, "source": [ "## Time dependence\n", "From the above example it is not clear why deriv, ExtForces and GetNumericTuple have a time parameter.\n", @@ -465,9 +1925,7 @@ "\n", "Regarding GetNumericTuple the value of parameters can by replaced with a function of the following signature (x,t). So if for example we wanted\n", " the mass of m_2 to vary over the first 5 seconds (as if water was draining out of it) we could do the following..." - ], - "cell_type": "markdown", - "metadata": {} + ] }, { "cell_type": "code", @@ -475,8 +1933,8 @@ "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "1\n" ] @@ -506,25 +1964,1373 @@ "metadata": {}, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "Text(0, 0.5, 'angle [deg]')" ] }, + "execution_count": 18, "metadata": {}, - "execution_count": 18 + "output_type": "execute_result" }, { - "output_type": "display_data", "data": { - "text/plain": "
", - "image/svg+xml": "\n\n\n \n \n \n \n 2021-04-23T14:21:31.850232\n image/svg+xml\n \n \n Matplotlib v3.4.1, https://matplotlib.org/\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n\n", - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEGCAYAAACZ0MnKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAABdVUlEQVR4nO2dd3xV5f3430/2JnuQkARC2CMMAQFRFEQcoNY66qwD/Vbbaqutrf1+v3b4re2vam1rtdpqXXWjuBkOFGQje4QAIXuTRXby/P54zoWQee69546E5/163ddJzn3OOZ8LuedzPltIKdFoNBqNxgw+nhZAo9FoNAMHrTQ0Go1GYxqtNDQajUZjGq00NBqNRmMarTQ0Go1GYxo/TwvgSmJjY2V6erqnxdBoNJoBxbZt2yqklHE9vTeolUZ6ejpbt271tBgajUYzoBBCHOvtPe2e0mg0Go1pPKo0hBDPCyHKhBB7Ou2LFkKsFkIcMrZRxn4hhPiLECJHCLFLCDHVc5JrNBrNmYmnLY1/Axd12fcg8JmUMhP4zPgdYDGQabyWAU+7SUaNRqPRGHg0piGl/EoIkd5l91LgPOPnF4EvgZ8b+1+Squ/JRiFEpBAiSUpZbM81W1tbKSgooKmpySnZvYmgoCBSUlLw9/f3tCgajWaQ442B8IROiqAESDB+TgbyO60rMPbZpTQKCgoIDw8nPT0dIYTTwnoaKSWVlZUUFBQwfPhwT4uj0WgGOZ52T/WJYVXY1VFRCLFMCLFVCLG1vLy82/tNTU3ExMQMCoUBIIQgJiZmUFlOGo3Ge/FGpVEqhEgCMLZlxv5CYFindSnGvtOQUj4rpZwupZweF9djmvGgURg2Btvn0Wg03os3Ko33gZuNn28GVnTaf5ORRTULqLE3nqHRaAYBFYdg3Z9h77vQ0e5pac44PBrTEEK8hgp6xwohCoD/BR4F3hRC3AYcA642ln8MXAzkAA3A990usEaj8SyHVsPr10N7s/p99MVw9Uvgq5NA3IWns6eu6+WtC3pYK4G7XSuR91FVVcU111xDbm4u6enpvPnmm0RFRXlaLI3G/VTnwdu3QdwouO4N2PcerPwlfP0YnPdgv4drrMEb3VOaTjz66KNccMEFHDp0iAsuuIBHH33U0yJpNJ7h80eUhXHNKzAkGc6+GyZ8B9Y9AXUlnpbujMEbU27dxq8/2Mu+olpLzzluaAT/e9n4ftc98sgjvPjii8THxzNs2DCmTZvG/fff323dihUr+PLLLwG4+eabOe+88/jDH/5gqcwajddTkQO73oDZP4So9FP75z8Ee9+D9X+Bi/7PU9KdUWhLwwNs27aN119/nR07dvDxxx+zZcuWXteWlpaSlJQEQGJiIqWlpe4SU6PxHra9AD6+cPY9p++PyYDxl8OOV6BVp527gzPa0jBjEbiCr7/+miuuuIKQkBAAlixZYuo4IYROr9WcebS1wM7XYPRiCE/o/v6UG2DPO3DwI+Wu0rgUbWl4OQkJCRQXq8zi4uJi4uPjPSyRRuNmcr+ChkrIur7n94efCxHJsPsd98p1hqKVhgeYN28e7733Ho2NjdTV1fHBBx/0unbJkiW8+OKLALz44ossXbrUXWJqNN7BwU/BLxhGnNfz+z6+ygo58oV2UbkBrTQ8wNSpU7nmmmuYPHkyixcv5qyzzup17YMPPsjq1avJzMxkzZo1PPigTi3UnEFICQc/gYzzwT+493WjFkNrAxz9yn2ynaFopeEhHnroIbKzs1m3bh2jRo3qdV1MTAyfffYZhw4dYs2aNURHR7tRSo3Gw5TshtoCZUn0xfBzwD8Ecla7R64zGK00NBqN93LkS7UduaDvdX6BMGwGHPvG5SKd6Wil4QU8/PDDHD16lKysrNNeL7zwgqdF02g8y7FvIDoDIpL6X5s2B0r3QkOV6+U6gzmjU269iaeeesrTImg03kVHB+RtgLGXmVufNgeQkLcRxlzsUtHOZLSlodFovJPy/dBUbSgDEyRPA99AOLbepWKd6WilodFovBNbfCJttrn1/kFKceRvcp1MGq00NBqNl1KwBcISITLV/DFDp0DJHmhvc51cZzhaaWg0Gu+kaIdSAva0zhmaBW2NUHHQVVJ5B20tkL8ZaroNL3U5Wml4OW+99Rbjx4/Hx8eHrVu3elocjcY9NNdBRbZSAvaQZKwv2mGxQF7E8WPwzBz410L480T45m9uvbxWGl7OhAkTWL58OfPmzfO0KBqN+yjZDchTSsAsMRngHwrFO1wglBfQ3qYmF9aXwuXPqKLHVQ/BgY/cJoJXptwKIUYDb3TaNQL4HyASuAMoN/b/Ukr5scMX+uRB44/TQhInwuL+ByWZnacxduxYa+XTaAYCNkvBXkvDxxeSJg1eS2PbC1C6W424HbdUdfV97nz46H5VAOkX6HIRvNLSkFIelFJmSSmzgGmomeDvGm8/YXvPKYXhQeyZp6HRnJEU74DwJAhPtP/YpCz1MNjRYbVUnqW9Db5+XKUgjzXGKfgFwIW/gboi1T7eDXilpdGFC4DDUspjls+SMGERuAJH52loNGcMJbshcZJjx8aPVcHw6lyIHmGpWB4l+xOlHC750+nJASPmq4SBb/4GU2+2L3HAAbzS0ujCtUBnFXqPEGKXEOJ5IURU18VCiGVCiK1CiK3l5eVd39ZoNN5OeytUHFI3f0ewHVd2wDqZvIHtL6u5IZmLTt8vBEy/FSoPQeF2l4vh1UpDCBEALAHeMnY9DWQAWUAx8FjXY6SUz0opp0spp8fFxblLVLuwZ56GRnPGUXUEOlodVxpxo9W2fL91Mnmaplo1L2T8FeDbg4No3FLwC4Jdr7tcFK9WGsBiYLuUshRASlkqpWyXUnYAzwEzPCqdg9gzT+Pdd98lJSWFDRs2cMkll7Bo0aJe12o0g4Iy42YfN8ax44OGqCfy8kFUq5GzGtpbYMylPb8fNAQyF8L+D9UMEhfi7UrjOjq5poQQnVtdXgHscbtEFmF2nsYVV1xBQUEBzc3NlJaWsnLlSjdKqdF4gPIDgIDY3r8X/RI35pTyGQxkr4SQWNX+vTdGLVYxD6szQrvgtUpDCBEKLASWd9r9RyHEbiHELmA+cJ9HhNNoNK6jbD9EpUNAiOPniB+rigM72i0Ty2NICUe/huHzVEpxb2QuBARkf+pScbxWaUgpT0gpY6SUNZ323SilnCilnCSlXCKlLPakjFah52loNJ0oP+B4PMNG3Bhoa4LjuZaI5FGqjigLIn1u3+vC4lVdi21wlYsYCCm3liOlxPL0XSdxZp6GdLEPU6NxG20tUJkDo52chxGbqbZVR1SV+EAm92u1TT+n/7Vpc2Dzc9DapLr+ugCvtTRcRVBQEJWVlYPmRiulpLKykqAg1/yBaDRupeoIdLQ5b2lEG4qi8rDzMnma3HUQlnBKEfZF+lxob4ZC1/WpO+MsjZSUFAoKChhMNRxBQUGkpKR4WgyNxnls3WmdCYIDhMZCQLhSQgOdvE2Qera5or3UWYCA3PX9u7Mc5IxTGv7+/gwfPtzTYmg0mp6wWQbOupSEgJgRA19pnKiAmjyYcYe59cFRkDABjq0Dfu4Skc4495RGo/Fiqo5AaDwEhjt/rugRUDXA3VOONG5MOxsKtrksc0wrDY1G4z1YGbiOzoDqPNWWZKBS9K3aJk02f0zyNGg94bLiRq00NBqN91B52Lomg9EjVFC9Os+a83mC4h0QM1JVfJsleZraFrmmD5VWGhqNxjtoOQH1JdYpDZvFUnXUmvN5gqJvVQdbe4jOgMAhULjNJSJppaHRaLwDW9DaSksDBm5c40Ql1Bba3yLex0fFQFzU8faMy57SaDReik1pWBXTCI0b2Gm35UZr9/hx9h974W/B34k2LH2glYZGo/EObOm2VlkaQkB0+gBWGkbDxXgHuv3aEzi3E+2e0mg03kHVYevSbW1EpkF1vnXncyflB5WlFJHsaUlOQysNjUbjHVQdtb5P1JBhUJPv8hkTLqFsvxoo5WV98rTS0Gg03sHxXGUZWElkKrTUQ+Nxa8/rDsoPOuaacjFaaWg0Gs/T1gJ1xRBltdIYprYDrVajoQpOlDk+vdCFaKWh0QxkKg/DO3fAS5fD3vc8LY3j1BaC7FDuJCuxna9mgMU1bJlTcU52+3UBWmloNAOVqqPwr4VqUtvxXHjrZtj6vKelcgzbTT0y1drz2s430ILhJ+ekj/asHD3gtUpDCJFrjHbdIYTYauyLFkKsFkIcMrZRnpZT04mWE7Dibvh9Kjx7nssqUjVARwesuEf1VVr2JdyzBUYugE8eHJgppjb3UaTFlkZwFASEDTz3VMUh8A+FId438sBrlYbBfClllpRyuvH7g8BnUspM4DPjd403ICW8dQvs+A+MXqxaOr+41GVN0854Dn6s2l9f+FuVceTrD0v+qmZIr/2jp6Wzn+p8QECExTdJIU5lUA0kqo6o1u5eljkF3q80urIUeNH4+UXgcs+JojmNHa/CoVWw6Pdw5T/g1pXg6wcf/mRgpjt6M1LCuicgKh2ybji1P2IoTLkRdr8NtcUeE88hqvMgPAn8Aqw/d+SwgWdpVB2xrsjRYrxZaUhglRBimxBimbEvQUpp+zaUAAldDxJCLBNCbBVCbB1M0/m8mvZW+OL/IGUGzDD+q4Ykw/n/rZ6Gsz/1rHyDjZJdapznrLuVYu7MrLugoxW+fcUzsjlKTb718QwbkakDS2l0tKsYVZR3DovzZqUxV0o5FVgM3C2EmNf5TamGfHd7hJVSPiulnC6lnB4XF+cmUc9w9ryjsl/mPaCapdmYerOqZt34tOdkG4zsfgt8/GHiVd3fix4BqbPV/8lAovqY65TGkGHQVA3Nda45v9XUFCjFry0N+5BSFhrbMuBdYAZQKoRIAjC2ZZ6TUHOSbf+GmEzIXHj6fl8/OOt2OLpWxzasoqMDdr+jgt4h0T2vmXCl6ltUute9sjlKexvUFlkfBLdxslZjgMQ1jhut3KO1pWEaIUSoECLc9jNwIbAHeB+42Vh2M7DCZUK0tbjs1IOK6jzI2wCTr+k5aJd1PSBgz3K3izYoydsAdUU9Wxk2xi5R24OfuEcmZ6krVsOSXGVp2ILrtYWuOb/VWN0i3mK8UmmgYhXrhBA7gc3AR1LKT4FHgYVCiEPAAuN362mug0dTVcHUQExfdCd731XbCb3cxMITIH2uWqcD4s5zaBX4+EHmhb2vCU9QMxgOf+4+uZzBltlkdWGfjYihaltb5JrzW03VEfANhPChnpakR7xSaUgpj0gpJxuv8VLKR4z9lVLKC6SUmVLKBVLKKpcI0NYCM5epqVkvLVUl/ZqeObQaEib0bUqPWwoVB1XuucY5Dn8Gw2ZCUETf60ZeAPmboKnWPXI5w8kaDYtbiNgITwTEAFIaR1VmnI9X3p69U2l4nNAYWPgbuGE51BTC57/ztETeSXM95G2EjPP7Xmd7Kh4oT77eSn0ZlOxWCqE/Mi5QLp9j610vl7PYYg2uKmTz9YeweOXWGwhUHfVa1xRopdE3KdNg2s2w/SWoK/W0NN7HsfUqy6M/pRGVBjEj1VOyxnFsSjfDhNJIma4yrPI2ulYmK6g+puZo+Ae57hrhSQOjdkVKFQjXSmMAc/Y96oltoPb0cSU5n4FfMKSe3f/ajPMhd51OMHCGo19DcLS5mdH+wWp6W/4m18vlLLVFqq7HlUQMHRjuqfoyaG1Q7ikvRSuN/ojJUO6AHa/qQG5Xjq2H1FnmnhDT56ovQ8lu18s1WMnfqOIZZn3dqbOgcDu0NbtWLmepK3Z90Ddi6MBwT51s3OiipAAL0ErDDBO+o/4zi7Z7WhLvobkOyvapm5gZUmaobf4AcJd4IycqoDJHKQKzDJsJ7c1QvNN1cllBXTFEJLn2GuFJahBTa6Nrr+Msrs4kswCtNMwwerFKc9znurKQAUfhdjX/IOUsc+sjklQe/kBwl3gjttiEPUrDttab/81bG9XNPNzFSsM2Z9vbXVTV2tIYHARHQdoc5cPXKAq2qG3yVPPHDJsJ+Zu1m88R8jeCbwAkZZk/JixePbF6s6VRZwSnI1ztnjKUkrcrjZp8CIyAoCGelqRXtNIwy4hzoXQP1OsmiAAUbFWtQ3prZdETw2aqm8RAah7nLeRtgqFT7M8wSpzk3UrDltEUnuja69gsjTovz6CqKfBq1xRopWGe4eeqbe5XnpXDG5BSdVk165qykWKMRdGxIftoa4biHebjR51JmqyKKpvrLRfLEmw3cVcHwm3uL29vJVKd79WuKdBKwzxJWcpsPPq1pyXxPPWlcKJc3ZDsIX6cig3pDCr7KD8I7S3K0rCXpMmAVFayN2JzF7k6EB4Ypr6/3l6rUZPvldP6OqOVhll8/ZT/Xo8wPXUDShhv33F+gRA3Bop3WS/TYObkv/cE+49NMmo6vNVFVVeixpoG9tMWxQq8Pe22uU61cNfuqUHE0KkqzdRTaXuNx1XWUnurZ65vo3Sf2tqrNAASJ6ohQt5GSwOUZ6s23d5G6V7wC1I1Q/YSngShcV6sNIqUleGOsabhSd4dCK8pUFttaQwikqep6nBPuFcOfw5PTITn5sMzc1VPLE9Rulf5oO0JgttInKTcW97UlmX/h/D4GHjqLPjrFNWo0pso3QPxY9X8b3sRQil3b52tUVvs+nRbGxHJ3u2eOplu66IW8RahlYY9JE9T20I3B3Jri+HNW9Qf06VPqCeSd273XOpq6V7HrAxQlgZ4T1yjYCu8dQtEZ8Clf1azIF/5zqmnPk8jJZTscfzfGyBuLFRkqwFO3kZdkRuVRhLUl3inNQlQY2QVavfUICIiSf2BuzuusfZR1YLjmpdh+q2w6P8g7xvY/7575QDlGis/AAnjHDv+pNLwAhdVRzt8eK+qZ7hxOUz/Ptz4rnJVrfqVp6VT1JdBQwUkTHT8HPFj1N9PjZelOkupYhquDoLbCE9UBakNFe65nr3UFKgmk2EJnpakT7TSsJehU1X6o7toPA47X4cp15/yaU+5QT0Zb/i7++SwUZmjOts6EpQFCI5Urq2KbEvFcog97yiL58LfqgJOgNiRMOfHamhUwVbPygeOJx10Jm6s2pYdcF4eK2moVFlh7ho2FGbUgtSVuOd69lKdrxo3eukcDRteJ50QYpgQ4gshxD4hxF4hxI+N/Q8LIQqFEDuM18UeETBhHFQehtYm91xv15vQ1qQsDBs+vqple/5G98/etvnGnbqJjVbWiieREjb+HWJHwfgrT39v9g9VNs9GDyjlrliiNEarbfl+5+WxkpPV4G6yNGxP8PVeFE/rzAAo7AMvVBpAG/BTKeU4YBZwtxDC5gt5QkqZZbw+9oh08WNBtkOlm6bQ7XpTBY+71kRMvk7VPOx83T1y2Cg/AMJXVYM7StwYlankSR970XYV8J6xrHvmTmAYTLlR9Rrz9FNp6V4VwHUk6cBGcKRyq3qbpVHrpsI+G+FaaViB1ykNKWWxlHK78XMdsB9wcbN9O4g3nvhsaaeupL5MxU/GXtb9vbB4Nccie6Xr5ehM1RFVseoX4Pg54kZD6wmo9WCwec9y5T+e+N2e3592i8qU27PckstV1Dfzh08PcPlT61nyt3X89sN9FBxv6P9AZ4PgNuLGeKGlYaS/urqFiI3QeOO6Xqg0OtqNbr/eORe8M70qDSFEbT+vOiGESx3TQoh0YApga9N5jxBilxDieSFEVC/HLBNCbBVCbC0vd0GfqJgMdbMpc4PSyF4JSBh1Uc/vj1oEZXvd28up6ojzU8Xixqitu11rNqRUVkTG+eopvCfiRqmg/Z63nb7cNzkVnP+nL3n2qyME+PkQHuTHyxuOceETX/H+zj7qBtpa1Gx1R+NHnYkf63nrriu1xYBwn9LwD4KgSJVB5W2cqFAeDHf9WzhBX5bGYSllRB+vcOCEqwQTQoQB7wD3SilrgaeBDCALKAYe6+k4KeWzUsrpUsrpcXFx1gvm66/84GVueGo7/LlyKyT2kjljUyaHVrteFhuWKA2bj91D7pLCbapdw/jL+1434Sq11gmlvDa7nFte2ELSkGBW3juPN+88m1dvn8UXD5zH+KER/Pj1b1mxo5eam4psZe1YZWm0NarRqt5CXZEqPPT1d981wxO90z1ls7oGsqUBfMfE8WbW2I0Qwh+lMF6VUi4HkFKWSinbpZQdwHPADFdc2xTxY12vNKSEvA2QNrv3atmYkUqpHFvvWllsNFRBU43zSiMkWt0sPKU0Dnyo4jKjF/e9brSRa+GgUs6tOME9/9lORnwYb955NiPjw06+lxwZzEu3zmTm8Gh++uZOtucd734CZ9qHdCV2lNpWuCkWZ4ZaNwxf6kpYvHe6p2yxs4FsaUgpj/R3sJk19iKEEMC/gP1Sysc77e/813UF4LkObPFjVM57c53rrlGdp3ycfc3fFkIplWMb3FPoV3VUbaOGO3+uuDGec08d+VJ16A3u0cN5ithMiEyDnDV2X6K9Q/LjN3bg6yN49sZpDAnp/jQdHODLP26cTuKQIH702rfUNnVpD1O6B3wD1cOBs9jOUXXY+XNZRV2J+4LgNsK81NKwtTdx97+HA/QbCDdiF13jGflCiHeFEE4+cvbIHOBG4Pwu6bV/FELsFkLsAuYD97ng2uawZQ5VWa4zT2F2UlvabGXaHs91nSw2bJ/XWUsDjLTbg+6vam+ogqIdkDG//7VCQOZCpWTsnLP90oZcduZX8+sl4xkWHdLruiHB/vzluikUVTfy2MouSrRkj3pA8fWz69o9Ehqr0ogrvUlpFHnG0qgv9b5BYHUlIHyUBe7lmMme+jPwACqDKQW4H/gP8DrwvNUCSSnXSSmFlHJS5/RaKeWNUsqJxv4lUkrPNZGxPbVV5vS6pKWtA+nMH2beBvUlj++n8jp1trHeDbO3q44AAqLSnT9XTCY016oW6+4k92tAwojzzK3PvFBVUx/7xvQlahpaeXx1NvNGxbFkcv9PjlNTo7hxVhovbzzGnsKaU2+U7rXGNQVKAUaP6PNv1q20NaviPne1ELERnqjqnppq+l/rTuqKVB2JFQ8ILsaM0lgipfyHlLJOSlkrpXwWWCSlfAPox74fpNietCu7WxrZpXV895lvGPWrT5j2uzU8/eVhOjocUB75m5ULpb8mdXGjwT/EPVXqVUdUzYC90+N6wlbd7u4n3yNfQkD4qT5i/ZE2W8U/7Igb/eOrw9Q3t/GLxWMQJru3/uTC0USGBPDoJ0acp74MTpRZpzRAPex4i3vq5PAld1saRsygvsy91+2PupIBEc8Ac0qjQQhxtRDCx3hdDdjKob3MxnMTASHq5tnlqW1XQTWXP7WeoxUnuGf+SLKGRfKHTw9w35s77FMcrU0qSGxm6I6Pryr+K9ph32dwhONHIdqCeAacUryudPH1RN5GSJ1pPmMnMFwVVpq0NMrrmnlhfS6XTRrK2CTzMyKGBPvzg/MyWJdTwYbDldZUgnclJkMVkNnpanMJtW6uBrcRZtRqeFvabW3xgIhngDmlcT0qxlAGlBo/3yCECAbucaFs3k1MxmlKo6ahlTte2kpUSAAf/vAc7l80mn/dPJ2fLhzFih1FPPWFHW6Bsn0qZ7u3VNuuDM1SDQA72u37DJ1obe9gV0E1ewpraGvvJZe/6oh1SiMyVT3Bu/PJt6lGZb2l2Jl4lzZb9aEy0TrmxW9yaWpr594F9lfM3zArjYSIQP606iCyxMLMKRvRGaphnzviX/1R56HAr+1p3tsyqOqKB4+lIaU8IqW8TEoZK6WMM37OkVI2SinXuUNIryQ647Qb3v99vJ+K+hb+ceM0Eoco940QgnvOH8llk4fyl88PcaCk1ty5bW3DbVPX+iMpS/ndHWwCuGpvCfP++AVL/raeS/+6jvmPfck3OV06gTYZ8QcrguCgnvSj0tzrnircDkgYZuds87Q50N7c72zzptZ2Xt10jAVjExgRF9bn2p4I8vflnvkj2XbsOBWHtxsDlGLsPk+vmIjFWUFFfTNfZZfzVXY5VSdael5kSzF1u6Xhha1EWpugscr9/xYOYiZ7apQQ4jMhxB7j90lCCC/pG+1BYkaqDrQNVRwqrePNbfncOiedCclDTlsmhODXS8YTGujH7z82WZdQskv53SPTza0fmqW2DrioXtucx7KXtxEdGsBfrpvCn6/Jwt/Xh5tf2MzqfZ2+WMeNdFurlAZ0U7xdqW5oobLeQldKwRZAmI9n2LBlsPUT11ixo5DjDa3cOsdxa+yqacOIDg2gMX+Xta4pgBhbLM41ijq/qoEfvLqNGY+s4abnN3PT85uZ/rvV/Oi1bymr7WKl1RapaYRBkS6RpVeChqg0Zm9yT9lkGSDuKTOh+udQ2VP/AJBS7hJC/Af4nSsF83pOPrUd5q/r/Aj29+W/zus5nz46NID/OjeD339ygC25VZyV3k/zuZLdyjVltkVy7CgjGL4Tsq4z/RE2HqnkoXd3c97oOJ65YRpB/iroPn9MPDf9axP3vv4tK+6Zq4rSqlygNGIyVJaYlKcVMK47VMEfVx5gV4HKcBkRG8oPLxjJ5VnJpgPLPZK/WdWHBA3pf21nQqJVz7E+4hpSSp5fl8uYxHBmjXC8uWBwgC83z0gm8ZtcjocvsjbTJDgKgqNd4hL8dE8JP3lzB1LCnedmcO6oOKSELw+W8eKGXL45XMEzN0xjuu1vv86Y2OeOMa+dEUI1LvQm99TJxo2DxD0FhEgpN3fZ56Wjr9yIoTRKj+7hg11F3HR2OtGhvTfxu+nsdOLCA/nLZ/1U5HZ0qPx8s/EMUMHwuNF29cOqb27j/rd2khodwlPfm3pSYYAKyj5z4zQC/X255z/baW3vOBWwtiLd1kb0CGipPy2T5ekvD3PDvzZR09jKA4tG86tLxhIa6Md9b+zkp2/t7D3e0h8dHcrSsNc1ZSN1JhRs67V307ZjxzlYWsf356Q7p9iAm0c1EyDa+bQ81qnz9EjMSMstjXe2FXDXK9vITAjns5+ey88vGsOsETGcnRHDLy4eywf3zCU8yJ+bnt/M1twqdVCtB5vzhSV4l3vqZIv4gWFpmFEaFUKIDIxMKSHEVajeT2c2UWkgfNmxcytBfr7ccU7fLongAF9uPjuNrw9VkFNW3/vCmjzVAdbeyXjx4+xqy/HkmmwKqxv503cnExrY3eBMGhLM76+cyIGSOl5Yf1QpjdB4lU1kFdFG2q3x5PvyxmP84dMDXDZ5KCvvncfd80dy+zkjWHH3HH58QSbLtxfys3d2OVb/UnUYmqpVGrMjJE+D5ppe4wErdhQR6OfDJZOc/+JH1qkHi1dzw6lu6CUm4CgxGZYqjU/3lPDA2zuZMzKGN5bNYmhkcLc1mQnhvLFsFokRQdz+0lbyqxrcO+a1K96qNAaRpXE3yjU1RghRCNwL/JcrhRoQ+PrTGj6MlrIcbjo7jZiwwH4PuXZGKgG+PryysY+mceVGMDt2tH3yxI1RX4SGqn6XFhxv4MVvjnHV1JRT7oIeuHBcAheMiefPaw7RXJZjrWsKTvOxbzpSyf+u2MOCsfH8+Zqs0ywfHx/BfQtHcd+CUSzfXsi/1h21/1rFO9XWTBpzTyRPV9seRv22tnfw0e5iFoxLIKwHBWw3pXvo8AngQFsCb2+zuH18dIa6YbeYaMveD4dK67jvjR1MHhbJczdNP+3/rCvxEUE8f8tZdHRIlr20FemJvlM2whNNz0lpam1nS24Vb27N57XNeXx5sIzyOotTluuKwS/Y/fEdB+n3L9zoL7VACBEK+BgzLjRATns86T5lnD3P3M00NiyQiycm8s62Ah5cPKbnL1mF0Uoizk6lYascL9sP6XP6XPqXzw6BgPsWjupznRCCh5eMZ+ETa2koPUTg+Avtk6k/hqSCjx8t5Tncv2Ynw6JDePLaKfj69Oze+dEFI9lbVMOjnxxg5vAYJqbYEZso3aNa2turjG3EZqrkhMKt3eJG63MqqDrRwlIT1d+mKNmDT/xoJss4Xt2Ux61zhuPTy7+J3dhSpqvzVIsSB6lvbuOuV7YRGujHMzdMIySgf2WZHhvKk9dN4d4XvkAENXsu8BuWoKzOtmbw6/lhr7K+mb9+nsM72wuoazrdGy+EquK/YVYql04air+vk2OJao10W3fHdxykr3kaP+n8Au4E7uj0+xlNTlk9W2qHkOlXRmwfsYyuXDVtGHXNbXxxoJeK1IpsCImxf1Kb7QbQT1yjrLaJd78t5LqzhvXoSujKsOgQ7p6bTFRbBXlYbD77+kFkGgf37aDgeCOP9eIqsyGE4P9dNZmo0AB++e5u2u0pmCzdqxSxo8OjfHwheUqPlsb7O4qICPLj3NEW9Q0y2ofcOCuNoxUn+OZwpTXnhVMxKSdrNX79/l6OVpzgr9dNISHCfIeA+aPj+cFU9Xe3r773nlwupZ+028/2l3L+Y2t5eaNKn37upul89cB81j94Pm8sm8V9C0ZR09jKfW/sZOHja/kq28lWOHUlAyaeAX27p8KN13SUOyrZeN0FTHW9aN7Nk58dokgkEdRer1JvTXJ2Rgxx4YG819sMhfJsx56GI5JVr6p+4hovbThGW4fk1rnm00KXTVR/Jv855ON4ILoXKoNS8D1+lGXnjOjTVWZjSIg/v7pkLLsLa3h1kx2zIayYgJc8TZ2nU5FfY0s7K/eWcPHEJAL9+mn5YoYTFSoFM2ECiycmEh0awMsbc50/rw0LlMba7HLe2lbAXedmcHaG/XUk35+knu6f2FRvfczGDCeVRvcHt5c35HLbi1sZFh3Mpz8+hyeuyWLhuARSY0JIjgxm5ogYfnRBJqvuncdzN01HCMFNz2/mJ2/u4ESzg/lBdUUDJp4BfbdG/7WU8teoJoVTpZQ/lVL+FJgGpLpLQG/kYEkdH+4qInOsUXxnRysMXx/BZZOG8sWBcmoaW7svqMhWU+PsRYh+53w0trTzyqZjXDgugbSYUNOnDqxVN+dvjg/htc3WTQmsaWhldUkYw31Kuc+OCuolk4cyZ2QMj63K7t5OvCcaqtQX09nq6uRp0NF6qvgS+OxAKSda2k01JjRFp/YhgX6+XD19GGv2l1FS0381uilCYiAgzGGlUdfUyi/e2cXI+DB+dIFjc+IDGtQTfnZDOP+9Yq9D53AK26zwLnGN1zfn8d8r9rJgbAJv3zWbzITekz58fAQLxyXw6b3n8KPzR/Lut4UsfWo9h8v7SHLpCSkN99TAKOwDc4HwBKDz40CLse+MRErJbz/cR1igHwvnGrMu7OyftDRrKC3tHazc0yUYd6JCVYbGOqA0QAXDy/b32vb5493FVDtSfGZ8vvi0sTy2OpvjvVX52sn/vL+HAy3xBNNEUHNF/wcYCCH4xeKx1DS28s+vTPzb227Eic4qje7B8Pd3FBEfHsjMERZVbpcaN1Ej5fr6mal0SGmdshZCzQhxUGn8aeVBimub+ONVk/oMfPeJUZdw9fyz+GBnER/0NfLWFZxsWnjq+7fhcCUPvbeHc0fF8dT1U0x/tkA/X35y4WheuW0mx0+0cNXT3/BtTwO1eqOpRk1UHGRK4yVgsxDiYSHEw6h53f92pVDezEe7i1mXU8EDi0YTkTgSEKcK30wyKWUIyZHBrNrXRWlUOJg5ZSN+rFI6vXTwfHtbAekxIcwYbme8pOooBEdx/+UzqW1s5Y9d5z44wIe7ilixo4jJkw1Pp52Kd0LyEC6ZmMQ/1x3tv2rcqj5OEUkqeFu4FVCW0pcHy7ls8tBeg/d2U7JHuU9CVY3GsOgQzh0Vx+tb8lS9jBVEpTs09vVQaR2vbMrjhplpTE11ouywrghCYrnz/DFkDYvkV+/tobRrxbgrCY0DxMkCv5KaJn742nbSY0L42/emOORmnDMyluU/mE1EsD/fe24Ta83GOU7WaAwipSGlfAT4PnDceH1fSvl7VwvmjRRVN/Lf7+1hYvIQrp+ZplqED0mx+4YnhDJt1+VU0NjSqcmgbZJdrGNm/8mMq4ruN/X8qgY2HKnkO1NT7C8+qzoCUcMZkxjBbXOH89rmPNbsczzPveB4A796bw+Th0Vy2fy5aqcDtQP3LRxFY2s7L6zP7Xth6R5VY2LrcOoMyVOh6FsAPt1bTEt7B0uzLAxilnaPvVw/M43S2mY+229RO++odGVp2Fnv8sjH+wkJ8O03665f6kogPAk/Xx8ev3oyzW3t/OxtB+tvHMHXTynl+lKklPxi+S5ONLfzjxunER7k+LzytJhQ3r5rNsNjQ1n20lY2HjGRwOCiFvHfHK5gZ361pee0YSpXTEq5XUr5pPH61iWSeDkNLW3c/Z/ttLR18OS1WaeeLKPSHWrvvWBsAk2tHazv3BiwIlu1AxkyzDEhbRZKD2NUl28vRAi4clqK/eetOnKyRuP+RaMZlxTBA2/vpKi60e5TNbS0seylbbS3S564ejJ+USrt1pF/w5HxYSwal8hLG3L7DkKW7HbeNWVj6BRV4NdYzYodRQyPDWVisp1tSXqjvVUlMnSxiM4fE8/QIUH2Bf77IipdNbi0YwDW2uxyvjxYzo/Oz+yz84Epak9N7BsRF8YvLx7L2uxy/mNhvKxfwhKgvozl2wv54mA5Dywazch45wtX48IDeeX2maRGh3Dbv7ewo78bd631SqOptZ2fv7OLnztaCNsPfaXc9t3S0+QaqxFCXCSEOCiEyBFCPOiOax4/0cKt/97CzvxqHrt68ukdTKNHOHTDmzE8mvBAP9bs7/TEXpGt2jyY7TnVlYihqpagS7dbKSXvbC9gdkYMySbSbE+jrQVq8k8qjUA/X/5y3RTa2iW3vLCZmgYTgWiDlrYOfvTaDvaX1PKX701R/46+fobidaxK+c5zR1Db1MbrW/J7XtDe1uON2GGSlTvt+OHNbDhSyWWThzrdNuQklTnQ3tJNVl8fwbUzUvn6UAW5FSecv46dGVRt7R088tE+0mJCuGl2mvPXrzs98HvDzDTOyYzldx/u56gVn88MYQm01hTz6w/2Mj0tiltmp1t26ujQAF65fSYxYYHc9u8tFBzvo5DSBdXg//4ml/yqRh66ZKx1f5ud6OvuNFYIsauP127ABc1xekcI4Qs8BSwGxgHXCSHs7LdhnvrmNt7ams/iJ79m27HjPHFNFhdN6PJEED0CGipU63A7CPDzYd7oONbsLzs1oKk82/EgOKggZ9yobmm3ewpryatqYGlWsv3nrM5TMxg6VYOPjA/jHzdO42jFCa55dgPFNf1bHHVNrdz1yjbW7C/lN0vGM390J1eRg4oXYEpqFDOGR/Ovr4/07POvPNTjjdhhkrIAyNnxNVJiXdYUnAqC95AafO1Zw/D1EdYExKOMG79JpfHG1nyyS+v5xeIxzqcVt7UoC6dTXYKPj+CPV00i0N+H/3pl2+kuW1cRlkBdRSFNbR384apJ1hVPGiQYFfAt7R3c8dK23i3humLVSNLfzoe5Xiiva+Zvn+ewYGw852S6Zt54X0pjDHBZH69Lgdkukap3ZgA5xoyPFtSc8qVWX6Sstokpv1nFhP9dyQNv7yIqNIB3fzCn55uu7WZ63P7WFvNHx1NR38z+klrV1qEmz/5K8K7Ejj7VisRg9f5SfARcMMYBn34vLdFnj4zlhVtmUHC8kcVPfs1bW/N7rOGQUvL1oXKW/G09a7PL+d3lE7jx7PTTF0WPUMF2B03pZeeMoKimiVV7e4izlFiUOWUjJBqihtOat40JyRGqA7BVlOw2qta7PzjERwRx4bgE3tyaT1OrkzfVSCNj3oTSqG1q5fFV2cwYHs2i8RY8DZ9sA376w1fSkGCevHYKB0vr+MVy18c3jjaFEtZWxb0XZJDhwOwTM4yMD+Nv35vKwZJa7n9rZ8+fyYjvWMXjqw/S1NrOLy8ea9k5u9Jr+a2U0iIHqqUkA539EAXAzM4LhBDLgGUAqamOlZMMCfHn0klDiQ8P5Kzh0cwcHt27mdd5bGnSZLuuc06mMtTWHapgvDDyu52xNEApnZ3/gcZqCI4EYM2+UqalRZnqj9UNmwXQw8S+uZmxrLhnDg+8tZMH3t7Fk58d4sJxiYxJDMfXR3Cs8gRr9pexr7iWtJgQ/nP7zJ5TU6MzTnW7Dbc/m3v+mHhSooJ5eWMul0zq8gU82T7EyX/XTtTHTiK1aj1L5zpgufVFP1Xr189M45M9JXy6p4TLpzhxbf9gdaMyoTSe+iKHqoYW/n3JOGtcHXU9Kw2Ac0fF8ZMFo3hsdTaTh0XyfSfmkvRFfXMb7+W0c59o547pljaf78a5o+J4cPEY/u/jA7yy8Vj3B6Za6xo37iuq5Y0t+dwye7hDQ8DMYkF3Ne9CSvks8CzA9OnTHXpcCfTz5beXm3wytfmHHXCvJEQEMSohjK8PVXBntKELrVAaoOIaw2ZQWN3IvuJafrHYwT5DVUdUMVhoz6ZuRlwYb981m9X7S3l1Ux6vbDxGi2Fx+AiYmDyE3y4dz9VnDevdtdFZ8TqgNHx9BNfPTOMPnx7gUGnd6UVZpXtU/YrZmeAm2N42nHliBUsyLf76lOyGjPm9vj07I4bhsaG8uumYc0oDjAyqvp8L86saeGFdLldOSbGvz1df1Bo1Gb2kmN49fyQ7C2r47Yf7GBYVwoJx1peE/WnlQSqaQsEf/BvKIdw1bhwbt88dwTeHK/ntR/uZnh59+uz4upJTfeOcwFY/FhHsz48dLLo0i5OdttxOIdA5tSjF2Oc5AsNUJoaDPvlzMuPYnFtFW+l+ED6qdbUz2JSOkUFlS41d6OiXzzYXvI+nTB8fwaLxibx06wz2/mYRX/9sPmsfOI89v17EinvmcuPZ6X37wm3dbp0YDnT19JSeOwiX7LHONYX6ci4vUW6+hLreq+/tpr5MuW76mKPi4yP43oxUtuQeNz86uDdsabd98OgnB/D1ETywyEmXaWdOBn57jgX5+AievDaLCclDuOe17Wy3p1DOBDvzq3lxQy5ZY42HKDdM8PPxEfzpu5MZEuzPD1/79lTMpqNd9b+yoEZj5d5SNhyp5CcLRzEkxLoHpJ4wpTSEEGlCiAXGz8FCCAuHKtjFFiBTCDFcCBEAXAu87yFZTmHzyTvAOZmxtLR1cDxvr/oi99J10zRR6WqcpVGrsWZ/KSPiQh03V6uO2tUS3d/Xh2HRIaTFhJrqfAqc7HbrqOIFiAkL5JJJSbyzvfBU0LFTHyer2FtUy6rjiXTgY8wctwhba5J+hm9dNS2FAD8f/rPJyYB4ZBrUFqpOrz2wNbeKj3YXc+e5I07OvLeE2iL199lHQ87QQD+ev+UsEiKCuPXfW9hTWGPJpRtb2vnJmzuIDw/k2vONkb+9FMJaTWxYIE9cnUVOWT2PfGw0FT1RDrLdaffUieY2fv3BXsYkhnPdDNd3eDIzI/wO4G2Mca+op/v3XChTr0gp24B7gJXAfuBNKaUHmtd0wQmlMXN4DAG+Psjyg45XgnfGx1cVB5YfpLaplY1HKlk41kEro6NdPY1Guca3fBKj260zSgPghlmp1De38e63hvFpVfuQTry/s4hW32Bk7KiTRX6WYFMa/Si4qNAALp2YxPLOytERotIBCdXdU5U7OpSrIyEikGUm2/6bps5cG/DYsEBeuW0moQF+fO+5jf3XO5jg/z7ez+HyEzz23SzCYox6JTcOY5qbGcvtc4fzysY81eXa5qpzUmk8+dkhimuaeOSKCc63aTeB2SFMc4BaACnlIcCC0lrHkFJ+LKUcJaXMMKrVPU/UcIcH2wQH+DIjLYLIxjzHGhX2ROwoKD/IV9nltLZLx/3CNQWqQZ/Vw5d6InqE0xPlpqZGMTYpglc35alMFavahxh0dEg+2FnEuaPi8E2ZBkXbHc746kbJblXUaaIl/vWGcnzfmZ5NfdRqvL+ziJ0FNfxs0Rjz1qJZ7BjzOiw6hDfunEVkSADXP7eRzw84foN/e1sBL288xh3nDGduZqyK0/mHuH1W+P2LRjMmMZwH3t5FXYUxYMsJ99T+4lr+te4o180YxrQ0x2fT24MZpdFspLcCIITwwxj9qjGwZRY52ATuopQWAmijNtSiJ/q40VCdx9o9x4gODXC8T9DJzCk3KQ0n0m5BtWe5YVYq+4tr+Ta/WlkaYYkn+zg5y5bcKoprmliSlawqw0+UK8VqBSW7Tc+Fn5oaxZjEcF78Jtfx1NSTSuN0C7mxpZ0/fHqAiclDuMLZYHtP2CwNk6REhfDmnWczPC6U217cyjNrD9v9mTceqeQXy3cxZ2QMP7vIiGUIodrKuHnsa5C/L09ck0VtYyvvf616mDlqabS1d/CL5bsZEuzPzy9yMNHFAcwojbVCiF8CwUKIhcBbwAeuFWuA0Tn7xwHOiVQ9arY1WGTAxY0GJMeyd3L+mHjHm+m5U2nEZEBLnV2tLXpiaVYyoQG+KiBeam0Q/L0dhYQE+LJgbDwMNRotFlkQ12htVEWIJi0iIQS3nzOCAyV1fOnoAKCwBPAL6ta48J9fH6G4polfXTLW8oI3pDSUhn0FkYlDgnjrztlcPDGJRz85wM0vbDHdwmZtdjnff2ELaTGh/P17005334QlemRW+NikCO5fNIrKkmN0CN9eMxP745m1h9mRX83/XjaOyBAnW7vYgRml8SBQDuxGTe/7GPiVK4UacNgsDQeVxrB29bS6uiyin5UmMWIjiS15LHA0ngHKXeQX7J62zU4qXhthgX5cMTWZT3flqziRs4OXDJpa2/lwVzEXTUhULpvECar+w4q4Rtk+VXVv0tIAVYmeNCSIf6x10KXn46OK/DpZxyU1TTy99jAXjU+0rtV7Z5pqVM8rB9wxwQG+/O26Kfx26Xi25lax8PG1PLE6u9c2Niea2/jTyoPc8sJm0mJCeO2OWd2zijxgadi4be4IJoY3UNYxhLzj9s8c31NYw5/XHOLSSUmOdXpwAjMzwjuA54yXpieCoyA42qGqcACfykPU+Eaz6kgzj0jpfBFVTAYd+DDar+hkAaFDVB1WN3NHe2HZQ2elkTrLqVN9b0YaWzatQ7S3QIL5G3FfrNlfSl1TG9+ZagRQ/QKVQrIig8pk5lRnAvx8uG3ucH730X525FeTNSzS/ut2Sbt99JP9tHVIHrrERdXETnZ0FUJw49npnDsqnkc/3c+Tnx3i6bWHmT86jmlpUSQOCaappZ1dhdV8vLuEqhMtXDUthV8vGd/zGOHwRDiy1okP5Di+PoKz41vIzo3mN2/u4I07zzbtEahpbOWe/2wnOjSA3y61zpI2S69Kw+gt1avzUEo5ySUSDVSihzv+lFxxkKbIkVQUNnOgpO704h8HkL4BFIhEZoaV9zlzu18qD5+aPe5qIlNB+DodDAcYNzSCxXGVUAsyYTxWOFmWby8kaUgQszo/gQ+dAnuWQ0eHc4q1eKca1RtpXzPAa2ek8pfPDvHMl4d55sZp9l83Mg3yNoKUbMs7zns7irhn/kiGRbtodnetkdUW4dyTcWpMCH+/fhr7i1UF9Op9pazs1EIm2N+X+WPiuG3uCKal9RHPC4uH5hrlHrSo95M9BDWWEZuUxtbc4zyz9jB3zx/Z7zHtHZJ7X/+WguONvL5sFlHOdhx2gL7uKJe6TYrBQPQIyN9k/3FSQkU2YaMuh0L4+lC500oju7SeY21JzBROZNe0t6mn0LFu+jPw9VeN9Jx0T9m4OK6C5ho/ttVEM9vJouLyumbWZpdzxzkjTn8aTJ4K215QMsf2/4XvlcJtSgHZqXjCAv24ZXY6f/k8h90FNfZXbUelQ3MtHQ3Hefj9fSRGBPGD+U4Wl/bFyWpwa5o8jk2K4OEl43l4yXgq65s53tBCgK8vQyOD8DOTetp5VniUfQrbEuqKSZowh0siknhidTbjh0Zw3uje45odHZKfv7OLLw6W89vLJzA93T3ZUl3pa0b4sb5e7hRyQBA9QmXS9FIs1Sv1ZdBUQ2jyeDLjVUsRZ1mzv5QcmUxEY56a0eAINflGuq0LbyJdiR7hVFV4ZzJkLkfEMF7Z4nzDgPd3FtHeIblyapcnZCuC4a1NqudUsgOWAnD7vBFEhfjzx5UH+l/cFSODas03m9hdWMODi12QYtsZF8yOsBETFsjI+HBSY0LMKQzoNPbVA3GN1kZoPI4IT+T3V05kVEI4//XKdr7qJbGhqbWdB97exdvbCrh3QSY3zvKAkjMwU9xXJ4So7fLKF0K8K4RwQ1rNACF6hApmVttZqWubshc7SrUUOVrldBfT1ftKaY7MRHS0OVx0eNJN5GxbE3uwIO3Whm/pXlpix7FqbyllTowSlcZ87skpQxiV0KURQtwYlSjgTDC8ZDd0tDmsNCKC/Ll7/ki+PlTBNzl2PnAYT9er1m/mrPQoaycQ9kRtoZqg2EtDRrdjm+ToCaXRKb4TEeTPi7fOIC0mhO//ewuPrzp4snBTSsmmI5V85+lveGd7AfctGOXy3lL9YUYl/xl4ANVhNgW4H/gPqi358y6TbKBxMpBr50365FzwUZyTGUtzWwdbcqscFqOsrokd+dUMHWl03C134AkUTj3xu9XSyIDmWtX+wxnqy+BEGSljzqKtQ/JGbwOaTLDxSBU5ZfXc0NOTna8fJE1yLhheuE1tHVQaADfMSmPokCB+8+E+++aIGzGUhPZiHv3OJJcM7DmNThP7vAJbvUid6/tPdcNmdRn/HnHhgbz9X7O5dFISf/k8h2m/W81lf13HnEc/55pnN1JZ38KzN07jxwsyXf//1A9mlMYSKeU/pJR1Uspao4vsIinlG4Br+woPJKIcTLstz1bVqRFDmTkiGn9f4ZSLyjZHevLUGWpHD/PCTVF5WE0BtGKutllijLhA5SHnzlOyS50uYzpzR8by2uY82jscs15e2XiMyBB/Lutt2NLQqSqQ3e5gS4/CbapuwYmbaZC/Lw8vGc+Bkjqe/cr8398HB+uplOFcnNLsspkSp1Fb5HQQ3FJCYgHhtv5Tp9FD48awQD+evHYK7/5gNteelUpMWADT0qP5/ZUT+fz+c7nQinkmFmBGaTQIIa4WQvgYr6sBm72vK8NthMaqm6y9SqNsH8SPBSEICfBjelq0U0pj1d4SUqKCGT0sUbWl6DKQyTRVh1X3WXc+1djaujtqHdkoVkqDxIncMCuNopomPtlTbPdpiqobWbm3hKunDyPIv5cuvclToa0Ryh3seFu47eQIWWe4cHwiF09M5MnPDpnqgJtTVs+D7+yiyj+JscHWdpLtlboiy4LgluDrpwrr3NDptht1p1sanZmSGsXDS8bz7+/P4K/XTeG6GamujTXZiRmlcT1wI1AGlBo/3yCECEY1D9SAurnam3YrpfJpd6oEPmdULPuLax3yw9c1tbI+p5KLxicqEza2++hX01TmuNc1BTAkRVldZU4qjZLdKoU3OJKF4xLIiAvlb5/n2N1+wlY4d9PZfQQdhxkzwI5tsF/OhiqlnJ1wTXXm10smEBnsz50vb+tzdnvViRbuemUbgf6+pIwYi4+D7W/soqUBGo97l9IAlUHlCUujthj8Q1Wq9QCjX6VhjFa9TEoZK6WMM37OkVI2SinXuUPIAUPMyFMxCjPUFkFT9WlVy+cbI1lX77c/OPfFwXJa2ju4aIJhxsaNhopDqo7AHloa1ICeOPf1swGMGeejnbc0SnZBoioj8vUR/OC8kRwoqTvpujNDWW0Tr23J5ztTU0iJ6qNuITIVIlLgmANfhbyNapt6tv3H9kBceCBP3zCVoupGbvjXJo6faOm2pqyuiZue30ReVQNPfW8qwfEZRqaci+dy9zNHw2N4qiq8zojveDg+4QhmsqfihBC/FEI8K4R43vZyh3ADjoTxqpdPk8kBOSdbd5+qBB6dEM7w2FA+3WO/ybxyTwmxYYGnGhTGjlKukxo7A8EV2YB0fl65I8SNOTlAyiGa61U8JvFU7emSrKEMiw7m8dXZpmMbT689THuH7L9uQQhInwPHvrE/6+vYejVbwgL3lI1padH848ZpHCyt47K/rWPV3hJa2ztobmvng51FXPqXdeSU1fOPG6ZxdkaMyqDqaDtVeOcqLK7RsIzwRLd3ugWUpeGO9jwuwIx7agUwBFgDfNTppemKzc1Uts/cepvSiD/VtkEIwUUTEtlwuJLqhu5Pir3R1NrOlwfLuHB8wqlGczZLwd6bsO1JP95F7ST6Im608jE3OuhnL90LSJXVZODv68MDi8awr7iWt7f1r0APldbx8oZjXD09hbSY0P6vmTZHNVq0x8oEpTRSznJ+8FYXzh+TwOvLZuHv68Oyl7cx7n8+Zfz/rOSHr31LdGgA7909h/mGRdtXi3RLOak0vCgQDsrSOFFmvzXuLN4W37EDM0ojREr5cynlm1LKd2wvl0s2ELF1VLX1EuqPkj3KvRF0eiXv4gmJtHVIVu8z/wS0al8pJ1rauXRSp6eXk/PC7VQaZftVMz53dLftiqOKzkaJLQh+epebyyYlMT0tij98epCyut7jRe0dkv9esYeQAF/uv9CkpZU+V22PrTcvZ3OdyrpKm23+GDuYmhrF6vvm8Y8bp3Hb3BEsmzeCF245i49+dA5jEjv50d2mNGwtRLzs6TosUVlajY6nuduNlCrN144W8d6EGaXxoRDiYpdLAggh/p8Q4oAQYpdRPBhp7E8XQjQKIXYYr2fcIY/dRCRDUKTxtGuCkt09NtSbmDyE5MhgPthlPuNn+fYChg4JYtbwTr2RQqJVWqEjlkZspmrt4W5OKg0H4xolu1TzyC5PcUIIfn/lRE40t/HAW7vo6MVN9fcvcth4pIqHLhlLTJhJCyB6hLr55NoR18jbqIpBXaQ0APx8fVg0PpEHF4/hZxeNYX5PbfIjUlTPr+MubvJQW6QejgJMWG7uxBMFfg2V0N7iffEdk5hRGj9GKY5Goxq8Tgjh5FT7XlkNTDCaIWYDv+j03mEpZZbxustF13cOIZSLyuZ26ovG46oeoQd/thCC70xL4etD5RQc738aYFltE19ll3PF1OTuMxAciRGU7Xd/ENzGkGFqopqjlkbxLuWa6iHAmJkQzq8uHcfa7HJ+/cHeborjvW8LeWJNNkuzhnL19GHmrykEjDgPDn9hPqCcs0bNs3Cyo6/T+PqprDVXWxp1xd7nmgLPFPiddNV5mdVlEjPZU+FSSh8pZbCUMsL43SV5YlLKVcYccICNqAr0gUXiBCjd1//Nw1YJnHJWj29fPV199DdNVDO/uimPDsmptt2diRutbsBmg7QtJ1QrFE8pDR8fJbMZxduVtmYVT0qa3OuSG2amcsc5w3lxwzFufmEz3+RUsDO/mofe3c29b+xg5vAYHr3SgerozIXKxVGw1dz6Q6tg+DyPdFftRlSae9xT3ujD79y00F14ayaZSUx19hJCRAkhZggh5tlerhYMuBX4pNPvw4UQ3woh1gohzuntICHEMiHEViHE1vJy56bAOURSFrSe6P9JuWArIHrNnEmJCmFeZhyvb8nvsxdVU2s7r2w8xgVj4hnRU1Vv0mTV/tls/UjJHkDaNdvBcpImK4vB3myk4l3K7O9FEYOy4n558Vh+u3Q8O/Kr+d4/N7H0qfW8sSWfW2an88L3zyI4oJdCvr4YeYFy8xxa2f/aysPq/2PkQvuv4wqi0rtN8LOcWi8N/HrCPTXALY1+ywyFELejXFQpwA5gFrABON+RCwoh1gA9RYAeklKuMNY8BLQBrxrvFQOpUspKIcQ04D0hxHgpZTc3mdHm5FmA6dOnu79ifZjRviN/EySM631dwVaVnRQY3uuSO88dwfee28Rrm/P4/pye54cv315I5YkWbjunl/nitsKxwu3mmg/amu8NndL/WleRNBm2/VtZPPa0rC7YorbJ0/tcZhvmc/mUZLbmHqe5rZ0pqVEkRAQ5LnNwlHI1Za+CC/6n77WHVqttphcpjRPlKl050AXtRNpb1ZO8Nz5ZB4arIjt3Ko26EkCcsnIGGGZjGmcBx6SU84EpQLWjF5RSLpBSTujhZVMYt6BmeVwvjRJeKWWzlLLS+HkbcBgY5agMLiV6BITEnLqB9YSUULgVUvq+uc3OiGXm8Gj+/uXhk10vO3OiuY0n1mQzNTWSs3sbz2nrxGpzh/VH0bfqj9mTT0E291LxTvuOK9iiYiImZQ8P8mf+mHgumpDknMKwMfpiKN2tCir7Yu+7ED/u1JhgT2Mb/uQqa6OuBJDeaWmA+wv86opU+xJPJJpYgBml0SSlbAIQQgRKKQ8ALqn6EkJcBPwM1SSxodP+OCGEr/HzCCATsGZaj9UIoVpL9DWQqXSvCoQP6z8I+rOLxlBR38zvP+ne2+jRTw5QXtfMry4d17sP3tcPhmaZVxrFOzxrZQDEj1euHnuVhglF7FImXgXCB3a+3vua6nzI3wgTvuM+ufrD1mzTVRlU3lrYZ8PdBX61xQPWNQXmlEaBkfr6HrBaCLECcJUD9G9AuHGdzqm184BdQogdwNvAXVJKNyZW20nabNW7qaag5/cPf662GfP7PdW0tChumzOcVzbm8cL6oyf7J734TS4vbzzGsnkjTlWA90byNJWK2t9ApuZ6FYvxtNLwD1KuO3uURl2pcmf1Ec9wOeGJMGI+7Hqz92Ixm0LxKqWRrrauCobbOhIMsSMjzZ243dIo9k5XnUn6jWlIKa8wfnxYCPEFqjr8U1cII6XscWamUUw4cAoKRy6AVb+CnM9g2s3d3z/8OcSNNf3k9fPFY8itbODXH+zjw13F+AjYknucheMSzBWgJU+FDU1KcfTVHK94J6qaOsuUXC4laTJkr1SuPDOZTIVG1pInlQZA1vfgndtUSu2oC09/r70Vtv4LMs73HtcUqHqegDDXKQ3bYLJIb1UaCSpd2l3UFp2KfQ5A7BpKLKVcK6V8X0ppvr/FmUjcGJWTnrOm+3tNNapPUYb5PAJ/Xx+euWEq/3PpOJpa22loaeeXF4/h6eunEuBn4r8w3Ug2O/pV3+vyjE6tnr7xgvpSNVScmiDYH7lGH6culeBuZ+wSVTC37vHu2V+731JPmTPu9IxsvSGEazOoavJVwaW3FfbZCEtQw79a+q+JcprWJpWaPYAtDfsm2WvMIQRkXqiURnPd6e/t/xDam2H8FT0f2wt+vj7cOnc4H/3oHD760Tksm5dhxyzkeBV4PbK273W561Q8IbSXoLo7STUqpfO+Mbf+6FpInalcW57ELwDm3qsU8L4Vp/a3nIDPfqOGNmVe2OvhHiMq3YWWRr73WhnQqVbDDS6qPuZoDBS00nAVk6+D1gbY+97p+3e/qb6g7g7YDp+nWle0Nff8fluLCt4P77UExr3EZqoWKGbmVNSXq2LA4ee6Xi4zTPu+cvF99BM1BKu9Fd77gcoiuuhRVcDobUSmqUC4BfPZu1GT773xDDjlJq4z37bHYTrNBh+oeOFf7yBh2AyIyVQ+bNsXsXQfHPkSsq53fx/94eeqNun5m3t+v2CLUnK25nueRghV92DG0sg13G4jznOpSKbx9YPv/FP9/MxceHwc7HsPFv5GWUPeSFS6+vuwujJaSsPSSLX2vFZiUxq2LC9XYruGVhqabggBs3+o6h72vKOyaVY9pEbCnnW7++VJnwu+AXDw457fP/CRigl4y40XVBba8dzes9BsHPlSTUDzhgC+jdhMuPMrmHaLst6uewPm/MjTUvWOqzKoGo+rDgkDwdJw9UwR0O4pTT9kXa+qk1fcA/9aqLKmFj6sslXcTVCEalux973u6aBSwoEPlMLoo0Ld7WRcoLaHVvW+pqMdDn6qEgt8vWeOMqAaAV78R7jqeRh9kael6Rtb5b3VSsMWXPfmmEZghMoeq3WDe6q2WBXbBkW6/louQisNV+LrB9e9pvoSNVbBhY/A9Ns8J8/4K1Q1ate5D/mbVVrk2Es9I1dvxI1WvvbsPvo5FWxRQ3TGXuY+uQYjkWmAgONHrT1vtZfXaIDyCoQnucfSsDVuHIBjXm142aPZICQsHq59tf917mDMJSr1cePfTw94b35WPW2Nv9JzsvWEEDDqItj+Yu99kfatUAOjvKWP00DFP0hZA/21QLEXW2GfN8c0QN3I3RHTqCnwbqvLBNrSOJMICIEZd6i4hq3auiJHBWmzrndNszpnmXAltDWdnr5qo60Zdr0BYy7uNv1Q4wAxI1UnAyupzlcNAYP76VrgaSKS3ZM9VVOg3JYDGK00zjRm3qWapS1fptxSy+9QQ4/m3udpyXpm2EyIzoBvX+n+3oEP1RS0qTe5X67BSMxIVUxpZdptjVGj4e3umIgklRLd3r0xqGW0NUN9iXe76kyglcaZRki0CsweP6aC8yW74IpnINxL2zQLoVqx5H1zerpwRwd89ZhSKCP67+GlMUHMSGipszbttvqY97umQLmnZLuKj7kKm/tLWxqaAcfweXDPFrj8abh7s4p1eDNn3a6sozUPn8r82vEqlO2F+b8EHweGJmm6Y5u3YpWLSkqoOqrGBXg7tlG0rsygsqWOa6WhGZBEDlPN9cwMZvI0AaFqsNGx9fDhvcpV9cnPVKsRbwveD2RijH6hVimNExXQUn+q9bo3445aDdu5B7h7SmdPaQYGU26Eimz45q8qmypxInz3397ZkmOgMmSYKvCstCiDyjZieCBYGuFuaCViyyTz1rkiJtFKQzMwEAIu/B1MvVk9waac5X3FfAMdH191gzfbWbg/TiqNAWBphMSojgmutDRqCpSb1T/YdddwA/pbpxlYxGaql8Y1xGQoi84Kjh9VkwwHQiDcx8co8HNhrcYgSLcFHdPQaDSdiRmpgtdWpJ5WHVGzRfwCnT+XO4gY6vpAuC3gPoDxOqUhhHhYCFFojHvdIYS4uNN7vxBC5AghDgohFnlSTo1mUBIzEjpaoSbP+XNVHR0YrikbEUNd556S0rA0BnYQHLxQaRg8IaXMMl4fAwghxgHXAuOBi4C/CyF0rqVGYyU211+5BS6qqiMDUGkU9T7f3RmaqlUmmXZPuZWlwOtSymYp5VEgBxi4g3Y1Gm8kzpg5X77fufM0VqsmnQMhc8rGkFQ1VfNEufXnHiQ1GuC9SuMeIcQuIcTzQghb05pkIL/TmgJj32kIIZYJIbYKIbaWl7vgP1+jGcwER6n007IDzp3H1i13ICkNW8C+2gLXXFdOKg3tnnIIIcQaIcSeHl5LgaeBDCALKAYes+fcUspnpZTTpZTT4+LirBdeoxnsxI+Fsn3OncOWtjsglcYx6899skX8wLc0PJJyK6VcYGadEOI54EPj10Kgs5pOMfZpNBoriR8LW9arAVeOtmgpP6jSbW1V5gMBW8vymvy+1zlC9TE1fCks3vpzuxmvc08JITrPQbwC2GP8/D5wrRAiUAgxHMgEehl4rdFoHCZ+rGpH78wUv/IDqn3IQEm3BTW1MjjKNe6p47lqpK63d/s1gTcW9/1RCJEFSCAXuBNASrlXCPEmsA9oA+6WUrZ7SkiNZtASP1Zty/Y53pus/CDEjbFOJncRmepapTEI8DqlIaW8sY/3HgEecaM4Gs2Zh+1mX3bAsTG67a1QdVgNxxpoRKZak27cGVu33/Rz+l87APA695RGo/EwAaFqZrijwfCqI9DRNjAtjSGGpWHlIKoTFdB6YtBYGlppaDSa7iSMh9I9/a/rifKDahs7yjp53EVkKrQ1qhu9VdhiQ1ppaDSaQcvQKVBxCJrr7D+23KjxGKhKA6yNa9iUxkCqju8DrTQ0Gk13krIACcW77D+2ZJfKnAoMs1oq12NTGlb03rJhUxoDoduvCbTS0Gg03RmapbZF39p/bPEuSJpkqThuw1arcdzCAr/juart+gCfo2FDKw2NRtOdsHjVxrt4h33HNVarQrbEAao0goZAcPSpAVJWMIjSbUErDY1G0xtDp9hvaZTsVtukLMvFcRsxGRYrjaNaaWg0mjOAoVlQmQNNNeaPKTFiIAPVPQUQnWHdyNuWBjWjYyD14OoHrTQ0Gk3PJE1R26Id5o8p3gVhiQO7x1JMBtQVqRu+s1TmqO0gGlGslYZGo+mZlOmAgLyN5o8p2KLcWgMZm1VghYvKNm89RisNjUYz2AmOhMQJcGydufX1Zap9SNrZLhXL5dj6bVVZ4KKqzAGE4z28vBCtNDQaTe+kzYH8LdDW0v/avA1qmzrAlUa0cYO3Iq5Rka3qMwZJui1opaHRaPoibY5qq2EmiypvI/gFDezMKYCgCAiNs8bSqDg0qOIZoJWGRqPpi7Q5apv7Vf9r8zZA8nTwC3CtTO4gOgMqnYxpdHQo99RAbKfSB1ppaDSa3gmNUZZD9qq+1zVUQfFOSJvtFrFcTkyG85ZGXRG0Ngys6YUm0EpDo9H0zZhLVFZUfVnvaw5/DrIDMi90n1yuJGYk1JeqCndHsWVOaUvDdQgh3hBC7DBeuUKIHcb+dCFEY6f3nvGwqBrNmcPoxYCEg5/0viZ7JYTEQPJUt4nlUuLHqa2tzbsjVBxS20EW0/CqyX1SymtsPwshHgM6l6IellJmuV0ojeZMJ2GCGk60/wOYdnP391ub4NBKGH0x+Pi6Xz5XEG+bXrgPUmc6do7SvWrmeFiCdXJ5AV5ladgQQgjgauA1T8ui0ZzxCAGTvguHP4Oawu7vZ3+iWo1Mutr9srmKIangH3pqNogjlO5VClcI6+TyArxSaQDnAKVSykOd9g0XQnwrhFgrhBgcw3Y1moHClBtVzGL7S93f2/4yhA+F4ee6Xy5X4eOjrA1HR952dKhjEyZYK5cX4HalIYRYI4TY08Nraadl13G6lVEMpEoppwA/Af4jhIjo5fzLhBBbhRBby8vLXfdBNJoziejhMOoi2PQ0NB4/tb9wu7JAzrp18LimbMSPhbL9jh17/KjKnEoYb61MXoDblYaUcoGUckIPrxUAQgg/4ErgjU7HNEspK42ftwGHgR5TEqSUz0opp0spp8fFxbn+A2k0Zwrn/wqaauGL/1O/d7TDqv+GoEiYcadHRXMJcWPhRLlj88Jt89UHodLwqkC4wQLggJSywLZDCBEHVEkp24UQI4BMwMKG9xqNpl8SJ8LMO2GTkbxYV6z6Ui19SlVRDzYSjAyqkt2QMd++Y0v2gPBR1sogwxuVxrV0D4DPA34jhGgFOoC7pJRVbpdMoznTWfhbaG2Ezc+Brz9c8D+Qdb2npXINtnYoxTscUBq7Va3HIOo5ZcPrlIaU8pYe9r0DvON+aTQazWn4BcCSv8CCh5XSCAz3tESuIyQaItPsn14oJRRug4zzXSOXh/E6paHRaAYAIdGelsA9DJ0CRdvtO6YmH06UGfNIBh/emnKr0Wg0nmfoFKjOU721zFKwVW2Tp7lGJg+jlYZGo9H0hm0KoT0uqsJt4Bs4KGs0QCsNjUaj6Z2hWYBQDRvNUrAVkiYPjhbxPaCVhkaj0fRG0BCVapxrcuRtqzGwatgM18rlQbTS0Gg0mr5IP0dZGq1N/a/N3wTtzTB8nuvl8hBaaWg0Gk1fpM+BtiYVq+iPI1+Cj9/gGUbVA1ppaDQaTV+kng0IOLa+/7VH1qqRt4O4fkUrDY1Go+mLkGhImgQ5a/pe11ClqsdHDKJuvz2glYZGo9H0x+hLIH9z3yNvsz8dXCNve0ErDY1Go+mPMZfQ78jbfStgyLBBW9RnQysNjUaj6Y+E8RA9Ana/1fP7DVVw+HMYu2TQTerrilYaGo1G0x9CqOmFuV9D5eHu73/7MrS3wJQb3C+bm9FKQ6PRaMyQ9T2VTrvx76fvb2uBLf+EtDmnZnAMYrTS0Gg0GjOEJ8LUm2Dbi1DVaQbc5mdVU8O5P/GcbG5EKw2NRqMxy7yfgV8QLF+mRt8WboMvHoGRCyFzgaelcwt6noZGo9GYJSIJLv87vHULPD4OWhsgIhmW/s3TkrkNj1gaQojvCiH2CiE6hBDTu7z3CyFEjhDioBBiUaf9Fxn7coQQD7pfao1GowHGLYFbV8KEK2HOj2DZF8p1dYbgKUtjD3Al8I/OO4UQ41AzwscDQ4E1QohRxttPAQuBAmCLEOJ9KeU+94ms0Wg0BsPOUq8zEI8oDSnlfgDRPZ95KfC6lLIZOCqEyAFsPYZzpJRHjONeN9ZqpaHRaDRuxNsC4clAfqffC4x9ve3vhhBimRBiqxBia3l5ucsE1Wg0mjMRl1kaQog1QE+OvoeklCtcdV0p5bPAswDTp0+XrrqORqPRnIm4TGlIKR3JPysEhnX6PcXYRx/7NRqNRuMmvM099T5wrRAiUAgxHMgENgNbgEwhxHAhRAAqWP6+B+XUaDSaMxKPBMKFEFcAfwXigI+EEDuklIuklHuFEG+iAtxtwN1SynbjmHuAlYAv8LyUcq8nZNdoNJozGSHl4HX7T58+XW7dutXTYmg0Gs2AQgixTUo5vaf3vM09pdFoNBovZlBbGkKIcuCYE6eIBSosEmegcKZ95jPt84L+zGcKznzmNCllXE9vDGql4SxCiK29mWiDlTPtM59pnxf0Zz5TcNVn1u4pjUaj0ZhGKw2NRqPRmEYrjb551tMCeIAz7TOfaZ8X9Gc+U3DJZ9YxDY1Go9GYRlsaGo1GozGNVhoajUajMY1WGj1wpk0JFEIME0J8IYTYZ0xU/LGnZXIXQghfIcS3QogPPS2LOxBCRAoh3hZCHBBC7BdCnO1pmVyNEOI+4+96jxDiNSFEkKdlshohxPNCiDIhxJ5O+6KFEKuFEIeMbZQV19JKowtCCF/UlMDFwDjgOmOi4GCmDfiplHIcMAu4+wz4zDZ+DOz3tBBu5EngUynlGGAyg/yzCyGSgR8B06WUE1C96671rFQu4d/ARV32PQh8JqXMBD4zfncarTS6MwNjSqCUsgWwTQkctEgpi6WU242f61A3kh6HXA0mhBApwCXAPz0tizsQQgwB5gH/ApBStkgpqz0qlHvwA4KFEH5ACFDkYXksR0r5FVDVZfdS4EXj5xeBy624llYa3TE9JXAwIoRIB6YAmzwsijv4M/AzoMPDcriL4UA58ILhkvunECLU00K5EillIfAnIA8oBmqklKs8K5XbSJBSFhs/lwAJVpxUKw3NSYQQYcA7wL1SylpPy+NKhBCXAmVSym2elsWN+AFTgaellFOAE1jksvBWDD/+UpTCHAqECiFu8KxU7keq2gpL6iu00uhOX9MDBy1CCH+UwnhVSrnc0/K4gTnAEiFELsoFeb4Q4hXPiuRyCoACKaXNinwbpUQGMwuAo1LKcillK7AcmO1hmdxFqRAiCcDYlllxUq00unPGTQkUQgiUn3u/lPJxT8vjDqSUv5BSpkgp01H/x59LKQf1E6iUsgTIF0KMNnZdgBp4NpjJA2YJIUKMv/MLGOTB/068D9xs/HwzsMKKk3pkcp83I6VsOwOnBM4BbgR2CyF2GPt+KaX82HMiaVzED4FXjQeiI8D3PSyPS5FSbhJCvA1sR2UJfssgbCkihHgNOA+IFUIUAP8LPAq8KYS4DTUi4mpLrqXbiGg0Go3GLNo9pdFoNBrTaKWh0Wg0GtNopaHRaDQa02ilodFoNBrTaKWh0Wg0GtNopaHRaDQa02ilodGYxGgr/oNOvw81agCsvs7DQohCIcRv+liTIYTYIYSot/r6Gk1f6DoNjcYkRjPHD40W2668zsNAvZTyTybW1kspw1wpj0bTGW1paDTmeRSwPeH/PyFEum3ojRDiFiHEe8awm1whxD1CiJ8Y3WQ3CiGijXUZQohPhRDbhBBfCyHG9HdRIcS5xjV3GOcLd/Hn1Gh6RbcR0WjM8yAwQUqZBSctj85MQLWVDwJygJ9LKacIIZ4AbkK1Yn8WuEtKeUgIMRP4O3B+P9e9H7hbSrne6ETcZM3H0WjsRysNjcY6vjCGWNUJIWqAD4z9u4FJxg1/NvCW6p0HQKCJ864HHhdCvAosl1IWWCy3RmMarTQ0Guto7vRzR6ffO1DfNR+g2mapmEVK+agQ4iPgYmC9EGKRlPKABfJqNHajYxoajXnqAIfjCcZgq6NCiO+CakkvhJjc33FCiAwp5W4p5R9Qrfv7jYNoNK5CKw2NxiRSykrUk/4eIcT/c/A01wO3CSF2AnsxN3/+XuOau4BW4BMHr63ROI1OudVovAydcqvxZrSlodF4H/XAMjPFfUCp26TSaNCWhkaj0WjsQFsaGo1GozGNVhoajUajMY1WGhqNRqMxjVYaGo1GozHN/wf5ES32gQlplQAAAABJRU5ErkJggg==\n" + "image/png": "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\n", + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " 2021-04-23T14:21:31.850232\n", + " image/svg+xml\n", + " \n", + " \n", + " Matplotlib v3.4.1, https://matplotlib.org/\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n" + ], + "text/plain": [ + "
" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } ], "source": [ @@ -546,8 +3352,9 @@ ], "metadata": { "kernelspec": { - "name": "python377jvsc74a57bd0b82620ad2a452c4c896d1e56da7510b7000ae9557b85812401bb2a5890485f01", - "display_name": "Python 3.7.7 64-bit ('venv')" + "display_name": "fwt_models", + "language": "python", + "name": "fwt_models" }, "language_info": { "codemirror_mode": { @@ -559,7 +3366,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.7" + "version": "3.8.8" }, "metadata": { "interpreter": { @@ -569,4 +3376,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/setup.py b/setup.py index b31943e..d439911 100644 --- a/setup.py +++ b/setup.py @@ -1,10 +1,28 @@ +import shutil +from os import path from setuptools import find_packages, setup +import os + + +dir_path = path.dirname(path.realpath(__file__)) + +with open(path.join(dir_path,'version.txt'),'r') as f: + ver = f.read() + +# clean up directories +dirs = ['.eggs','build','dist','moyra.egg-info'] +for _dir in dirs: + if path.exists(path.join(dir_path,_dir)): + shutil.rmtree(path.join(dir_path,_dir)) + + + setup( name='moyra', packages=find_packages(include=['moyra','moyra.*']), - version='0.1.4.1', + version=ver, description='Generate Multi-body Symbolic and Numeric Equations of Motion', - long_description = open('README.md').read(), + long_description = open(path.join(dir_path,'README.md')).read(), long_description_content_type="text/markdown", author='Fintan Healy', author_email = 'fintan.healy@bristol.ac.uk', diff --git a/tests/test_Homogenous.py b/tests/test_Homogenous.py new file mode 100644 index 0000000..2923a69 --- /dev/null +++ b/tests/test_Homogenous.py @@ -0,0 +1,8 @@ +import moyra as ma + +p = ma.DynamicModelParameters(2) +p.L_1 = ma.ModelSymbol(value = 1, string = 'L_1') # the length from the origin to the first mass +p.L_2 = ma.ModelSymbol(value = 1, string = 'L_2') # the ength from the 1st to the 2nd mass +m_1_frame = ma.HomogenousTransform().R_x(p.q[0]).Translate(0,0,-p.L_1) +m_2_frame = m_1_frame.R_x(p.q[1]).Translate(0,0,-p.L_2) +quit() \ No newline at end of file diff --git a/version.txt b/version.txt new file mode 100644 index 0000000..fe694d5 --- /dev/null +++ b/version.txt @@ -0,0 +1 @@ +0.1.5.0 \ No newline at end of file